PGCRYPT/OpenBlender_Train huggingface dataset:
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Geometry
:   The input geometry containing the hair curves to be shrinkwrapped.

Surface Input Type
:   Determines how the surface data is provided for shrinkwrapping.
    The geometry input takes priority over the object input.

    Object:
    :   Use an object reference to sample the target surface.

    Geometry:
    :   Use a geometry input to sample the surface directly.

Surface
:   The surface object or geometry used as the target for the shrinkwrap projection.

Factor
:   Controls the overall influence of the shrinkwrap effect.
    A value of 0.0 leaves the hair unchanged, while 1.0 fully conforms the hair to the surface.

Offset Distance
:   Defines a distance offset from the target surface.
    Positive values move curves away from the surface, while negative values move them inward.

Above Surface
:   Blends the shrinkwrap effect for points that start above the surface,
    allowing smoother transitions when only some parts of the curve should adhere to the mesh.

Smoothing Steps
:   The number of smoothing iterations applied to the curves after shrinkwrapping.
    Increasing this value helps to reduce artifacts and achieve smoother results.

Lock Roots
:   When enabled, prevents the root points of each curve from moving during the shrinkwrap operation.
    This ensures hair roots remain fixed to their original positions (e.g., attached to a scalp).
user: Describe Duplicate from the Blender manual or Python API, including usage steps and snippets.

assistant: Creates a copy of the selected points and reposition the duplicated points.

