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

assistant: Fluid physics share options with [Newtonian Physics](newtonian.xhtml).
These are covered on that page.

### Fluid Properties

Stiffness
:   How incompressible the fluid is.

Viscosity
:   Linear viscosity. Use lower viscosity for thicker fluids.

Buoyancy
:   Artificial buoyancy force in negative gravity direction based on pressure differences inside the fluid.

### Advanced

Repulsion Factor
:   How strongly the fluid tries to keep from clustering (factor of stiffness).
    Checkbox sets repulsion as a factor of stiffness.

Stiff Viscosity
:   Creates viscosity for expanding fluid. Checkbox sets this to be a factor of normal viscosity.

Interaction Radius
:   Fluid’s interaction radius. Checkbox sets this to be a factor of 4 × *particle size*.

Rest Density
:   Density of fluid when at rest. Checkbox sets this to be a factor of default density.

### Springs

Force
:   Spring force.

Rest Length
:   Rest length of springs. Factor of particle radius. Checkbox sets this to be a factor of 2 × *particle size*.

Viscoelastic Springs
:   Use viscoelastic springs instead of Hooke’s springs.

Elastic Limit
:   How much the spring has to be stretched/compressed in order to change its rest length.

Plasticity
:   How much the spring rest length can change after the elastic limit is crossed.

Initial Rest Length
:   Use initial length as spring rest length instead of 2 × *particle size*.

Frames
:   Create springs for this number of frames since particle’s birth (0 is always).
user: Provide the full official documentation entry for Rip, preserving all code examples.

assistant: # Rip

The *Rip* tool interactively separates selected UV elements (vertices, edges, or faces) from connected components,
creating a “rip” in the UV map. After the separation, the selection can be moved in the direction of the mouse
pointer, allowing the detached elements to be repositioned interactively.

