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

assistant: # Repeat Zone

A *Repeat Zone* executes a set of nodes multiple times.

[image reference removed]

The zone consists of an input node on the left, an output node on the right,
and an orange area in the middle for placing the nodes to repeat. When the zone executes
for the first time, it evaluates its inputs and forwards them to its inner nodes.
These inner nodes can then write to the output node for providing inputs to the next
iteration, and for providing the result of the zone after the last iteration.

The nodes inside the zone can also take inputs from nodes outside the zone – these
inputs are then the same in every iteration. However, nodes inside the zone can’t
send their outputs to nodes outside the zone.
user: Provide the full official documentation entry for Overview, preserving all code examples.

assistant: Closures are a socket type that represent callable node graphs.
They define a set of inputs and outputs that can be evaluated inside another node group through the
[Evaluate Closure](evaluate_closure.html) node.

When a closure is connected, its internal node graph is *injected* into the evaluation of the node group where it is
used. This allows procedural systems to remain flexible while exposing clear, customizable control points.

Closures can be thought of as function parameters for node groups.
They let users define operations that can be executed in a controlled environment defined by the parent node tree.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Tone Compositor Only
:   Standard:
    :   The Combined curve is applied to each channel individually, which may result in a change of hue.

    Filmlike:
    :   Keeps the hue constant.

Channel
:   The curve to show.

    C:
    :   Combined

    R:
    :   Red

    G:
    :   Green

    B:
    :   Blue

