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

assistant: # GeometryNodeDeformCurvesOnSurface(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.GeometryNodeDeformCurvesOnSurface(*GeometryNode*)
:   Translate and rotate curves based on changes between the object’s original and evaluated surface mesh

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

assistant: Camera
:   Used to select which camera is used as the active camera.
    You can also set the active camera in the 3D Viewport with `Ctrl`-`Numpad0`.

Background Scene
:   Allows you to use a scene as a background,
    this is typically useful when you want to focus on animating the foreground for example,
    without background elements getting in the way.

    This scene can have its own animation, physics simulations, etc,
    but you will have to select it from the *Scene* data-block menu, if you want to edit any of its contents.

    Background Scenes can themselves have a Background Scene (they’re recursively included).
    So you can always make additions to existing scenes by using them as a background
    to a newly created scene where your additions are made.

Active Clip
:   Selects a [Movie Clip](../../movie_clip/index.xhtml) that can be used by
    [Motion Tracking Constraints](../../animation/constraints/motion_tracking/index.xhtml) or a camera’s [Background Images](../../render/cameras.xhtml#bpy-types-camerabackgroundimage).
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Shader
:   Shaders to mix, such that incoming rays hit either with the specified probability in the *Factor* socket.

Factor
:   Blend weight to use for mixing two shaders;
    at zero it uses the first shader entirely and at one the second shader.
user: Describe Project from View from the Blender manual or Python API, including usage steps and snippets.

assistant: Projects the selected faces onto the view plane. The UV map essentially becomes a wireframe picture
of the mesh, taken in the 3D Viewport at the current viewing angle. Use this option if you are using a picture
of a real object as a texture. You will get stretching in areas where the model recedes away from you.

### Options

The [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel allows fine control over how the mesh is unwrapped:

Orthographic
:   Use an [Orthographic](../../../editors/3dview/navigate/projections.xhtml#bpy-ops-view3d-view-persportho) projection instead of Perspective.

Camera Bounds
:   Map the borders of the image that would be rendered through the current camera to the borders of the UV map.
    This option only has an effect when viewing the scene through the camera;
    see [Viewing the Active Camera](../../../editors/3dview/navigate/camera_view.xhtml#bpy-ops-view3d-view-camera).

Correct Aspect
:   Adjusts the UV mapping to account for the aspect ratio of the image associated with the material.
    This ensures that UVs are scaled correctly when unwrapping onto non-square textures.

    For this option to work, the mesh must have a material with an
    [Image Texture node](../../../render/shader_nodes/textures/image.xhtml), and this node must be selected in the
    [Shader Editor](../../../editors/shader_editor.xhtml).

Clip to Bounds
:   Moves any out-of-bounds UVs to the nearest border.

Scale to Bounds
:   Stretches the resulting UV map to fill the complete texture.
user: Show practical ways to work with KeyingSets(bpy_struct) in a Blender add-on or script – include code.

assistant: # KeyingSets(bpy_struct)

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

*class* bpy.types.KeyingSets(*bpy_struct*)
:   Scene keying sets

    active
    :   Active Keying Set used to insert/delete keyframes

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

    active_index
    :   Current Keying Set index (negative for ‘builtin’ and positive for ‘absolute’)

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

    new(*\**, *idname='KeyingSet'*, *name='KeyingSet'*)
    :   Add a new Keying Set to Scene

        Parameters:
        :   - **idname** (*string**,* *(**optional**,* *never None**)*) – IDName, Internal identifier of Keying Set
            - **name** (*string**,* *(**optional**,* *never None**)*) – Name, User visible name of Keying Set

        Returns:
        :   Newly created Keying Set

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

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

assistant: [image reference removed]

3D Viewport Mode selector: Sculpt Mode.

Sculpt Mode is selected from the *Mode* menu in the 3D Viewport header.
Once Sculpt Mode is activated, the Toolbar of the 3D Viewport will change to
Sculpt Mode specific panels.
A red circle will appear and follow the location of the cursor in the 3D Viewport.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Image/Color
:   Standard color input.

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

Black Level Compositor Only
:   Defines the input color that should be mapped to black.

White Level Compositor Only
:   Defines the input color that should be mapped to white.
user: What is GeometryNodeBake(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeBake(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.GeometryNodeBake(*GeometryNode*)
:   Cache the incoming data so that it can be used without recomputation

    active_index
    :   Index of the active item

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

    active_item
    :   Index of the active item

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

    bake_items
    :   Type:
        :   [`NodeGeometryBakeItems`](bpy.types.NodeGeometryBakeItems.html#bpy.types.NodeGeometryBakeItems "bpy.types.NodeGeometryBakeItems") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`NodeGeometryBakeItem`](bpy.types.NodeGeometryBakeItem.html#bpy.types.NodeGeometryBakeItem "bpy.types.NodeGeometryBakeItem"), (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 Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

Particles are lots of items emitted from mesh objects, typically in the thousands.
Each particle can be a point of light or a mesh, and be joined or dynamic.
They may react to many different influences and forces, and have the notion of a lifespan.
Dynamic particles can represent fire, smoke, mist,
and other things such as dust or magic spells.

[Hair](hair/index.xhtml) type particles are a subset of regular particles.
Hair systems form curves that can represent hair, fur, grass and bristles.

You see particles as a Particle Modifier,
but all settings are done in the *Particle tab*.

[image reference removed]

Some fur made from particles.

Particles generally flow out from their mesh into space.
Their movement can be affected by many things, including:

- Initial velocity out from the mesh.
- Movement of the emitter (vertex, face or object) itself.
- Movement according to “gravity” or “air resistance”.
- Influence of force fields like wind, vortexes or guided along a curve.
- Interaction with other objects like collisions.
- Partially intelligent members of a flock (herd, school, …),
  that react to other members of their flock, while trying to reach a target or avoid predators.
- Smooth motion with soft body physics (only *Hair* particle systems).
- Or even manual transformation with [Lattices](../../modeling/modifiers/deform/lattice.xhtml).

Particles may be rendered as:

- [Halos](emitter/render.xhtml#particle-halo) (for Flames, Smoke, Clouds).
- Meshes which in turn may be animated (e.g. fish, bees, …).
  In these cases, each particle “carries” another object.
- [Hair curves](hair/shape.xhtml), following the path of the particle.
  These hair curves can be manipulated in the 3D Viewport (combing, adding, cutting, moving, etc.).

Every object may carry many particle systems. Each particle system may contain up to
10,000,000 particles. Certain particle types (*Hair* and *Keyed*)
may have up to 10,000 children for each particle
(children move and emit more or less like their respective parents).
The size of your memory and your patience are your practical boundaries.
user: Describe VIEW3D_AST_brush_gpencil_paint(AssetShelf) from the Blender manual or Python API, including usage steps and snippets.

assistant: # VIEW3D_AST_brush_gpencil_paint(AssetShelf)

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

*class* bpy.types.VIEW3D_AST_brush_gpencil_paint(*AssetShelf*)
:   *classmethod* brush_type_poll(*context*, *asset*)

    *static* draw_popup_selector(*layout*, *context*, *brush*, *show_name=True*)

    *static* get_shelf_name_from_context(*context*)

    *classmethod* has_tool_with_brush_type(*context*, *brush_type*)

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

assistant: # Geometry Data

This panel is used to manage any generic data attributes that a mesh could have.

Clear Sculpt Mask Data
:   Deletes the internal `sculpt_mask` attribute.
    This attribute is used by the [Sculpt Masking Feature](../../../sculpt_paint/sculpting/introduction/visibility_masking_face_sets.xhtml#face-sets).

Add/Clear Skin Data
:   Used to manage the skin data which is used by the [Skin Modifier](../../modifiers/generate/skin.xhtml).
    This operator can be needed in case a Skin modifier is created but no skin data exist.

Reorder Mesh Spatially
:   The operation sorts the vertex and face indices according to their location in space,
    so nearby geometry elements are also nearby in memory.

    This does not change the visible geometry or topology of the mesh.
    This does however improve performance in areas where spatial coherence is important, such as:

    - Faster BVH (Bounding Volume Hierarchy) building for rendering and viewport performance.
    - Improved memory access patterns during sculpting on high-poly meshes.
    - Potentially smoother interaction in edit and sculpt modes on dense geometry.

Add/Clear Custom Split Normals Data
:   Adds [Custom Split Normals](../structure.xhtml#modeling-meshes-normals-custom) data, if none exists yet.
user: Give a detailed overview of Independent Sites: syntax, arguments, return values, common patterns.

assistant: There are [several independent websites](https://www.blender.org/community/) such as forums, blogs, news, and
tutorial sites dedicated to Blender.

One of the largest community forums is [Blender Artists](https://blenderartists.org/), where Blender users gather
to show off their creations, get feedback, ask and offer help and, in general, discuss Blender.
user: Provide the full official documentation entry for Limitations, preserving all code examples.

assistant: The message bus system is triggered by updates via the RNA system. This means
that the following updates will result in a notification on the message bus:

- Changes via the Python API, for example `some_object.location.x += 3`.
- Changes via the sliders, fields, and buttons in the user interface.

The following updates do **not** trigger message bus notifications:

- Moving objects in the 3D Viewport.
- Changes performed by the animation system.

Changes done from `msgbus` callbacks are not included in related undo steps,
so users can easily skip their effects by using Undo followed by Redo.

Unlike properties `update` callbacks, message bus update callbacks are postponed
until all operators have finished executing.
Additionally, for each property the callback is only triggered once per update cycle,
even if the property was changed multiple times during that period.
user: What is Set Point Radius Node and how is it used in Blender Python scripting?

assistant: # Set Point Radius Node

[image reference removed]

The *Set Point Radius* node controls the size each selected point cloud point should display with in the viewport.

The input node for this data is the [Radius Node](../geometry/read/radius.xhtml).
user: Describe Mesh from the Blender manual or Python API, including usage steps and snippets.

assistant: Converts the selected curve, metaball, surface, or text object to a mesh object.
The actual defined resolution of these objects will be taken into account for the conversion.
Note that it also keeps the faces and volumes created by closed and extruded curves.
user: Explain CompositorNodeColorCorrection(CompositorNode) in complete detail according to the official Blender documentation.

assistant: # CompositorNodeColorCorrection(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.CompositorNodeColorCorrection(*CompositorNode*)
:   Adjust the color of an image, separately in several tonal ranges (highlights, midtones and shadows)

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is limbs.spline_tentacle and how is it used in Blender Python scripting?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Assign FK Layers
:   If enabled, allows placing the FK chain in different bone collections from the IK bones.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.camera`](bpy.context.html#bpy.context.camera "bpy.context.camera") - [`BlendData.cameras`](bpy.types.BlendData.html#bpy.types.BlendData.cameras "bpy.types.BlendData.cameras") - [`BlendDataCameras.new`](bpy.types.BlendDataCameras.html#bpy.types.BlendDataCameras.new "bpy.types.BlendDataCameras.new") | - [`BlendDataCameras.remove`](bpy.types.BlendDataCameras.html#bpy.types.BlendDataCameras.remove "bpy.types.BlendDataCameras.remove") - [`RenderEngine.update_custom_camera`](bpy.types.RenderEngine.html#bpy.types.RenderEngine.update_custom_camera "bpy.types.RenderEngine.update_custom_camera") |
user: Describe Recovering Save Versions from the Blender manual or Python API, including usage steps and snippets.

assistant: By default Blender keeps an additional backup when saving files.
So saving renames the previously saved file with a `.blend1` extension instead of overwriting it.

This file can be used to revert to a previous state.

See [Save Versions](../editors/preferences/save_load.html#bpy-types-preferencesfilepaths-save-version) to configure the number of versions kept.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`Object.animation_visualization`](bpy.types.Object.html#bpy.types.Object.animation_visualization "bpy.types.Object.animation_visualization") | - [`Pose.animation_visualization`](bpy.types.Pose.html#bpy.types.Pose.animation_visualization "bpy.types.Pose.animation_visualization") |
user: Show practical ways to work with Toolbar in a Blender add-on or script – include code.

assistant: # Toolbar

Mesh Edit Mode tools:

[Select](../../../../interface/selecting.html#tool-select-tweak)
:   Select or move.

    [Select Box](../../../../interface/selecting.html#tool-select-box)
    :   Select geometry by dragging a box.

    [Select Circle](../../../../interface/selecting.html#tool-select-circle)
    :   Select geometry by dragging a circle.

    [Select Lasso](../../../../interface/selecting.html#tool-select-lasso)
    :   Select geometry by drawing a lasso.

Cursor
:   Change the location of the 3D Cursor.

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

    [Scale Cage](../../../../scene_layout/object/tools/scale_cage.html#tool-scale-cage)
    :   Change the scale of an object by controlling its cage.

Transform
:   Tool to adjust the objects translation, rotations and scale.

[Annotate](../../../../interface/annotate_tool.html#tool-annotate-freehand)
:   Draw free-hand annotation.

    [Annotate Line](../../../../interface/annotate_tool.html#tool-annotate-line)
    :   Draw straight line annotation.

    [Annotate Polygon](../../../../interface/annotate_tool.html#tool-annotate-polygon)
    :   Draw a polygon annotation.

    [Annotate Eraser](../../../../interface/annotate_tool.html#tool-annotate-eraser)
    :   Erase previous drawn annotations.

[Measure](../../../../editors/3dview/toolbar/measure.html#tool-measure)
:   Measure distances in the scene.

[Roll](../editing/bone_roll.html#tool-bone-roll)
:   Rotates a bone around its local Y axis.

Bone Size

Extrude
:   Creates a new bone connected to the last selected joint.

    Extrude to Cursor
    :   Creates a new bone between the last selected joint and the mouse position.

Shear
user: Provide the full official documentation entry for Noise Texture Node, preserving all code examples.

assistant: # Noise Texture Node

[image reference removed]

The *Noise Texture* node evaluates a fractal Perlin noise at the input texture coordinates.
It can be used for a single Perlin noise evaluation, or for combining multiple octaves
(layers) with increasingly finer detail.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Grid
:   The input grid whose transform will be changed.

Transform
:   The new transform from grid index space to object space.
    This determines how the voxel grid is positioned and oriented in 3D space.
    Typically this input comes from a [Transformation Matrix](../../../../glossary/index.xhtml#term-Transformation-Matrix)/
user: Explain GeometryNodeSetCurveTilt(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeSetCurveTilt(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.GeometryNodeSetCurveTilt(*GeometryNode*)
:   Set the tilt angle at each curve control point

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is SpreadsheetTable(bpy_struct) and how is it used in Blender Python scripting?

assistant: # SpreadsheetTable(bpy_struct)

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

*class* bpy.types.SpreadsheetTable(*bpy_struct*)
:   Persistent data associated with a table

    columns
    :   Columns within the table

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

    id
    :   Data used to identify the table

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Strip.name`](bpy.types.Strip.html#bpy.types.Strip.name "bpy.types.Strip.name") - [`Strip.type`](bpy.types.Strip.html#bpy.types.Strip.type "bpy.types.Strip.type") - [`Strip.select`](bpy.types.Strip.html#bpy.types.Strip.select "bpy.types.Strip.select") - [`Strip.select_left_handle`](bpy.types.Strip.html#bpy.types.Strip.select_left_handle "bpy.types.Strip.select_left_handle") - [`Strip.select_right_handle`](bpy.types.Strip.html#bpy.types.Strip.select_right_handle "bpy.types.Strip.select_right_handle") - [`Strip.mute`](bpy.types.Strip.html#bpy.types.Strip.mute "bpy.types.Strip.mute") - [`Strip.lock`](bpy.types.Strip.html#bpy.types.Strip.lock "bpy.types.Strip.lock") - [`Strip.frame_final_duration`](bpy.types.Strip.html#bpy.types.Strip.frame_final_duration "bpy.types.Strip.frame_final_duration") - [`Strip.frame_duration`](bpy.types.Strip.html#bpy.types.Strip.frame_duration "bpy.types.Strip.frame_duration") - [`Strip.frame_start`](bpy.types.Strip.html#bpy.types.Strip.frame_start "bpy.types.Strip.frame_start") - [`Strip.frame_final_start`](bpy.types.Strip.html#bpy.types.Strip.frame_final_start "bpy.types.Strip.frame_final_start") | - [`Strip.frame_final_end`](bpy.types.Strip.html#bpy.types.Strip.frame_final_end "bpy.types.Strip.frame_final_end") - [`Strip.frame_offset_start`](bpy.types.Strip.html#bpy.types.Strip.frame_offset_start "bpy.types.Strip.frame_offset_start") - [`Strip.frame_offset_end`](bpy.types.Strip.html#bpy.types.Strip.frame_offset_end "bpy.types.Strip.frame_offset_end") - [`Strip.channel`](bpy.types.Strip.html#bpy.types.Strip.channel "bpy.types.Strip.channel") - [`Strip.use_linear_modifiers`](bpy.types.Strip.html#bpy.types.Strip.use_linear_modifiers "bpy.types.Strip.use_linear_modifiers") - [`Strip.blend_type`](bpy.types.Strip.html#bpy.types.Strip.blend_type "bpy.types.Strip.blend_type") - [`Strip.blend_alpha`](bpy.types.Strip.html#bpy.types.Strip.blend_alpha "bpy.types.Strip.blend_alpha") - [`Strip.effect_fader`](bpy.types.Strip.html#bpy.types.Strip.effect_fader "bpy.types.Strip.effect_fader") - [`Strip.use_default_fade`](bpy.types.Strip.html#bpy.types.Strip.use_default_fade "bpy.types.Strip.use_default_fade") - [`Strip.color_tag`](bpy.types.Strip.html#bpy.types.Strip.color_tag "bpy.types.Strip.color_tag") - [`Strip.modifiers`](bpy.types.Strip.html#bpy.types.Strip.modifiers "bpy.types.Strip.modifiers") - [`Strip.show_retiming_keys`](bpy.types.Strip.html#bpy.types.Strip.show_retiming_keys "bpy.types.Strip.show_retiming_keys") |
user: Give a detailed overview of Weight Paint Tools: syntax, arguments, return values, common patterns.

assistant: # Weight Paint Tools

For Grease Pencil Weight Paint modes each brush type is exposed as a tool,
the brush can be changed in the Tool Settings.
See [Brush](tool_settings/brush.xhtml) for more information.

[image reference removed]

Brush
:   Tool to use for any of the weight paint [brushes](brushes.xhtml).

[Annotate](../../../interface/annotate_tool.xhtml#tool-annotate-freehand)
:   Draw free-hand annotation.

    [Annotate Line](../../../interface/annotate_tool.xhtml#tool-annotate-line)
    :   Draw straight line annotation.

    [Annotate Polygon](../../../interface/annotate_tool.xhtml#tool-annotate-polygon)
    :   Draw a polygon annotation.

    [Annotate Eraser](../../../interface/annotate_tool.xhtml#tool-annotate-eraser)
    :   Erase previous drawn annotations.
user: How do I use BoneCollectionMemberships(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # BoneCollectionMemberships(bpy_struct)

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

*class* bpy.types.BoneCollectionMemberships(*bpy_struct*)
:   The Bone Collections that contain this Bone

    clear()
    :   Remove this bone from all bone collections

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

The Remesh modifier.

Mode
:   There are three basic modes available in the *Remesh* modifier.
    The output topology is almost identical between the three modes, what changes is the smoothing.

    Blocks
    :   There is no smoothing at all.

    Smooth
    :   Output a smooth surface.

    Sharp
    :   Similar to *Smooth*, but preserves sharp edges and corners.

        Sharpness
        :   Higher values produce edges more similar to the input, while lower values filter out noise.

    Voxel
    :   Uses an OpenVDB to generate a new manifold mesh from the current geometry
        while trying to preserve the mesh’s original volume.

        Adaptivity
        :   Reduces the final face count by simplifying geometry where detail is not needed.
            This introduce triangulation to faces that do not need as much detail.

        Smooth Shading
        :   Outputs faces with [Smooth Shading](../../../scene_layout/object/editing/shading.xhtml#bpy-ops-object-shade-smooth) instead of flat shading.

Octree Depth
:   Sets the resolution of the output. Low values will generate larger faces relative to the input,
    higher values will generate a denser output.

Scale
:   The result can be tweaked further by this, lower values effectively decrease the output resolution.

Remove Disconnected
:   Filter out small disconnected pieces of the output.

    Thin parts of the input mesh can become loose, and generate small isolated bits of mesh.
    This option will remove those.

    Threshold
    :   Use this to control how small a disconnected component must be to be removed.

Smooth Shading
:   Output faces with smooth shading rather than flat shading.
    The smooth/flat shading of the input faces is not preserved.
user: How do I use Getting Started in Blender? Include parameters, examples, warnings and best practices.

assistant: # Getting Started

Welcome! This section guides you through contributing to the Blender manual.

Blender’s manual is written in [reStructuredText (RST)](https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html),
a straightforward markup language ideal for technical documentation.
You can edit the manual either directly online or by using your local text editor.

All contributions are managed through a collaborative workflow on Blender’s development platform,
[projects.blender.org](https://projects.blender.org/).

You have two options for editing the manual:
user: How do I use CompositorNodeGroup(CompositorNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CompositorNodeGroup(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.CompositorNodeGroup(*CompositorNode*)
:   node_tree
    :   Type:
        :   [`NodeTree`](bpy.types.NodeTree.html#bpy.types.NodeTree "bpy.types.NodeTree")

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

assistant: Simply check out the Blender Manual’s repository using:

```
cd ~
git clone https://projects.blender.org/blender/blender-manual.git
```

The repository will now be downloaded which may take a few minutes depending on your internet connection.
user: How do I use Nested Instancing in Blender? Include parameters, examples, warnings and best practices.

assistant: Since instances can store a geometry, and a geometry can contain instances, nested instancing is possible.
In other words, it is possible to instance an instance, or even a collection of instances.
For example, by default, the [Instance on Points Node](instances/instance_on_points.xhtml) will create
nested instances by instancing instances on the points of real geometry.

[image reference removed]

A node group that creates nested instancing by chaining
[Instance on Points](instances/instance_on_points.xhtml) nodes.

Here, nested instancing is used to distribute geometry that contains both a mesh
and instances. The output geometry contains a “real” mesh and a group of instances.
Each instance contains a sphere mesh and many instances of a cone geometry.

[image reference removed]

The tree of instanced geometry for the example above.

What makes this method helpful is the output geometry only contains three unique meshes:
the plane, the sphere, and the cone. This would make the performance much better if the meshes
were more complicated.
user: Describe CorrectiveSmoothModifier(Modifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CorrectiveSmoothModifier(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.CorrectiveSmoothModifier(*Modifier*)
:   Correct distortion caused by deformation

    factor
    :   Smooth effect factor

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

    invert_vertex_group
    :   Invert vertex group influence

        Type:
        :   boolean, default False

    is_bind
    :   Type:
        :   boolean, default False, (readonly)

    iterations
    :   Type:
        :   int in [0, 32767], default 5

    rest_source
    :   Select the source of rest positions

        - `ORCO`
          Original Coords – Use base mesh vertex coordinates as the rest position.
        - `BIND`
          Bind Coords – Use bind vertex coordinates for rest position.

        Type:
        :   enum in [`'ORCO'`, `'BIND'`], default `'ORCO'`

    scale
    :   Compensate for scale applied by other modifiers

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

    smooth_type
    :   Method used for smoothing

        - `SIMPLE`
          Simple – Use the average of adjacent edge-vertices.
        - `LENGTH_WEIGHTED`
          Length Weight – Use the average of adjacent edge-vertices weighted by their length.

        Type:
        :   enum in [`'SIMPLE'`, `'LENGTH_WEIGHTED'`], default `'SIMPLE'`

    use_only_smooth
    :   Apply smoothing without reconstructing the surface

        Type:
        :   boolean, default False

    use_pin_boundary
    :   Excludes boundary vertices from being smoothed

        Type:
        :   boolean, default False

    vertex_group
    :   Name of Vertex Group which determines influence of modifier per point

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

assistant: The base layer is a mix between metal, diffuse, subsurface, and transmission components.
Most materials will use one of these components, though it is possible to smoothly mix
between them.

[image reference removed]

The metal component is opaque and only reflect lights. Diffuse is fully opaque, while
subsurface also involves light scattering just below the surface. Both diffuse and
subsurface sit below a specular layer. The transmission component includes both
specular reflection and refraction.

On top of all base layers there is an optional glossy coat. And finally the sheen layer
sits on top of all other layers, to add fuzz or dust.

Light emission can also be added. Light emits from below the coat and sheen layers,
to model for example emissive displays with a coat or dust.
user: Describe Separate Images from the Blender manual or Python API, including usage steps and snippets.

assistant: For images sequence only – Converts the strip into multiple strips, one strip for each frame.
Useful for slide shows and other cases where you want to bring in a set on non-continuous images.

Length
:   You have to specify the duration you want the resulting strips will be.
user: Show practical ways to work with Selecting Nodes in a Blender add-on or script – include code.

assistant: # Selecting Nodes

Nodes in the editor can be selected and manipulated.
Selections determine which nodes can be moved, duplicated, or connected.
The active node (last selected) is highlighted with a lighter outline.
It serves as the reference for certain operations, such as grouping or linking,
and also determines which properties are displayed in the *Sidebar* and *Properties Editor*.

Nodes are selected with `LMB`.
Multiple nodes can be selected by holding `Shift`-`LMB`.

Blender also provides a variety of selection tools and shortcuts for quickly choosing nodes
based on their type, connections, or layout.
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: Below are some common curves you can use to achieve desired effects.

[image reference removed]

From left to right: 1. Lighten shadows 2. Negative 3. Decrease contrast 4. Posterize.

### Color Correction using Curves

[image reference removed]

Color correction with curves.

In this example, the image has too much red in it,
so we run it through an *RGB Curves* node and reduce the Red channel.

The documentation for the [Mix Color Node](../../../../compositing/types/color/mix_color.xhtml) has an additional
example about fixing overexposure.

### Color Correction using Black/White Levels

[image reference removed]

Color correction with Black/White Levels.

Manually adjusting the RGB curves for color correction can be difficult.
Another option for color correction is to use the Black and White Levels instead,
which really might be their main purpose.

In this example,
the White Level is set to the color of a bright spot of the sand in the background,
and the Black Level to the color in the center of the fish’s eye.
To do this efficiently it is best to bring up the Image Editor showing the original input image.
You can then use the levels’ color picker to easily choose
the appropriate colors from the input image, zooming into pixel level if necessary.
The result can be fine-tuned with the R, G, and B curves like in the previous example.

The curve for C is used to compensate for the increased contrast that is a side effect of
setting Black and White Levels.

### Effects

[image reference removed]

Changing colors by inverting the red channel.
user: How do I use Separate Cylindrical Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Separate Cylindrical Node

[image reference removed]

The *Separate Cylindrical* node converts a vector from Cartesian coordinates (X, Y, Z)
into cylindrical coordinates (R, Φ, Z) and outputs each component separately. It is the inverse of the
[Combine Cylindrical](../../../../modeling/geometry_nodes/utilities/vector/combine_cylindrical.xhtml) node.

This node is useful for analyzing geometry or generating procedural effects that depend on
radial distance, angular position, or height – for example, creating spiral deformations,
cylindrical gradients, or radial masks.
user: Explain Single Click Tools in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Simpler tools that apply an operation on surfaces that are clicked on.

[Edit Face Set](tools/edit_face_set.xhtml)
:   Modifies the face set under the cursor.

[Mask by Color](tools/mask_by_color.xhtml)
:   Create a mask from any color from the color attribute by clicking on it.