This is useful for isolating UV islands or unwrapping overlapping elements
without affecting surrounding geometry.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_uv_tools_rip_before.png   Before. | ../../../../_images/modeling_meshes_uv_tools_rip_after.png   After. |
user: Describe GeometryNodeFillCurve(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeFillCurve(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.GeometryNodeFillCurve(*GeometryNode*)
:   Generate a mesh on the XY plane with faces on the inside of input curves

    *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 Options in a Blender add-on or script – include code.

assistant: After the modal tool is run
the [Loop Cut and Slide Options](../editing/edge/loopcut_slide.xhtml#modeling-meshes-editing-edge-loopcut-slide-options)
are available in the [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.
user: Explain Mix Vector Node in complete detail according to the official Blender documentation.

assistant: # Mix Vector Node

The *Mix Node* mixes values, colors and vectors inputs
using a factor to control the amount of interpolation.
The *Color* mode has additional blending modes.

[image reference removed]
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Color 1/2
:   Color of the bricks.

Mortar
:   The color of the area between bricks.

Scale
:   Overall texture scale.

Mortar Size
:   The size of the filling between the bricks known as “mortar”; 0 means no mortar.

Mortar Smooth
:   Blurs/softens the edge between the mortar and the bricks.
    This can be useful with a texture and displacement textures.

Bias
:   The color variation between *Color 1/2*.
    Values of -1 and 1 only use one of the two colors; values in between mix the colors.

Brick Width
:   The ratio of brick’s width relative to the texture scale.

Row Height
:   The ratio of brick’s row height relative to the texture scale.
user: What is Property Subtype Number Array Items and how is it used in Blender Python scripting?

assistant: # Property Subtype Number Array Items

COLOR:
:   Linear Color.

    Color in the scene linear working color space.

TRANSLATION:
:   Translation.

DIRECTION:
:   Direction.

VELOCITY:
:   Velocity.

ACCELERATION:
:   Acceleration.

MATRIX:
:   Matrix.

EULER:
:   Euler Angles.

    Euler rotation angles in radians.

QUATERNION:
:   Quaternion.

    Quaternion rotation (affects NLA blending).

AXISANGLE:
:   Axis-Angle.

    Angle and axis to rotate around.

XYZ:
:   XYZ.

XYZ_LENGTH:
:   XYZ Length.

COLOR_GAMMA:
:   sRGB Color.

    Color in sRGB color space (mainly for user interface colors).

COORDINATES:
:   Coordinates.

LAYER:
:   Layer.

LAYER_MEMBER:
:   Layer Member.

NONE:
:   None.
user: What is CompositorNodeBrightContrast(CompositorNode) and how is it used in Blender Python scripting?

assistant: # CompositorNodeBrightContrast(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.CompositorNodeBrightContrast(*CompositorNode*)
:   Adjust brightness and contrast

    *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 AlphaUnderStrip(EffectStrip) and how is it used in Blender Python scripting?

assistant: # AlphaUnderStrip(EffectStrip)

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

*class* bpy.types.AlphaUnderStrip(*EffectStrip*)
:   Alpha Under Strip

    input_1
    :   First input for the effect strip

        Type:
        :   [`Strip`](bpy.types.Strip.html#bpy.types.Strip "bpy.types.Strip"), (never None)

    input_2
    :   Second input for the effect strip

        Type:
        :   [`Strip`](bpy.types.Strip.html#bpy.types.Strip "bpy.types.Strip"), (never None)

    input_count
    :   Type:
        :   int in [0, inf], default 0, (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: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

Geometry Nodes is a system for modifying the geometry of an object with node-based operations.
It can be accessed by adding a [Geometry Nodes Modifier](../modifiers/geometry_nodes.xhtml)
and setting up the nodes in the [Geometry Node Editor](../../editors/geometry_node.xhtml).

[image reference removed]

The properties of a Geometry Nodes modifier in the modifier stack.

The geometry node tree connected to a modifier is a [Node Group](../../interface/controls/nodes/groups.xhtml).
The geometry from the state before the modifier (the original geometry or the result of the previous
modifier) will be passed to the *Group Input* node. Then the node group can operate on the geometry
and pass an output to the *Group Output* node, where it will be passed to the next modifier.

Geometry nodes can modify different types of geometry:

- [Meshes](../meshes/introduction.xhtml)
- [Curves](../curves/introduction.xhtml)
- [Point Clouds](../point_cloud/index.xhtml)
- [Volumes](../volumes/introduction.xhtml)
- [Instances](instances.xhtml)

The interface of the modifier is described in the
[Modifier](../modifiers/geometry_nodes.xhtml) page.

To expand Blender with node-group operators, see the [Node-Based Tools](tools.xhtml) page.
user: Give a detailed overview of Effector: syntax, arguments, return values, common patterns.

assistant: # Effector

Effector objects are used to deflect fluids and influence the fluid flow. To define any mesh object
as an effector object, add fluid physics by clicking *Fluid* in Properties ‣ Physics.
Then select *Effector* as the fluid *Type*.
user: Describe GeometryNodeViewer(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeViewer(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.GeometryNodeViewer(*GeometryNode*)
:   Display the input data in the Spreadsheet Editor

    active_index
    :   Index of the active item

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

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

    domain
    :   Domain to evaluate fields on

        Type:
        :   enum in [Attribute Domain With Auto Items](bpy_types_enum_items/attribute_domain_with_auto_items.html#rna-enum-attribute-domain-with-auto-items), default `'POINT'`

    ui_shortcut
    :   Type:
        :   int in [-32768, 32767], default 0

    viewer_items
    :   Type:
        :   [`NodeGeometryViewerItems`](bpy.types.NodeGeometryViewerItems.html#bpy.types.NodeGeometryViewerItems "bpy.types.NodeGeometryViewerItems") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`NodeGeometryViewerItem`](bpy.types.NodeGeometryViewerItem.html#bpy.types.NodeGeometryViewerItem "bpy.types.NodeGeometryViewerItem"), (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 Limit Total Vertex Groups from the Blender manual or Python API, including usage steps and snippets.

assistant: Reduce the number of weight groups per vertex to the specified Limit.
The tool removes lowest weights first until the limit is reached.

Subset
:   Restrict the tool to a subset.
    See above [The Subset Option](../../../sculpt_paint/weight_paint/editing.xhtml#sculpt-paint-weight-paint-editing-subset) for how subsets are defined.

Limit
:   Maximum number of weights allowed on each vertex.
user: How do I use Attributes in Blender? Include parameters, examples, warnings and best practices.

assistant: Layers can store [Custom Attributes](../../modeling/geometry_nodes/attributes_reference.xhtml).
The attributes are stored on the [Layer](../../modeling/geometry_nodes/attributes_reference.xhtml#attribute-domains) domain.

For example, the [Layer Adjustments](layers.xhtml#layer-adjustments) are stored as layer attributes.

Attributes
:   [List view](../../interface/controls/templates/list_view.xhtml#ui-list-view) of all the attributes stored on the layers.

    Name
    :   Name of the layer attribute.

    Data Type
    :   The [Data Type](../../modeling/geometry_nodes/attributes_reference.xhtml#attribute-data-types) of the attribute.
user: Give a detailed overview of Wind: syntax, arguments, return values, common patterns.

assistant: # Wind

[image reference removed]

Wind force field visualization.

The *Wind* force field gives a constant force in a single direction, along the force object’s local Z axis.
The strength of the force is visualized by the spacing of the circles shown.

[image reference removed]

UI for a Wind force field.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Segment Coordinates
:   Segment coordinates for texture mapping within each radial segment.

Segment ID
:   Unique ID for every radial segment startiing at 0 and increasing counterclockwise by 1 for every for each segment.

Segment Width
:   Relative width of each radial segment. May be used to scale textures to fit into each segment.

Segment Rotation
:   Counterclockwise rotation of each segment coordinate system. May be used to align the rotation of the textures of each segment.
user: Explain Intersect (Boolean) in complete detail according to the official Blender documentation.

assistant: # Intersect (Boolean)

Performs Boolean operations between the selected and unselected geometry.

[image reference removed]

Selecting a sphere and performing an Intersection, Union, and Difference
with a cube.

The [Adjust Last Operation](../../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel offers the following options:

Boolean Operation
:   Intersect:
    :   Only keep the volume that’s inside both the selected and the unselected geometry.

    Union:
    :   Remove the interior faces between the selected and the unselected geometry.

    Difference:
    :   Cut the selected geometry out of the unselected geometry, then remove the selected geometry.

Solver
:   Algorithm used to perform the Boolean operation.

    Float:
    :   Uses a simple solver which offers the good performance;
        however, this solver lacks support for overlapping geometry.

        Merge Threshold
        :   Tolerance for close faces to be considered touching.
            It may be useful to increase this when some intersections aren’t detected that should be and
            when extra geometry is being created because edges aren’t detected as overlapping.

    Exact:
    :   Uses a complex solver which offers the best results and has full
        support for overlapping geometry; however, this solver is much slower.

Swap
:   When using *Difference*, cut the unselected geometry out of the selected geometry instead
    of the other way around.

Self Intersection
:   Correctly handle self-intersection in the participating geometry, at the cost of performance.
user: What is Constraints and how is it used in Blender Python scripting?

assistant: When moving, rotating or scaling, if you only want certain axes to be affected,
you can restrict the transformation to those axes.

By default the constraint keys are `X`, `Y` and `Z`.
This constraint can be restricted to a plane if `Shift`
is pressed or automatically detected if `MMB` is pressed.

It is worth noting that if you press the same constraint hotkey a second time,
you change the orientation from Local to Global or vice versa. Pressing a third time disables the constraint.
user: What is Add Constraint (with Targets) and how is it used in Blender Python scripting?

assistant: Adds a constraint to the active object.
The type of constraint must be chosen from a pop-up menu,
though it can be changed later from the *Add Constraint (with Targets)*
[Adjust Last Operation](../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel.
If there is an other object selected besides the active one,
that object will be the constraint target (if the chosen constraint accepts targets).

When using a bone from another armature as the target for a constraint, the tool
will look inside the non-active armature and use its active bone,
provided that armature is in Pose Mode.
user: Show practical ways to work with Mask in a Blender add-on or script – include code.

assistant: # Mask

This mode shows all the [masks](../../../movie_clip/masking/introduction.xhtml) in the blend-file
(that have at least one layer) and lets you adjust their keyframes.

[image reference removed]

The Mask mode of the Dope Sheet Editor.
user: Describe Active Point from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Active Point panel.

This panel is shown when both a tracking marker and mask is selected.

### Parent

In the *Movie Clip Editor* it is possible to link the whole mask or its points to motion tracks.
This way the mask or points will follow the tracks.

Parent
:   [Data ID](../../interface/controls/templates/data_block.html#ui-data-id) to which the mask or spline is parented to
    in case of parenting to movie tracking data set to Movie Clip data-block.

Parent Type
:   Point Track, Plane Track

Object
:   [Object](../tracking/clip/sidebar/track/objects.html#movie-clip-tracking-properties-object) to parent to.

Track
:   Name of individual tracks.

### Animation

Controls animation data for mask properties, including active [Actions](../../animation/actions.html)
and their assigned [Slot](../../animation/actions.html#animation-actions-slots).

See [Manually Assigning Actions and Slots](../../animation/actions.html#animation-actions-slots-manual-assign) for more information.
user: Give a detailed overview of Draw Sharp: syntax, arguments, return values, common patterns.

assistant: # Draw Sharp

Similar to the [Draw](draw.xhtml) brush,
but it always deforms the mesh from the original coordinates
and uses the *Sharper* Falloff by default.

Draw Sharp is useful on high density meshes for creating cloth wrinkles, stylized hair or hard surface edges.
To further sharpen or polish sharp edges in the case that the mesh density is not enough,
it’s recommended to use the [Pinch](pinch.xhtml),
[Crease](crease.xhtml) or
[Multiplane Scrape](multiplane_scrape.xhtml) brushes.

A limitation is that the brush does not remesh the sculpted surfaces
with [Dyntopo](../tool_settings/dyntopo.xhtml#bpy-ops-sculpt-dynamic-topology-toggle) enabled.
Because of that, a better brush to use with Dyntopo can be [Crease](crease.xhtml).
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

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

The Screw modifier.

Angle
:   Degrees for a single helix revolution.

Screw
:   The height of one helix iteration.

Iterations
:   Number of revolutions.

Axis
:   The axis along which the helix will be built.

Axis Object
:   The name of an object to define the axis direction.

    Object Screw
    :   Use the distance from the *Axis Object* to define the height of one helix iteration.

Steps Viewport
:   Number of steps used for a single revolution displayed in the 3D Viewport.

Render
:   As above, but used during render time. Increase to improve quality.

Merge
:   Merge vertices that lie on the axis of rotation.
    Use this to close off end points with a triangle fan.

    Merge Distance
    :   Vertices under this distance to the axis are merged.

Stretch UVs
:   Stretch the UV coordinates from (0.0 to 1.0) when UVs are present.

### Normals

Smooth Shading
:   Output faces with smooth shading rather than flat shading.
    The smooth/flat shading of the input geometry is not preserved.

Calculate Order
:   Order of edges is calculated to avoid problems with normals and shading. Only needed for meshes, not curves.

Flip
:   Flip normals direction.
user: Explain Shear in complete detail according to the official Blender documentation.

assistant: # Shear

Shearing is a form of movement where parallel surfaces move past one another. During this transform,
movement of the selected elements will occur along the horizontal axis of the current view.
The axis location will be defined by
the [Pivot Point](../../../../../editors/3dview/controls/pivot_point/index.xhtml).
Everything that is “above” this axis will move (shear)
in the same direction as your mouse pointer (but always parallel to the horizontal axis).
Everything that is “below” the horizontal axis will move in the opposite direction.

[image reference removed]

Shear Offset Factor.
user: Show practical ways to work with GeometryNodeSampleIndex(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeSampleIndex(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.GeometryNodeSampleIndex(*GeometryNode*)
:   Retrieve values from specific geometry elements

    clamp
    :   Clamp the indices to the size of the attribute domain instead of outputting a default value for invalid indices

        Type:
        :   boolean, default False

    data_type
    :   Type:
        :   enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items), default `'FLOAT'`

    domain
    :   Type:
        :   enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items), default `'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: What is HDRIs and how is it used in Blender Python scripting?

assistant: This panel manages [HDRI](../../glossary/index.html#term-HDRI) image files
which can be used to light the view when [Material Preview](../3dview/display/shading.html#dview-material-preview) or
[Rendered](../3dview/display/shading.html#dview-rendered) shading is enabled.
user: Describe Getting Started from the Blender manual or Python API, including usage steps and snippets.

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

Default UV editing workspace.

By default, meshes are not created with UVs. First you must map the faces, then
you can [edit them](../editing.html).
The process of unwrapping your model is done within Edit Mode in the 3D Viewport.
This process creates one or more UV Islands in the [UV Editor](../../../../editors/uv/index.html#editors-uv-index).

To begin, choose the *UV Editing* [workspace](../../../../interface/window_system/workspaces.html)
from the selection list at the top of your screen in the Preferences header.
This sets one of the areas to show you the UV Editor, and the other area to the 3D Viewport.

Enter *Edit Mode*, as all unwrapping is done in Edit Mode.
You can be in vertex, face, or edge selection mode.

### Workflow

The general workflow is as follows, but know that different models may require
different approaches to unwrapping:

1. Mark Seams if necessary. See more about [marking seams](seams.html).
2. Select mesh faces in the 3D Viewport.
3. Select a UV mapping method from the UV ‣ Unwrap menu or
   the UV menu in the 3D Viewport.
4. Adjust the unwrap settings in the [Adjust Last Operation](../../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel.
5. Add a test image to see if there will be any distortion.
   See [Applying Images to UVs](../applying_image.html).
6. Adjust UVs in the UV editor. See [Editing UVs](../editing.html).
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: For this example the model was shot against a *white* background.
Using the Luminance Key node, we get a matte out where the background is white,
and the model is black; the opposite of what we want.
If we wanted to use the matte, we have to switch the white and the black.
How to do this? Color Ramp node to the rescue – we set the left color to White Alpha 1.0,
and the right color to be Black Alpha 0.0. Thus, when the Color Ramp gets in black,
it spits out white, and vice versa. The reversed mask is shown;
its white outline is usable as an alpha mask now.

[image reference removed]

Using Luma Key with a twist.

Now to mix, we do not really need the *Alpha Over* node;
we can just use the mask as our Factor input. In this kinda weird case,
we can use the matte directly; we just switch the input nodes. As you can see,
since the matte is white (1.0) where we do not want to use the model picture,
we feed the background photo to the bottom socket
(recall the Mix node uses the top socket where the factor is 0.0,
and the bottom socket where the factor is 1.0). Feeding our original photo into the top socket
means it will be used where the Luminance Key node has spit out Black. Voilà,
our model is teleported from Atlanta to aboard a cruise ship docked in Miami.
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

Mesh Modeling typically begins with
a [Mesh Primitive](primitives.html) shape (e.g. circle, cube, cylinder…).
From there you might begin editing to create a larger, more complex shape.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

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: Give a detailed overview of Examples: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Equidistant objects being pushed together.

[image reference removed]

Random objects being pushed together.

[image reference removed]

Push (middle) vertices around the 3D cursor compared to Scale (right).
user: Give a detailed overview of IMAGE_UL_render_slots(UIList): syntax, arguments, return values, common patterns.

assistant: # IMAGE_UL_render_slots(UIList)

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

*class* bpy.types.IMAGE_UL_render_slots(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *_icon*, *_active_data*, *_active_propname*, *_index*)

    *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 Subdivide in a Blender add-on or script – include code.

assistant: The *Subdivide* operator adds new control points to selected curve segments by dividing them into smaller sections.
This is useful for creating smoother transitions, preparing curves for finer adjustments,
or adding more detail for animation or modeling.

Number of Cuts
:   Specifies the number of divisions for each selected segment; each cut adds one new control point per segment.
user: Explain NodeTreeInterfaceSocketVectorPercentage2D(NodeTreeInterfaceSocket) in complete detail according to the official Blender documentation.

assistant: # NodeTreeInterfaceSocketVectorPercentage2D(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketVectorPercentage2D(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

    *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 Displace Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Displace Node

[image reference removed]

The *Displace Node* displaces the pixel position based on an input vector.

This node could be used to model phenomena, like hot air distortion,
refractions of uneven glass or for surreal video effects.
user: What is Image Kernels and how is it used in Blender Python scripting?

assistant: # Image Kernels

An *image kernel* is a small matrix of numeric values used to process an image by applying a
mathematical operation known as *convolution*.
Each value in the kernel defines how much neighboring pixels contribute to the output pixel’s value.

Kernels are a fundamental concept in image processing and are used to perform operations such as
blurring, sharpening, and edge detection.
They determine how pixel neighborhoods are weighted and combined to produce new image details.
user: Describe Default Workspaces from the Blender manual or Python API, including usage steps and snippets.

assistant: Blender’s default startup shows the “Layout” workspace in the main area.
This workspace is a general workspace to preview your scene
and contains the following Editors:

- [3D Viewport](../../editors/3dview/introduction.xhtml) on top left.
- [Outliner](../../editors/outliner/introduction.xhtml) on top right.
- [Properties](../../editors/properties_editor.xhtml) on bottom right.
- [Dopesheet](../../editors/dope_sheet/index.xhtml) on bottom left.

[image reference removed]

Blender’s ‘Layout’ Workspace with four editors.

3D Viewport (yellow), Outliner (green), Properties (blue) and Timeline (red).

Blender also has several other workspaces added by default:

Modeling:
:   For modification of geometry by modeling tools.

Sculpting:
:   For modification of meshes by sculpting tools.

UV Editing:
:   For mapping of image texture coordinates to 3D surfaces.

Texture Paint:
:   For coloring image textures in the 3D Viewport.

Shading:
:   For specifying material properties for rendering.

Animation:
:   For making properties of objects dependent on time.

Rendering:
:   For viewing and analyzing rendering results.

Compositing:
:   For combining and post-processing of images and rendering information.

Geometry Nodes:
:   For procedural modeling using [Geometry Nodes](../../modeling/geometry_nodes/index.xhtml).

Scripting:
:   For interacting with Blender’s Python API and writing scripts.

### Additional Workspaces

Blender has a couple additional Workspaces to choose from when adding a new Workspace:

2D Animation

2D Animation:
:   General workspace to work with Grease Pencil.

2D Full Canvas:
:   Similar to “2D Animation” but contains a larger canvas.

VFX

Masking:
:   For creating 2D masks for compositing or video editing.

Motion Tracking:
:   For calculating camera motion and stabilizing video footage.

Video Editing

Video Editing:
:   For sequencing together media into one video.
user: Describe Removing Data-Blocks from the Blender manual or Python API, including usage steps and snippets.

assistant: As covered in [Life Time](#life-time), data-blocks are typically removed when they are no longer used.
They can also be manually *unlinked* or *deleted*.

Unlinking a data-block means that its user won’t use it anymore.
This can be achieved by clicking on the “X” icon next to a data-block’s name.
If you unlink a data-block from all of its users,
it will eventually be deleted by Blender as described above (unless it is a protected one).

Deleting a data-block directly erases it from the blend-file, automatically unlinking it from all of its users.
This can be achieved by `Shift`-`LMB` on the “X” icon next to its name.

Those two operations are also available in the context menu
when `RMB`-clicking on a data-block in the *Outliner*.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Next Vertex Index
:   The following vertex on the shortest path from every vertex to the closest endpoint
    (as defined by the cost input).

Total Cost
:   The remaining cost before an end vertex is reached.
user: What is Properties and how is it used in Blender Python scripting?

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

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

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

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

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

Clamp Result (Color only)
:   Limit the Result to the range between 0.0 and 1.0.
user: How do I use Vertex Group in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Typical modifier Vertex Group options.

[Vertex Groups](../meshes/properties/vertex_groups/introduction.xhtml) are an easy way to control
which vertices are affected by a modifier, and to which extent (using their weights).
They are available when modifying meshes or lattices.

Vertex Group
:   The vertex group name.

    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.
        Only available in some modifiers.
user: What is Hints and how is it used in Blender Python scripting?

assistant: Your computer accidentally turns off in the middle of rendering your movie!
:   Unless your animation renders in a few minutes,
    it is best to render the animation as separate image files.
    Instead of rendering directly to a compressed movie file, use a lossless format (e.g. `PNG`).

    This allows you an easy recovery if there is a problem and you have to re-start the rendering,
    since the frames you have already rendered will still be in the output directory.

    Just disable the *Overwrite* option to start rendering where you left off.

    You can then make a movie out of the separate frames with Blender’s Sequence editor
    or use 3rd party encoding software.

Animation Preview
:   It can be useful to render a subset of the animated sequence,
    since only part of an animation may have an error.

    Using an image format for output,
    you can use the *Frame Step* option to render every *N’th* frame.
    Then disable *Overwrite* and re-render with *Frame Step* set to 1.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

Masks can be created in the *Image* and *Movie Clip* editors, by changing the mode to *Mask* in the header.
This will add various tools and properties to the editor panels,
while hiding others that are not needed for interacting with masks.

Masks have many purposes. They can be used in a motion tracking workflow to mask out,
or influence a particular object in the footage.
They can be used for manual rotoscoping to pull a particular object out of the footage,
or as a rough matte for green-screen keying. Masks are independent from a particular image of movie clip,
and so they can just as well be used for creating motion graphics or other effects in the Compositor.

[image reference removed]

Using the Mask node to isolate an object in compositing.

While the *Movie Clip Editor* and *Image Editor* are used to edit masks,
the *Compositor* and *Sequencer* are just using already created mask.

Masks can be animated over the time so that they follow some object from the footage,
e.g. a running actor. This can be achieved with shape keys or parenting the mask to tracking markers.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

The Skin modifier.

Branch Smoothing
:   A branch point is a vertex with three or more connected edges.
    These areas tend to produce more complicated topology, some of which may overlap.
    This setting relaxes the surface around these points,
    with the side effect of shrinking it.

Symmetry
:   These checkboxes are used to keep the output topology symmetrical in their respective axes.
    In other words, using it avoids merging triangles across an axis unless the triangles form a symmetric quad.

Smooth Shading
:   Output faces with smooth shading rather than flat shading.
    The smooth/flat shading of the input geometry is not preserved.

Create Armature
:   Create an armature on top of the object. Each edge becomes a bone.

    This tool does the following:

    1. A new armature object is added with bones matching the input mesh.
       The active selection is switched to the new armature.
    2. Weight groups are added to the input mesh. The Skin modifier propagates these weights to the output as well.
    3. An [Armature](../deform/armature.xhtml) modifier is added directly below the Skin one.
       Note that the Armature modifier is being applied after
       the Skin one because it should only deform the output,
       whereas if it were above, it might change the resulting topology.

Add Skin Data
:   This modifier uses a [custom set of data](#modeling-modifiers-generate-skin-data) in the mesh,
    that is generated automatically when you add the modifier the first time.

    However, you may remove that data, or loose it some way or the other. That operator will generate it again.

Mark/Clear Loose
:   By default, a branch vertex (vertex with three or more connected edges)
    will generate extra edge loops along adjacent edges in order to keep the output tight.
    Branches can be made loose by clicking *Mark Loose*, which will allow the output to stretch between
    all adjacent vertices. This can be disabled again by clicking *Clear Loose*.

Mark Root
:   Marking a vertex as root causes that vertex to be used for calculating rotations for connected limbs.
    Root vertices also affect the armature output, they will be used as the origin for the root bones.

    Each set of connected vertices should have one root node
    (one is selected by default if you do not assign any manually).
    *Mark Root* enforces the one-root per set rule, so it is not necessary to manually unmark roots.

Equalize Radii
:   Makes the skin radii of selected vertices equal on each axis.