PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe Bpy.Types.World from the Blender manual or Python API, including usage steps and snippets.

assistant: world BlendData.worlds BlendDataWorlds.new BlendDataWorlds.remove Scene.world ViewLayer.world_override Next WorldLighting(bpy_struct) Previous WorkSpaceTool(bpy_struct) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page World(ID) World World.animation_data World.color World.cycles World.cycles_visibility World.light_settings World.lightgroup World.mist_settings World.node_tree World.probe_resolution World.sun_angle World.sun_shadow_filter_radius World.sun_shadow_jitter_overblur World.sun_shadow_maximum_resolution World.sun_threshold World.use_eevee_finite_volume World.use_nodes World.use_sun_shadow World.use_sun_shadow_jitter World.inline_shader_nodes() World.bl_rna_get_subclass() World.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: How do I use Key(ID) in Blender? Include parameters, examples, warnings and best practices.

assistant: # Key(ID)

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

*class* bpy.types.Key(*ID*)
:   Shape keys data-block containing different shapes of geometric data-blocks

    animation_data
    :   Animation data for this data-block

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

    eval_time
    :   Evaluation time for absolute shape keys

        Type:
        :   float in [0, 1.04857e+06], default 0.0

    key_blocks
    :   Shape keys

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

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

    use_relative
    :   Make shape keys relative, otherwise play through shapes as a sequence using the evaluation time

        Type:
        :   boolean, default False

    user
    :   Data-block using these shape keys

        Type:
        :   [`ID`](bpy.types.ID.html#bpy.types.ID "bpy.types.ID"), (readonly, 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: Explain View3D Operators in complete detail according to the official Blender documentation.

assistant:            Orbit Left – Orbit the view around to the left.
          - `ORBITRIGHT`
            Orbit Right – Orbit the view around to the right.
          - `ORBITUP`
            Orbit Up – Orbit the view up.
          - `ORBITDOWN`
            Orbit Down – Orbit the view down.

bpy.ops.view3d.view_pan(*\**, *type='PANLEFT'*)
:   Pan the view in a given direction

    Parameters:
    :   **type** (enum in [`'PANLEFT'`, `'PANRIGHT'`, `'PANUP'`, `'PANDOWN'`], (optional)) –

        Pan, Direction of View Pan

        - `PANLEFT`
          Pan Left – Pan the view to the left.
        - `PANRIGHT`
          Pan Right – Pan the view to the right.
        - `PANUP`
          Pan Up – Pan the view up.
        - `PANDOWN`
          Pan Down – Pan the view down.

bpy.ops.view3d.view_persportho()
:   Switch the current view from perspective/orthographic projection

bpy.ops.view3d.view_roll(*\**, *angle=0.0*, *type='ANGLE'*)
:   Roll the view

    Parameters:
    :   - **angle** (*float in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Roll
        - **type** (enum in [`'ANGLE'`, `'LEFT'`, `'RIGHT'`], (optional)) –

          Roll Angle Source, How roll angle is calculated

          - `ANGLE`
            Roll Angle – Roll the view using an angle value.
          - `LEFT`
            Roll Left – Roll the view around to the left.
          - `RIGHT`
            Roll Right – Roll the view around to the right.

bpy.ops.view3d.view_selected(*\**, *use_all_regions=False*)
:   Move the view to the selection center

    Parameters:
    :   **use_all_regions** (*boolean**,* *(**optional**)*) – All Regions, View selected for all regions

bpy.ops.view3d.walk()
:   Interactively walk around the scene

bpy.ops.view3d.zoom(*\**, *mx=0*, *my=0*, *delta=0*, *use_cursor_init=True*)
:   Zoom in/out in the view

    Parameters:
    :   - **mx** (*int in* *[**0**,* *inf**]**,* *(**optional**)*) – Region Position X
        - **my** (*int in* *[**0**,* *inf**]**,* *(**optional**)*) – Region Position Y
        - **delta** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Delta
        - **use_cursor_init** (*boolean**,* *(**optional**)*) – Use Mouse Position, Allow the initial mouse position to be used

bpy.ops.view3d.zoom_border(*\**, *xmin=0*, *xmax=0*, *ymin=0*, *ymax=0*, *wait_for_input=True*, *zoom_out=False*)
:   Zoom in the view to the nearest object contained in the border

    Parameters:
    :   - **xmin** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – X Min
        - **xmax** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – X Max
        - **ymin** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Y Min
        - **ymax** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Y Max
        - **wait_for_input** (*boolean**,* *(**optional**)*) – Wait for Input
        - **zoom_out** (*boolean**,* *(**optional**)*) – Zoom Out

bpy.ops.view3d.zoom_camera_1_to_1()
:   Match the camera to 1:1 to the render output
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_shader_emission_example.jpg   Emission shader, with strength at 1.0. | ../../../_images/render_shader-nodes_shader_emission_example-bright.jpg   Emission shader, with strength at 3.0. |
user: Explain Contribute in complete detail according to the official Blender documentation.

assistant: # Contribute

This guide uses French (`fr`) as an example, but other
[language codes](https://www.gnu.org/software/gettext/manual/html_node/Usual-Language-Codes.html) can be used.
Replace `/fr` in this guide with the code for your desired language.

The currently available languages can be checked on the
[online translation interface](https://translate.blender.org/projects/blender-manual/manual/)
or in the [underlying git repository](https://projects.blender.org/blender/blender-manual-translations).
user: Explain Link in complete detail according to the official Blender documentation.

assistant: *Link* creates a reference to data in a source file such that changes made there will be
reflected in the current file the next time it is reloaded.
In the [File Browser](../../editors/file_browser.xhtml), navigate to the external source blend-file
and select the data-blocks you want to reuse.

Linked data-blocks are indicated with a chain icon in the [Outliner](../../editors/outliner/introduction.xhtml).
They’re also listed in the Outliner’s *Blender File* [Display Mode](../../editors/outliner/interface.xhtml#bpy-types-spaceoutliner-display-mode),
along with the path of the blend-file they originate from.

Linked data-blocks are initially not editable. This even includes the location/rotation/scale
of linked objects, which are locked to the transformation they have in the source file.
There are ways around this, however:

- If you link a collection with *Instance Collections* enabled or some
  [object data](../../scene_layout/object/introduction.xhtml) with
  *Instance Object Data* enabled, the collection/object data will be referenced through
  an object created inside the current blend-file, which *can* be transformed.
  (This new object will be created at the [3D Cursor](../../editors/3dview/3d_cursor.xhtml#editors-3dview-3d-cursor).)
- You can also do some level of editing/animating on linked (and thus normally locked)
  data-blocks using [Library Overrides](library_overrides.xhtml).

### Options

These options are available in the right-hand panel of the File Browser.

Relative Path
:   Reference the external blend-file using a
    [relative path](../blend/open_save.xhtml#files-blend-relative-paths) rather than an absolute one.

Select
:   Select the newly added objects.

Active Collection
:   When enabled, objects and collections will be added to the active collection of the active
    [view layer](../../render/layers/introduction.xhtml).
    Otherwise, they will be added to a new “Linked Data” collection in the active view layer.

Instance Collections
:   When enabled, each linked collection will be added to the scene as an
    [instance collection](../../scene_layout/object/properties/instancing/collection.xhtml)
    (that is, a single object that represents the entire collection).
    You can add more such instances using Add ‣ Collection Instance,
    or replace an instance by the collection contents using [Make Instances Real](../../scene_layout/object/editing/apply.xhtml#bpy-ops-object-duplicates-make-real).

    When disabled, the collections will be added as-is so you can see their content in the
    Outliner and create Library Overrides.

Instance Object Data
:   When enabled, an object will be created for each directly linked object data.
    Otherwise, no object will be created and the object data will not be visible in
    the scene until you create one yourself (e.g. by dragging the object data from the
    Outliner into the 3D Viewport).
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Laplacian
:   A float grid representing the Laplacian of the input field.

    Each voxel contains the sum of the second derivatives of the input
    field along the X, Y, and Z axes. This can be used to detect local
    peaks and valleys or to drive smoothing and diffusion effects in
    procedural grids.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`Object.constraints`](bpy.types.Object.html#bpy.types.Object.constraints "bpy.types.Object.constraints") - [`ObjectConstraints.active`](bpy.types.ObjectConstraints.html#bpy.types.ObjectConstraints.active "bpy.types.ObjectConstraints.active") - [`ObjectConstraints.copy`](bpy.types.ObjectConstraints.html#bpy.types.ObjectConstraints.copy "bpy.types.ObjectConstraints.copy") - [`ObjectConstraints.copy`](bpy.types.ObjectConstraints.html#bpy.types.ObjectConstraints.copy "bpy.types.ObjectConstraints.copy") - [`ObjectConstraints.new`](bpy.types.ObjectConstraints.html#bpy.types.ObjectConstraints.new "bpy.types.ObjectConstraints.new") - [`ObjectConstraints.remove`](bpy.types.ObjectConstraints.html#bpy.types.ObjectConstraints.remove "bpy.types.ObjectConstraints.remove") - [`Panel.custom_data`](bpy.types.Panel.html#bpy.types.Panel.custom_data "bpy.types.Panel.custom_data") | - [`PoseBone.constraints`](bpy.types.PoseBone.html#bpy.types.PoseBone.constraints "bpy.types.PoseBone.constraints") - [`PoseBoneConstraints.active`](bpy.types.PoseBoneConstraints.html#bpy.types.PoseBoneConstraints.active "bpy.types.PoseBoneConstraints.active") - [`PoseBoneConstraints.copy`](bpy.types.PoseBoneConstraints.html#bpy.types.PoseBoneConstraints.copy "bpy.types.PoseBoneConstraints.copy") - [`PoseBoneConstraints.copy`](bpy.types.PoseBoneConstraints.html#bpy.types.PoseBoneConstraints.copy "bpy.types.PoseBoneConstraints.copy") - [`PoseBoneConstraints.new`](bpy.types.PoseBoneConstraints.html#bpy.types.PoseBoneConstraints.new "bpy.types.PoseBoneConstraints.new") - [`PoseBoneConstraints.remove`](bpy.types.PoseBoneConstraints.html#bpy.types.PoseBoneConstraints.remove "bpy.types.PoseBoneConstraints.remove") - [`UILayout.template_constraint_header`](bpy.types.UILayout.html#bpy.types.UILayout.template_constraint_header "bpy.types.UILayout.template_constraint_header") |
user: Provide the full official documentation entry for Handle Type Selection Node, preserving all code examples.

assistant: # Handle Type Selection Node

[image reference removed]

Creates a selection based on the handle types of the control points.

The handle type of each control point can be changed with the
[Set Handle Type Node](../write/set_handle_type.xhtml).
user: Show practical ways to work with Relative Shape Keys in a Blender add-on or script – include code.

assistant: [image reference removed]

Relative Shape Keys options.

See [Relative or Absolute Shape Keys](introduction.xhtml#animation-shapekeys-relative-vs-absolute).

With relative shape keys, the value shown for each shape in the list represents
the current weight or influence of that shape in the current *Mix*.

(Clear Shape Keys)
:   Set all influence values, or weights, to zero.
    Useful to quickly guarantee that the result shown in the 3D Viewport is not affected by shapes.

Value
:   The weight of the blend between the shape key and its reference key (usually the Basis shape).

    A value of 0.0 denotes 100% influence of the reference key and 1.0 of the shape key.

Range
:   Minimum and maximum range for the influence value of the active shape key.
    Blender can extrapolate results when the *Value* goes lower than 0.0 or above 1.0.

Vertex Group
:   Limit the active shape key deformation to a vertex group.
    Useful to break down a complex shape into components by assigning temporary vertex groups
    to the complex shape and copying the result into new simpler shapes.

Relative To
:   Select the shape key to deform from. This is called the *Reference Key* for that shape.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`ToolSettings.vertex_paint`](bpy.types.ToolSettings.html#bpy.types.ToolSettings.vertex_paint "bpy.types.ToolSettings.vertex_paint") | - [`ToolSettings.weight_paint`](bpy.types.ToolSettings.html#bpy.types.ToolSettings.weight_paint "bpy.types.ToolSettings.weight_paint") |
user: Provide the full official documentation entry for Common Brushes, preserving all code examples.

assistant: There are many brushes to choose from but these are the most common brushes to be used during sculpting.
More information on sculpting brushes in the [Toolbar](../toolbar.xhtml).

[image reference removed]

[Clay Strips](../brushes/clay_strips.xhtml)
:   Block out broad shapes and build up volumes before refining them further.

[Grab](../brushes/grab.xhtml)
:   Move geometry across the screen for general shaping.

[Smooth](../brushes/smooth.xhtml)
:   Smooth and shrink surfaces to remove noise or flatten shapes.

[Draw](../brushes/draw.xhtml)
:   Generic adding and subtracting on surfaces.
    This brush is often customized with different stroke methods and textures for various effects.

[Plane](../brushes/plane.xhtml)
:   Scrape and fill surfaces either for hard surface sculpting or more aggressive smoothing.

[Inflate](../brushes/inflate.xhtml)
:   Inflate or shrink volumes or surfaces.
    Especially useful for controlling the thickness of cylindrical shapes.

[Draw Sharp](../brushes/draw_sharp.xhtml)
:   Same as *Draw* but with a much sharper falloff. Useful for adding creases, cracks and other sharp edges.

[Crease](../brushes/crease.xhtml)
:   A mix of the *Draw* and *Pinch* brushes.
    Useful for creating detailed creases or sharpening existing creases for additional polish.

[Snake Hook](../brushes/snake_hook.xhtml).
:   Similar to *Grab* but this brush will dynamically let go and pick up geometry during the stroke.
    The dragged geometry is also following the angle of the stroke, making it very useful for
    pulling geometry out.
    Ideally used together with [Dyntopo](adaptive.xhtml#dyntopo-introduction).
user: How do I use Delete in Blender? Include parameters, examples, warnings and best practices.

assistant: Options for the *Delete* pop-up menu:

Vertices
:   This will delete the selected control points, *without* breaking the curve
    (i.e. the adjacent points will be directly linked, joined, once the intermediary ones are deleted).
    Remember that NURBS order cannot be higher than its number of control points,
    so it might decrease when you delete some control point.
    Of course, when only one point remains, there is no more visible curve,
    and when all points are deleted, the curve itself is deleted.

Segment
:   Deletes the segment that connects the selected control points and disconnecting them.

### Dissolve Vertices

Deletes the selected control points, while the remaining segment
is fitted to the deleted curve by adjusting its handles.

|  |  |
| --- | --- |
| ../../../_images/modeling_curves_editing_curve_make-segment.png   Before deleting. | ../../../_images/modeling_curves_editing_curve_delete-vertices.png   Deleting vertices. |
| ../../../_images/modeling_curves_editing_curve_delete-segment.png   Deleting segment. | ../../../_images/modeling_curves_editing_curve_dissolve-vertices.png   Dissolve vertices. |
user: Show practical ways to work with Selecting Multiple Data-Blocks in a Blender add-on or script – include code.

assistant: Extend the selection one data-block at a time using `Ctrl`-`LMB`.
Each data-block added to the selection this way will be made the active data-block.

Select a range of elements from the active element using `Shift`-`LMB`.
To select a range without deselecting the previous selection, use `Shift`-`Ctrl`-`LMB`.

Select all children of an item by double clicking the item’s icon.

A click and drag from any location in the Outliner other than a name or icon will begin a box selection.
Use `Shift` to add and `Ctrl` to subtract from existing selections with box select.
Box select can also be started with `B`.

To select all items use `A`; `Alt`-`A` will deselect all items.

The keyboard arrow keys can be used to navigate and select in the Outliner.
Keyboard selection and navigation starts from the active data-block.

|  |  |
| --- | --- |
| `Up` | Select the previous element in the list. |
| `Down` | Select the next element in the list. |
| `Shift`-`Up` | Select the previous element without deselecting. |
| `Shift`-`Down` | Select the next element without deselecting. |
| `Left` | Close the data-block or select the parent. |
| `Right` | Open the data-block to view children or select the first child. |
| `Shift`-`Left` | Close this and all child data-blocks. |
| `Shift`-`Right` | Open this and all child data-blocks. |
user: Give a detailed overview of RenderSettings(bpy_struct): syntax, arguments, return values, common patterns.

assistant:  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 ClothSolverResult(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # ClothSolverResult(bpy_struct)

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

*class* bpy.types.ClothSolverResult(*bpy_struct*)
:   Result of cloth solver iteration

    avg_error
    :   Average error during substeps

        Type:
        :   float in [-inf, inf], default 0.0, (readonly)

    avg_iterations
    :   Average iterations during substeps

        Type:
        :   float in [-inf, inf], default 0.0, (readonly)

    max_error
    :   Maximum error during substeps

        Type:
        :   float in [-inf, inf], default 0.0, (readonly)

    max_iterations
    :   Maximum iterations during substeps

        Type:
        :   int in [-inf, inf], default 0, (readonly)

    min_error
    :   Minimum error during substeps

        Type:
        :   float in [-inf, inf], default 0.0, (readonly)

    min_iterations
    :   Minimum iterations during substeps

        Type:
        :   int in [-inf, inf], default 0, (readonly)

    status
    :   Status of the solver iteration

        - `SUCCESS`
          Success – Computation was successful.
        - `NUMERICAL_ISSUE`
          Numerical Issue – The provided data did not satisfy the prerequisites.
        - `NO_CONVERGENCE`
          No Convergence – Iterative procedure did not converge.
        - `INVALID_INPUT`
          Invalid Input – The inputs are invalid, or the algorithm has been improperly called.

        Type:
        :   enum set in {`'SUCCESS'`, `'NUMERICAL_ISSUE'`, `'NO_CONVERGENCE'`, `'INVALID_INPUT'`}, default set(), (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: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Geometry
:   Standard geometry input.

Mode
:   How the transformation is specified.

    Components:
    :   Provide separate inputs for location, rotation and scale.

    Matrix:
    :   Use a transformation matrix.

Translation
:   Translation of the entire geometry in the local space of the modified object.

Rotation
:   Euler rotation in the local space of the modified object.

Scale
:   Scale for the geometry in the local space of the modified object.

Transform
:   A [Transformation Matrix](../../../../glossary/index.xhtml#term-Transformation-Matrix), available when using *Matrix* mode.
user: How do I use ShaderNodeNormalMap(ShaderNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ShaderNodeNormalMap(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.ShaderNodeNormalMap(*ShaderNode*)
:   Generate a perturbed normal from an RGB normal map image. Typically used for faking highly detailed surfaces

    space
    :   Space of the input normal

        - `TANGENT`
          Tangent Space – Tangent space normal mapping.
        - `OBJECT`
          Object Space – Object space normal mapping.
        - `WORLD`
          World Space – World space normal mapping.
        - `BLENDER_OBJECT`
          Blender Object Space – Object space normal mapping, compatible with Blender render baking.
        - `BLENDER_WORLD`
          Blender World Space – World space normal mapping, compatible with Blender render baking.

        Type:
        :   enum in [`'TANGENT'`, `'OBJECT'`, `'WORLD'`, `'BLENDER_OBJECT'`, `'BLENDER_WORLD'`], default `'TANGENT'`

    uv_map
    :   UV Map for tangent space maps

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

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

assistant: # GeometryNodeResampleCurve(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.GeometryNodeResampleCurve(*GeometryNode*)
:   Generate a poly spline for each input spline

    keep_last_segment
    :   Do not collapse curves to single points if they are shorter than the given length. The collapsing behavior exists for compatibility reasons.

        Type:
        :   boolean, default False

    *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 Keyboard Shortcuts in Blender? Include parameters, examples, warnings and best practices.

assistant: To quickly add a *Subdivision Surface* modifier to one or more objects, select the object(s) and press `Ctrl`-`1`.
That will add a Subdivision Surface modifier with *Viewport* subdivisions set to 1.
You can use other numbers too, such as `Ctrl`-`2`, `Ctrl`-`3`, etc,
to add a modifier with that number of subdivisions.
Adding a *Subdivision Surface* modifier in this fashion will not modify the *Render* subdivisions.

If an object already has a *Subdivision Surface* modifier,
doing this will simply change its subdivision level instead of adding another modifier.
user: Give a detailed overview of CompositorNodeGlare(CompositorNode): syntax, arguments, return values, common patterns.

assistant: # CompositorNodeGlare(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.CompositorNodeGlare(*CompositorNode*)
:   Add lens flares, fog and glows around bright parts of the image

    *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: Explain Viewport Display in complete detail according to the official Blender documentation.

assistant: These settings control the 3D Viewport display in solid shading.
They provide a faster alternative to full shader nodes,
which may be too heavy or distracting for tasks like modeling, layout or sculpting.

Color
:   Diffuse or metal surface color.

Metallic
:   Blends between a non-metallic and metallic material model.
    A value of 1.0 gives a fully specular reflection tinted with the base color,
    without diffuse reflection or transmission.
    At 0.0 the material consists of a diffuse or transmissive base layer, with a specular reflection layer on top.

Roughness
:   Specifies microfacet roughness of the surface for metal and specular reflection.
user: Provide the full official documentation entry for Motion Paths, preserving all code examples.

assistant: # Motion Paths

[[image reference removed]](../_images/animation_motion-paths_example-object.png)

An animated cube with its motion path displayed.

The Motion Paths tool allows you to visualize the motion of points as paths over a series of frames.
These points can be object origins and bone joints.

To create or remove motion paths, it is necessary to first select the bones. Then:

1. To show the paths (or update them, if needed), click on the *Calculate Path* button.
2. To hide the paths, click on the *Clear Paths* button.

The paths are shown in red for the section in the past and green for the section in the future.
These colors follow the user preference options “Before Current Frame” and “After Current Frame”,
which can be found in the 3D Viewport section.
Each frame is displayed by a small dot on the paths.

The paths are automatically updated when you edit your poses/keyframes,
and they are also active during animation playback. Playing the animation
affects the paths only when using the *Around Frame* type.
user: Describe Luminance Key Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Luminance Key Node

[image reference removed]

The *Luminance Key* node determines background objects from foreground objects by
the difference in the luminance (brightness) levels.

Stock footage of explosions, smoke or debris are normally shot against a solid,
dark background rather than a green screen.
This node can separate the foreground effect from the background.
It can also be used for sky replacement for overexposed or gray skies
that aren’t suitable for chroma keying.
user: Describe Field Variance Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Field Variance Node

[image reference removed]

The *Field Variance* node computes the variance and standard deviation of a field over a given domain.
This is useful for measuring how much a value varies across geometry or within specific groups.

For example, it can be used to analyze the spread of values like weights, positions, or custom attributes
within each group defined by the *Group ID*.
user: Describe CompositorNodeImageCoordinates(CompositorNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CompositorNodeImageCoordinates(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.CompositorNodeImageCoordinates(*CompositorNode*)
:   Returns the coordinates of the pixels of an image

    *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: Show practical ways to work with Inherited Properties in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`NodeTreeInterfaceItem.item_type`](bpy.types.NodeTreeInterfaceItem.html#bpy.types.NodeTreeInterfaceItem.item_type "bpy.types.NodeTreeInterfaceItem.item_type") - [`NodeTreeInterfaceItem.parent`](bpy.types.NodeTreeInterfaceItem.html#bpy.types.NodeTreeInterfaceItem.parent "bpy.types.NodeTreeInterfaceItem.parent") | - [`NodeTreeInterfaceItem.position`](bpy.types.NodeTreeInterfaceItem.html#bpy.types.NodeTreeInterfaceItem.position "bpy.types.NodeTreeInterfaceItem.position") - [`NodeTreeInterfaceItem.index`](bpy.types.NodeTreeInterfaceItem.html#bpy.types.NodeTreeInterfaceItem.index "bpy.types.NodeTreeInterfaceItem.index") |
user: How do I use Float4x4Attribute(Attribute) in Blender? Include parameters, examples, warnings and best practices.

assistant: # Float4x4Attribute(Attribute)

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

*class* bpy.types.Float4x4Attribute(*Attribute*)
:   Geometry attribute that stores a 4 by 4 float matrix

    data
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`Float4x4AttributeValue`](bpy.types.Float4x4AttributeValue.html#bpy.types.Float4x4AttributeValue "bpy.types.Float4x4AttributeValue"), (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: Provide the full official documentation entry for Relations, preserving all code examples.

assistant: # Relations

[image reference removed]

Bone Relations panel.

In this panel you can manage the relationship of this bone with its parent bone.
It also shows the bone collections the bone is assigned to.
user: Give a detailed overview of Falloff: syntax, arguments, return values, common patterns.

assistant: # Falloff

The *Falloff* is a curve that determines how the strength of the brush decreases
with increasing distance from the center. You can set up a custom curve or choose
a predefined one.

[image reference removed]

Brush falloff example.

Curve Preset
:   Custom
    :   Shows a [Curve Widget](../../interface/controls/templates/curve.xhtml) for configuring a custom falloff.
        The left side of the curve corresponds to the center of the brush while the right side
        corresponds to the edge.

    Predefined
    :   The predefined falloff curves look as follows:

        Built-in falloff curves

        |  |  |  |
        | --- | --- | --- |
        | ../../_images/sculpt-paint_brush_falloff_smooth.png   Smooth | ../../_images/sculpt-paint_brush_falloff_smoother.png   Smoother | ../../_images/sculpt-paint_brush_falloff_sphere.png   Sphere |
        | ../../_images/sculpt-paint_brush_falloff_root.png   Root | ../../_images/sculpt-paint_brush_falloff_sharp.png   Sharp | ../../_images/sculpt-paint_brush_falloff_linear.png   Linear |
        | ../../_images/sculpt-paint_brush_falloff_sharper.png   Sharper | ../../_images/sculpt-paint_brush_falloff_invsquare.png   Inverse Square | ../../_images/sculpt-paint_brush_falloff_constant.png   Constant |

Falloff Shape
:   Determines how the falloff distance is calculated.

    Sphere:
    :   The falloff is calculated using a sphere in three-dimensional world space.
        If two points on the mesh appear near each other in the 3D Viewport but are
        far away in the world, painting one will not affect the other.

    Projected:
    :   The falloff is calculated using a circle in two-dimensional screen space.
        If two points on the mesh appear near each other in the 3D Viewport, painting
        one will also affect the other, no matter their distance in the world.

    Texture Paint Mode does not have this option – it always uses *Projected*.

Normal Falloff / Front-Face Falloff
:   Weakens the brush strength for faces whose normal points towards the screen edges
    instead of the camera.

    This feature is not available in Sculpt Mode.

    Angle
    :   The minimum angle between the face normal and the viewing direction for the
        falloff to start.
user: Describe Texture Operators from the Blender manual or Python API, including usage steps and snippets.

assistant: # Texture Operators

bpy.ops.texture.new()
:   Add a new texture

bpy.ops.texture.slot_copy()
:   Copy the material texture settings and nodes

bpy.ops.texture.slot_move(*\**, *type='UP'*)
:   Move texture slots up and down

    Parameters:
    :   **type** (enum in [`'UP'`, `'DOWN'`], (optional)) – Type

bpy.ops.texture.slot_paste()
:   Copy the texture settings and nodes
user: Show practical ways to work with NodeCombineBundleItem(bpy_struct) in a Blender add-on or script – include code.

assistant: # NodeCombineBundleItem(bpy_struct)

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

*class* bpy.types.NodeCombineBundleItem(*bpy_struct*)
:   color
    :   Color of the corresponding socket type in the node editor

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

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

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

    structure_type
    :   What kind of higher order types are expected to flow through this socket

        Type:
        :   enum in [Node Socket Structure Type Items](bpy_types_enum_items/node_socket_structure_type_items.html#rna-enum-node-socket-structure-type-items), default `'AUTO'`

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

assistant: # Newtonian

The particles will move according to classical (Newtonian) mechanics.
Particles start their life with the specified initial velocities and angular velocities,
and move according to external forces.
The response to environment and to forces is computed differently,
according to the given integrator chosen by the animator.

[image reference removed]

Newtonian Physics settings.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Instances
:   Standard geometry input.

Selection
:   Boolean field used to determine if an instance will be scaled.

Scale
:   The scale factor to apply to the instance’s transform on each axis.

Center
:   The position from which the instance origins are scaled. Each instance will move away from this location.
    When the *Local Space* input is enabled, this location is relative to the initial transform
    of each instance.

Local Space
:   If enabled, the instances are scaled in local space. In other words,
    they are scaled in the directions the described by the initial transform of each instance.
    When the input is disabled, the *Center* and *Scale* inputs are specified in
    the local space of the modifier object.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Level
:   H (Hue), S (Saturation), V (Value)

Curve
:   For the curve controls see: [Curve widget](../../../../interface/controls/templates/curve.html#ui-curve-widget).
    By default, the curve is a straight line, meaning there is no change.
    The spectrum allows you to raise or lower HSV levels for each range of pixel colors.
    To change an H, S, or V level, move the curve points up or down. Pixels with hue values each
    point in the horizontal position of the graph will be changed depending on the shape of the curve.
user: Show practical ways to work with Header in a Blender add-on or script – include code.

assistant: # Header

Every constraint has a header at the top:

[image reference removed]

Constraint header

/ Expand/Collapse
:   Show or hide the settings of the constraint. Collapsed constraints remain active.

Icon
:   Icon representing the constraint’s type. If this icon is red, one or more settings are not
    correctly filled in and the constraint has no effect.

Name
:   Initially this is simply the constraint type, but it can be customized to something
    more specific.

Enabled
:   Enable or disable the constraint. Disabling a constraint turns off its effects while keeping
    its settings around for the future.

    Another way of disabling a constraint is to set its [Influence](common.xhtml#bpy-types-constraint-influence)
    to zero. Unlike the *Enabled* setting, this can be animated.

Extras
:   Apply `Ctrl`-`A`
    :   Applies the constraint’s result to the object’s/bone’s own transformation,
        then deletes the constraint.

    Duplicate `Shift`-`D`
    :   Creates a copy of the constraint just below current one.

    Copy to Selected
    :   Copies the constraint from the [Active](../../../glossary/index.xhtml#term-Active) object to all selected objects.

    Move to First/Last
    :   Moves the constraint to the first or last position in the stack.

Delete `X`, `Delete`
:   Delete the constraint from the stack.
    Its settings will be lost and it will no longer affect the object/bone.

Move
:   Drag to move the constraint up or down in the [stack](stack.xhtml).
    Since the stack is evaluated from top to bottom,
    moving a constraint can significantly affect the final outcome.
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

Drivers are a way to control values of properties by means of a function,
or a mathematical expression.

Effectively, drivers consist of:

- A **driver configuration** that specifies zero, one, or more input values using
  other properties or object transformation channels, and combines them using
  a predefined mathematical function or a custom Python expression.
- An **animation** [F-Curve](../../editors/graph_editor/fcurves/introduction.html)
  that maps the output of the driver configuration to the final value to apply
  to the driven property.

As an example, the rotation of Object 1 can be controlled by the scale of Object 2.
It is then said that the scale of Object 2 *drives* the rotation of Object 1.

Not only can drivers directly set the value of a property to the value of a different one,
they can also combine multiple values using a fixed function or a Python expression
and further modulate it with a manually defined curve and/or a modifier stack.

Drivers are an extremely powerful tool for building rigs and are typically used
to drive bone transforms and the influence of shape keys, action constraints and
modifiers, often using custom properties as inputs.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Data Type
:   Float:
    :   The node will average a *Float* field.

    Vector:
    :   The node will average a *Vector* field.

Domain
:   The [attribute domain](../../attributes_reference.xhtml#attribute-domains) used for evaluate the *Value* input.