PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use Shrink/Fatten in Blender? Include parameters, examples, warnings and best practices.

assistant: # Shrink/Fatten

Moves the selected vertices “inwards” or “outwards” along their normal,
all by the same distance. You can control this distance by moving the mouse up or down,
typing a number, or using the slider in the [Adjust Last Operation](../../../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel.

Even Thickness `S`, `Alt`
:   Applies a larger offset to vertices that are part of a sharp corner, for a more uniform result.
    You can toggle this option by pressing `S`, holding `Alt`, or clicking the
    checkbox in the Adjust Last Operation panel.

|  |  |  |
| --- | --- | --- |
| <../../../../../_images/modeling_meshes_editing_mesh_transform_shrink-fatten_before.png>   Mesh before shrink/fatten. | <../../../../../_images/modeling_meshes_editing_mesh_transform_shrink-fatten_inflate-positive.png>   Inflated using a positive value. | <../../../../../_images/modeling_meshes_editing_mesh_transform_shrink-fatten_inflate-negative.png>   Shrunk using a negative value. |
user: Explain Query Parameters in complete detail according to the official Blender documentation.

assistant: When Blender fetches the extensions listing it passes the following arguments to make sure only
compatible extensions are listed:

- `platform`
- `blender_version`

These arguments are passed as parameters to the server via a query URL:

> URL:
> :   `https://extensions.blender.org/api/v1/extensions/`
>
> query URL:
> :   `https://extensions.blender.org/api/v1/extensions/?blender_version=4.2.0&platform=linux-x64`
user: Provide the full official documentation entry for Bpy.Types.Softbodysettings, preserving all code examples.

assistant: _group_mass ¶ Control point mass values Type : string, default “”, (never None) vertex_group_spring ¶ Control point spring strength values Type : string, default “”, (never None) classmethod bl_rna_get_subclass ( id , default = None , / ) ¶ Parameters : id ( str ) – The RNA type identifier. Returns : The RNA type or default when not found. Return type : bpy.types.Struct 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 Inherited Properties ¶ bpy_struct.id_data Inherited Functions ¶ bpy_struct.as_pointer bpy_struct.driver_add bpy_struct.driver_remove bpy_struct.get bpy_struct.id_properties_clear bpy_struct.id_properties_ensure bpy_struct.id_properties_ui bpy_struct.is_property_hidden bpy_struct.is_property_overridable_library bpy_struct.is_property_readonly bpy_struct.is_property_set bpy_struct.items bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values References ¶ Object.soft_body SoftBodyModifier.settings Next SolidifyModifier(Modifier) Previous SoftBodyModifier(Modifier) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page SoftBodySettings(bpy_struct) SoftBodySettings SoftBodySettings.aero SoftBodySettings.aerodynamics_type SoftBodySettings.ball_damp SoftBodySettings.ball_size SoftBodySettings.ball_stiff SoftBodySettings.bend SoftBodySettings.choke SoftBodySettings.collision_collection SoftBodySettings.collision_type SoftBodySettings.damping SoftBodySettings.effector_weights SoftBodySettings.error_threshold SoftBodySettings.friction SoftBodySettings.fuzzy SoftBodySettings.goal_default SoftBodySettings.goal_friction SoftBodySettings.goal_max SoftBodySettings.goal_min SoftBodySettings.goal_spring SoftBodySettings.gravity SoftBodySettings.location_mass_center SoftBodySettings.mass SoftBodySettings.plastic SoftBodySettings.pull SoftBodySettings.push SoftBodySettings.rotation_estimate SoftBodySettings.scale_estimate SoftBodySettings.shear SoftBodySettings.speed SoftBodySettings.spring_length SoftBodySettings.step_max SoftBodySettings.step_min SoftBodySettings.use_auto_step SoftBodySettings.use_diagnose SoftBodySettings.use_edge_collision SoftBodySettings.use_edges SoftBodySettings.use_estimate_matrix SoftBodySettings.use_face_collision SoftBodySettings.use_goal SoftBodySettings.use_self_collision SoftBodySettings.use_stiff_quads SoftBodySettings.vertex_group_goal SoftBodySettings.vertex_group_mass SoftBodySettings.vertex_group_spring SoftBodySettings.bl_rna_get_subclass() SoftBodySettings.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Describe Inherited Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`PropertyGroup.name`](bpy.types.PropertyGroup.html#bpy.types.PropertyGroup.name "bpy.types.PropertyGroup.name") |
user: Give a detailed overview of Simulation Brushes: syntax, arguments, return values, common patterns.

assistant: These brushes are similar to regular brushes but with an additional cloth simulation applied.
These are ideally used on a relatively low resolution, since the mesh density defines the size of cloth dynamics.

[image reference removed]

Drag Cloth
:   Brush Type: [Cloth](cloth.html)

    Nudges the geometry along the surface while minimally affecting the overall shape of the object.

Push Cloth
:   Brush Type: [Cloth](cloth.html)

    Pushes geometry inwards or outwards.

Grab Cloth
:   Brush Type: [Cloth](cloth.html)

    Grabs geometry within the brush radius firmly, while surrounding geometry is being simulated to follow.

Grab Planar Cloth
:   Brush Type: [Cloth](cloth.html)

    Similar to Grab Cloth but with a line as the brush radius instead of a circle.

Grab Random Cloth
:   Brush Type: [Cloth](cloth.html)

    Similar to Grab Cloth but with a noise texture applied to create more random variation.

Inflate Cloth
:   Brush Type: [Cloth](cloth.html)

    Inflates the geometry outwards or inwards.

Expand/Contract Cloth
:   Brush Type: [Cloth](cloth.html)

    Creates compression or stretching on geometry.

Pinch Point Cloth
:   Brush Type: [Cloth](cloth.html)

    Pinches geometry to the center point of the radius, creating folds from all sides.

Pinch Folds Cloth
:   Brush Type: [Cloth](cloth.html)

    Pinches only from two perpendicular sides along the stroke direction, creating parallel folds along the stroke.

Bend/Twist Cloth
:   Brush Type: [Pose](pose.html)

    A pose brush that rotates geometry.

Stretch/Move Cloth
:   Brush Type: [Pose](pose.html)

    A pose brush that translates and scales geometry.

Bend Boundary Cloth
:   Brush Type: [Boundary](boundary.html)

    Bend only open boundaries of the mesh, folding the surrounding geometry in the process.

Twist Boundary Cloth
:   Brush Type: [Boundary](boundary.html)

    Twist open boundaries of the mesh, creating twisting folds.
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

The goal of this example is to turn a Curve into a tube-shaped mesh with pieces
cut away at regular intervals. At first, this seems straightforward: use the
[Curve to Mesh Node](../curve/operations/curve_to_mesh.html) to create the tube,
read from the [Spline Parameter Node](../curve/read/spline_parameter.html) to find
out where each tube vertex lies on the original curve, and do some math to decide
whether to delete the vertex.

This alone doesn’t work, however: the *Spline Parameter* node calculates its outputs
on the fly, and it can only do so for curves. Once the curve has been converted
to a mesh, this node can no longer be used.

This is where the *Capture Attribute* node comes in: it can *store* the calculated
distance on each curve control point. The *Curve to Mesh* node then transfers these
numbers to the mesh vertices (as it does for any attribute). From there, the attribute
can be retrieved again by connecting to the same *Capture Attribute* node that stored it.
user: Provide the full official documentation entry for Shadows, preserving all code examples.

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

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

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

    Steps
    :   Number of steps to compute volumetric shadowing.

Resolution
:   Resolution percentage of shadow maps.
user: Provide the full official documentation entry for Time, preserving all code examples.

assistant: The Time panel is used to control source and timeline position of the strip.

Lock (padlock icon in panel header)
:   Prevents the strip from being moved.

Show Retiming Keys
:   Toggle visibility and selectability of [Retiming Keys](../../../../video_editing/edit/montage/editing.xhtml#sequencer-editing-retiming).

Channel
:   Changes the channel number, or row, of the strip.

Start
:   Changes the starting frame of the strip, which is the same as selecting and moving the strip.

Duration
:   Changes the length (in frames) of the strip. This works by changing the end frame,
    which is the same as selecting and moving the strip’s right handle.

End
:   Shows the ending time and frame of the strip.

Strip Offset Start/End
:   Positive values will move the strip’s handles inwards, making it start later than the start
    of the source material and stop before its end. This lets you trim down the source material
    to the part you need. You can enable the
    [Offsets overlay](../display.xhtml#bpy-types-sequencertimelineoverlay-show-strip-offset)
    to see the start and end of the full source file.

    Negative values will move the strip’s handles outwards, making it start earlier than the start
    of the source material and stop after its end. This lets you show the first and/or last frame
    as a frozen image for some time.

    Instead of adjusting these offsets in the Sidebar, you can also drag the strip’s handles.

Hold Offset Start/End
:   Used for trimming frames off the start/end of the source material. At first sight, this
    does the same as the *Strip Offset* properties, but you can in fact combine them
    to hold (freeze) a frame other than the first or last one. For example, if you set the
    *Hold Offset Start* to 10 and the *Strip Offset Start* to -20, the video will first show
    the 11th frame of the source for 21 frames, and then play the remaining frames.

Current Frame
:   The Playhead’s frame number relative to the start of the strip.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Axis
:   Local axis of the object that is to be rotated towards the vector input.

Pivot
:   The local axis to rotate around.

    Auto:
    :   The best rotation angle is computed automatically.
        This minimizes the angle of rotation.

    X, Y, Z:
    :   Rotate around a specific local axis.
user: How do I use Remesh in Blender? Include parameters, examples, warnings and best practices.

assistant: Mesh objects, in particular meshes that have been modeled to represent organic objects,
often have geometry that is not particularly uniform.
This can cause problems if the object needs to be [rigged](../../../animation/introduction.xhtml#animation-rigging)
or just needs simpler geometry for workflows such as 3D printing.
Remeshing is a technique that rebuilds the geometry with a more uniform topology.
Remeshing can either add or remove the amount of topology depending on the defined resolution.
Remeshing is especially useful for [sculpting](../../../sculpt_paint/sculpting/index.xhtml),
to generate better topology after blocking out the initial shape.

See [Remeshing](../retopology.xhtml) for more information.
user: How do I use Sharing in Blender? Include parameters, examples, warnings and best practices.

assistant: Data-blocks can be shared among other data-blocks.

Examples where sharing data is common:

- Sharing textures among materials.
- Sharing meshes between objects (instances).
- Sharing animated actions between objects,
  for example to make all the lights dim together.

You can also share data-blocks between files, see
[linked libraries](linked_libraries/index.xhtml).
user: How do I use Bone Parent in Blender? Include parameters, examples, warnings and best practices.

assistant: Bone parenting allows you to make a certain bone in an armature the parent object of another object.
This means that when transforming an armature the child object will only move
if the specific bone is the child object of moves.

[image reference removed]

Three pictures of armatures with four bones.

In Fig. [Three pictures of armatures with four bones.](#fig-view3d-parent-bone-parent) with the 2nd bone being the bone parent of the child object cube.
The cube is only transformed if the 1st or 2nd bones are.
Notice altering the 3rd and 4th bones has no effect on the cube.

To use bone parenting, you must first select all the child objects you wish to parent to a specific armature bone,
then `Shift`-`LMB` select the armature object and switch it into Pose Mode and
then select the specific bone you wish to be the parent bone by `LMB` selecting it.
Once done press `Ctrl`-`P` and select bone from the *Set Parent To* pop-up menu.

Now transforming that bone in Pose Mode will result in the child objects also transforming.

### Relative Parenting

Bone relative parenting is an option you can toggle for each bone.
This works in the same way as bone parenting with one difference.

With bone parenting if you have parented a bone to some child objects and
you select that bone and switch it into Edit Mode and then move that bone;
When you switch back into Pose Mode on that bone,
the child object which is parented to that bone will snap back to the location of the bone in Pose Mode.

[image reference removed]

Single armature bone which has a child object cube parented to it using bone parenting.

In Fig. [Single armature bone which has a child object cube parented to it using bone parenting.](#fig-view3d-parent-bone-parent-child) the 1st picture shows the position of the cube and
armature before the bone is moved in Edit Mode.
2nd picture shows the position of the cube and armature after the bone was selected in Edit Mode,
moved and switched back into Pose Mode. Notice that the child object moves to the new location of the pose bone.

Bone relative parenting works differently;
If you move a parent bone in Edit Mode, when you switch back to Pose Mode,
the child objects will not move to the new location of the Pose Bone.

[image reference removed]

Single bone with bone relative parent to a cube.

In Fig. [Single bone with bone relative parent to a cube.](#fig-view3d-parent-bone-parent-relative) the 1st picture
shows the position of the cube and armature before the bone is moved in Edit Mode.
2nd picture shows the position of the cube and armature after the bone was selected in Edit Mode,
moved and switched back into Pose Mode.
Notice that the child object does not move to the new location of the pose bone.
user: What is CompositorNodeFilter(CompositorNode) and how is it used in Blender Python scripting?

assistant: # CompositorNodeFilter(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.CompositorNodeFilter(*CompositorNode*)
:   Apply common image enhancement filters

    *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: Provide the full official documentation entry for LimitLocationConstraint(Constraint), preserving all code examples.

assistant: # LimitLocationConstraint(Constraint)

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

*class* bpy.types.LimitLocationConstraint(*Constraint*)
:   Limit the location of the constrained object

    max_x
    :   Highest X value to allow

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

    max_y
    :   Highest Y value to allow

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

    max_z
    :   Highest Z value to allow

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

    min_x
    :   Lowest X value to allow

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

    min_y
    :   Lowest Y value to allow

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

    min_z
    :   Lowest Z value to allow

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

    use_max_x
    :   Use the maximum X value

        Type:
        :   boolean, default False

    use_max_y
    :   Use the maximum Y value

        Type:
        :   boolean, default False

    use_max_z
    :   Use the maximum Z value

        Type:
        :   boolean, default False

    use_min_x
    :   Use the minimum X value

        Type:
        :   boolean, default False

    use_min_y
    :   Use the minimum Y value

        Type:
        :   boolean, default False

    use_min_z
    :   Use the minimum Z value

        Type:
        :   boolean, default False

    use_transform_limit
    :   Transform tools are affected by this constraint as well

        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: Provide the full official documentation entry for Drawing Tools, preserving all code examples.

assistant: # Drawing Tools

[image reference removed]

Cursor
:   Change the location of the 3D Cursor.

[Brush](tools/brush.xhtml)
:   Tool to use for any of the [drawing brushes](brushes/draw.xhtml).

[Erase](tools/erase.xhtml#tool-grease-pencil-draw-erase)
:   Erase strokes.

[Fill](tools/fill.xhtml#tool-grease-pencil-draw-fill)
:   Automatic fill closed strokes areas.

[Box](tools/box.xhtml#tool-grease-pencil-draw-box)
:   Draw rectangular shapes.

    [Circle](tools/circle.xhtml#tool-grease-pencil-draw-circle)
    :   Draw oval shapes.

    [Line](tools/line.xhtml#tool-grease-pencil-draw-line)
    :   Draw straight lines.

    [Polyline](tools/polyline.xhtml#tool-grease-pencil-draw-polyline)
    :   Draw straight multiple lines.

    [Arc](tools/arc.xhtml#tool-grease-pencil-draw-arc)
    :   Draw simple arcs.

    [Curve](tools/curve.xhtml#tool-grease-pencil-draw-curve)
    :   Draw complex Bézier style curves.

[Trim](tools/trim.xhtml#tool-grease-pencil-draw-trim)
:   Cut strokes in between others.

[Eyedropper](tools/eyedropper.xhtml#tool-grease-pencil-draw-eyedropper)
:   Eyedropper to create new materials or palette color based on sampled colors in the 3D Viewport.

[Interpolate](tools/interpolate.xhtml#tool-grease-pencil-draw-interpolate) `Ctrl`-`E`
:   Automatically create a breakdown keyframe between two normal keyframes.
user: Give a detailed overview of limbs.paw: syntax, arguments, return values, common patterns.

assistant: Will create a fully featured bendy and stretchy paw depending on the user-defined options.

Requirement: A chain of four or five connected bones (thigh, shin, paw, *optional* digit, toe).

[image reference removed]

Front/Rear paw required bones.

Rotation Axis (Automatic, X, Z)
:   Defines the bend axis for the IK chain. FK chains will have a totally free degree of rotation on all axes.

Limb Segments (integer)
:   Defines the number of additional tweak controls each limb bone will have on the final rig.

B-Bone Segments (integer)
:   Defines the number of b-bone segments each tweak control will be split into.

Custom IK Pivot
:   Generates an extra control for the end of the IK limb that allows rotating it around an arbitrarily placed pivot.

Assign FK Layers
:   If enabled, allows placing the FK chain in different bone collections from the IK bones.

Assign Tweak Layers
:   If enabled, allows placing the Tweak controls in different bone collections from the IK bones.
user: Show practical ways to work with Output in a Blender add-on or script – include code.

assistant: Mesh
:   Standard geometry output.

Top
:   A boolean field indicating the “top” elements in the extrusion. In *Vertex* mode, these are the new vertices;
    in *Edge* mode, the new edges; and in *Face* mode, the moved faces.

Side
:   A boolean field indicating the “side” elements in the extrusion. In *Vertex* mode, these are the new edges;
    in *Edge* mode, the new faces; and in *Face* mode, too, the newly generated faces (as opposed to the moved ones).
user: Show practical ways to work with TextureNodeTexDistNoise(TextureNode) in a Blender add-on or script – include code.

assistant: # TextureNodeTexDistNoise(TextureNode)

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

*class* bpy.types.TextureNodeTexDistNoise(*TextureNode*)
:   *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 Properties: syntax, arguments, return values, common patterns.

assistant: The *Evaluate Closure* node does not have functional properties, but its input and output interface can be managed in
the *Node* tab of the Sidebar.

Sync Sockets
:   Updates the current node to match the socket signature of the connected nodes.
    Use this after renaming, adding, or removing sockets.

Define Signature
:   Marks the node as defining a closure signature to be used by other closure nodes. Ensures consistent input and output
    definitions across related closures.

### Input Items

List of input sockets
:   Displays one entry per socket defined in the closure. Double-click to rename.

Add Item
:   Add a new input socket to the closure interface.

Remove Item
:   Delete the selected input socket.

Type
:   The data type for the selected socket (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value field appears and is used when the socket is unlinked.

Shape
:   Defines the data structure supported by the input socket, such as a *Single* value, *Field*, or *Grid*.
    The shape determines how the data is evaluated and passed through the node network.
    See [Socket Shape](../../../../interface/controls/nodes/parts.xhtml#interface-controls-nodes-socket-shape) for more information.

### Output Items

List of output sockets
:   Displays one entry per output socket. Double-click to rename.

Add Item
:   Add a new output socket to the node.

Remove Item
:   Delete the selected output socket.

Type
:   The data type for the selected socket (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value field appears and is used when the socket is unlinked.
user: Give a detailed overview of Fast GI Approximation: syntax, arguments, return values, common patterns.

assistant: Fast GI Approximation is a fallback to the ray-tracing pipeline for
BSDF with high roughness.
It produces a less noisy output and captures bounce lighting more efficiently than individually traced rays.

This is currently implemented as a screen space effect and will inherit all associated
[limitations](../limitations/limitations.html#eevee-limitations-screenspace).

Threshold
:   Maximum roughness a BSDF can have to use ray-tracing.
    BSDFs with higher roughness will progressively use the *Fast GI Approximation*.
    A value of 1 will raytrace every surfaces and disable the Fast GI.

Method
:   Determine the method used to compute the fast GI approximation.

    Ambient Occlusion:
    :   Use scene intersections to shadow the distant lighting from light-probes.
        This is the fastest option.

    Global Illumination:
    :   Compute global illumination taking into account light bouncing off surrounding objects.

Resolution
:   Resolution at which the fast GI is computed.
    Lower options will be faster and use less memory but will produce blurrier results.

Rays
:   Number of GI rays per pixel at the specified *Resolution*.
    Higher values will reduce noise.

Steps
:   Number of screen samples per GI ray.
    Higher values will reduce the noise amount and increase the quality.

Precision
:   Higher values increase the precision of the scene intersections with the GI rays.
    Increased precision also increases performance cost.

Distance
:   If non-zero, the maximum distance at which other surfaces will contribute to the fast GI approximation.

Thickness Near
:   Geometric thickness of the surfaces when computing fast GI and ambient occlusion.
    Reduces light leaking and missing contact occlusion.
    The effectiveness decreases proportionally to the distance from the shading point,
    following the inverse square law.

Far
:   Angular thickness of the surfaces when computing fast GI and ambient occlusion.
    Reduces energy loss and missing occlusion of far geometry.
    Higher values will make the very thin objects block or reflect too much light.

Bias
:   Bias the shading normal to reduce self intersection artifacts.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Color
:   Color of the emitted light.

Strength
:   Strength of the emitted light. For point and area lights, the unit is Watts.
    For materials, a value of 1.0 will ensure that the object in the image has
    the exact same color as the Color input, i.e. make it ‘shadeless’.
user: What is Color Picker and how is it used in Blender Python scripting?

assistant: Color

Brushes have two colors that can be set using the [Color Picker](../../interface/controls/templates/color_picker.xhtml#ui-color-picker):

- **Primary Color**: The active color used for painting by default.
- **Secondary Color**: An alternate color that can be quickly accessed.

By default, painting uses the primary color. The secondary color can be used temporarily by holding `Ctrl` while
painting. The two colors can also be swapped at any time using
[Swap Colors](#bpy-ops-paint-brush-colors-flip).

(Swap Colors) `X`
:   Swaps the primary and secondary colors.

(Use Unified Color)
:   Use the same brush color across all brushes.

Gradient

A gradient can be used as a color source.

Gradient Colors
:   The [Color Ramp Widget](../../interface/controls/templates/color_ramp.xhtml#ui-color-ramp-widget) to define the gradient colors.

Mode
:   Pressure:
    :   Will choose a color from the color ramp according to the stylus pressure.

    Clamp:
    :   Will alter the color along the stroke and as specified by *Gradient Spacing* option.
        With *Clamp* it uses the last color of the color ramp after the specified gradient.

    Repeat:
    :   Similar to *Clamp*. After the last color it resets the color to the first color in the color ramp and
        repeats the pattern.

### Randomize Color

Applies random variation to the brush color for more natural and varied strokes.
Useful for hand-painting textures or adding subtle irregularities.

The randomness can affect hue, saturation, and value independently.
Each channel also supports pressure sensitivity and stroke-based randomness.

Hue
:   Amount of random variation applied to the hue of the brush color.

    (Stroke Random)
    :   Apply a single random hue per stroke instead of varying continuously during the stroke.

    (Use Pressure)
    :   Modulate hue variation based on pen pressure.

Saturation
:   Amount of random variation applied to the saturation of the brush color.

    (Stroke Random)
    :   Apply a single random saturation per stroke instead of varying continuously during the stroke.

    (Use Pressure)
    :   Modulate saturation variation based on pen pressure.

Value
:   Amount of random variation applied to the value (brightness) of the brush color.

    (Stroke Random)
    :   Apply a single random value per stroke instead of varying continuously during the stroke.

    (Use Pressure)
    :   Modulate value variation based on pen pressure.
user: What is Mark Seam and how is it used in Blender Python scripting?

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

Seamed Suzanne.

To add an edge to a seam, simply select the edge and press `Ctrl`-`E` to *Mark Seam*,
or to remove it, use `Ctrl`-`E` to *Clear Seam*.

In the example to the right, the back-most edge of the cylinder was selected as the seam
(to hide the seam), and the default unwrap calculation was used.
In the UV Editor, you can see that all the faces are nicely unwrapped,
just as if you cut the seam with a scissors and spread out the fabric.

When marking seams, you can use [Select Linked](../../selecting/linked.html#bpy-ops-mesh-select-linked)
in Face Select Mode to check your work.
This menu option selects all faces connected to the selected one, up to a seam.
If faces outside your intended seam are selected, you know that your seam is not continuous.
You do not need continuous seams, however, as long as they resolve regions that may stretch.

Just as there are many ways to skin a cat, there are many ways to go about deciding where seams should go.
In general though, you should think as if you were holding the object in one hand, and a pair of
sharp scissors in the other, and you want to cut it apart and spread it on the table with as little
tearing as possible. Note that we seamed the outside edges of her ears, to separate the front from the back.
Her eyes are disconnected sub-meshes, so they are automatically unwrapped by themselves.
A seam runs along the back of her head vertically, so that each side of her head is flattened out.

Another use for seams is to limit the faces unwrapped. For example, when texturing a head, you
do not really need to texture the scalp on the top and back of the head since it will be
covered in hair. So define a seam at the hairline. Then, when you select a frontal face,
and then select linked faces before unwrapping,
the select will only go up to the hairline seam, and the scalp will not be unwrapped.

When unwrapping anything that is bilateral, like a head or a body, seam it along the mirror axis.
For example, cleave a head or a whole body right down the middle in front view. When you unwrap,
you will be able to overlay both halves onto the same [Texture Space](../../../../glossary/index.html#term-Texture-Space),
so that the image pixels for the right hand will be shared with the left;
the right side of the face will match the left, etc.

### Seams from Islands

Adds seams at the boundaries of existing UV islands.
This is useful when modifying the UVs of already unwrapped meshes.
user: How do I use Rendering in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Depth Buffer Glitches

Sometimes when setting a large [clipping range](../editors/3dview/sidebar.html#bpy-types-spaceview3d-clip-start) will allow you to see both
near and far objects, but reduces the depth precision resulting in artifacts.

|  |  |  |
| --- | --- | --- |
| <../_images/troubleshooting_3d-view_graphics-z-fighting-none.png>   Model with no clipping artifacts. | <../_images/troubleshooting_3d-view_graphics-z-fighting-example.png>   Model with clipping artifacts. | <../_images/troubleshooting_3d-view_graphics-z-fighting-example-editmode.png>   Mesh with artifacts in Edit Mode. |

To avoid this:

- Increase the near clipping when working on large scenes.
- Decrease the far clipping when objects are not viewed at a distance.

When perspective is disabled only the far Clip End is used, very high values can still result in artifacts. This is
**not** specific to Blender, all graphics applications have these same limitations.

### Objects Invisible in Camera View

If you have a large scene, viewing it through Camera View may not display all of the objects in the scene. One
possibility may be that the [clipping distance](../render/cameras.html#camera-clipping) of the camera is too low. The camera will only
show objects that fall within the clipping range.
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Here, the selection outputs are used to set materials on certain faces of the mesh.
A [Random Value Node](../../utilities/random_value.xhtml) is used to limit the
extrusion to a random set of faces.
user: Explain String to Curves Node in complete detail according to the official Blender documentation.

assistant: # String to Curves Node

[image reference removed]

The *String to Curves* node converts a string to curve instances. Each unique character used in the string
is converted to a curve once, and further uses of that character are instances of the same geometry.
The name of each instance geometry is the character it represents.

This makes processing the output geometry very efficient, because each unique character
only has to be processed once. However, it means that the result will be the same
for every instance of the same character. To process each character individually,
the [Realize Instances Node](../../instances/realize_instances.html) can be used.
user: Describe Inherited Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleColorModifier.name`](bpy.types.LineStyleColorModifier.html#bpy.types.LineStyleColorModifier.name "bpy.types.LineStyleColorModifier.name") |
user: How do I use Delete Active Keyframe (Active Layer) in Blender? Include parameters, examples, warnings and best practices.

assistant: Deletes the last keyframe in the Dope Sheet or the current keyframe if you are on one.

Type
:   Pick which layer to delete keyframes.

    Active Frame:
    :   Deletes current frame in the active layer.

    All Active Frames:
    :   Delete active frames for all layers.
user: Give a detailed overview of NodeTreeInterfaceSocketVectorPercentage(NodeTreeInterfaceSocket): syntax, arguments, return values, common patterns.

assistant: # NodeTreeInterfaceSocketVectorPercentage(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.NodeTreeInterfaceSocketVectorPercentage(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 3 items in [-inf, inf], default (0.0, 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 Scenes as Assets from the Blender manual or Python API, including usage steps and snippets.

assistant: Scenes can also be marked and used as [Assets](../../files/asset_libraries/index.xhtml).
This allows them to appear in the [Asset Browser](../../editors/asset_browser.xhtml) for reuse across projects.

Scene assets are a convenient way to manage pre-built scene templates, lighting rigs, or shot setups.
They store all relevant data (such as cameras, lights, and render settings) and can be dragged into any open Blender file.

When a scene asset is dragged into another window (except the Asset Browser itself),
Blender performs one of the following actions:

- **Link or Append:** Imports the scene into the current blend-file as a linked or appended data-block.
- **Activate:** Sets the imported (or linked) scene as the *active* one in the window.

Scene assets generate preview images automatically by rendering from the active camera in *Solid View* mode.
For this to work, the scene must contain an active camera.

Typical uses for scene assets include:

- Creating reusable lighting or studio setups.
- Storing shot layouts for multi-shot projects.
- Maintaining consistent render settings across files.
- Building base templates for new projects or departments.
user: Describe Fluid from the Blender manual or Python API, including usage steps and snippets.

assistant: # Fluid

[image reference removed]

Fluid Physics settings.

Fluid particles are similar to Newtonian ones but this time particles are influenced by
internal forces like pressure, surface tension, viscosity, springs, etc.
From liquids to slime, goo to sand and wispy smoke the number of possible use cases is endless.

Blender particle fluids use the SPH techniques to solve the particles fluid equations.
Smoothed-particle hydrodynamics (SPH) is a computational method used for simulating fluid flows.
It has been used in many fields of research, including astrophysics, ballistics, vulcanology,
and oceanography. It is a mesh-free Lagrangian method (where the coordinates move with the fluid),
and the resolution of the method can easily be adjusted with respect to variables such as the density.
user: How do I use Metaball Primitives in Blender? Include parameters, examples, warnings and best practices.

assistant: # Metaball Primitives

There are five predefined metaball “primitives” (or configurations)
available in the Add ‣ Metaball submenu:

[[image reference removed]](../../_images/modeling_metas_primitives_all-five.png)

The five Metaball primitives.
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

A Surface is a smooth sheet that’s defined by a set of control points.
It’s an extension of a [Curve](../curves/introduction.html),
which is a smooth line.

[image reference removed]

Surface in Edit Mode.

The control points are arranged in a grid with yellow lines indicating
the rows (U direction) and pink lines the columns (V direction).
The surface can be open or closed (cyclic) in either or both directions,
which allows the creation of, say, a cylinder or a sphere.

A Surface can be converted to a mesh using the menu item
Object ‣ Convert ‣ Mesh or the context menu item
Convert To ‣ Mesh.
user: Describe Misc from the Blender manual or Python API, including usage steps and snippets.

assistant: Banking
:   Amount of rotation around velocity vector on turns. Banking of 1.0 gives a natural banking effect.

Pitch
:   Amount of rotation around side vector.

Height
:   Boid height relative to particle size.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Curves
:   The input geometry containing the curves whose control points will be redistributed.

Factor
:   Controls the strength of the redistribution effect.
    A value of 0.0 leaves the curves unchanged, while 1.0 fully applies even spacing.

Feature Awareness
:   Enables a simple feature-preserving algorithm that attempts to maintain
    local curve features and direction changes while redistributing points.
    This helps keep detailed areas or sharp bends more accurate.
user: Describe Brush Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: # Brush Settings

[image reference removed]

Brush settings panel.

Information on brush settings for every mode can be found in these pages:

[Brush](../../brush/brush_settings.xhtml)
:   General and advanced settings.

[Texture](../../brush/texture.xhtml)
:   Color and mask texture settings.

[Stroke](../../brush/stroke.xhtml)
:   Stroke methods and settings.

[Falloff](../../brush/falloff.xhtml)
:   Falloff curves and settings.

[Cursor](../../brush/cursor.xhtml)
:   Cursor and appearance settings.
user: Describe Precision from the Blender manual or Python API, including usage steps and snippets.

assistant: Holding `Shift` during transformations allows for very fine control that does not
rely on fixed increments. Rather, large movements of the mouse across
the screen only result in small transformations of the selection.

In rotation mode the selected element will be rotate in 0.01 degree increments.
user: Show practical ways to work with GeometryNodeFlipFaces(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeFlipFaces(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.GeometryNodeFlipFaces(*GeometryNode*)
:   Reverse the order of the vertices and edges of selected faces, flipping their normal direction

    *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