PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is CompositorNodeColorBalance(CompositorNode) and how is it used in Blender Python scripting?

assistant: # CompositorNodeColorBalance(CompositorNode)

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

*class* bpy.types.CompositorNodeColorBalance(*CompositorNode*)
:   Adjust color and values

    input_whitepoint
    :   The color which gets mapped to white (automatically converted to/from temperature and tint)

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, inf], default (0.0, 0.0, 0.0)

    output_whitepoint
    :   The color which gets white gets mapped to (automatically converted to/from temperature and tint)

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, inf], default (0.0, 0.0, 0.0)

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Proportional Editing is available in UV editing. The controls are the same as in the 3D Viewport.
See [Proportional Editing in 3D](../../../editors/3dview/controls/proportional_editing.xhtml)
for a full reference.
user: Give a detailed overview of Selecting Text: syntax, arguments, return values, common patterns.

assistant: # Selecting Text

[image reference removed]

Text in Edit Mode.

In Edit Mode, your text has a white cursor, and as in any text editor,
it determines where new chars will be inserted.

Select All `Ctrl`-`A`
:   Selects the full text.

Top/Bottom `Shift`-`Ctrl`-`Home`/ `Shift`-`Ctrl`-`End`
:   Moves the cursor to the start or end of the text object.

Next/Previous Character `Left`/ `Right`
:   You can move the cursor with the arrow keys.

Next/Previous Word `Ctrl`-`Left`/ `Ctrl`-`Right`
:   To move the cursor on a word’s boundary.

Line Begin/End `Home`/ `End`
:   Move the cursor to the beginning and end of a line respectively.

Next/Previous Line `Up`/ `Down`
:   To jump between lines.

Next/Previous Block `PageUp`/ `PageDown`
:   To jump back/forward ten lines at a time.

Hold `Shift` while using the arrow keys to select a part of the text.
You can use it to specify different materials, the normal/bold/italic style…
user: Show practical ways to work with Bpy.Types.Geometryattributeconstraint in a Blender add-on or script – include code.

assistant: rna_get_subclass_py() Inherited Properties Inherited Functions
user: How do I use Set Sharpness by Angle in Blender? Include parameters, examples, warnings and best practices.

