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

assistant: # BlendTexture(Texture)

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

*class* bpy.types.BlendTexture(*Texture*)
:   Procedural color blending texture

    progression
    :   Style of the color blending

        - `LINEAR`
          Linear – Create a linear progression.
        - `QUADRATIC`
          Quadratic – Create a quadratic progression.
        - `EASING`
          Easing – Create a progression easing from one step to the next.
        - `DIAGONAL`
          Diagonal – Create a diagonal progression.
        - `SPHERICAL`
          Spherical – Create a spherical progression.
        - `QUADRATIC_SPHERE`
          Quadratic Sphere – Create a quadratic progression in the shape of a sphere.
        - `RADIAL`
          Radial – Create a radial progression.

        Type:
        :   enum in [`'LINEAR'`, `'QUADRATIC'`, `'EASING'`, `'DIAGONAL'`, `'SPHERICAL'`, `'QUADRATIC_SPHERE'`, `'RADIAL'`], default `'LINEAR'`

    use_flip_axis
    :   Flip the texture’s X and Y axis

        - `HORIZONTAL`
          Horizontal – No flipping.
        - `VERTICAL`
          Vertical – Flip the texture’s X and Y axis.

        Type:
        :   enum in [`'HORIZONTAL'`, `'VERTICAL'`], default `'HORIZONTAL'`

    users_material
    :   Materials that use this texture

        Type:
        :   tuple of [`Material`](bpy.types.Material.html#bpy.types.Material "bpy.types.Material")

        (readonly)

    users_object_modifier
    :   Object modifiers that use this texture

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

        (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 Viewing Color Attributes, preserving all code examples.

assistant: Color Attributes can be used in a material node tree using the [Color Attribute Node](../../render/shader_nodes/input/vertex_color.html).

Color Attributes can be viewed in the 3D viewport using the Workbench render engine.
To use such feature, set the 3D Viewport to [Solid Shading](../../editors/3dview/display/shading.html#dview-shading-solid)
and select the *Attribute* Color option.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Instances
:   The input geometry containing the instances to be randomized.

Selection
:   Controls which instances are affected by the randomization.
    Only selected instances will receive random transformations.

Local Space
:   - When enabled, transformations are applied in each instance’s local coordinate space.
    - When disabled, randomization is performed in the global coordinate space.

Offset
:   The maximum translation offset for each axis. Defines the random range for instance movement.

Rotation
:   The maximum rotation for each axis. Defines how much each instance can be rotated.

Scale Axes
:   Determines how scaling is applied.

    Uniform:
    :   Applies a single random scale factor uniformly to all axes.

    Axes:
    :   Applies an independent random scale factor to each axis.

Scale
:   The maximum scaling factor applied to each instance.

Flipping
:   Randomly flips instances along one or more axes, effectively mirroring them.

Seed
:   An integer value that initializes the random number generator.
    Changing the seed produces a different random arrangement while keeping the same parameters.
user: Describe Reusing Existing Materials from the Blender manual or Python API, including usage steps and snippets.

assistant: Blender is built to allow you to reuse *anything*, including material settings,
between many objects. Instead of creating duplicate materials,
you can simply reuse an existing material.
There are several ways to do this using the Material’s data-block menu:

*Single Object* – With the object selected, click the sphere located to the left of the Material name.
A pop-up appears showing all the materials available in the current blend-file.
To use one, just click on it.

*Multiple Objects* – In the 3D Viewport, with `Ctrl`-`L`
you can quickly link all selected objects to the material (and other aspects)
of the [active object](../../scene_layout/object/selecting.xhtml#object-active).
Very useful if you need to set a large number of objects to the same material;
just select all of them,
then the object that has the desired material, and `Ctrl`-`L` links them to that “parent”.
user: Give a detailed overview of Misc Options: syntax, arguments, return values, common patterns.

assistant: `--open-last`
:   Open the most recently opened blend file, instead of the default startup file.

`--app-template` `<template>`
:   Set the application template (matching the directory name), use `default` for none.

`--factory-startup`
:   Skip reading the `startup.blend` in the users home directory.

`--enable-event-simulate`
:   Enable event simulation testing feature `bpy.types.Window.event_simulate`.

`--env-system-datafiles`
:   Set the `BLENDER_SYSTEM_DATAFILES` environment variable.

`--env-system-scripts`
:   Set the `BLENDER_SYSTEM_SCRIPTS` environment variable.

`--env-system-extensions`
:   Set the `BLENDER_SYSTEM_EXTENSIONS` environment variable.

`--env-system-python`
:   Set the `BLENDER_SYSTEM_PYTHON` environment variable.

`-noaudio`
:   Force sound system to None.

`-setaudio`
:   Force sound system to a specific device.
    `None` `Default` `SDL` `OpenAL` `CoreAudio` `JACK` `PulseAudio` `WASAPI`.

`-c`, `--command` `<command>`
:   Run a command which consumes all remaining arguments.
    Use `-c help` to list all other commands.
    Pass `--help` after the command to see its help text.

    This implies `--background` mode.

`-h`, `--help`
:   Print this help text and exit.

`/?`
:   Print this help text and exit (Windows only).

`-r`, `--register`
:   Register blend-file extension for current user, then exit (Windows & Linux only).

`--register-allusers`
:   Register blend-file extension for all users, then exit (Windows & Linux only).

`--unregister`
:   Unregister blend-file extension for current user, then exit (Windows & Linux only).

`--unregister-allusers`
:   Unregister blend-file extension for all users, then exit (Windows & Linux only).

`--qos` `<level>`
:   Set the Quality of Service (QoS) mode for hybrid CPU architectures (Windows only).

    default: Uses the default behavior of the OS.
    high: Always makes use of performance cores.
    eco: Schedules Blender threads exclusively to efficiency cores.

`-v`, `--version`
:   Print Blender version and exit.

`--`
:   End option processing, following arguments passed unchanged. Access via Python’s `sys.argv`.
user: Describe LineStyleModifier(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # LineStyleModifier(bpy_struct)

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

subclasses —
[`LineStyleAlphaModifier`](bpy.types.LineStyleAlphaModifier.html#bpy.types.LineStyleAlphaModifier "bpy.types.LineStyleAlphaModifier"), [`LineStyleColorModifier`](bpy.types.LineStyleColorModifier.html#bpy.types.LineStyleColorModifier "bpy.types.LineStyleColorModifier"), [`LineStyleGeometryModifier`](bpy.types.LineStyleGeometryModifier.html#bpy.types.LineStyleGeometryModifier "bpy.types.LineStyleGeometryModifier"), [`LineStyleThicknessModifier`](bpy.types.LineStyleThicknessModifier.html#bpy.types.LineStyleThicknessModifier "bpy.types.LineStyleThicknessModifier")

*class* bpy.types.LineStyleModifier(*bpy_struct*)
:   Base type to define modifiers

    *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 Selection Modes, preserving all code examples.

assistant: Selection modes limits selection operators to certain curve domains.
This feature is makes it easy to select whole segments at once, or to give more granular control over editing.

Control Points:
:   Allows selection of individual control points.

Curve:
:   Limits selection to whole curve segments.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Grid
:   The input signed distance field to smooth.
    Typically, the grid represents a surface or volume generated from a mesh or procedural operation.

Iterations
:   The number of mean curvature flow iterations to apply.
    Each iteration progressively smooths the surface, with higher values
    resulting in a more pronounced smoothing effect.
    A small number of iterations will gently polish the surface, while
    larger values can significantly alter its shape.
user: How do I use Fixed Constraint in Blender? Include parameters, examples, warnings and best practices.

assistant: # Fixed Constraint

This constraint cause the two objects to move as one.
Since the physics system does have a tiny bit of slop in it,
the objects do not move as rigidly as they would if they were part of the same mesh.

[image reference removed]

*Fixed* constraint options.
user: Provide the full official documentation entry for Sphere Projection, preserving all code examples.

assistant: Projects the selected faces onto a virtual sphere, then flattens that sphere
much like a world map: the latitude lines vertical and the longitude lines
evenly spaced. This is useful for texturing spherical shapes such as eyes or planets.

The sphere is centered on the [Transform Pivot Point](../../../editors/3dview/controls/pivot_point/index.html),
which is normally the averaged-out position of the selected faces; however, you
can also move it to a different place using e.g. the [3D Cursor](../../../editors/3dview/3d_cursor.html).

[image reference removed]

Using an equirectangular image with a Sphere Projection.

### Options

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

Direction, Align
:   The direction of the sphere’s vertical axis.

    View on Equator
    :   Use an axis that’s perpendicular to the viewing direction in the 3D Viewport.
        If *Align* is *Polar ZX*, use the vertical axis of the viewing plane;
        if it’s *Polar ZY*, use the horizontal one.

    View on Poles
    :   Use an axis that’s parallel to the viewing direction in the 3D Viewport.
        Depending on *Align*, the sphere will be rotated by 90° around its vertical axis
        and the UV map will be shifted horizontally by a quarter.

    Align to Object
    :   Use the object’s local Z axis.
        Depending on *Align*, the sphere will be rotated by 90° around its vertical axis
        and the UV map will be shifted horizontally by a quarter.

Pole
:   How to handle vertices that lie on the sphere’s vertical axis.
    (See [Cylinder Projection](#bpy-ops-uv-cylinder-project) for an example.)

    Pinch
    :   Place all UV versions of the vertex at the same U coordinate.
        This tends to result in heavily distorted UV faces.

    Fan
    :   Place each UV version of the vertex at a U coordinate that minimizes distortion.

Preserve Seams
:   Cut the mesh along its seams before projecting.

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

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

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

Scale to Bounds
:   Stretches the resulting UV map to fill the complete texture.
user: What is Example and how is it used in Blender Python scripting?

assistant: Results with the nodes applied to an image from
the [Mango Open Movie](https://mango.blender.org/).

|  |  |
| --- | --- |
| ../../../_images/compositing_types_matte_color-spill_example-before.jpg   Before: green border and green reflections. | ../../../_images/compositing_types_matte_color-spill_example-after.jpg   After: no unwanted green. |
user: Explain Options in complete detail according to the official Blender documentation.

assistant: Type
:   *Soft* or *Hard*, changes contrast and sharpness.

Color
:   Grayscale:
    :   The standard noise, gives a floating-point intensity value.

    Color:
    :   The noise gives an RGB value.

Size
:   The dimension of the Noise table.

Depth
:   The depth of the *Clouds* calculation.
    A higher number results in a long calculation time, but also in finer details.

Nabla
:   Size of the derivative offset used for calculating surface normals.
    Smaller values give more precision, larger values are smoother/faster.
    This is mostly relevant when the texture is used in displacement or bump channels.
user: Provide the full official documentation entry for Mix Vector Node, preserving all code examples.

assistant: # Mix Vector Node

The *Mix Node* mixes values, colors and vectors inputs
using a factor to control the amount of interpolation.
The *Color* mode has additional blending modes.

[image reference removed]
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Mode
:   Points:
    :   The position and radius of the circle are determined by three points.
        The center of the circle is also given as an output.
        If the three points lie on one line, no geometry is generated.

    Radius:
    :   The circle is determined by the radius.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: ID Value
:   Input for the *Object Index* or *Material Index* render pass.
    Once a pass is enabled, it can be accessed through the *IndexOB* or *IndexMA* slot of the
    [Render Layers Node](../input/scene/render_layers.xhtml).

Index
:   The index for which to create a mask. This index can be configured for objects at
    Properties ‣ Object ‣ Relations ‣ Pass Index,
    and for materials at Properties ‣ Material ‣ Settings ‣ Pass Index.

    [image reference removed]

    Object Pass Index.

[Anti-Aliasing](../../../glossary/index.xhtml#term-Anti-Aliasing)
:   Whether to smooth the mask edges.
user: Give a detailed overview of Stabilize 2D Node: syntax, arguments, return values, common patterns.

assistant: # Stabilize 2D Node

[image reference removed]

Stabilizes the footage according to the settings set in
Movie Clip Editor ‣ Properties ‣ Stabilization ‣ 2D Stabilization.
For more information,
see [2D Stabilization](../../../movie_clip/tracking/clip/sidebar/stabilization/index.html).
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

Freestyle is an edge/line-based non-photorealistic (NPR) rendering engine.
It relies on mesh data and Z-depth information to draw lines on selected edge types.
Various line styles can be added to produce artistic (“hand drawn”, “painted”, etc.)
or technical (hard line) looks.

Freestyle can generate a powerful diversity of line styles and results.
There are currently, two ways to define the way lines look;
the first uses a series of parameter to create a [Line Style](view_layer/line_style/index.xhtml).
This mode allows intuitive editing of features such as dotted lines
and easy setup of multiple line types and edge definitions.
On top of all of that, with line style modifiers, the sky is the limit!

The second method of generating lines is by using [Python Scripting](python.xhtml).
This method is much more advanced but Blender includes many pre-scripted styles
such as Japanese big brush, cartoon, blueprint, and thickness-with-depth.

|  |  |
| --- | --- |
| ../../_images/render_freestyle_introduction_example-1.png   ATV buggy by Rylan Wright (RONIN). CC BY. ([File:AtvBuggy.zip](https://archive.blender.org/wiki/2015/index.php/File:AtvBuggy.zip)) | ../../_images/render_freestyle_introduction_example-2.png   By mato.sus304. CC BY-SA. ([File:Mato_sus304_cut02.zip](https://archive.blender.org/wiki/2015/index.php/File:Mato_sus304_cut02.zip)) |
| ../../_images/render_freestyle_introduction_example-3.png   A cartoon scene from [OHA Studio](https://oha-studios.com/) © Mechanimotion Entertainment. ([blend-file](https://download.blender.org/demo/test/freestyle_demo_file.blend.zip)) | ../../_images/render_freestyle_introduction_example-4.png   Blueprint render of Martin M-130 from 1935 by LightBWK. CC0. Warning: heavy file! designed for stress test Blender to the limits and may crash Blender. ([File:M-130Blueprint.zip](https://archive.blender.org/wiki/2015/index.php/File:M-130Blueprint.zip)) |
user: How do I use Inherited Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`StripModifier.name`](bpy.types.StripModifier.html#bpy.types.StripModifier.name "bpy.types.StripModifier.name") - [`StripModifier.type`](bpy.types.StripModifier.html#bpy.types.StripModifier.type "bpy.types.StripModifier.type") - [`StripModifier.mute`](bpy.types.StripModifier.html#bpy.types.StripModifier.mute "bpy.types.StripModifier.mute") - [`StripModifier.enable`](bpy.types.StripModifier.html#bpy.types.StripModifier.enable "bpy.types.StripModifier.enable") - [`StripModifier.show_expanded`](bpy.types.StripModifier.html#bpy.types.StripModifier.show_expanded "bpy.types.StripModifier.show_expanded") | - [`StripModifier.input_mask_type`](bpy.types.StripModifier.html#bpy.types.StripModifier.input_mask_type "bpy.types.StripModifier.input_mask_type") - [`StripModifier.mask_time`](bpy.types.StripModifier.html#bpy.types.StripModifier.mask_time "bpy.types.StripModifier.mask_time") - [`StripModifier.input_mask_strip`](bpy.types.StripModifier.html#bpy.types.StripModifier.input_mask_strip "bpy.types.StripModifier.input_mask_strip") - [`StripModifier.input_mask_id`](bpy.types.StripModifier.html#bpy.types.StripModifier.input_mask_id "bpy.types.StripModifier.input_mask_id") - [`StripModifier.is_active`](bpy.types.StripModifier.html#bpy.types.StripModifier.is_active "bpy.types.StripModifier.is_active") |
user: Provide the full official documentation entry for Controls, preserving all code examples.

assistant: You can select and create scenes with the *Scene* data-block menu in the
[Topbar](../../interface/window_system/topbar.xhtml).

[image reference removed]

Scene data-block menu.

Scenes
:   A list of available scenes in the current blend-file.

Add
:   New
    :   Creates an empty scene with default values.

    Copy Settings
    :   Creates an empty scene but copies render and world settings from the active scene.

    Linked Copy
    :   Creates a new scene that shares all data with the current one.
        The new scene contains links to the same collections, objects, and data-blocks as the original.
        Changes made in one scene automatically affect the other, since they reference the same data.

    Full Copy
    :   Creates a fully independent scene with unique copies of all objects and their data.
        This is useful for variations or alternate versions of a scene that should not affect the original.

(Delete Scene)
:   Deletes the current scene data-block.
    Note that Blender always requires at least one scene in a file; you cannot delete the last remaining one.
user: How do I use Editing in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Join in New Frame

Creates a new *Frame* node around the selected nodes.

When called using the shortcut `F`, a popup appears allowing you to assign a custom
[Label](../../node_editors.html#bpy-types-node-label) to the new frame node.
This label is shown as the title of the frame and can be used to describe its contents.

### Add to Frame

Once a frame node is placed, nodes can be added by dropping them onto the frame or
by selecting the node(s) then the frame and using `Ctrl`-`P`.
This can be thought of as Parenting the selection to the frame.

### Remove from Frame

To remove nodes from a frame, select and use `Alt`-`P`.
This can be thought of as unparenting the selection from the frame.
user: Provide the full official documentation entry for ShaderNodeAddShader(ShaderNode), preserving all code examples.

assistant: # ShaderNodeAddShader(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.ShaderNodeAddShader(*ShaderNode*)
:   Add two Shaders together

    *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 Action Menu, preserving all code examples.

assistant: Merge Animation
:   This operator merges the animation of all selected objects into the animation of the
    active object. Since the data is moved and not copied, the source Actions might end up
    empty and without users.
    Note that this will not only merge the object level Action, but Actions on related data-blocks
    as well (See [Related data-blocks](../../../animation/actions.html#working-with-actions)). As a result of that
    this operator can also be used to merge Actions of one Object. For example
    Translation & Rotation and animation on Shape Keys.

Separate Slots
:   This splits all Slots of the Action on the active Object into separate Actions.
    All users of those Slots will be re-assigned to their respective Action and
    the newly created Actions are named after the Slot.
    The source Action will not be deleted, but might end up with 0 users if no
    [Fake User](../../../files/data_blocks.html#data-system-datablock-fake-user) is set.

Move Slots to new Action
:   This moves Slots selected in the [Channels Region](../../graph_editor/channels/introduction.html#editors-graph-editor-channels-region)
    to a newly created Action. All users of those Slots are re-assigned to the new Action.
    If more than one Slot is selected, all Slots are moved into a single Action.

Push Down Action
:   Creates a new NLA track below the Action Track and moves the active action into it.
    This is the same as clicking [Push Down Action](../../nla/tracks.html#bpy-ops-nla-action-pushdown)
    in the NLA editor.

Stash Action
:   Creates a new *muted* NLA track at the bottom of the NLA tracks and moves the active action into it.
    In effect, this sets the action aside for later use, disabling it so it no longer
    affects the animation. Later, you can choose to either unmute it again or delete it.

    If you click *New Action* in the data-block menu for an object that already has an
    active action, that previous action will be stashed automatically.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: For each field input, a separate grid output is created that contains the
evaluated voxel data.
All output grids share the same topology as the input grid, ensuring that
they are aligned and compatible for further processing or combination.
user: Show practical ways to work with Grease Pencil in a Blender add-on or script – include code.

assistant: # Grease Pencil

This mode lets you adjust the timing of a [Grease Pencil object’s](../../../grease_pencil/introduction.xhtml)
animation frames. It is especially useful for blocking out shots.

[image reference removed]
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

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

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

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

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

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

Clamp Result (Color only)
:   Limit the Result to the range between 0.0 and 1.0.
user: Explain Pointcloud Operators in complete detail according to the official Blender documentation.

assistant: # Pointcloud Operators

bpy.ops.pointcloud.attribute_set(*\**, *value_float=0.0*, *value_float_vector_2d=(0.0, 0.0)*, *value_float_vector_3d=(0.0, 0.0, 0.0)*, *value_int=0*, *value_int_vector_2d=(0, 0)*, *value_color=(1.0, 1.0, 1.0, 1.0)*, *value_bool=False*)
:   Set values of the active attribute for selected elements

    Parameters:
    :   - **value_float** (*float in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Value
        - **value_float_vector_2d** (*float array* *of* *2 items in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Value
        - **value_float_vector_3d** (*float array* *of* *3 items in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Value
        - **value_int** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Value
        - **value_int_vector_2d** (*int array* *of* *2 items in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Value
        - **value_color** (*float array* *of* *4 items in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Value
        - **value_bool** (*boolean**,* *(**optional**)*) – Value

bpy.ops.pointcloud.delete()
:   Remove selected points

bpy.ops.pointcloud.duplicate()
:   Copy selected points

bpy.ops.pointcloud.duplicate_move(*\**, *POINTCLOUD_OT_duplicate=None*, *TRANSFORM_OT_translate=None*)
:   Make copies of selected elements and move them

    Parameters:
    :   - **POINTCLOUD_OT_duplicate** (`POINTCLOUD_OT_duplicate`, (optional)) – Duplicate, Copy selected points
        - **TRANSFORM_OT_translate** (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items

bpy.ops.pointcloud.select_all(*\**, *action='TOGGLE'*)
:   (De)select all point cloud

    Parameters:
    :   **action** (enum in [`'TOGGLE'`, `'SELECT'`, `'DESELECT'`, `'INVERT'`], (optional)) –

        Action, Selection action to execute

        - `TOGGLE`
          Toggle – Toggle selection for all elements.
        - `SELECT`
          Select – Select all elements.
        - `DESELECT`
          Deselect – Deselect all elements.
        - `INVERT`
          Invert – Invert selection of all elements.

bpy.ops.pointcloud.select_random(*\**, *seed=0*, *probability=0.5*)
:   Randomizes existing selection or create new random selection

    Parameters:
    :   - **seed** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Seed, Source of randomness
        - **probability** (*float in* *[**0**,* *1**]**,* *(**optional**)*) – Probability, Chance of every point being included in the selection

bpy.ops.pointcloud.separate()
:   Separate selected geometry into a new point cloud
user: Describe 2D Transform from the Blender manual or Python API, including usage steps and snippets.

assistant: # 2D Transform

The *2D Transform* modifier applies two-dimensional scaling and/or rotation to
the stroke backbone geometry. Scale is applied before rotation.

Pivot
:   The center (pivot point) of these 2D transformations can be:

    Stroke Center:
    :   The median point of the stroke.

    Stroke Start:
    :   The beginning point of the stroke.

    Stroke End:
    :   The end point of the stroke.

    Stroke Point Parameter:
    :   The *Stroke Point Parameter* factor controls where along the stroke the pivot point is
        (start point if set to 0.0; end point if set to 1.0).

    Absolute 2D Point:
    :   The *Pivot X* and *Y* values define the position of the pivot point in the final render
        (from the bottom left corner).

Scale X, Y
:   The scaling factors, in their respective axes.

Rotation Angle
:   The rotation angle.

[[image reference removed]](../../../../../../_images/render_freestyle_parameter-editor_line-style_modifiers_geometry_2d-transform_example.png)

2D Transform modifier
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Toycar_Three_Contours.zip)).
user: Describe Inpaint Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Inpaint Node

[image reference removed]

The *Inpaint node* is used to extend borders of an image into transparent or masked regions.
This can be useful to solve problems like “wire removal” and holes created during chroma keying.
user: Provide the full official documentation entry for Adjust Last Operation, preserving all code examples.

assistant: You can tweak the parameters of an [operator](operators.xhtml) after running it.
In editors that support it, there is a “head-up display” panel in the bottom left
based on the last performed operation.
Alternatively, you can create a pop-up with `F9` which does the same thing.

For example, if your last operation was a rotation in *Object Mode*,
Blender will show you the last value changed for the angle
(see Fig. [Rotation (Object Mode, 60 degrees).](#fig-interface-redo-last-object-mode) left),
where you can change your action back completely by typing `Numpad0` in the *Angle* Field.
There are other useful options, based on the operator,
and you cannot only Undo actions, but change them completely using the available options.

If you are in *Edit Mode*,
Blender will also change its contents based on your last action taken.
In the second example (on the right), the last operation was a Move in Object Mode;
but a *Scale* on a Face in Edit Mode, and, as you can see,
the contents of *Adjust Last Operation* are different, because of the mode (Edit Mode)
(See Fig. [Scale (Edit Mode, Resize face).](#fig-interface-redo-last-edit-mode) right).

Adjust Last Operation.

|  |  |
| --- | --- |
| ../_images/interface_undo-redo_redo-last-object-mode.png   Rotation (Object Mode, 60 degrees). | ../_images/interface_undo-redo_redo-last-edit-mode.png   Scale (Edit Mode, Resize face). |
user: Show practical ways to work with GeometryNodeStoreNamedAttribute(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeStoreNamedAttribute(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.GeometryNodeStoreNamedAttribute(*GeometryNode*)
:   Store the result of a field on a geometry as an attribute with the specified name

    data_type
    :   Type of data stored in attribute

        Type:
        :   enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items), default `'FLOAT'`

    domain
    :   Which domain to store the data in

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Circle in a Blender add-on or script – include code.

assistant: Adds a flat, 2D ring of vertices forming a polygonal approximation of a circle.
This primitive is useful as a starting point for cylindrical objects, holes, pipe ends,
or extrusion-based modeling workflows.

Vertices
:   Number of vertices used to define the perimeter of the circle.
    Higher values result in a smoother shape.

Fill Type
:   Sets how the center of the circle is filled:

    Triangle Fan:
    :   Fills the circle with triangular faces sharing a central vertex.

    N-gon:
    :   Fills the center with a single N-gon face.

    Nothing:
    :   Leaves the circle unfilled; only the perimeter vertices are created.

Radius
:   Distance from the center to the outer edge of the circle.
user: Provide the full official documentation entry for Edge Crease, preserving all code examples.

assistant: This operator interactively sets the [Edge Crease](../mesh/transform/basic.xhtml#modeling-edges-crease-subdivision) amount
by moving the mouse (or typing a value with the keyboard).
Selecting more than one edge will adjust the mean (average) crease value.
A negative value will subtract from the actual crease value, if present.
To clear the crease edge property, enter a value of -1.
user: Provide the full official documentation entry for Distance from Object, preserving all code examples.

assistant: # Distance from Object

The *Distance from Object* modifier alters the base property with a new one
from a given range using the distance to the active *camera* or to a given *object* as the parameter.

Target
:   The object to measure distance from.

Range Min, Max
:   The limits of the mapping from “distance to camera” to “property in mapping”.
    If the current point of the stroke is at *Range Min* or less from the active camera or the object,
    it will take the start value. And conversely,
    if it is at *Max* or more from the camera/object, it will take the end value.
    These values are in the current scene’s units, not in pixels!

Fill Range by Selection
:   Set the min/max range values from the distances between the current selected mesh vertices and
    the camera or the target.
user: Provide the full official documentation entry for Denoising, preserving all code examples.

assistant: Denoising can be enabled to reduce the amount of noise from the raw ray-traced output.
This can help image stability but will also over-blur the final ray-traced output.

Spatial Reuse
:   Reuse the rays from neighbor pixels.
    Can introduce some light leaks across surfaces.

Temporal Accumulation
:   Accumulate samples by re-projecting the last ray tracing results.
    This removes [Fireflies](../../../glossary/index.xhtml#term-Fireflies) but also introduces color bias.
    Useful for viewport temporal stability or making renders converge faster.

Bilateral Filter
:   Blur the resolved ray-traced output using a bilateral filter.
user: Give a detailed overview of Ray Types: syntax, arguments, return values, common patterns.

assistant: Ray types can be divided into four categories:

1. Camera: the ray comes straight from the camera.
2. Reflection: the ray is generated by a reflection off a surface.
3. Transmission: the ray is generated by a transmission through a surface.
4. Shadow: the ray is used for (transparent) shadows.

Reflection and transmission rays can further have these properties:

- Diffuse: the ray is generated by a diffuse reflection or transmission (translucency).
- Glossy: the ray is generated by a glossy specular reflection or transmission.
- Singular: the ray is generated by a perfectly sharp reflection or transmission.

The Light Path node can be used to find out the type of ray the shading is being computed for.

[image reference removed]
user: Give a detailed overview of Viewer Node: syntax, arguments, return values, common patterns.

assistant: # Viewer Node

[image reference removed]

The *Viewer* node allows viewing data from inside a geometry node group in both the
[Spreadsheet Editor](../../../editors/spreadsheet.html) and the 3D Viewport.

Any geometry or attribute connected to the viewer can be visualized in the viewport,
and its evaluated attribute values can be inspected in the spreadsheet.
Other data can also be viewed and inspected such as scaler values and grids by showing them in the spreadsheet.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`CurveSlice.points`](bpy.types.CurveSlice.html#bpy.types.CurveSlice.points "bpy.types.CurveSlice.points") | - [`Curves.points`](bpy.types.Curves.html#bpy.types.Curves.points "bpy.types.Curves.points") |
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Attribute Type
:   Specifies the type of the attribute.

    Geometry:
    :   The attribute is associated with the geometry of the object, and its value varies from
        vertex to vertex, or within the volume of the object.

        Most geometry attributes are directly accessible through the various input nodes, except for these:

        Ocean Foam
        :   Gives a scalar defining where foam might appear when using
            an [Ocean Modifier](../../../modeling/modifiers/physics/ocean.xhtml).
            This depends on the name you give this property.

    Object:
    :   The attribute name specifies a [custom property](../../../files/custom_properties.xhtml#files-data-blocks-custom-properties) name,
        or an RNA path to a built-in property (like the single property [driver variables](../../../animation/drivers/drivers_panel.xhtml#drivers-variables)).

        The values of attributes of this type are defined once per object. The name or path is looked up
        first in the object data-block, followed by the mesh data-block if not found.
        Custom properties have priority over built-in ones.

        The property value must be an integer, float, boolean, or a vector of 1 to 4 floats or ints; properties of other
        types are ignored. If a suitable property is not found, all sockets of the node, including *Alpha*, output 0.

    Instancer:
    :   Similar to *Object*, but the attribute is looked up in the instancer particle system settings,
        followed by [Geometry Node instance](../../../modeling/geometry_nodes/instances.xhtml) attributes
        (searching from the innermost instancing layer to outer ones), and finally in the instancer object.
        If the current object is not instanced, or the property is not found, it falls back to the *Object* mode.

    View Layer:
    :   The attribute is looked up in the current [View Layer](../../layers/introduction.xhtml),
        [Scene](../../../scene_layout/scene/introduction.xhtml) and [World](../../lights/world.xhtml), using the same lookup
        logic as *Object*, and likewise producing all zero outputs including *Alpha* if not found. Attributes of this
        type have the same uniform value throughout the whole Render Layer.

Name
:   The name of the attribute to retrieve.
user: How do I use Known Limitations in Blender? Include parameters, examples, warnings and best practices.

assistant: For the most part, linking data will work as expected.
However, there are some limitations to be aware of.

### Circular Dependencies

In general, dependencies should not go in both directions.
Attempting to link or append data which links back to the current file will likely result in missing links.

### Scene-Level Settings

Scene-level settings such as the [Rigid Body World](../../physics/rigid_body/world.xhtml) will not
be copied when linking objects. As an alternative, you can link the
entire scene and use it as a [Background Scene](../../scene_layout/scene/properties.xhtml#bpy-types-scene-background-set).

### Compression & Memory Use

Referencing [compressed](../blend/open_save.xhtml#files-blend-compress) blend-files may need a lot of
memory because they have to be loaded in their entirety, even if you only link/append
a small part of them. Once the data-blocks are loaded, however, memory usage is the same.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`SpaceFileBrowser.bookmarks`](bpy.types.SpaceFileBrowser.html#bpy.types.SpaceFileBrowser.bookmarks "bpy.types.SpaceFileBrowser.bookmarks") - [`SpaceFileBrowser.recent_folders`](bpy.types.SpaceFileBrowser.html#bpy.types.SpaceFileBrowser.recent_folders "bpy.types.SpaceFileBrowser.recent_folders") | - [`SpaceFileBrowser.system_bookmarks`](bpy.types.SpaceFileBrowser.html#bpy.types.SpaceFileBrowser.system_bookmarks "bpy.types.SpaceFileBrowser.system_bookmarks") - [`SpaceFileBrowser.system_folders`](bpy.types.SpaceFileBrowser.html#bpy.types.SpaceFileBrowser.system_folders "bpy.types.SpaceFileBrowser.system_folders") |
user: Describe GeometryNodeVolumeToMesh(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeVolumeToMesh(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.GeometryNodeVolumeToMesh(*GeometryNode*)
:   Generate a mesh on the “surface” of a 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: What is Use Blender without it’s User Interface and how is it used in Blender Python scripting?

assistant: While developing your own scripts Blender’s interface can get in the way,
manually reloading, running the scripts, opening file import, etc. adds overhead.
For scripts that are not interactive it can end up being more efficient not to use
Blender’s interface at all and instead execute the script on the command line.

```
blender --background --python myscript.py
```

You might want to run this with a blend-file so the script has some data to operate on.

```
blender myscene.blend --background --python myscript.py
```

Once the script is running properly in background mode, you’ll want to check the output of the script,
this depends completely on the task at hand, however, here are some suggestions:

- Render the output to an image, use an image viewer and keep writing over the same image each time.
- Save a new blend-file, or export the file using one of Blender’s exporters.
- If the results can be displayed as text then print them or write them to a file.

While this can take a little time to setup, it can be well worth the effort
to reduce the time it takes to test changes. You can even have
Blender running the script every few seconds with a viewer updating the results,
so no need to leave your text editor to see changes.