Curve
:   A Bézier curve that maps each input level (X axis) to an output level (Y axis).
    For the curve controls, see [Curve widget](../../../../interface/controls/templates/curve.xhtml#ui-curve-widget).
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Offset
:   Determines the brick offset of the various rows.

Frequency
:   Determines the offset frequency. A value of 2 gives an even/uneven pattern of rows.

Squash
:   Amount of brick squashing.

Frequency
:   Brick squashing frequency.
user: Show practical ways to work with Mirror Modifier in a Blender add-on or script – include code.

assistant: # Mirror Modifier

The *Mirror* modifier mirrors the strokes along its local X, Y and/or Z axes, across the [Object Origin](../../../glossary/index.xhtml#term-Object-Origin).
It can also use another object as the mirror center, then use that object’s local axes instead of its own.
user: How do I use MultiresModifier(Modifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # MultiresModifier(Modifier)

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

*class* bpy.types.MultiresModifier(*Modifier*)
:   Multiresolution mesh modifier

    boundary_smooth
    :   Controls how open boundaries are smoothed

        Type:
        :   enum in [Subdivision Boundary Smooth Items](bpy_types_enum_items/subdivision_boundary_smooth_items.html#rna-enum-subdivision-boundary-smooth-items), default `'ALL'`

    filepath
    :   Path to external displacements file

        Type:
        :   string, default “”, (never None, blend relative `//` prefix supported)

    is_external
    :   Store multires displacements outside the .blend file, to save memory

        Type:
        :   boolean, default False, (readonly)

    levels
    :   Number of subdivisions to use in the viewport

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

    quality
    :   Accuracy of vertex positions, lower value is faster but less precise

        Type:
        :   int in [1, 10], default 4

    render_levels
    :   The subdivision level visible at render time

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

    sculpt_levels
    :   Number of subdivisions to use in sculpt mode

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

    show_only_control_edges
    :   Skip drawing/rendering of interior subdivided edges

        Type:
        :   boolean, default True

    total_levels
    :   Number of subdivisions for which displacements are stored

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

    use_creases
    :   Use mesh crease information to sharpen edges or corners

        Type:
        :   boolean, default True

    use_custom_normals
    :   Interpolates existing custom normals to resulting mesh

        Type:
        :   boolean, default False

    use_sculpt_base_mesh
    :   Make Sculpt Mode tools deform the base mesh while previewing the displacement of higher subdivision levels

        Type:
        :   boolean, default False

    uv_smooth
    :   Controls how smoothing is applied to UVs

        Type:
        :   enum in [Subdivision Uv Smooth Items](bpy_types_enum_items/subdivision_uv_smooth_items.html#rna-enum-subdivision-uv-smooth-items), default `'PRESERVE_BOUNDARIES'`

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

assistant: # Normal Selection Node

[image reference removed]

The *Normal Selection* node creates a selection of elements whose normals point
in a specified direction within a given angular threshold.
It is useful for selecting geometry that faces a certain way, such as upward-facing
surfaces, walls, or elements oriented toward a light or camera.
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: [image reference removed]

The Cube object was linked duplicated.

The object `Cube` was linked duplicated, using `Alt`-`D`.
Though both these cubes are separate objects with unique names:
`Cube` and `Cube.001`, the single mesh named `Cube`, is shared by both.

- As a mesh is edited in *Edit Mode* in one object, the same occurs in
  the other cube as well. The mesh data are links, not copies.
- In contrast, if one of these two cubes is rotated or scaled in *Object Mode*,
  the other remains unchanged. The transform properties are copied, not linked.
- As in the previous example, the newly created cube has inherited
  the material of the original cube. The material properties are linked, not copied.

A common table has a top and four legs. Model one leg, and then make linked duplicates
three times for each of the remaining legs. If you later make a change to the mesh,
all the legs will still match. Linked duplicates also apply to a set of drinking glasses,
wheels on a car… anywhere there is repetition or symmetry.
user: What is CPU Rendering and how is it used in Blender Python scripting?

assistant: Being a rasterization engine, EEVEE only uses the power of
the GPU to render.
There is no plan to support CPU (software) rendering
as it would be very inefficient. CPU power is still needed to handle high scene complexity
as the geometry must be prepared by the CPU before rendering each frame.
user: Provide the full official documentation entry for F-Curve Modifiers, preserving all code examples.

assistant: # F-Curve Modifiers

F-Curve modifiers are similar to object modifiers, in that they add non-destructive effects
that can be adjusted at any time and layered to create more complex effects.

Modifiers are evaluated from top to bottom.
You can change their order by dragging the dots in their top right corner.
user: How do I use Display in Blender? Include parameters, examples, warnings and best practices.

assistant: Text Info Overlay
:   Object Info
    :   Display the active Object name and frame number at the top left of the 3D Viewport.

    View Name
    :   Display the name and type of the current view in the top left corner of the 3D Viewport.
        For example: “User Perspective” or “Top Orthographic”.

Playback Frame Rate (FPS)
:   Show the frames per second screen refresh rate while an animation is played back.
    It appears in the top left of the 3D Viewport, displaying red if the frame rate set cannot be reached.

    Frame Rate Samples
    :   Calculate the FPS displayed in the viewport based on an average of the current and previously displayed frames.
        A value of zero uses the number of frames in 1.0 second.

        - More samples represent the average FPS over a longer period of time,
          however sudden changes to performance result in a more gradual increase/decrease over time.
        - Fewer samples shows an FPS which more closely matches the actual performance,
          however the value may jitter - making the FPS difficult to comprehend.

Gizmo Size
:   Diameter of the gizmo.

HDRI Preview Size
:   Diameter of the HDRI sphere overlay.

3D Viewport Axes
:   Interactive Navigation:
    :   Display the axis as an interactive gizmo.
        Click sets the viewport to display along this axis and dragging orbits the view.

    Simple Axes:
    :   Display simple, less intrusive axis in the viewport.

        Brightness
        :   How vivid the colors of the simple axis are.

    Off:
    :   Disables the viewport axis.

Size
:   Diameter of the *3D Viewport Axis* widget.

Fresnel – Edit Mode
:   Enable a fresnel effect on edit mesh overlays.
    It improves shape readability of very dense meshes, but increases eye fatigue when modeling lower poly.
user: Explain System in complete detail according to the official Blender documentation.

assistant: # System

The *System* section allows you to set graphics card options, memory limits & sound settings.

If your hardware does not support some of the options described on this page,
then they will either not be displayed or be corrected on startup.

[image reference removed]

Preferences System section.
user: What is Copy/Paste and how is it used in Blender Python scripting?

assistant: Use `Ctrl`-`C` to copy the selected keyframes and `Ctrl`-`V` to paste them.
After pasting, the [Adjust Last Operation](../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel provides some extra options:

Frame Offset
:   Offsets the pasted keyframes horizontally so that…

    Frame Start
    :   …the first one lands on the current frame.

    Frame End
    :   …the last one lands on the current frame.

    Frame Relative
    :   …they land at the same distance from the current frame as when they were copied.

    No Offset
    :   …they stay at their original frames.

Value Offset
:   Offsets the pasted keyframes vertically so that…

    Left Key
    :   …the first one has the value of the existing keyframe to the left of the Playhead.

    Right Key
    :   …the last one has the value of the existing keyframe to the right of the Playhead.

    Current Frame Value
    :   …the first one has the value of the curve at the current frame.

    Cursor Value
    :   …the first one has the value of the [2D Cursor](../introduction.html#graph-editor-2d-cursor).

    No Offset
    :   …they keep their original values.

Type
:   Mix
    :   Integrates the pasted keyframes with existing ones, only overwriting those that share a frame.

    Overwrite All
    :   Removes all previous keyframes in the target F-Curves.

    Overwrite Range
    :   Within each F-Curve, remove the existing keyframes that are in the range of the keyframes
        pasted into it.

    Overwrite Entire Range
    :   Within each F-Curve, remove the existing keyframes that are in the range of all pasted
        keyframes combined.

Flipped
:   If you copied keyframes from one or more pairs of
    [symmetrically opposite bones](../../../animation/armatures/bones/editing/naming.html),
    enabling this option will paste the keyframes of the left bones into the curves of the right ones
    and vice versa. In addition, the values are inverted, effectively mirroring the animation.
user: How do I use Duplicate Active Keyframe (Active Layer) in Blender? Include parameters, examples, warnings and best practices.

assistant: Duplicates the strokes on the last keyframe by copying them to the current frame.

Mode
:   Pick which layers to duplicate.

    Active:
    :   Duplicate only the active layer.

    All:
    :   Duplicate all the layers.
user: Explain ShaderNodeVolumeAbsorption(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeVolumeAbsorption(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.ShaderNodeVolumeAbsorption(*ShaderNode*)
:   Absorb light as it passes through the volume

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Exterior

Exterior forces are applied to the vertices (and nearly exclusively to the vertices)
of soft body objects. This is done using Newton’s Laws of Physics:

- If there is no force on a vertex, it stays either unmoved or moves with constant speed in a straight line.
- The acceleration of a vertex depends on its mass and the force.
  The heavier the mass of a vertex the slower the acceleration. The larger the force the greater the acceleration.
- For every action there is an equal and opposite reaction.

Well, this is done only in the range of computing accurateness,
there is always a little damping to avoid overshoot of the calculation.
user: How do I use Bpy.Types.Volume in Blender? Include parameters, examples, warnings and best practices.

assistant: ge Volume(ID) Volume Volume.animation_data Volume.display Volume.filepath Volume.frame_duration Volume.frame_offset Volume.frame_start Volume.grids Volume.is_sequence Volume.materials Volume.packed_file Volume.render Volume.sequence_mode Volume.velocity_grid Volume.velocity_scale Volume.velocity_unit Volume.velocity_x_grid Volume.velocity_y_grid Volume.velocity_z_grid Volume.bl_rna_get_subclass() Volume.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [[image reference removed]](../../../_images/modeling_modifiers_generate_edge-split_panel.png)

The Edge Split modifier.

Edge Angle
:   When enabled, an edge will be split if the angle between its
    two adjacent faces is greater than the *Split Angle*.

    Split Angle
    :   On 0: all edges are split. On 180: no edges are split.

Sharp Edges
:   When enabled, edges will be split if they were [marked as sharp](../../meshes/editing/edge/edge_data.html#bpy-ops-mesh-mark-sharp).
user: Explain Side of Active in complete detail according to the official Blender documentation.

assistant: # Side of Active

With an active vertex, this tool will select all vertices in a specified direction.
It is similarly to the *Loop Inner-Region* tool in that it will fill select faces within its perimeters,
however, it is determined by direction and not by a closed loop.

Axis Mode
:   Determines the behavior of the selection.
    More information on this can be found in [Transform Orientations](../../../editors/3dview/controls/orientation.html).

Axis Sign
:   Positive/Negative Axis
    :   Depending on which *Axis* is chosen, the selection will encompass the positive or negative axis
        starting from the active vertex outward.

    Aligned Axis
    :   Where *Positive and Negative Axis* select all vertices in a given direction,
        *Aligned Axis* will only select the vertices that are in-line with the active vertex.

[image reference removed]

While following along the X axis: (from left to right) active vertex, Aligned, Positive, and Negative.

Axis
:   Chooses the direction of the selection.

Threshold
:   The amount of influence the selection has outside the original perimeters.
    The higher the *Threshold* the more vertices will be selected.
user: What is NodeSocketVectorVelocity4D(NodeSocketStandard) and how is it used in Blender Python scripting?

assistant: # NodeSocketVectorVelocity4D(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVectorVelocity4D(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 4 items in [-inf, inf], default (0.0, 0.0, 0.0, 0.0)

    links
    :   List of node links from or to this socket.

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: In EEVEE, GPU
Memory management is done by the GPU driver.
In theory, only the needed textures and meshes (now referred as “the resources”) for a single draw call
(i.e. one object) needs to fit into the GPU memory.

So if the scene is really heavy,
the driver will swap things in and out to make sure all objects are rendered correctly.

In practice, using too much GPU memory can make the GPU driver crash, freeze, or kill the application.
So be careful of what you ask.

There is no standard way of estimating if the resources will fit into the GPU memory and/or
if the GPU will render them successfully.
user: Provide the full official documentation entry for BrushTextureSlot(TextureSlot), preserving all code examples.

assistant: # BrushTextureSlot(TextureSlot)

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

*class* bpy.types.BrushTextureSlot(*TextureSlot*)
:   Texture slot for textures in a Brush data-block

    angle
    :   Brush texture rotation

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

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

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

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

    map_mode
    :   Type:
        :   enum in [`'VIEW_PLANE'`, `'AREA_PLANE'`, `'TILED'`, `'3D'`, `'RANDOM'`, `'STENCIL'`], default `'VIEW_PLANE'`

    mask_map_mode
    :   Type:
        :   enum in [`'VIEW_PLANE'`, `'TILED'`, `'RANDOM'`, `'STENCIL'`], default `'VIEW_PLANE'`

    random_angle
    :   Brush texture random angle

        Type:
        :   float in [0, 6.28319], default 6.28319

    use_rake
    :   Type:
        :   boolean, default False

    use_random
    :   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: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`BoolAttribute.data`](bpy.types.BoolAttribute.html#bpy.types.BoolAttribute.data "bpy.types.BoolAttribute.data") | - [`MeshUVLoopLayer.pin`](bpy.types.MeshUVLoopLayer.html#bpy.types.MeshUVLoopLayer.pin "bpy.types.MeshUVLoopLayer.pin") |
user: Provide the full official documentation entry for Asset Browser, preserving all code examples.

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: Give a detailed overview of Image Coordinates Node: syntax, arguments, return values, common patterns.

assistant: # Image Coordinates Node

[image reference removed]

The *Image Coordinates* node outputs various coordinate fields for an input image.
These outputs provide information about each pixel’s location in different coordinate spaces,
which can be useful for procedural texturing, compositing effects, or image-based masking.

The coordinate outputs are calculated per pixel based on the image resolution and placement
within the compositor’s virtual space.
user: Show practical ways to work with Extension files in a Blender add-on or script – include code.

assistant: An extension is shared as a `.zip` archive containing a manifest file and other files.
The expected files depend on the extension type.

### Add-on extension

[Add-ons](addons.xhtml#extensions-addons) need at least the manifest and an `__init__.py` file,
while more complex add-ons have a few different .py files or wheels together.

```
my_extension-0.0.1.zip
├─ __init__.py
├─ blender_manifest.toml
└─ (...)
```

### Theme extension

A theme extension only needs the manifest and the .xml theme file.

```
my_extension-0.0.1.zip
├─ blender_manifest.toml
└─ theme.xml
```
user: Describe Shutter Curve from the Blender manual or Python API, including usage steps and snippets.

assistant: Curve defining how the shutter opens and closes.
The X axis is time, Y values of 0 mean fully closed shutter, Y values of 1 mean fully opened shutter.
The default mapping is set to when shutter opens and closes instantly.
user: How do I use Bpy.Types.Dopesheet in Blender? Include parameters, examples, warnings and best practices.

assistant: rt filter search Type : boolean, default False use_multi_word_filter ¶ Perform fuzzy/multi-word matching. Warning: May be slow 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 subclass classmethod bl_rna_get_subclass_py ( id , default = None , / ) ¶ Parameters : id ( str ) – The RNA type identifier. Returns : The class or default when not found. Return type : type Inherited Properties ¶ bpy_struct.id_data Inherited Functions ¶ bpy_struct.as_pointer bpy_struct.driver_add bpy_struct.driver_remove bpy_struct.get bpy_struct.id_properties_clear bpy_struct.id_properties_ensure bpy_struct.id_properties_ui bpy_struct.is_property_hidden bpy_struct.is_property_overridable_library bpy_struct.is_property_readonly bpy_struct.is_property_set bpy_struct.items bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values References ¶ SpaceDopeSheetEditor.dopesheet SpaceGraphEditor.dopesheet SpaceNLA.dopesheet Next Driver(bpy_struct) Previous DistortedNoiseTexture(Texture) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page DopeSheet(bpy_struct) DopeSheet DopeSheet.filter_collection DopeSheet.filter_fcurve_name DopeSheet.filter_text DopeSheet.show_armatures DopeSheet.show_cache_files DopeSheet.show_cameras DopeSheet.show_curves DopeSheet.show_datablock_filters DopeSheet.show_driver_fallback_as_error DopeSheet.show_expanded_summary DopeSheet.show_gpencil DopeSheet.show_hair_curves DopeSheet.show_hidden DopeSheet.show_lattices DopeSheet.show_lightprobes DopeSheet.show_lights DopeSheet.show_linestyles DopeSheet.show_materials DopeSheet.show_meshes DopeSheet.show_metaballs DopeSheet.show_missing_nla DopeSheet.show_modifiers DopeSheet.show_movieclips DopeSheet.show_nodes DopeSheet.show_only_errors DopeSheet.show_only_selected DopeSheet.show_only_slot_of_active_object DopeSheet.show_particles DopeSheet.show_pointclouds DopeSheet.show_scenes DopeSheet.show_shapekeys DopeSheet.show_speakers DopeSheet.show_summary DopeSheet.show_textures DopeSheet.show_transforms DopeSheet.show_volumes DopeSheet.show_worlds DopeSheet.source DopeSheet.use_datablock_sort DopeSheet.use_filter_invert DopeSheet.use_multi_word_filter DopeSheet.bl_rna_get_subclass() DopeSheet.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Describe NodeTreeInterfaceSocketFloatAngle(NodeTreeInterfaceSocket) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeTreeInterfaceSocketFloatAngle(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketFloatAngle(*NodeTreeInterfaceSocket*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Unlike Blender and many other applications and file formats, Alembic files don’t have any concept of frames.
Alembic works purely with time, and values that are sampled over time. For example,
there is no way to distinguish 30 FPS with 2 samples per frame, and 60 FPS with 1 sample per frame.
This has caused many developers to just
[hard-coded 24 FPS](https://projects.blender.org/blender/blender/issues/55288)
when reading Alembic files.

Blender uses the current scene frame rate to convert a frame number (in Blender) to a time
in seconds (in Alembic). As a result, you can import an Alembic file that was produced at 120 FPS into
a Blender scene that is 30 FPS and still not see any time stretching.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Color Parametrization
:   The shader provides three different ways, or *parametrizations*, to color the hair strands.

    Direct Coloring:
    :   Choose the desired RGB color and the shader will approximate
        the necessary *absorption coefficient* (below).

    Melanin Concentration:
    :   This mode defines the color as the quantity and
        ratio of the pigments which are commonly found in hair and fur,
        *eumelanin* (prevalent in brown-black hair) and *pheomelanin* (red hair).
        The quantity is specified in the *Melanin* input, and the ratio between them in *Melanin Redness*.
        Increasing concentrations darken the hair (the following are with *Melanin Redness* \(1\)):

        - White (Melanin \(0\))
        - Blonde (Melanin \(0.25\))
        - Reddish (Melanin \(0.5\))
        - Brown (Melanin \(0.75\))
        - Black (Melanin \(1\))

        Additionally, the *Tint* inputs allows to dye the hair with the desired color.

    Absorption Coefficient:
    :   Specifies the attenuation coefficient \(\sigma_{a}\), as applied by the [Beer-Lambert law](https://en.wikipedia.org/wiki/Beer%E2%80%93Lambert_law#Expression_with_attenuation_coefficient).
        This mode is intended mainly for technical users who want to use coefficients from the literature
        without any sort of conversion.
user: How do I use ShaderNodeBsdfAnisotropic(ShaderNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ShaderNodeBsdfAnisotropic(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.ShaderNodeBsdfAnisotropic(*ShaderNode*)
:   Reflection with microfacet distribution, used for materials such as metal or mirrors

    distribution
    :   Light scattering distribution on rough surface

        - `BECKMANN`
          Beckmann.
        - `GGX`
          GGX.
        - `ASHIKHMIN_SHIRLEY`
          Ashikhmin-Shirley.
        - `MULTI_GGX`
          Multiscatter GGX – GGX with additional correction to account for multiple scattering, preserve energy and prevent unexpected darkening at high roughness.

        Type:
        :   enum in [`'BECKMANN'`, `'GGX'`, `'ASHIKHMIN_SHIRLEY'`, `'MULTI_GGX'`], default `'BECKMANN'`

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

assistant: # Introduction

A *Keyframe* is simply a marker of time which stores the value of a property.

For example, a Keyframe might define that the horizontal position of a cube is at 3 m on frame 1.

The purpose of a Keyframe is to allow for interpolated animation, meaning, for example,
that the user could then add another key on frame 10, specifying the cube’s horizontal position at 20 m,
and Blender will automatically determine the correct position of the cube for all the frames between frame 1 and 10
depending on the chosen interpolation method (e.g. Linear, Bézier, Quadratic, etc.).

An overview of existing keyframes can be seen via the [Dope Sheet](../../editors/dope_sheet/index.xhtml) editor.
user: Provide the full official documentation entry for Example, preserving all code examples.

assistant: Blur node blur modes using 20% of image size as XY, no Bokeh/Gamma.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/compositing_types_filter_blur-node_example-1-original.png   Original image. | ../../../../_images/compositing_types_filter_blur-node_example-2-flat.png   Flat. | ../../../../_images/compositing_types_filter_blur-node_example-3-tent.png   Tent. |
| ../../../../_images/compositing_types_filter_blur-node_example-4-quadratic.png   Quadratic. | ../../../../_images/compositing_types_filter_blur-node_example-5-cubic.png   Cubic. | ../../../../_images/compositing_types_filter_blur-node_example-6-gaussian.png   Gaussian. |
| ../../../../_images/compositing_types_filter_blur-node_example-7-fast-gaussian.png   Fast Gaussian. | ../../../../_images/compositing_types_filter_blur-node_example-8-catmull-rom.png   Catmull-Rom. | ../../../../_images/compositing_types_filter_blur-node_example-9-mitch.png   Mitch. |
user: Show practical ways to work with NURBS in a Blender add-on or script – include code.

assistant: One of the characteristics of a NURBS object is the *knot vector*.
This is a sequence of numbers used to determine the influence of the control points on the curve.
While you cannot edit the knot vectors directly,
you can influence them through the *Endpoint* and *Bézier* options in the Active Spline panel.
Note that, the *Endpoint* and *Bézier* settings only apply to open NURBS curves.

[image reference removed]

Active Spline: NURBS Spline.

Cyclic U
:   See [Common Options](#spline-common-options).

Bézier U
:   Makes the NURBS curve act like a Bézier curve.
    The NURBS control points act like *Free* handles of Bézier curve.

Endpoint U
:   Makes the curve contact the end control points.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_active-spline_nurbs-default.png   Default NURBS curve. | ../../../_images/modeling_curves_properties_active-spline_nurbs-endpoint.png   A NURBS curve with Endpoint enabled. |

Order U
:   The order of the NURBS curve determines the area of influence of the control points over the curve.
    Higher order values means that a single control point has a greater
    influence over a greater relative proportion of the curve.
    The valid range of *Order* values is 2-6 depending on the number of control points present in the curve.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_active-spline_nurbs-default.png   NURBS curves with orders of 4. | ../../../_images/modeling_curves_properties_active-spline_nurbs-order.png   NURBS curves with orders of 2. |

Resolution U
:   See [Common Options](#spline-common-options).

Smooth
:   See [Common Options](#spline-common-options).
user: Give a detailed overview of Light Settings (EEVEE): syntax, arguments, return values, common patterns.

assistant: # Light Settings (EEVEE)

Besides lighting from the background and materials with emission shaders,
lights are another way to add light into the scene.
The difference is that they are not directly visible in the rendered image,
and can be more easily managed as objects of their own type.

See [Light settings](../lights/light_object.html) for settings common to all renderers.
user: Show practical ways to work with GeometryNode(NodeInternal) in a Blender add-on or script – include code.

assistant: yNodeWarning`](bpy.types.GeometryNodeWarning.html#bpy.types.GeometryNodeWarning "bpy.types.GeometryNodeWarning")

*class* bpy.types.GeometryNode(*NodeInternal*)
:   *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 Workflow, preserving all code examples.

assistant: # Workflow

Depending on the original footage’s properties, achieving good stabilization results might be simple and easy,
or it might require some work, dedication and careful planning. This section covers some practical considerations
to help improving the results.
user: Explain GeometryNodeSDFGridOffset(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeSDFGridOffset(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.GeometryNodeSDFGridOffset(*GeometryNode*)
:   Offset a signed distance field surface by a world-space distance. Dilates (positive) or erodes (negative) while maintaining the signed distance property

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

assistant: # Gesture Tools

Separate from brushes and filters, Sculpt mode also has a set of tools that perform actions to a drawn
selection area. These tools are similar to the selection tools (e.g. [box selection](../../../interface/selecting.xhtml#tool-select-box)
and [lasso selection](../../../interface/selecting.xhtml#tool-select-lasso) in other areas of Blender).

These tools do not provide a selection of elements that are then modified, they directly modify the underlying
mesh.
user: What is Usage and how is it used in Blender Python scripting?

assistant: A locked axis will display in a brighter color than an unlocked axis. For example in the image to the right,
the Z axis is shown in light blue as movement is constrained to this axis. This example, can be achieved in two ways:

### Hotkey

The axis of movement can be changed at any time during transformation by typing `X`, `Y`, `Z`.

### Pointing

[image reference removed]

Axis constraint in action.

Holding `MMB` after starting a transformation lets you select an axis to constrain to.
A visual option to constrain the translation will be available,
showing the three axes in the 3D Viewport space. A dotted white line is used as a pointer.
The axis of choice to confirm the operation
will depend on the highlighted axis about which the `MMB` is released.

When you already moved the mouse in the desired direction,
pressing `MMB` will lock to the axis which was pointed at.
user: Show practical ways to work with Voxel Index Node in a Blender add-on or script – include code.

assistant: # Voxel Index Node

[image reference removed]

The *Voxel Index* node outputs the integer index of the voxel that the field
is currently being evaluated on.

Unlike a position in object space, the voxel index refers to the discrete
cell coordinates inside a voxel grid. This makes it possible to reason
about neighboring voxels directly in index space, without converting
through world or object space.

This node can be combined with nodes such as
[Integer Math](../../utilities/math/integer_math.xhtml)
and [Sample Grid Index](../sample/sample_grid_index.xhtml)
to sample values from nearby voxels by offsetting the indices.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: Transition
:   The type of transition used.

    Single
    :   Reveals the next strip by uncovering it in a straight line moving across the image.

    Double
    :   Similar to *Single*, but uses two lines either starting from the middle of the image or the outside.
        Like the blink of an eye.

    Iris
    :   Reveals the next strip through an expanding (or contracting) circle.
        Like the aperture of a camera or pupil of an eye.
        You can blur the transition, so it looks like ink bleeding through a paper.

    Clock
    :   Like the hands of an analog clock, it sweeps clockwise or (if Wipe In is enabled)
        counterclockwise from the 9:00 position. As it sweeps, it reveals the next strip.

Direction
:   Controls whether to fade *In* or *Out*.

Blur Width
:   The width of the blur used to blur the transition.

Angle
:   Controls the angle of the line for *Single* and *Double* transition types.

Default Fade
:   Automatically calculates a linear fade over the length of the strip.

    Effect Fader
    :   Allows you to manually [keyframe](../../../../../animation/keyframes/index.html) a custom fade.
        This can be used with different [easings](../../../../../editors/graph_editor/fcurves/properties.html#editors-graph-fcurves-settings-easing)
        to fine-tune the fade in/out.