Duplicated points inherit all attributes from the original points.
- Can be used for manually scattering point clusters or duplicating specific regions for further modification.
user: How do I use NodeLinks(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeLinks(bpy_struct)

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

*class* bpy.types.NodeLinks(*bpy_struct*)
:   Collection of Node Links

    new(*input*, *output*, *\**, *verify_limits=True*, *handle_dynamic_sockets=False*)
    :   Add a node link to this node tree

        Parameters:
        :   - **input** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – The input socket
            - **output** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – The output socket
            - **verify_limits** (*boolean**,* *(**optional**)*) – Verify Limits, Remove existing links if connection limit is exceeded
            - **handle_dynamic_sockets** (*boolean**,* *(**optional**)*) – Handle Dynamic Sockets, Handle node specific features like virtual sockets

        Returns:
        :   New node link

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

    remove(*link*)
    :   remove a node link from the node tree

        Parameters:
        :   **link** ([`NodeLink`](bpy.types.NodeLink.html#bpy.types.NodeLink "bpy.types.NodeLink"), (never None)) – The node link to remove

    clear()
    :   remove all node links from the node tree

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

assistant: # BlendDataNodeTrees(bpy_struct)

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

*class* bpy.types.BlendDataNodeTrees(*bpy_struct*)
:   Collection of node trees

    new(*name*, *type*)
    :   Add a new node tree to the main database

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – New name for the data-block
            - **type** (enum in [`'GeometryNodeTree'`, `'CompositorNodeTree'`, `'ShaderNodeTree'`, `'TextureNodeTree'`]) –

              Type, The type of node_group to add

              - `GeometryNodeTree`
                Geometry Node Editor – Advanced geometry editing and tools creation using nodes.
              - `CompositorNodeTree`
                Compositor – Create effects and post-process renders, images, and the 3D Viewport.
              - `ShaderNodeTree`
                Shader Editor – Edit materials, lights, and world shading using nodes.
              - `TextureNodeTree`
                Texture Node Editor – Edit textures using nodes.

        Returns:
        :   New node tree data-block

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

    remove(*tree*, *\**, *do_unlink=True*, *do_id_user=True*, *do_ui_user=True*)
    :   Remove a node tree from the current blendfile

        Parameters:
        :   - **tree** ([`NodeTree`](bpy.types.NodeTree.html#bpy.types.NodeTree "bpy.types.NodeTree"), (never None)) – Node tree to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this node tree before deleting it
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this node tree
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this node tree

    tag(*value*)
    :   tag

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Inherited Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleThicknessModifier.name`](bpy.types.LineStyleThicknessModifier.html#bpy.types.LineStyleThicknessModifier.name "bpy.types.LineStyleThicknessModifier.name") |
user: What is Usage and how is it used in Blender Python scripting?

assistant: Vertex groups can be created manually or generated automatically. They are most commonly used for armature-based
deformation (also called *skinning*), but they are also used in many other areas of Blender, such as:

- Shape keys
- Modifiers
- Particle systems
- Physics simulations
user: What is Language and how is it used in Blender Python scripting?

assistant: Language
:   The language used for translating the user interface (UI).
    The list is broken up into categories determining how complete the translations are.

Translate
:   Tooltips
    :   Translates the descriptions when hovering over UI elements.

    Interface
    :   Translates all labels in menus, buttons, and panels.

    New Data
    :   Translates the names of new data-blocks.
user: What is Custom Shape and how is it used in Blender Python scripting?

assistant: Apart from custom colors, bones can also have custom shapes (in *Object Mode*
and *Pose Mode*), using another object as a “template.”

[image reference removed]

A bone referencing a cone as its Custom Shape.

You can temporarily disable these shapes by unchecking
*Shapes* in the armature’s Viewport Display panel.

Custom Object
:   Object that defines the custom shape of the selected bone.

Translation X, Y, Z
:   Additional translation to apply to the custom shape.

Rotation X, Y, Z
:   Additional rotation to apply to the custom shape.

Scale X, Y, Z
:   Additional scaling factor to apply to the custom shape.

Override Transform
:   A bone that defines the display transform of the custom shape.
    The shape defined in *Custom Object* will be placed at the location and orientation of that bone.
    This is only visual and does not affect the transform values of this bone.

Affect Gizmo
:   The location and orientation of the *Override Transform* bone will be used for transform
    gizmos and for other transform operators in the 3D Viewport.

Use As Pivot
:   Transform the bone as if it was a child of the *Override Transform* bone.
    This is useful in special cases, where the mesh is deformed away from the bind pose by
    a separate mechanism, for example [Shape Keys](../../../shape_keys/index.xhtml#animation-shape-keys-index).

Scale to Bone Length
:   Whether the custom shape should be scaled by a factor
    equal to the [bone’s length](transform.xhtml#bpy-types-editbone-length).

Wireframe
:   When enabled, the bone is displayed in wireframe mode regardless of the viewport’s shading mode.

Wire Width
:   The line thickness of the wireframe for the custom shape.
user: How do I use Mesh Island Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Mesh Island Node

[image reference removed]

The *Mesh Island* node outputs information about separate connected regions, or “islands” of a mesh.
Whenever two vertices are connected together by an edge, they are considered as part of the same island,
and will have the same *Island Index* output.

This node’s behavior is similar to the [Select Linked](../../../meshes/selecting/linked.xhtml#bpy-ops-mesh-select-linked) operator
in edit mode, or the *Random per Island* output of the
[Geometry shader node](../../../../render/shader_nodes/input/geometry.xhtml).
user: Provide the full official documentation entry for Guides, preserving all code examples.

assistant: Grid
:   Show the grid.

Over Image
:   Show the grid on top of the image rather than behind it.

Grid Shape Source
:   How the row and column counts are determined.

    Dynamic:
    :   The grid starts at 8×8 cells that are automatically subdivided further as you zoom in.

    Fixed:
    :   The row and column counts are fixed and can be configured manually.

    Pixel:
    :   Each grid cell matches one image pixel.

Fixed Subdivisions X, Y
:   Number of columns/rows in the grid.

Tiles X, Y
:   The number of [UDIM](../../modeling/meshes/uv/workflows/udims.xhtml)
    tile grids to display in each cardinal direction.
user: What is TrackToConstraint(Constraint) and how is it used in Blender Python scripting?

assistant: # TrackToConstraint(Constraint)

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

*class* bpy.types.TrackToConstraint(*Constraint*)
:   Aim the constrained object toward the target

    head_tail
    :   Target along length of bone: Head is 0, Tail is 1

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

    subtarget
    :   Armature bone, mesh or lattice vertex group, …

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

    target
    :   Target object

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

    track_axis
    :   Axis that points to the target object

        Type:
        :   enum in [`'TRACK_X'`, `'TRACK_Y'`, `'TRACK_Z'`, `'TRACK_NEGATIVE_X'`, `'TRACK_NEGATIVE_Y'`, `'TRACK_NEGATIVE_Z'`], default `'TRACK_X'`

    up_axis
    :   Axis that points upward

        Type:
        :   enum in [`'UP_X'`, `'UP_Y'`, `'UP_Z'`], default `'UP_X'`

    use_bbone_shape
    :   Follow shape of B-Bone segments when calculating Head/Tail position

        Type:
        :   boolean, default False

    use_target_z
    :   Target’s Z axis, not World Z axis, will constrain the Up direction

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: This panel controls how [Color Management](../../color_management/index.xhtml) is applied when saving images.

Follow Scene:
:   Uses the same color management settings defined by the active Scene.
    These properties are defined in the Render Settings

Override:
:   Uses custom color management settings defined by the properties below in the panel;
    disregarding any color management settings set at the Scene level.

For a detailed description of color management properties,
see the [Color Management](../../color_management/displays_views.xhtml#render-post-color-management) page.
user: What is Filter and how is it used in Blender Python scripting?

assistant: # Filter

These options control which types of data are included in the final render for the current view layer.

Include
:   Environment Cycles, EEVEE
    :   Disables rendering the *Environment* render pass in the final render.

    Surfaces Cycles, EEVEE
    :   Disables rendering object materials in the final render.

    Curves Cycles, EEVEE
    :   Disables rendering curve strands in the final render.

    Volume Cycles, EEVEE
    :   Disables rendering [Volumes](../../modeling/volumes/index.xhtml) in the final render.

    Grease Pencil Cycles, EEVEE
    :   Render Grease Pencil objects on current layer

Use
:   Motion Blur Cycles, EEVEE
    :   Render motion blur for current layer,
        if enabled in the [Render Settings](../cycles/render_settings/motion_blur.xhtml#bpy-types-rendersettings-use-motion-blur).
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: Mesh
:   Standard geometry output.

UV Map
:   A 2D vector representing the default X/Y coordinates of the [UV Map](../../../../glossary/index.html#term-UV-Map) for the primitive’s shape.
    This can be connected to the [Store Named Attribute Node](../../attribute/store_named_attribute.html),
    to be used once the Geometry Nodes Modifier get applied.
    The UV map must be stored on the face corner in order to be accessed.
user: Describe Sidebar from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Find & Replace

Find Text `Ctrl`-`F`
:   Searches for instances of a text that occur after the cursor.
    Using the eyedropper icon will search for the currently selected text
    and sets the selection to the match.
    *Find Next* searches for the next instance of the text.

Replace Text `Ctrl`-`H`
:   Searches for the text specified in *Find Text* and replaces it with the new text.
    Using the eyedropper icon will set the currently selected text as the replace text.
    *Replace* searches for the next match and replaces it.
    *Replace All* searches for the match and replaces all occurrences of the match with the new text.

Case
:   Search is sensitive to uppercase and lowercase letters.

Wrap
:   Search again from the start of the file when reaching the end.

All
:   Search in all text data-blocks instead of only the active one.

### Properties

Margin
:   Shows a vertical margin line to help keep text lines at a reasonable length.
    The position of this margin line is specified by *Margin Column*.

Font Size `Ctrl`-`WheelUp`
:   The size of the font used to display text.

Tab Width
:   The number of character spaces to display tab characters with.

Indentation
:   Whether to use *Tabs* or *Spaces* for indentation.
user: Give a detailed overview of Gas Simulations: syntax, arguments, return values, common patterns.

assistant: Gas or smoke simulations are a subset of the fluids system, and can be used for simulating collections
of airborne solids, liquid particulates and gases, such as those that make up smoke.
It simulates the fluid movement of air and generates animated [Voxel](../../glossary/index.html#term-Voxel)
textures representing the density, heat, and velocity of other fluids or suspended particles
(e.g. smoke) which can be used for rendering.

[image reference removed]

Example of a fire simulation.

Gases or smoke are emitted inside of a [Domain](type/domain/index.html) from
a mesh object or particle system. The smoke movement is controlled by airflow inside the domain,
which can be influenced by [Effector](type/effector.html) objects.
Smoke will also be affected by the scene’s gravity and [force fields](../forces/force_fields/index.html).
Airflow inside the domain can affect other physics simulations
via the [Fluid Flow](../forces/force_fields/types/fluid_flow.html) force field.
user: Describe Child Of Constraint from the Blender manual or Python API, including usage steps and snippets.

assistant: # Child Of Constraint

The *Child Of* constraint transforms an object or bone as though it were a
[child](../../../scene_layout/object/editing/parent.xhtml) of another object or bone.

The main advantage over a regular parent-child relationship is that the
constraint has an animatable *Influence*, which makes it possible to switch
to different parents over time.

This same *Influence* can also be used to mix multiple *Child Of* constraints
and create a weighted average between multiple parents. However, if those parents
are bones, the [Armature Constraint](armature.xhtml) may be a better choice.
user: What is Face Bones and how is it used in Blender Python scripting?

assistant: Start by identifying basic face landmarks to follow as guide for bones placement.

[image reference removed]

Basic Face Landmarks.

- Orange lines represent bones that should be placed in closed loops.
- Yellow lines represent bones whose position depends on surrounding bone loops.
- Red lines represent outer edge bones.
- Purple lines represent bridging bones used to cover deforming flesh.

[image reference removed]

Eyes-Nose Landmarks.

The eyes-nose loop area is split in different parts identified by bone names. Follow the image to place the bones.

[image reference removed]

Eyes-Nose Bone Positions.

[image reference removed]

Jaw-Ear Bone Positions.

Also the jaw-ear area is split in different parts identified by bone names. Follow the image to place the bones.

[image reference removed]

Lips Merge Point.

[image reference removed]

Face Stretcher Bones.

After the main face bones are placed use the cheek bone to connect the eye-nose area to the jaw mouth area.
Then do the same with the brow area. This process will automatically define face muscles compression areas.

Position the eye bones in the eye pivot point facing right **toward** the face on the Y axis.
The length of the eye bones should correspond to the radius of the eye.

[image reference removed]

Eyes Pivot Position.

Finally position the teeth bones on your teeth geometry and the tongue bone chain as described in the figure.

[image reference removed]

Mouth and Teeth Positions.

Before generating the rig ensure the face master bone is facing upward.
user: Give a detailed overview of Extrude Faces Along Normals: syntax, arguments, return values, common patterns.

assistant: Available when a [Face](../../../../glossary/index.html#term-Face) is selected.

See [Extrude Faces Along Normals](../face/extrude_faces_normal.html#bpy-ops-view3d-edit-mesh-extrude-move-shrink-fatten).
user: Describe Contribute Documentation from the Blender manual or Python API, including usage steps and snippets.

assistant: # Contribute Documentation

The Blender Manual is a community driven effort to which anyone can contribute. Whether you’d like to fix a tiny
spelling mistake or rewrite an entire chapter, your help with the Blender manual is most welcome!

If you find an error in the documentation, please [report the problem](https://projects.blender.org/blender/documentation/issues/new).

Get involved in discussions through any of the project [Contacts](#contacts).
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Volume
:   The input volume geometry that contains one or more named grids.

Name
:   The name of the grid to retrieve from the volume.
    The name must match an existing grid stored in the volume data block.

Remove
:   When enabled, removes the grid from the volume after it has been retrieved.
    This can be useful when restructuring volume data to avoid duplication or
    manage memory more efficiently.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Data Type
:   The type of data being converted.

    Float:
    :   A single float value.

    Vector:
    :   A vector (e.g. 2D) value.

Reference Dimension
:   Defines which part of the image’s dimensions the relative value refers to.

    Per Dimension:
    :   Each axis (X and Y) is scaled independently by the image width and height.

    X:
    :   The value is scaled relative to the image width.

    Y:
    :   The value is scaled relative to the image height.

    Greater:
    :   The value is scaled relative to the larger of the image dimensions.

    Smaller:
    :   The value is scaled relative to the smaller of the image dimensions.

    Diagonal:
    :   The value is scaled relative to the diagonal length of the image.
user: Explain Offscreen Rendering in complete detail according to the official Blender documentation.

assistant: What one can see on the screen after rendering is called the *Front Buffer*.
When draw calls are issued, batches are drawn on a *Back Buffer* that will only be displayed
when all drawing is done and the current back buffer will become the new front buffer.
Sometimes, one might want to draw the batches into a distinct buffer that could be used as
texture to display on another object or to be saved as image on disk.
This is called Offscreen Rendering.
In Blender Offscreen Rendering is done using the [`gpu.types.GPUOffScreen`](gpu.types.html#gpu.types.GPUOffScreen "gpu.types.GPUOffScreen") type.
user: Describe View Menu from the Blender manual or Python API, including usage steps and snippets.

assistant: Toolbar `T`
:   Show or hide the [Toolbar](../../../interface/tool_system.xhtml#ui-region-toolbar).

Sidebar `N`
:   Show or hide the [Sidebar](../../../interface/window_system/regions.xhtml#ui-region-sidebar).

Tool Settings
:   Show or hide the settings for the currently selected tool.

Footer
:   Show or hide the [Sidebar](../../../interface/window_system/regions.xhtml#ui-region-footer).

---

Preview During Transform
:   Show a preview of the start or end frame of a strip while transforming its respective handle.

---

Refresh All
:   Reloads external files and refreshes the current frame preview.
    This is useful when you modified an external file or made a change in a scene that Blender
    didn’t detect.

---

Frame Selected
:   Pan and zoom the view to focus on the selected image.

Fit Preview in Window `Home`
:   Pan and zoom the view so that the entire video is visible.
    This enables *Zoom to Fit*.

Zoom
:   Menu with convenient zoom levels and operations.
    The zoom levels are calculated based on the images resolution compared to the screen resolution.

    - 12.5% (1:8) `Numpad8` zoom out to a factor of 12.5%.
    - 25% (1:4) `Numpad4` zoom out to a factor of 25%.
    - 50% (1:2) `Numpad2` zoom out to a factor of 50%.
    - 100% (1:1) `Numpad1` resets the zoom to 100%.
    - 200% (2:1) `Ctrl`-`Numpad2` zoom in to a factor of 200%.
    - 400% (4:1) `Ctrl`-`Numpad4` zoom in to a factor of 400%.
    - 800% (8:1) `Ctrl`-`Numpad8` zoom in to a factor of 800%.

    Zoom In/Out `Wheel`
    :   Zooms the view in or out.

    Zoom to Fit `Shift`-`Home`
    :   Like *Frame All*, but uses as much space in the editor as possible.

    Zoom Region `Shift`-`B`
    :   Zoom in the view to the nearest item contained in the border.

Auto Zoom
:   As long as this option is enabled, the preview will automatically zoom to keep the
    video size synchronized with the editor size.

---

Proxy
:   See [Proxy](../sequencer/sidebar/proxy.xhtml).

---

Sequence Render Image
:   Show the current frame preview as a Render Result where you can save it as an image file.

Sequence Render Animation
:   Save previews of the frames in the scene range (or the preview range, if active) to a video file
    or a series of image files. See the [Output](../../../render/output/properties/output.xhtml) panel for details.

---

Export Subtitles
:   Exports [Text strips](../../../video_editing/edit/montage/strips/text.xhtml),
    which can act as subtitles, to a [SubRip](https://en.wikipedia.org/wiki/SubRip) file (`.srt`).
    The exported file contains all Text strips in the video sequence.

---

Toggle Sequencer/Preview `Ctrl`-`Tab`
:   Switch the editor mode between *Sequencer* and *Preview*.

---

Area
:   Area controls. See the [user interface](../../../interface/window_system/areas.xhtml)
    documentation for more information.
user: How do I use XrComponentPath(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # XrComponentPath(bpy_struct)

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

*class* bpy.types.XrComponentPath(*bpy_struct*)
:   path
    :   OpenXR component path

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

assistant: [image reference removed]

Lattice properties.

Lattice
:   A [Data-Block Menu](../interface/controls/templates/data_block.xhtml#ui-data-block).

### Lattice

Points
:   Rate of subdivision in the axes:

    U, V, W

Interpolation Type
:   Selector for each axis. See [Different types of interpolation.](shape_keys/shape_keys_panel.xhtml#fig-interpolation-type).

    Linear, Cardinal, Catmull-Rom, B-Spline

Outside
:   Takes only the vertices on the surface of the lattice into account.

Vertex Group
:   The strength of the influence assigned as a weight to the individual vertices in the selected vertex group.
user: How do I use ShaderNodeNormal(ShaderNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ShaderNodeNormal(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.ShaderNodeNormal(*ShaderNode*)
:   Generate a normal vector and a dot product

    *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

[image reference removed]

The Texture Type list in the Texture panel of the Texture buttons.

Procedural textures are textures that are defined mathematically.
They are generally relatively simple to use,
because they do not need to be mapped in a special way.
This does not mean that procedural textures cannot become very complex.

These types of textures are ‘real’ 3D. By that we mean that they fit together perfectly at
the edges and continue to look like what they are meant to look like even when they are cut;
as if a block of wood had really been cut in two.
Procedural textures are not filtered or anti-aliased. This is hardly ever a problem:
the user can easily keep the specified frequencies within acceptable limits.
user: What is Make Meta and how is it used in Blender Python scripting?

assistant: Groups the selected NLA-strips into a meta strip.

|  |  |
| --- | --- |
| ../../../_images/editors_nla_strips_meta1.png   Select two or more strips. | ../../../_images/editors_nla_strips_meta2.png   Combine them into a meta strip. |
user: Describe LineStyleAlphaModifier_Material(LineStyleAlphaModifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # LineStyleAlphaModifier_Material(LineStyleAlphaModifier)

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

*class* bpy.types.LineStyleAlphaModifier_Material(*LineStyleAlphaModifier*)
:   Change alpha transparency based on a material attribute

    blend
    :   Specify how the modifier value is blended into the base value

        Type:
        :   enum in [`'MIX'`, `'ADD'`, `'SUBTRACT'`, `'MULTIPLY'`, `'DIVIDE'`, `'DIFFERENCE'`, `'MINIMUM'`, `'MAXIMUM'`], default `'MIX'`

    curve
    :   Curve used for the curve mapping

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

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

    invert
    :   Invert the fade-out direction of the linear mapping

        Type:
        :   boolean, default False

    mapping
    :   Select the mapping type

        - `LINEAR`
          Linear – Use linear mapping.
        - `CURVE`
          Curve – Use curve mapping.

        Type:
        :   enum in [`'LINEAR'`, `'CURVE'`], default `'LINEAR'`

    material_attribute
    :   Specify which material attribute is used

        Type:
        :   enum in [`'LINE'`, `'LINE_R'`, `'LINE_G'`, `'LINE_B'`, `'LINE_A'`, `'DIFF'`, `'DIFF_R'`, `'DIFF_G'`, `'DIFF_B'`, `'SPEC'`, `'SPEC_R'`, `'SPEC_G'`, `'SPEC_B'`, `'SPEC_HARD'`, `'ALPHA'`], default `'LINE'`

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Alpha Modifier Type Items](bpy_types_enum_items/linestyle_alpha_modifier_type_items.html#rna-enum-linestyle-alpha-modifier-type-items), default `'ALONG_STROKE'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleAlphaModifier_Material.type "bpy.types.LineStyleAlphaModifier_Material.type")
user: What is Inherited Properties and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleGeometryModifier.name`](bpy.types.LineStyleGeometryModifier.html#bpy.types.LineStyleGeometryModifier.name "bpy.types.LineStyleGeometryModifier.name") |
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [[image reference removed]](../../../_images/modeling_modifiers_modify_weight-proximity_panel.png)

The Vertex Weight Proximity modifier panel.

Vertex Group
:   The vertex group to affect.

Target Object
:   The object from which to compute distances.

Proximity Mode
:   Object Distance
    :   Use the distance between the modified mesh object and the target object as
        weight for all vertices in the affected vertex group.

    Geometry Distance
    :   Use the distance between each vertex and the target object, or its geometry.

        Vertex
        :   This will set each vertex’s weight from its distance to the nearest vertex of the target object.

        Edge
        :   This will set each vertex’s weight from its distance to the nearest edge of the target object.

        Face
        :   This will set each vertex’s weight from its distance to the nearest face of the target object.

Lowest
:   Distance mapping to 0.0 weight.

Highest
:   Distance mapping to 1.0 weight.

Normalize Weights
:   Scale the weights in the vertex group to keep the relative weight
    but the lowest and highest values follow the full 0 - 1 range.

### Falloff

Type
:   Type of mapping.

    Linear
    :   No mapping.

    Custom Curve
    :   Allows you to manually define the mapping using a curve.

    Sharp, Smooth, Root and Sphere
    :   These are classical mapping functions, from spikiest to roundest.

    Random
    :   Uses a random value for each vertex.

    Median Step
    :   Creates binary weights (0.0 or 1.0), with 0.5 as cutting value.

Invert
:   Inverts the falloff.

### Influence

Those settings are the same for the three *Vertex Weight* modifiers,
see the [Vertex Weight Edit modifier](weight_edit.html#modeling-modifiers-weight-edit-influence-mask-options) page.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`Curves.attributes`](bpy.types.Curves.html#bpy.types.Curves.attributes "bpy.types.Curves.attributes") | - [`Curves.color_attributes`](bpy.types.Curves.html#bpy.types.Curves.color_attributes "bpy.types.Curves.color_attributes") |
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Curve
:   Standard geometry input, containing curves.

Selection
:   Whether or not to change the value on each control point. True values mean the value will be changed,
    false values mean the value will remain the same.

Radius
:   The radius value for each control point.
user: Describe FunctionNodeFloatToInt(FunctionNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # FunctionNodeFloatToInt(FunctionNode)

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

*class* bpy.types.FunctionNodeFloatToInt(*FunctionNode*)
:   Convert the given floating-point number to an integer, with a choice of methods

    rounding_mode
    :   Method used to convert the float to an integer

        Type:
        :   enum in [Node Float To Int Items](bpy_types_enum_items/node_float_to_int_items.html#rna-enum-node-float-to-int-items), default `'ROUND'`

    *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: How do I use BlendDataCameras(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # BlendDataCameras(bpy_struct)

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

*class* bpy.types.BlendDataCameras(*bpy_struct*)
:   Collection of cameras

    new(*name*)
    :   Add a new camera to the main database

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the data-block

        Returns:
        :   New camera data-block

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

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

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

    tag(*value*)
    :   tag

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: ### Unpack Resources

Unpack all external resource files stored into a blend-file.

#### Options

Use files in current directory (create when necessary)
:   Unpacks all files in the same directory `//` as the blend-file,
    grouping them in proper folders (like ‘’textures’’ for instance).
    However, if the final file exists already, it will use that file, instead of unpacking it.

Write files to current directory (overwrite existing files)
:   As with previous option, but if the final file exists already, it will overwrite it.

Use files in original location (create when necessary)
:   Unpacks all files in their original location.
    However, if the final file exists already, it will use that file, instead of unpacking it.

Write files to original location (overwrite existing files)
:   As with previous option, but if the final file exists already, it will overwrite it.

Disable AutoPack, keep all packed files
:   Only deactivates the *Automatically Pack Resources* option.

### Selective Unpacking

A single file can be unpacked by clicking on the little “gift box” icon to the left of its file-path UI widget.

#### Options

Remove Pack
:   Just mark the file as unpacked, without actually writing it or reloading it from the drive.

Create <local file path>
:   Unpack the file at the proposed path, which is local to the current blend-file.

Use <original file path> (differs)|(identical)
:   If the original file path still exists, mark it as unpacked.
    Note that it won’t be automatically reloaded from the drive.
    *(differs)* or *(identical)* show difference status between the packed version
    and the one on-drive.

Overwrite <original file path>
:   If the original file path still exists but differs from the packed version,
    mark it as unpacked and overwrite the on-drive file with the packed version.

Create <original file path>
:   If the original file path does not exist, mark it as unpacked and write it to drive.
user: What is Relocate Linked ID and how is it used in Blender Python scripting?

assistant: A right-click a linked ID will show the *Relocate* option in the *ID Data* sub-menu. It allows to
relocate a directly linked ID by another one, from the same library or from a different one.
This can be used to either fix a broken linked data-block (e.g. because the ID was renamed),
or to switch to a variation of the same data.
user: Explain Camera in complete detail according to the official Blender documentation.

assistant: # Camera

This panel contains all settings of the camera used for filming the movie
which is currently being edited in the Clip editor.
Different predefined settings can be used here and can be chosen from the panel header.
But such settings as distortion coefficients and principal point are not included in the presets and
should be filled in even if camera presets are used.

Sensor Width
:   Is the width of the CCD sensor in the camera. This value can be found in camera specifications.

Pixel Aspect
:   Is the pixel aspect of the CCD sensor. This value can be found in camera specifications,
    but can also be guessed. For example, you know that the footage should be 1920×1080,
    but the images themselves are 1280×1080. In this case, the pixel aspect is: 1920 / 1280 = 1.5.
user: How do I use Dual Mesh Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Dual Mesh Node

[image reference removed]

The *Dual Mesh Node* converts a mesh into its dual, i.e. faces are turned into
vertices and vertices are turned into faces. This also means that attributes
which were on the face domain are transferred to the point domain in the dual mesh.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Many nodes have settings which can affect the way they interact with inputs and outputs.
Node settings are located below the outputs and above any inputs.

[image reference removed]

An example of the controls on the Chroma Key node.
user: Explain Asset Browser in complete detail according to the official Blender documentation.

assistant: # Asset Browser

The *Asset Browser* is the main interface for organizing and using assets.
To access it, create a new [area](../interface/window_system/areas.xhtml),
click the *Editor Type* button in its top left corner, and choose
*Asset Browser*.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`CompositorNodeOutputFile.file_output_items`](bpy.types.CompositorNodeOutputFile.html#bpy.types.CompositorNodeOutputFile.file_output_items "bpy.types.CompositorNodeOutputFile.file_output_items") - [`NodeCompositorFileOutputItems.new`](bpy.types.NodeCompositorFileOutputItems.html#bpy.types.NodeCompositorFileOutputItems.new "bpy.types.NodeCompositorFileOutputItems.new") | - [`NodeCompositorFileOutputItems.remove`](bpy.types.NodeCompositorFileOutputItems.html#bpy.types.NodeCompositorFileOutputItems.remove "bpy.types.NodeCompositorFileOutputItems.remove") |
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Geometry
:   The input geometry containing the original hair curves to duplicate.

Amount
:   The number of duplicates generated for each original curve.
    Higher values increase hair density.

Viewport Amount
:   Defines the percentage of *Amount* used for viewport display.
    Reducing this value improves performance in the viewport while keeping render results unaffected.

Radius
:   The maximum distance around each guide curve within which duplicates are placed.
    Larger values spread the duplicates further apart.

Distribution Shape
:   Controls how duplicates are distributed within the radius, from the center to the outer edge.
    Different shapes can produce uniform, clustered, or edge-biased distributions.

Tip Roundness
:   Adjusts the rounding of duplicate curves near their tips.
    Higher values make the distribution more circular and natural toward the ends.

Even Thickness
:   When enabled, keeps an even density across the radius of duplicates.
    When disabled, density may vary depending on the distribution pattern.

Seed
:   Sets the random seed for duplicate placement.
    Changing this value alters the random arrangement of duplicates while maintaining the same parameters.