assistant: Sets the [sharp edge attribute](../../../geometry_nodes/attributes_reference.xhtml#geometry-nodes-builtin-attributes)
based on the angle between neighboring faces.

Angle
:   Maximum angle between face normals that will be considered as smooth.

Extend
:   Add new sharp edges without clearing existing sharp edges.
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

Compositing Nodes allow you to assemble and enhance an image (or movie). Using composition nodes,
you can glue two pieces of footage together and colorize the whole sequence all at once.
You can enhance the colors of a single image or an entire movie clip in a static manner or
in a dynamic way that changes over time (as the clip progresses). In this way,
you use composition nodes to both assemble video clips together and enhance them.

To process your image, you use nodes to import the image into Blender, change it,
optionally merge it with other images, and finally, save it.

[image reference removed]

An example of a composition.

[image reference removed]

An example of color correction.
user: Give a detailed overview of Noise Modifier: syntax, arguments, return values, common patterns.

assistant: # Noise Modifier

The *Noise* Modifier changes the value of one or more stroke/points properties like:
location, strength, thickness or UV texture position
by adding varied values that make the line unstable and noisy.

Random values can be used for the noise factor for more vivid effects.
user: Show practical ways to work with Rigid Body Cache in a Blender add-on or script – include code.

assistant: The *Cache* subpanel specifies the frame range in which the simulation is active.
Can be used to bake the simulation.

Start/End
:   First and last frame of the simulation.

Bake
:   Calculates the simulation and protects the cache. You need to be in *Object Mode* to bake.

Delete Bake
:   Active after the baking of simulation. Clears the baked cache.

Calculate to Frame
:   Bake physics to current frame.

Current Cache to Bake
:   Bake from Cache.

Bake All Dynamics
:   Bake all physics.

Delete All Bakes
:   Deletes all baked caches of all objects in the current scene.

Update All to Frame
:   Update cache to current frame.

If you have not saved the blend-file, the cache is created in memory,
so save your file first or the cache may be lost.
user: How do I use GeometryNodeCornersOfFace(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeCornersOfFace(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.GeometryNodeCornersOfFace(*GeometryNode*)
:   Retrieve corners that make up a face

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

assistant: # Collection Color Items

NONE:
:   None.

    Assign no color tag to the collection.

COLOR_01:
:   Color 01.

COLOR_02:
:   Color 02.

COLOR_03:
:   Color 03.

COLOR_04:
:   Color 04.

COLOR_05:
:   Color 05.

COLOR_06:
:   Color 06.

COLOR_07:
:   Color 07.

COLOR_08:
:   Color 08.
user: What is Shape and how is it used in Blender Python scripting?

assistant: # Shape

[image reference removed]

Shape panel.

Resolution Preview U/V
:   The density of the generated surface mesh in the 3D Viewport. The higher this number, the more vertices
    there will be and the smoother the surface will look.

Render U/V
:   The density of the generated surface mesh in the render. If a number is 0, the corresponding number
    from *Resolution Preview* will be used instead.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_surfaces_properties_shape_resolution-1x1-wire.png   Resolution 1×1. | ../../../_images/modeling_surfaces_properties_shape_resolution-3x3-wire.png   Resolution 3×3. |
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Fill Type
:   How the circle is filled with faces.

    None:
    :   Output just the edge ring without any faces.

    N-Gon:
    :   Fill the circle with a single face.

    Triangles:
    :   Fill the circle with triangles connected to a new vertex at the origin.
user: Describe Snapping from the Blender manual or Python API, including usage steps and snippets.

assistant: Snapping aligns the position and size of nodes to the background grid.
This feature allows nodes to snap to a grid, ensuring that node layouts remain clean and visually aligned.
Snapping can be toggling the snap icon (/) in the editor’s headers
or toggled temporarily while [transforming](editing.html#nodes-editing-transform) nodes by holding `Ctrl`.
user: What is Usage and how is it used in Blender Python scripting?

assistant: The *Bend* tool can be used in any case where you might want to bend a shape in two
with a gradual transition between both sides.

This may take a little getting used to, the basics are listed below controls are noted here:

- The initial position of the cursors define the axis to bend on.
- The distance of the mouse cursor to the 3D cursor controls how sharp the bend will be.
- The relative angle of the mouse cursor to the initial axis defines the bend angle.

If this seems overly complicated, it’s probably best to try the tool
where it becomes quickly apparent how the tool reacts to your input.

Bend Angle
:   The amount of rotation.

Radius
:   The sharpness of the bend.

Clamp
:   Normally the arc turns through a clamped rotation angle with the selected elements extended along
    a tangent line beyond that (see above left).
    When the clamp is deactivated, the arc continues around aligning the selected elements into a circle (right).

    When off `Alt` all selected elements follow a circle,
    even when outside the segment between the 3D cursor and the mouse.

[image reference removed]

Bend Transform example.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Point Index
:   The index of the input control point.

Offset
:   The number of points to move around the curve before finding the result.
    If the curve is [cyclic](../read/is_spline_cyclic.xhtml)
    and the offset goes past the start or end point of the curve, it will wrap around
    to the other side.
user: Give a detailed overview of View Menu: syntax, arguments, return values, common patterns.

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

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

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

Asset Shelf
:   Toggle the visibility of the [Asset Shelf](../../interface/window_system/regions.html#ui-region-asset-shelf).

Adjust Last Operation
:   Displays a pop-up panel to alter properties of the last
    completed operation. See [Adjust Last Operation](../../interface/undo_redo.html#bpy-ops-screen-redo-last).

Update Automatically
:   Instantly update any other editors that are affected by changes in this Image Editor.
    When disabled, the other editors may display outdated information until they’re manually refreshed
    (e.g. by orbiting for the 3D Viewport).

Show Metadata
:   Displays metadata about the selected Render Result. See the Output tab’s
    [Metadata](../../render/output/properties/metadata.html) panel to change what metadata to include.

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

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

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

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

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

Frame All `Home`
:   Pans and zooms the view so that the image is centered and fully visible.

Center View to Cursor
:   Pan the view so that the 2D cursor is at the center of the editor.

Render Region `Ctrl`-`B`
:   Only available when viewing the Render Result.
    See [Render Region](../3dview/navigate/regions.html#editors-3dview-navigate-render-region).

Clear Render Region `Ctrl`-`Alt`-`B`
:   Only available when viewing the Render Result.
    See [Render Region](../3dview/navigate/regions.html#editors-3dview-navigate-render-region).

Render Slot Cycle Next/Previous `J`/`Alt`-`J`
:   Switch to the next/previous render slot (that contains a render).

Area
:   Adjust the [area](../../interface/window_system/areas.html) the Image Editor is in.
user: Give a detailed overview of MeshEdges(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # MeshEdges(bpy_struct)

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

*class* bpy.types.MeshEdges(*bpy_struct*)
:   Collection of mesh edges

    add(*count*)
    :   add

        Parameters:
        :   **count** (*int in* *[**0**,* *inf**]*) – Count, Number of edges to add

    *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 Outputs: syntax, arguments, return values, common patterns.

assistant: R
:   The radial distance from the origin in the X-Y plane.

Phi
:   The angular position around the Z axis.

Z
:   The vertical component of the input vector, corresponding directly to its Z coordinate.
user: Give a detailed overview of IKParam(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # IKParam(bpy_struct)

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

subclasses —
[`Itasc`](bpy.types.Itasc.html#bpy.types.Itasc "bpy.types.Itasc")

*class* bpy.types.IKParam(*bpy_struct*)
:   Base type for IK solver parameters

    ik_solver
    :   IK solver for which these parameters are defined

        - `LEGACY`
          Standard – Original IK solver.
        - `ITASC`
          iTaSC – Multi constraint, stateful IK solver.

        Type:
        :   enum in [`'LEGACY'`, `'ITASC'`], default `'LEGACY'`, (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 ThemeStripColor(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # ThemeStripColor(bpy_struct)

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

*class* bpy.types.ThemeStripColor(*bpy_struct*)
:   Theme settings for strip colors

    color
    :   Strip Color

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Pivot Point in complete detail according to the official Blender documentation.

assistant: # Pivot Point

The Pivot Point is the point around which images are rotated and scaled.
It’s indicated by the position of the selected tool’s gizmo.

Bounding Box Center ()
:   Use the center of the rectangle that’s wrapped as tightly as possible around the selected
    images’ origin points.

Median Point ()
:   Use the averaged-out position of the selected images’ origin points.

2D Cursor ()
:   Use the location of the [2D Cursor](../sidebar.xhtml#editors-sequencer-preview-2d-cursor),
    for when you want to specify the pivot point by hand.

Individual Origins ()
:   Rotate/scale each image around its own origin, rather than rotating/scaling
    all of them around the same single point like the other options do.
user: Show practical ways to work with Notes in a Blender add-on or script – include code.

assistant: The slightest difference in seed values would result in completely different outputs.
Consequently, bad precision may have significant impact on the output.
Usually, we can mitigate this issue by:

- Eliminating the problematic seed value. If the problematic seed value is constant,
  it should be eliminated by choosing a lower dimension or multiplying it by zero.
- Adding an arbitrary value to the seed. The issue might only happen at certain boundaries,
  like unit boundaries, so simply adding an arbitrary value might solve the issue.
- Taking the absolute value of the seed. In computing, zero may be positive or negative,
  so taking the absolute values unifies the zero into a single value.

|  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_textures_white-noise_issue.png   Precision issue due to signed zeros on the Z axis. | ../../../_images/render_shader-nodes_textures_white-noise_solution1.png   Mitigating the issue by eliminating the Z axis. |
| ../../../_images/render_shader-nodes_textures_white-noise_solution2.png   Mitigating the issue by adding an arbitrary value. | ../../../_images/render_shader-nodes_textures_white-noise_solution3.png   Mitigating the issue by taking the absolute value. |
user: Give a detailed overview of Sound(ID): syntax, arguments, return values, common patterns.

assistant: # Sound(ID)

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

*class* bpy.types.Sound(*ID*)
:   Sound data-block referencing an external or packed sound file

    channels
    :   Definition of audio channels

        - `INVALID`
          Invalid – Invalid.
        - `MONO`
          Mono – Mono.
        - `STEREO`
          Stereo – Stereo.
        - `STEREO_LFE`
          Stereo LFE – Stereo FX.
        - `CHANNELS_4`
          4 Channels – 4 Channels.
        - `CHANNELS_5`
          5 Channels – 5 Channels.
        - `SURROUND_51`
          5.1 Surround – 5.1 Surround.
        - `SURROUND_61`
          6.1 Surround – 6.1 Surround.
        - `SURROUND_71`
          7.1 Surround – 7.1 Surround.

        Type:
        :   enum in [`'INVALID'`, `'MONO'`, `'STEREO'`, `'STEREO_LFE'`, `'CHANNELS_4'`, `'CHANNELS_5'`, `'SURROUND_51'`, `'SURROUND_61'`, `'SURROUND_71'`], default `'INVALID'`, (readonly)

    filepath
    :   Sound sample file used by this Sound data-block

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

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

    samplerate
    :   Sample rate of the audio in Hz

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

    use_memory_cache
    :   The sound file is decoded and loaded into RAM

        Type:
        :   boolean, default False

    use_mono
    :   If the file contains multiple audio channels they are rendered to a single one

        Type:
        :   boolean, default False

    factory
    :   The aud.Factory object of the sound.

        (readonly)

    pack()
    :   Pack the sound into the current blend file

    unpack(*\**, *method='USE_LOCAL'*)
    :   Unpack the sound to the samples filename

        Parameters:
        :   **method** (enum in [Unpack Method Items](bpy_types_enum_items/unpack_method_items.html#rna-enum-unpack-method-items), (optional)) – method, How to unpack

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

assistant: Source Channel
:   The channel which the Multicam Selector gets its input from.

Cut To
:   Cuts the Multicam strip at the current frame and
    changes the *Source Channel* automatically to the selected channels.
user: How do I use LineStyleGeometryModifier_Simplification(LineStyleGeometryModifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # LineStyleGeometryModifier_Simplification(LineStyleGeometryModifier)

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

*class* bpy.types.LineStyleGeometryModifier_Simplification(*LineStyleGeometryModifier*)
:   Simplify the stroke set

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    tolerance
    :   Distance below which segments will be merged

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

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Geometry Modifier Type Items](bpy_types_enum_items/linestyle_geometry_modifier_type_items.html#rna-enum-linestyle-geometry-modifier-type-items), default `'2D_OFFSET'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # BoolAttributeValue(bpy_struct)

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

*class* bpy.types.BoolAttributeValue(*bpy_struct*)
:   Bool value in geometry attribute

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

assistant: |  |  |
| --- | --- |
| - [`Object.shader_effects`](bpy.types.Object.html#bpy.types.Object.shader_effects "bpy.types.Object.shader_effects") - [`ObjectShaderFx.new`](bpy.types.ObjectShaderFx.html#bpy.types.ObjectShaderFx.new "bpy.types.ObjectShaderFx.new") | - [`ObjectShaderFx.remove`](bpy.types.ObjectShaderFx.html#bpy.types.ObjectShaderFx.remove "bpy.types.ObjectShaderFx.remove") |
user: What is Custom Attributes and how is it used in Blender Python scripting?

assistant: Vertex groups, UV maps and Color Attributes are available as attributes in geometry nodes.
They are referred to by their name.
Naming collisions (e.g. a vertex group and a UV map with the same name) should be avoided.
If there is a naming collision, only one of the attributes is accessible in geometry nodes.

Attributes with any other name can also be created by nodes, when the name is used for the first time.

Note that geometry nodes does not always produce e.g. vertex groups if a node like
[Join Geometry](geometry/join_geometry.xhtml) is used.
Similarly, if the data type of a vertex group attribute is changed from the initial “Float” type,
the attribute will no longer be a vertex group.
user: What is Examples and how is it used in Blender Python scripting?

assistant: [image reference removed]

Noise Texture with high detail.

Different Noise types with the same parameters.

|  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_textures_musgrave_example-type-fbm.jpg   fBM (fractal Brownian Motion). | ../../../_images/render_shader-nodes_textures_musgrave_example-type-multifractal.jpg   Multifractal. |
| ../../../_images/render_shader-nodes_textures_musgrave_example-type-hybrid.jpg   Hybrid Multifractal. | ../../../_images/render_shader-nodes_textures_musgrave_example-type-terrain.jpg   Heterogeneous Terrain. |
| ../../../_images/render_shader-nodes_textures_musgrave_example-type-ridged.jpg   Ridged Multifractal. |  |
user: What is Mix Color Node and how is it used in Blender Python scripting?

assistant: # Mix Color 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: Provide the full official documentation entry for Marker, preserving all code examples.

assistant: Add
:   See [Add Marker](../editing/track.xhtml#bpy-ops-clip-add-marker-move).

Delete
:   See [Delete Track](../editing/track.xhtml#bpy-ops-clip-delete-track).

Detect Features
:   See [Detect Features](../editing/track.xhtml#bpy-ops-clip-detect-features).
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

The UV Project modifier.

UV Map
:   Which UV map to modify. Defaults to the active rendering layer.

Aspect X/Y
:   Changes the image’s aspect ratio. Only apply when a camera is used as projector object.

Scale X/Y
:   Scales the image. Only apply when a camera is used as projector object.

Projectors
:   Up to ten projector objects are supported.
    Each face will choose the closest and aligned projector with its surface normal.
    Projections emit from the negative Z axis (i.e. straight down a camera or light).
    If the projector is a camera, the projection will adhere to its perspective/orthographic setting.

Object
:   Specify the projector object(s).
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Data Type
:   The [data type](../../attributes_reference.xhtml#attribute-data-types) to use for the retrieved values.

Domain
:   The [attribute domain](../../attributes_reference.xhtml#attribute-domains) that the attribute is transferred from, or in other words,
    the domain used to evaluate the *Attribute* input. For example, it is possible to transfer data from the
    faces of one geometry to the points of another.

Clamp
:   Clamp the indices to the size of the attribute domain instead of outputting a default value for invalid indices.
user: Describe Alpha Convert Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Alpha Convert Node

[image reference removed]

The *Alpha Convert Node* converts the alpha channel format of an image.

For compositing and rendering, [Premultiplied Alpha](../../../glossary/index.xhtml#term-Premultiplied-Alpha) is the standard in Blender.
Render layers will be premultiplied alpha, and images loaded into rendering
or compositing will be converted to this.

If you want to do a compositing operation with straight alpha,
the *Alpha Convert* node can be used. Typically this would be a color correction operation
where it might give better results working on RGB channels without alpha.
If the alpha is converted to straight in the Compositor,
it should be converted back to premultiplied before the *Group Output* node,
otherwise some artifacts might occur.
user: What is OpenVDB File and how is it used in Blender Python scripting?

assistant: File Path
:   The VDB file to use.

Sequence
:   Loads further VDB files, one for each frame in an animation. Much like with image sequences,
    all the files should have a numerical suffix in their name; so if you selected smoke-000.vdb
    in the *File Path*, there should be a smoke-001.vdb, a smoke-002.vdb and so on.

    Frames
    :   How many frames of the sequence to use.

    Start
    :   Scene frame at which the sequence should start.

    Offset
    :   How many frames of the sequence to skip at the beginning.

    Mode
    :   How the volume should behave before the sequence’s first frame (*Start*) and after its
        last (*Start* + *Frames*).

        Clip:
        :   Show nothing.

        Extend:
        :   Keep showing the first/last frame of the sequence.

        Repeat:
        :   Play the sequence again (and again, and again…).

        Ping-Pong:
        :   Play the sequence forwards, then backwards, then forwards again and so on.
user: Give a detailed overview of Snap: syntax, arguments, return values, common patterns.

assistant: [Mesh snapping](../../../editors/3dview/controls/snapping.xhtml) also works with curve components.
Both control points and their handles will be affected by snapping,
except for within itself (other components of the active curve).
Snapping works with 2D curves but points will be constrained to the local XY axes.
user: What is The Armature Object and how is it used in Blender Python scripting?

assistant: As you can see, an armature is like any other object type in Blender:

- It has an origin, a position, a rotation and a scale factor.
- It has an Object Data data-block, that can be edited in *Edit Mode*.
- It can be linked to other scenes, and the same armature data can be reused on multiple objects.
- All animation you do in *Object Mode* is only working on the whole object,
  not the armature’s bones (use the *Pose Mode* to do this).

As armatures are designed to be posed, either for a static or animated scene,
they have a specific state, called “rest position”. This is the armature’s default “shape”,
the default position/rotation/scale of its bones, as set in *Edit Mode*.

In *Edit Mode*, you will always see your armature in rest position,
whereas in *Object Mode* and *Pose Mode*,
you usually get the current “pose” of the armature
(unless you enable the *Rest Position* button of the *Armature* panel).
user: What is Distortion vs Undistortion and how is it used in Blender Python scripting?

assistant: Although, both, distortion of render and undistortion of movie clip are possible, and produce similar results,
there is a difference between these two methods.

There are two kinds of lens distortion possible and, in simple terms, they can be said as:

1. When the movie clip is bulging out.
2. When the movie clip is bulging in.

For the first case, it is recommended to distort the render and leave the movie clip as it is, because,
undistorting the movie clip will require extra pixel information, which is not available to Blender.
Similarly, in the second case, it is recommended to undistort the movie clip and leave the render as it is,
because, distorting the render will require those extra unavailable pixels.
Doing the wrong method in the wrong case can create weird results around the edges, such as in the image shown.

[image reference removed]

Problems (notice the edges?)
user: What is Threads and how is it used in Blender Python scripting?

assistant: Threads Mode
:   Method to determine the maximum number of CPU cores to use while rendering.

    Auto-Detect:
    :   Automatically chooses the amount of threads to match the number of logical processors on your computer.

    Fixed:
    :   Manually choose the maximum number threads to use for rendering.
        This can be useful for example, if you want to use your computer while rendering,
        you can set the property to a thread count lower the amount of logical processors on your computer.

Threads
:   The maximum number of CPU cores to use simultaneously while rendering.
user: Describe Texture Nodes from the Blender manual or Python API, including usage steps and snippets.

assistant: # Texture Nodes

These nodes generate procedural textures,
and function just like their non-node-based counterparts.

Common Options

Color 1/Color 2
:   Remaps the procedural texture with these colors. These do not function in the Magic node.
user: How do I use Add Duplicate in Blender? Include parameters, examples, warnings and best practices.

assistant: Duplicates the selected control points and creates a new surface based on them.
The new control points are placed in the *Move* mode: move the mouse to bring
them to the desired position, then click `LMB` to confirm. Alternatively,
press `RMB` or `Esc` to keep them at their original position.

Note that the selected control points must form a single, valid sub grid.
If this is not the case, the duplication will fail with an error.
user: What is Visualization and how is it used in Blender Python scripting?

assistant: There are some important visualization features in the 3D Viewport that can help animation.

When the current frame is a keyframe for the current active object, the name of this object
(shown in the upper left corner of the 3D Viewport) turns yellow.

[image reference removed]

Top: Current frame is a keyframe for Cube. Bottom: Current frame isn’t a keyframe.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Density
:   The value for the new grid at each voxel.

Background
:   The value of the grid outside the *Min*..\*Max\* grid bounds.
    Voxels with a density equal to the background are pruned, which can lead to more memory-efficient volumes.

Min
:   Location of the left-most grid point and lower bound of the voxel volume.

Max
:   Location of the right-most grid point and upper bound of the voxel volume.

Resolution X,Y,Z
:   The number of grid points on each axis.
    The grid contains one less full voxel on each axis than there are grid points.
    For example a *Volume Cube* with resolution 10 has 9 voxels between the left and right grid points.
user: Provide the full official documentation entry for Object Type Visibility, preserving all code examples.

assistant: # Object Type Visibility

This popover lets you control the visibility and selectability of the various object types.
For example, you can hide all the Lights in the scene with one click.

The settings only apply to the current 3D Viewport. Object types marked as unselectable
can still be selected in other viewports and in the
[Outliner](../../outliner/introduction.html), for example.
user: Explain Types in complete detail according to the official Blender documentation.

assistant: Blender defines a number of Python types but also uses Python native types.
Blender’s Python API can be split up into three categories.

### Native Types

In simple cases returning a number or a string as a custom type would be cumbersome,
so these are accessed as normal Python types.

- Blender float, int, boolean -> float, int, boolean
- Blender enumerator -> string

  ```
  >>> C.object.rotation_mode = 'AXIS_ANGLE'
  ```
- Blender enumerator (multiple) -> set of strings

  ```
  # Setting multiple snap targets.
  bpy.context.scene.tool_settings.snap_elements_base = {'VERTEX', 'EDGE'}

  # Passing as an operator argument for report types.
  self.report({'WARNING', 'INFO'}, "Some message!")
  ```

### Internal Types

[`bpy.types.bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct") is used for Blender data-blocks and collections.
Also for data that contains its own attributes: collections, meshes, bones, scenes, etc.

There are two main types that wrap Blender’s data, one for data-blocks
(known internally as `bpy_struct`), another for properties.

```
>>> bpy.context.object
bpy.data.objects['Cube']
```

```
>>> C.scene.objects
bpy.data.scenes['Scene'].objects
```

Note that these types reference Blender’s data so modifying them is visible immediately.

### Mathutils Types

Accessible from [`mathutils`](mathutils.html#module-mathutils "mathutils") are vectors, quaternions, Euler angles, matrix and color types.
Some attributes such as [`bpy.types.Object.location`](bpy.types.Object.html#bpy.types.Object.location "bpy.types.Object.location"),
[`bpy.types.PoseBone.rotation_euler`](bpy.types.PoseBone.html#bpy.types.PoseBone.rotation_euler "bpy.types.PoseBone.rotation_euler") and `bpy.types.Scene.cursor_location`
can be accessed as special math types which can be used together and manipulated in various useful ways.

Example of a matrix, vector multiplication:

```
bpy.context.object.matrix_world @ bpy.context.object.data.verts[0].co
```
user: Provide the full official documentation entry for Stiffness, preserving all code examples.

assistant: For quad faces, the diagonal edges are used as springs.
This stops quad faces to collapse completely on collisions (what they would do otherwise).

Shear
:   Stiffness of the virtual springs created for quad faces.
user: Explain Cone in complete detail according to the official Blender documentation.

assistant: Creates a cone- or pyramid-shaped mesh. Useful for modeling objects like spikes, traffic cones, or wizard hats.
You can also create frustums (truncated cones) or simple pyramids by adjusting the top radius.

Vertices
:   Number of vertices used to define the circular base (or polygon base in the case of a pyramid).
    Higher values produce smoother curves.

Radius 1
:   Radius of the base of the cone (bottom circle).

Radius 2
:   Radius of the tip (top circle). A value of 0 creates a standard cone with a pointed tip.
    Non-zero values result in a frustum shape.

Depth
:   Height of the cone along the Z axis.

Cap Fill Type
:   Determines how the base of the cone is filled:

    Nothing:
    :   No bottom cap is added. Only the side faces are created.
        Useful for creating open containers or hollow cones.

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

    Triangle Fan:
    :   Fills the base with triangular faces sharing a central vertex.
user: What is Documentation Todo List and how is it used in Blender Python scripting?

assistant: # Documentation Todo List

This page provides a list of changes that need to be made to the manual. This is a great place for new contributors to
start. This page is auto-generated from any items marked with the `.. todo::` tag.

It is recommended to also check the [documentation workboard](https://projects.blender.org/blender/documentation/projects) since this will contain larger initiatives and
structured work efforts, as well as laying out priorities.
user: Provide the full official documentation entry for LockedTrackConstraint(Constraint), preserving all code examples.

assistant: # LockedTrackConstraint(Constraint)

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

*class* bpy.types.LockedTrackConstraint(*Constraint*)
:   Point toward the target along the track axis, while locking the other axis

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

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

    lock_axis
    :   Axis that points upward

        Type:
        :   enum in [`'LOCK_X'`, `'LOCK_Y'`, `'LOCK_Z'`], default `'LOCK_X'`

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

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

    target
    :   Target object

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

    track_axis
    :   Axis that points to the target object

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

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

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

assistant: While the noise is random in nature, it follows a certain pattern that might not evaluate to
random values in some configurations. For instance, consider the following configuration
where a grid of objects have a material that evaluates a noise texture at their locations.
One might expect the objects to have random values since they have different locations,
but this is not the case.

[image reference removed]

An example configuration where the noise evaluates to a constant value.

It seems all objects have a value of 0.5. To understand why this happens, let us
look at the following plot of a 1D noise texture.

[image reference removed]

A plot of a 1D noise with zero details and zero distortion.

The horizontal line denotes a value of 0.5 and the vertical lines denotes whole numbers assuming
a noise scale of 1. As can be seen, the noise always intersects the 0.5 line at whole numbers.
Since the aforementioned objects were distributed on a grid and have whole number locations,
they all evaluate to 0.5. Which explains the issue at hand.

Generally, any discrete evaluation of noise at integer multiples of the reciprocal of
the noise scale will always evaluate to 0.5. It also follows that evaluations closer to
that will have values close to 0.5. In such cases, it is almost always preferred to use
the White Noise Texture.

Regardless, one can mitigate this issue in a number of ways:

- Adjust the scale of the noise to avoid aligning the noise with the evaluation domain.
- Add an arbitrary offset to the texture coordinates to break the alignment with the evaluation domain.
- Evaluate the noise at a higher dimension and adjust the extra dimension
  until a satisfactory result is achieved.

|  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_textures_noise_issue-constant-value.png   Constant value issue. | ../../../_images/render_shader-nodes_textures_noise_solution1-constant-value.png   Mitigating the issue by adjusting the scale. |
| ../../../_images/render_shader-nodes_textures_noise_solution2-constant-value.png   Mitigating the issue by adding an arbitrary offset. | ../../../_images/render_shader-nodes_textures_noise_solution3-constant-value.png   Mitigating the issue by evaluating at a higher dimension. |

Similarly, in other configurations, one might experience some banding patterns in the noise,
where there are bands of high contrast areas followed by banding of low contrast areas.
For instance, planar surfaces that are slightly tilted along one of the axis
will have such a banding pattern.

[image reference removed]

An example configuration where the noise have a banding pattern.

This happens because the slight tilt along one of the axis causes values along
the perpendicular axis to change very slowly making the grid structure of
the noise more apparent. The easiest way to mitigate this issue to rotate
the coordinates by an arbitrary amount.

[image reference removed]

Mitigating the issue by rotating the coordinates by an arbitrary amount.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Value
:   The Gabor noise value with both random intensity and phase. This is equal to sine the phase
    multiplied by the intensity.

Phase
:   The phase of the Gabor noise, which has no random intensity.

Intensity
:   The intensity of the Gabor noise, which has no random phase.