PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is Set Pivot and how is it used in Blender Python scripting?

assistant: Like Object and Edit Mode, Sculpt Mode also has a [Pivot Point](../../../glossary/index.xhtml#term-Pivot-Point).
This is because the basic [move, rotate and scale](../tools/transforms.xhtml)
transforms are also supported in Sculpt Mode.
But the pivot point in Sculpt Mode is unique. It always moves together with the transformed mesh
and can be both manually & automatically placed.

Origin
:   Sets the pivot to the origin of the sculpt.

Unmasked
:   Sets the pivot position to the average position of the unmasked vertices.

Mask Border
:   Sets the pivot position to the center of the mask’s border.
    This operation will automatically happen when using [Expand](expand.xhtml#bpy-ops-sculpt-expand).

Active Vertex
:   Sets the pivot position to the active vertex position.

Surface `Shift`-`RMB`
:   Sets the pivot position to the surface under the cursor.
user: How do I use Subdivision Surface Modifier in Blender? Include parameters, examples, warnings and best practices.

assistant: # Subdivision Surface Modifier

The *Subdivision Surface* modifier (often shortened as slang to “Subdiv” or “Subsurf”)
is used to split the faces of a mesh into smaller faces, giving it a smooth appearance.
It enables you to create complex smooth surfaces while modeling simple, low-vertex meshes.
It avoids the need to save and maintain huge amounts of data,
and gives a smooth “organic” look to the object.

As with any modifier, order of execution (position in the [modifier stack](../introduction.xhtml#modifier-stack))
has an important bearing on the results.

Keep in mind that this is a different operation than its companion,
[Smooth Shading](../../meshes/editing/mesh/shading.xhtml#modeling-meshes-editing-normals-shading).
You can see the difference between the two in the grid image below.

[image reference removed]

Subdivision levels 0 to 3, without and with Smooth Shading.
user: Provide the full official documentation entry for MeshSkinVertexLayer(bpy_struct), preserving all code examples.

assistant: # MeshSkinVertexLayer(bpy_struct)

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

*class* bpy.types.MeshSkinVertexLayer(*bpy_struct*)
:   Per-vertex skin data for use with the Skin modifier

    data
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`MeshSkinVertex`](bpy.types.MeshSkinVertex.html#bpy.types.MeshSkinVertex "bpy.types.MeshSkinVertex"), (readonly)

    name
    :   Name of skin layer

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Concept, preserving all code examples.

assistant: When an image is convolved with a kernel, the kernel is centered over each pixel in the image.
Each pixel in the neighborhood is multiplied by the corresponding kernel value, and the results
are summed to form the output pixel color.
The process repeats for every pixel in the image.

The kernel values can be positive, negative, or fractional,
and their pattern determines the effect produced.
user: How do I use The Armature Object in Blender? Include parameters, examples, warnings and best practices.

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

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

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

In *Edit Mode*, you will always see your armature in rest position,
whereas in *Object Mode* and *Pose Mode*,
you usually get the current “pose” of the armature
(unless you enable the *Rest Position* button of the *Armature* panel).
user: How do I use Channels Region in Blender? Include parameters, examples, warnings and best practices.

assistant: The Channels region shows the Grease Pencil object in light blue and its
[layers](../../../grease_pencil/properties/layers.xhtml) in gray.
Layers have the following settings:

Opacity
:   The layer’s [opacity](../../../grease_pencil/properties/layers.xhtml#bpy-types-greasepencillayer-opacity).

Use Mask
:   Toggle the layer’s [masks](../../../grease_pencil/properties/layers.xhtml#bpy-types-greasepenciltreenode-use-masks) on or off.

Onion Skinning
:   Toggle [onion skinning](../../../grease_pencil/properties/onion_skinning.xhtml).

Visibility (eye icon)
:   Toggle layer visibility in the viewport and in render.

Show all keyframes (checkbox)
:   When unchecked, the layer gets frozen in its current state, and moving to
    a different keyframe will no longer change its appearance.

Lock (padlock)
:   Locked layers can’t be edited.
user: Show practical ways to work with Adaptive Subdivision in a Blender add-on or script – include code.

assistant: Cycles Only

Adaptive Subdivision
:   Subdivide objects based on their distance to the camera, automatically adding more or less
    detail. Particularly useful for fine displacement detail.

Adaptive Space
:   Pixel:
    :   Subdivide polygons to reach a specified pixel size on screen.

    Object:
    :   Subdivide to reach a specified edge length in object space. This is required to use
        adaptive subdivision for instanced meshes.

Pixel Size
:   Target polygon pixel size for adaptive subdivision.

Edge Length
:   Target object space edge length.

### Limitations

- Multi-view renders can have some inconsistencies between views.
- Instancing does not work well with Pixel space subdivision. Subdivision will be
  based on the original object position relative to the camera, and it is recommended
  to use Object space instead.
user: Give a detailed overview of Offset Corner in Face Node: syntax, arguments, return values, common patterns.

assistant: # Offset Corner in Face Node

[image reference removed]

Retrieves another corner in the same face as the input corner.
This is like “rotating” the input corner around in its face.

Conceptually the operation is similar to the
[Offset Point in Curve Node](../../curve/topology/offset_point_in_curve.html).
user: What is ShaderNodeBlackbody(ShaderNode) and how is it used in Blender Python scripting?

assistant: # ShaderNodeBlackbody(ShaderNode)

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

*class* bpy.types.ShaderNodeBlackbody(*ShaderNode*)
:   Convert a blackbody temperature to an RGB value

    *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 Header and how is it used in Blender Python scripting?

assistant: See [Nodes](../../interface/controls/nodes/index.xhtml) for the header items common to
all node editors.

Texture Type
:   World
    :   Deprecated – the scene’s [World Environment](../../render/lights/world.xhtml) is now defined using
        a Material rather than a Texture.

    Brush
    :   Show brush Textures in the data-block menu. Because the other two types are deprecated,
        this effectively shows all Textures.

    Line Style
    :   Deprecated – [Line Styles](../../render/freestyle/view_layer/line_style/index.xhtml)
        for the Freestyle renderer are now defined using Materials rather than Textures.
user: Provide the full official documentation entry for Settings, preserving all code examples.

assistant: # Settings

General settings for Grease Pencil strokes.

[image reference removed]

Settings panel.

Stroke Depth Order
:   Defines how the strokes are ordered in 3D space (for objects not displayed *In Front*).

    2D Layers:
    :   The Strokes drawing order respect the order of the 2D layers list (top to bottom)
        and ignores the real position of the strokes in 3D space.
        See [2D Layers](layers.xhtml) for more information.

    3D Location:
    :   The strokes drawing order is based on the stroke location in 3D space.

    |  |  |
    | --- | --- |
    | ../../_images/grease-pencil_properties_strokes_depth-order-2d.png   Blue, Green and Red strokes in three different layers using 2D Layers depth order. | ../../_images/grease-pencil_properties_strokes_depth-order-3d.png   Blue, Green and Red strokes in three different layers using 3D Location depth order. |
user: Describe Radius Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Radius Node

[image reference removed]

The *Radius* node outputs the radius value at each point on the evaluated geometry.
For curves, this value is used for things like determining the size of the mesh created in
the [Curve to Mesh](../../curve/operations/curve_to_mesh.xhtml) node.
For point clouds, the value is used for the display size of the point in the viewport.
user: How do I use Evaluate Closure in Blender? Include parameters, examples, warnings and best practices.

assistant: # Evaluate Closure

[image reference removed]

The *Evaluate Closure* node executes a connected [Closure Zone](closure.html).
It acts as the *call site* of the closure, running its internal node graph and returning the resulting values.

Closures enable dynamic and customizable node groups by allowing users to pass procedural logic into another node tree.
When the *Evaluate Closure* node runs, the connected closure is evaluated within the current context, matching its input
and output sockets by name.

Common uses for the *Evaluate Closure* node include:

- Allowing user-defined behaviors inside procedural systems (e.g. custom scattering, placement rules, or shading logic).
- Injecting logic into reusable node groups for advanced effects.
- Providing optional customization inputs for high-level node-based tools.
user: How do I use Interactive Mirror in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Mirror* operator flips the selected elements across a chosen axis.
Mirroring is equivalent to scaling the selection by -1 along the selected axis,
but it offers a faster and more direct workflow.

The mirror is relative to the [Transformation Orientation](../../../../editors/3dview/controls/orientation.xhtml)
and [Pivot Point](../../../../editors/3dview/controls/pivot_point/index.xhtml)
This gives full control over how and where the mirroring occurs, for example:

- Position the pivot point wherever you want the center of symmetry.
- Choose a transformation orientation (e.g. *Global*, *Local*, *Normal*).
- Select an axis (X, Y, or Z) along which to mirror.

### Usage

To mirror along a specific axis:

- Press `Ctrl`-`M`, then `X`, `Y`, or `Z` to select an axis.
- Pressing the same key again toggles the orientation between the active
  [Transform Orientation](../../../../editors/3dview/controls/orientation.xhtml) and the global orientation.
- Hold `MMB` and drag to mirror interactively in the desired direction.

### Properties

Orientation
:   The [Transform Orientation](../../../../editors/3dview/controls/orientation.xhtml) used to align the X, Y, and Z axes.

Constraint Axis
:   The axis (or axes) to mirror across.
    For example, mirroring across the X axis flips the selection horizontally.
user: How do I use Example in Blender? Include parameters, examples, warnings and best practices.

assistant: We will begin with a very simple example: the default cube.

- To judge the effect of the external forces you should at first turn off the *Goal*,
  so that the vertices are not retracted to their original position.
- Start playback to run the simulation.

What happens? The cube moves in negative Z direction.
Each of its eight vertices is affected by a global, constant force – the gravitation.
Gravitation without friction is independent from the weight of an object,
so each object you would use as a soft body here would fall with the same acceleration.
The object does not deform, because every vertex moves with the same speed in the same direction.
user: Give a detailed overview of Set Curve Tilt Node: syntax, arguments, return values, common patterns.

assistant: # Set Curve Tilt Node

[image reference removed]

The *Set Curve Tilt* controls the tilt angle at each curve control point.
That angle rotates normal vector which is generated at each point
when evaluating the curve. The normal then can be retrieved with
the [Normal Node](../../geometry/read/normal.xhtml).

The rotation of the normal vector is an [Axis Angle](../../../../glossary/index.xhtml#term-Axis-Angle) rotation.
It is the same as the [Vector Rotate Node](../../utilities/vector/vector_rotate.xhtml) operation
with the tangent vector as the axis, the raw evaluated normal is used as
the original vector, and the tilt as the rotation angle.

The input node for this data is the [Curve Tilt Node](../read/curve_tilt.xhtml).
user: What is Gravity and how is it used in Blender Python scripting?

assistant: Factor
:   Setting the factor allows you to add gravity to your brush strokes,
    giving it a draping effect.

Orientation
:   Using another object, the gravity can be oriented to the set object’s local Z axis,
    changing the direction of the gravity.
user: What is Velocity and how is it used in Blender Python scripting?

assistant: [image reference removed]

Velocity panel.

This panel shows brush options that are based on object velocity.

On top you have a color ramp and several related settings.
Basically the color ramp represents brush velocity values:
left side being zero velocity and right side being the “Max velocity”.
Speed is measured in “units per frame”.

Checkboxes above can be used to define color ramp influence.

Multiply Alpha
:   Uses color ramp’s alpha value depending on current velocity and multiplies brush alpha with it.

Replace Color
:   Replaces the brush color with the values from the [Color Ramp Widget](../../interface/controls/templates/color_ramp.html#ui-color-ramp-widget).

Multiply Depth
:   Multiplies brushes “depth intersection” effect.
    Basically you can adjust displace and wave strength depending on brush speed.

Do Smudge
:   Enabling Smudge makes the brush “smudge” (or “smear”) existing colors on the surface as it moves.
    The strength of this effect can be defined from the *Smudge Strength* property.

    Even when smudge is enabled brush still does its normal paint effect.
    If you want a purely smudging brush use zero alpha.
    It is also possible to have *Erase* option enabled together with smudge.
user: Give a detailed overview of Workflow: syntax, arguments, return values, common patterns.

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

To avoid doubling up transforms, it is recommended to:

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

The compositor will then output colors in the
[working space](../../../render/color_management/color_spaces.xhtml#bpy-types-blendfilecolorspace-working-space) as usual,
but with color grading baked in. Unlike workflows using the Raw view
transform, this works correctly with the video sequencer and OpenEXR output.
user: Show practical ways to work with L in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [**Lattice**](glossary/index.html#term-Lattice) - [Licenses](advanced/extensions/licenses.html#index-0) | - [**Light Bounces**](glossary/index.html#term-Light-Bounces) - [**Local Space**](glossary/index.html#term-Local-Space) - [**Luminance**](glossary/index.html#term-Luminance) |
user: How do I use Acceleration Structure in Blender? Include parameters, examples, warnings and best practices.

assistant: Use Spatial Splits
:   Spatial splits improve the rendering performance in scenes with a mix of large and small polygons.
    The downsides are longer BVH build times and slightly increased memory usage.

Use Curves BVH
:   Use a special type of [BVH](../../../glossary/index.xhtml#term-BVH) for rendering curves.
    The bounding boxes are not axis aligned allowing a spatially closer fit to the curve geometry.
    Disabling this option will reduce memory, at the cost of increasing curve render time.

BVH Time Steps
:   Split BVH primitives by this number of time steps to speed up render time at the expense of memory.

Use Compact BVH
:   Use a more compact BVH structure, which can reduce RAM usage but render slower.
user: Describe Interpolation from the Blender manual or Python API, including usage steps and snippets.

assistant: Keyframe interpolation is represented and controlled by
[animation curves](../../editors/graph_editor/fcurves/introduction.html),
also known as [F-Curves](../../glossary/index.html#term-F-Curve). These curves can be viewed and modified
via the [Graph Editor](../../editors/graph_editor/index.html).

[image reference removed]

Constant, Linear, Quadratic and Bézier interpolation, with Linear extrapolation.

The X axis of the curve corresponds to time, while Y represents the value of the property.
Keyframes themselves define points of the curve, while interpolation is controlled by additional parameters.

The [Interpolation Mode](../../editors/graph_editor/fcurves/properties.html#editors-graph-fcurves-settings-interpolation) is the main setting
that specifies for each keyframe how the curve is interpolated from that key to
the next one. There are a number of modes with fixed shapes,
e.g. *Constant*, *Linear*, *Quadratic* etc, and a free form *Bézier* mode.

[Extrapolation](../../editors/graph_editor/channels/editing.html#editors-graph-fcurves-settings-extrapolation) specifies how
the curve extends before the first, and after the last keyframe.
The main available choices are *Constant* and *Linear*;
it is also possible to configure the curve to loop.

*Bézier* interpolation is controlled by handles, which have
a [handle type](../../editors/graph_editor/fcurves/properties.html#editors-graph-fcurves-settings-handles) and position.
The position of *Free* and *Aligned* handles must be set manually from the Graph editor,
while *Vector*, *Automatic* and *Auto Clamped* handles are computed automatically from
keyframe values.

Interpolation, Extrapolation and Handle Type can also be changed from
the [Dope Sheet](../../editors/dope_sheet/index.html) editor.

[image reference removed]

Handle smoothing modes. Red: *None*, Green: *Continuous Acceleration*.

The method how the three automatic handle types are computed is controlled by
the per-curve [Auto Handle Smoothing](../../editors/graph_editor/fcurves/properties.html#bpy-types-fcurve-auto-smoothing) setting.
The *None* mode resembles how most other software works and only considers the values
of the immediately adjacent keys. The *Continuous Acceleration* mode considers the shape
of the whole curve, which produces smoother results out of the box, but means that changes
in one key affect interpolation over a larger section of the curve; it also tends to
overshoot more with *Automatic* handles.
user: What is Usage and how is it used in Blender Python scripting?

assistant: Even with a correct compositing setup with Image, Z and Speed nodes all linked to the appropriate passes,
there may still be artifacts. The 2D render passes does not contain 3D information,
and so the information what is behind a moving object or outside the camera view is lost.

Better results can be achieved by rendering the scene into multiple render layers,
applying vector blur to each render layer, and then compositing the results together.
Typically an animated character would be rendered in a separate render layer than the background set.
Especially if hair or transparency is involved this is important.

For other artifacts it can help to slightly blur the Speed pass or to set a Maximum Speed limit.
This helps to smoothen out the motion, but too much blurring leads to its own problems.
user: What is PoseBone(bpy_struct) and how is it used in Blender Python scripting?

assistant: ive’
        but saved generating a list.

    translate(*vec*)
    :   Utility function to add *vec* to the head and tail of this bone.

    *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 RaytraceEEVEE(bpy_struct), preserving all code examples.

assistant: # RaytraceEEVEE(bpy_struct)

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

*class* bpy.types.RaytraceEEVEE(*bpy_struct*)
:   Quality options for the raytracing pipeline

    denoise_bilateral
    :   Blur the resolved radiance using a bilateral filter

        Type:
        :   boolean, default True

    denoise_spatial
    :   Reuse neighbor pixels’ rays

        Type:
        :   boolean, default True

    denoise_temporal
    :   Accumulate samples by reprojecting last tracing results

        Type:
        :   boolean, default True

    resolution_scale
    :   Determines the number of rays per pixel. Higher resolution uses more memory.

        - `1`
          1:1 – Full resolution.
        - `2`
          1:2 – Render this effect at 50% render resolution.
        - `4`
          1:4 – Render this effect at 25% render resolution.
        - `8`
          1:8 – Render this effect at 12.5% render resolution.
        - `16`
          1:16 – Render this effect at 6.25% render resolution.

        Type:
        :   enum in [`'1'`, `'2'`, `'4'`, `'8'`, `'16'`], default `'2'`

    screen_trace_quality
    :   Precision of the screen space ray-tracing

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

    screen_trace_thickness
    :   Surface thickness used to detect intersection when using screen-tracing

        Type:
        :   float in [1e-06, inf], default 0.2

    trace_max_roughness
    :   Maximum roughness to use the tracing pipeline for. Higher roughness surfaces will use fast GI approximation. A value of 1 will disable fast GI approximation.

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

    use_denoise
    :   Enable noise reduction techniques for raytraced effects

        Type:
        :   boolean, default True

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

assistant: |  |  |
| --- | --- |
| - [`bpy.context.particle_system`](bpy.context.html#bpy.context.particle_system "bpy.context.particle_system") - [`bpy.context.particle_system_editable`](bpy.context.html#bpy.context.particle_system_editable "bpy.context.particle_system_editable") - [`DepsgraphObjectInstance.particle_system`](bpy.types.DepsgraphObjectInstance.html#bpy.types.DepsgraphObjectInstance.particle_system "bpy.types.DepsgraphObjectInstance.particle_system") - [`DynamicPaintBrushSettings.particle_system`](bpy.types.DynamicPaintBrushSettings.html#bpy.types.DynamicPaintBrushSettings.particle_system "bpy.types.DynamicPaintBrushSettings.particle_system") - [`FluidFlowSettings.particle_system`](bpy.types.FluidFlowSettings.html#bpy.types.FluidFlowSettings.particle_system "bpy.types.FluidFlowSettings.particle_system") | - [`Object.particle_systems`](bpy.types.Object.html#bpy.types.Object.particle_systems "bpy.types.Object.particle_systems") - [`ParticleInstanceModifier.particle_system`](bpy.types.ParticleInstanceModifier.html#bpy.types.ParticleInstanceModifier.particle_system "bpy.types.ParticleInstanceModifier.particle_system") - [`ParticleSystemModifier.particle_system`](bpy.types.ParticleSystemModifier.html#bpy.types.ParticleSystemModifier.particle_system "bpy.types.ParticleSystemModifier.particle_system") - [`ParticleSystems.active`](bpy.types.ParticleSystems.html#bpy.types.ParticleSystems.active "bpy.types.ParticleSystems.active") |
user: Show practical ways to work with Node Compositor Extension Items in a Blender add-on or script – include code.

assistant: # Node Compositor Extension Items

CLIP:
:   Clip.

    Areas outside of the image are filled with zero.

EXTEND:
:   Extend.

    Areas outside of the image are filled with the closest boundary pixel in the image.

REPEAT:
:   Repeat.

    Areas outside of the image are filled with repetitions of the image.
user: Show practical ways to work with Bake Pass Type Items in a Blender add-on or script – include code.

assistant: # Bake Pass Type Items

COMBINED:
:   Combined.

AO:
:   Ambient Occlusion.

SHADOW:
:   Shadow.

POSITION:
:   Position.

NORMAL:
:   Normal.

UV:
:   UV.

ROUGHNESS:
:   ROUGHNESS.

EMIT:
:   Emission.

ENVIRONMENT:
:   Environment.

DIFFUSE:
:   Diffuse.

GLOSSY:
:   Glossy.

TRANSMISSION:
:   Transmission.
user: How do I use Face Set Gesture Tools in Blender? Include parameters, examples, warnings and best practices.

assistant: # Face Set Gesture Tools

Face Set gesture tools apply a single new Face Set to all faces within the selection area.

All Face Set gesture tools can be activated in the Toolbar and are comprised of the following:
user: What is TextureNodeCurveRGB(TextureNode) and how is it used in Blender Python scripting?

assistant: # TextureNodeCurveRGB(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.TextureNodeCurveRGB(*TextureNode*)
:   mapping
    :   Type:
        :   [`CurveMapping`](bpy.types.CurveMapping.html#bpy.types.CurveMapping "bpy.types.CurveMapping"), (readonly)

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Cycles Only

Adaptive Subdivision
:   Subdivide objects based on their distance to the camera, automatically adding more or less
    detail. Particularly useful for fine displacement detail.

Adaptive Space
:   Pixel:
    :   Subdivide polygons to reach a specified pixel size on screen.

    Object:
    :   Subdivide to reach a specified edge length in object space. This is required to use
        adaptive subdivision for instanced meshes.

Pixel Size
:   Target polygon pixel size for adaptive subdivision.

Edge Length
:   Target object space edge length.

### Limitations

- Multi-view renders can have some inconsistencies between views.
- Instancing does not work well with Pixel space subdivision. Subdivision will be
  based on the original object position relative to the camera, and it is recommended
  to use Object space instead.
user: Provide the full official documentation entry for Usage, preserving all code examples.

assistant: Use the tool by:

1. Orient the 3D Viewport to define the direction in depth.
2. `LMB` and hold while moving the cursor to define direction of the line projection.
3. Adjust the operation with extra *Controls* shortcuts.
4. Release `LMB` to confirm.
user: How do I use Gamma Cross Strip in Blender? Include parameters, examples, warnings and best practices.

assistant: # Gamma Cross Strip

The Gamma Cross transition is similar to the [Cross Strip](cross.xhtml) transition,
however, the Gamma Cross strip transition uses color correction while transitioning between the two strips,
resulting in a smoother transition that is easier on the eyes.
user: Describe CLIP_UL_tracking_objects(UIList) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CLIP_UL_tracking_objects(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.CLIP_UL_tracking_objects(*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: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Color
:   Color of the surface, or physically speaking, the probability that light is reflected for each wavelength.

Scale
:   Global scale factor for the scattering radius.

Radius
:   Average distance that light scatters below the surface.
    Higher radius gives a softer appearance, as light bleeds into shadows and through the object.
    The scattering distance is specified separately for the RGB channels,
    to render materials such as skin where red light scatters deeper.
    The X, Y and Z values are mapped to the R, G and B values, respectively.

IOR Cycles Only
:   Index of refraction for *Subsurface Scattering*.

Anisotropy Cycles Only
:   Directionality of subsurface scattering. Higher anisotropy scatters deeper into the object.

Roughness Cycles Only
:   Roughness of the glossy surface surrounding the subsurface volume.

Normal
:   Normal used for shading; if nothing is connected the default shading normal is used.
user: What is Proportional Falloff Curve Only Items and how is it used in Blender Python scripting?

assistant: # Proportional Falloff Curve Only Items

SMOOTH:
:   Smooth.

    Smooth falloff.

SPHERE:
:   Sphere.

    Spherical falloff.

ROOT:
:   Root.

    Root falloff.

INVERSE_SQUARE:
:   Inverse Square.

    Inverse Square falloff.

SHARP:
:   Sharp.

    Sharp falloff.

LINEAR:
:   Linear.

    Linear falloff.
user: How do I use Smooth Laplacian Modifier in Blender? Include parameters, examples, warnings and best practices.

assistant: # Smooth Laplacian Modifier

The *Smooth Laplacian* modifier allows you to reduce noise on a mesh’s surface with minimal changes to its shape.

It can also exaggerate the shape using a negative *Factor*.

The *Smooth Laplacian* is useful for objects that have been reconstructed from
the real world and contain undesirable noise. It removes noise while still
preserving desirable geometry as well as the shape of the original model.

This modifier is based on a curvature flow *Laplace Beltrami* operator in a diffusion equation.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: # Properties

Most bones’ properties (except the transform ones) are regrouped in each bone’s panels,
in the *Bones* tab in *Edit Mode*. Let us detail them.

Note that some of them are also available in the 3D Viewport,
through the three pop-up menus within the same entry:

- *Toggle Setting*: `Shift`-`W` or Armature ‣ Bone Settings ‣ Toggle a Setting
- *Enable Setting*: `Shift`-`Ctrl`-`W` or Armature ‣ Bone Settings ‣ Enable a Setting
- *Disable Setting*: `Alt`-`W` or Armature ‣ Bone Settings ‣ Disable a Setting

Display Wire
:   Always display the bone as wireframe.

Deform
:   (also `Shift`-`W` ‣ (Deform, …)).

Multiply Vertex Group by Envelope
:   (also `Shift`-`W` ‣ (Multiply Vertex Group by Envelope, …)).

    These settings control how the bone influences its geometry, along with the bones’ joints radius.
    This will be detailed in the [skinning part](../../skinning/index.xhtml).

Inherit Rotation
:   The bone automatically rotates together with its parent in *Pose Mode*. For more details,
    see the [relations page](../properties/relations.xhtml#bpy-types-editbone-parent).

Lock
:   (also `Shift`-`W` ‣ (Locked, …))
    This will prevent all editing of the bone in *Edit Mode*;
    see [bone locking](introduction.xhtml#animation-armatures-bones-locking).
user: What is Track Preview Widget and how is it used in Blender Python scripting?

assistant: The widget in this panel is called “Track Preview” and it displays the content of the pattern area.
This helps to check how accurately the feature is being tracked
(controlling that there is no sliding off original position)
and also helps to move the track back to the correct position.
The track can be moved directly using this widget by mouse dragging.

If an anchor is used
(the position in the image which is tracking is different from the position which is used for parenting),
a preview widget will display the area around the anchor position.
This configuration helps in masking some things when there is no good feature at position where
the mask corner should be placed. Details of this technique will be written later.

There is small area below the preview widget which can be used to enlarge the vertical size of
preview widget (the area is highlighted with two horizontal lines).
user: Explain Material Selection Node in complete detail according to the official Blender documentation.

assistant: # Material Selection Node

[image reference removed]

The *Material Selection* node provides a selection for meshes that use this material.
Since the `material_index` is stored on each face, the output will be implicitly interpolated to
a different domain when necessary. For example, every vertex connected to
a selected face will be selected.
user: Explain SurfaceModifier(Modifier) in complete detail according to the official Blender documentation.

assistant: # SurfaceModifier(Modifier)

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

*class* bpy.types.SurfaceModifier(*Modifier*)
:   Surface modifier defining modifier stack position used for surface fields

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

assistant: ### Non-Uniform Scale

A parent with non-uniform scale and rotation in relation to its child may cause a *shear* effect.

While this is supported by parenting, the shear will be lost when the parent is cleared since it
can’t be represented by location, scale and rotation.

If *Clear and Keep Transformation* moves the object, non-uniform scale is the most likely cause.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

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

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

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

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

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

Clamp Result (Color only)
:   Limit the Result to the range between 0.0 and 1.0.
user: Describe Command-line from the Blender manual or Python API, including usage steps and snippets.

assistant: Extensions can be built, validated & installed via command-line.

To build the package defined in the current directory use the following commands:

```
blender --command extension build
```

See [build](../command_line/extension_arguments.html#command-line-args-extension-build) docs.

—

To validate the manifest without building the package:

```
blender --command extension validate
```

You may also validate a package without having to extract it first.

```
blender --command extension validate add-on-package.zip
```

See [validate](../command_line/extension_arguments.html#command-line-args-extension-validate) docs.
user: Provide the full official documentation entry for NodeGeometryBakeItem(bpy_struct), preserving all code examples.

assistant: # NodeGeometryBakeItem(bpy_struct)

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

*class* bpy.types.NodeGeometryBakeItem(*bpy_struct*)
:   attribute_domain
    :   Attribute domain where the attribute is stored in the baked data

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

    color
    :   Color of the corresponding socket type in the node editor

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

    is_attribute
    :   Bake item is an attribute stored on a geometry

        Type:
        :   boolean, default False

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

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

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

assistant: Blender has two main selection modes: left-click select and right-click select.
See the [Select with Mouse Button](../../editors/preferences/keymap.xhtml#keymap-blender-default-prefs-select-with) preference.

While left-click select is the default as it’s the most common in other applications,
right-click select does have its advantages.
See: [Learn the benefits of right-click select](https://vimeo.com/76335056).
user: Show practical ways to work with Bpy.Types.Keymapitems in a Blender add-on or script – include code.

assistant: KeyMapItems(bpy_struct) KeyMapItems KeyMapItems.new() KeyMapItems.new_modal() KeyMapItems.new_from_item() KeyMapItems.remove() KeyMapItems.from_id() KeyMapItems.find_from_operator() KeyMapItems.find_match() KeyMapItems.match_event() KeyMapItems.bl_rna_get_subclass() KeyMapItems.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Show practical ways to work with Shadows in a Blender add-on or script – include code.

assistant: - *Shadow Map Raytracing* can produce light leaking because of overlapping shadow casters.
  This can be mitigated by using lower [step count](../render_settings/sampling.xhtml#bpy-types-sceneeevee-shadow-step-count), enabling
  [jitter](../light_settings.xhtml#bpy-types-light-use-shadow-jitter), or reducing the light shape size.
- Thin objects (e.g. walls without thickness) might have light leaking on the shadowed side.
  This can be mitigated by making the object have some thickness or lowering
  [Resolution Limit](../light_settings.xhtml#bpy-types-light-shadow-maximum-resolution).
user: Show practical ways to work with ShaderNodeRGBCurve(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeRGBCurve(ShaderNode)

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

*class* bpy.types.ShaderNodeRGBCurve(*ShaderNode*)
:   Apply color corrections for each color channel

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type