PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with ShaderNodeTexChecker(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeTexChecker(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.ShaderNodeTexChecker(*ShaderNode*)
:   Generate a checkerboard texture

    color_mapping
    :   Color mapping settings

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

    texture_mapping
    :   Texture coordinate mapping settings

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Image Editor and how is it used in Blender Python scripting?

assistant: View Menu
:   After you render your scene with Stereo 3D you will be able to see
    the rendered result in the combined stereo 3D or to inspect the individual views.
    This works for Viewer nodes, render results or opened images.

    [image reference removed]

    Stereo 3D and view menu.

Views Format
:   When you drag and drop an image into the Image Editor, Blender will open it as an individual images at first.
    If your image was saved with one of the Stereo 3D formats, you can change how
    Blender should interpret the image by switching the mode to Stereo 3D,
    turning on *Use Multi-View* and picking the corresponding stereo method.

    [image reference removed]

    Views formats and stereo 3D.
user: Give a detailed overview of Array Modifier: syntax, arguments, return values, common patterns.

assistant: # Array Modifier

The *Array* modifier creates multiple copies of an input geometry and arranges them in
a linear, circular, or custom pattern. It offers flexible options for count, spacing,
and randomization, allowing for both precise and organic duplication of geometry.
user: How do I use Inflate in Blender? Include parameters, examples, warnings and best practices.

assistant: # Inflate

Similar to [Draw](clay.html),
except that vertices are moved in the direction of their own normals.
Especially useful when sculpting meshes with a lot of curvature.

Also available as a [Mesh Filter](../tools/mesh_filter.html)
to inflate all unmasked areas at once.
user: Show practical ways to work with Clear an Override in a Blender add-on or script – include code.

assistant: Reset the selected overrides to their original values, and if possible without breaking the
existing hierarchy, delete them and replace them by their linked reference data.
Otherwise, keep the overrides but mark them as non-editable.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [[image reference removed]](../../../_images/grease-pencil_modifiers_deform_shrinkwrap_nearest-surface-point.png)

The Shrinkwrap modifier in Nearest Surface Point mode.

Wrap Method
:   This selector specifies the method to be used to determine the nearest
    point on the target’s surface for each point of the modified object.
    Some options will add some extra, specific controls to the panel.
    See [Wrap Methods](#wrap-methods) for an explanation of each method.

Snap Mode
:   Most modes support an additional setting to control how the point
    is moved to the target point selected by the methods described above.
    Some of the choices only differ if *Offset* is not zero.

    On Surface:
    :   The point is always moved. The offset is applied along the projection line
        connecting the original point and selected target point towards the original position.

    Inside:
    :   The point is not moved if it is already inside the target.
        Offset shrinks the allowed volume towards the inside along the projection line.

    Outside:
    :   The point is not moved if it is already outside the target.
        Offset expands the exclusion volume towards the outside along the projection line.

    Outside Surface:
    :   Like *On Surface*, but the offset is always applied towards the outside of the target.

    Above Surface:
    :   Like *On Surface*, but the offset is applied along the smooth normal of the target.

Target
:   Shrink target, the mesh to shrink to/wrap around.

Offset
:   The distance that must be kept from the calculated target position.

Smooth Factor
:   Amount of smoothing to apply.

Repeat
:   The number of time to apply smoothing.

### Influence

See [Influence Filters](../introduction.html#grease-pencil-modifier-influence-filters).
user: How do I use Roles in Blender? Include parameters, examples, warnings and best practices.

assistant: `scene_linear`
:   Color space used for rendering, compositing, and storing all float precision images in memory.

`data`
:   Color space for non-color data.

`aces_interchange`
:   ACES2065-1 color space. Used to derive chromaticities of the *scene_linear* color space, for
    effects such as blackbody emission.

`cie_xyz_d65_interchange`
:   Intermediate display linear color space, to connected view transforms to display color spaces.

`color_picking`
:   Defines the distribution of colors in color pickers. It is expected to
    be approximately perceptually linear, have the same gamut as the *scene_linear* color space,
    map 0..1 values to 0..1 values in the scene linear color space for predictable editing of materials’ albedo.

`default_sequencer`
:   Default color space for the Sequencer, *scene_linear* if not specified.

`default_byte`
:   Default color space for byte precision images and files, *texture_paint* if not specified.

`default_float`
:   Default color space for float precision images and files, *scene_linear* if not specified.
user: Describe wmOwnerIDs(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # wmOwnerIDs(bpy_struct)

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

*class* bpy.types.wmOwnerIDs(*bpy_struct*)
:   new(*name*)
    :   Add ui tag

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the tag

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

    remove(*owner_id*)
    :   Remove ui tag

        Parameters:
        :   **owner_id** ([`wmOwnerID`](bpy.types.wmOwnerID.html#bpy.types.wmOwnerID "bpy.types.wmOwnerID"), (never None)) – Tag to remove

    clear()
    :   Remove all tags

    *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 Grid to Mesh Node: syntax, arguments, return values, common patterns.

assistant: # Grid to Mesh Node

[image reference removed]

The *Grid to Mesh* node converts a voxel grid into a polygonal mesh by
extracting an isosurface at a specified threshold value.
This process is similar to the *Marching Cubes* algorithm used in many
volumetric modeling systems.

The resulting mesh represents the boundary where the grid’s values cross the
given threshold—typically the surface of a signed distance field (SDF) or density grid.
This makes it possible to convert procedural volumetric data into geometry for
rendering, simulation, or further modeling operations.
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

Motion Tracking is used to track the motion of objects and/or a camera and, through the constraints,
to apply this tracking data to 3D objects (or just one), which have either been created in Blender or
imported into the application. Blender’s motion tracker supports a couple of very powerful tools for 2D tracking and
3D motion reconstruction, including camera tracking and object tracking, as well as some special features like
the plane track for compositing. Tracks can also be used to move and deform masks for rotoscoping in the Mask Editor,
which is available as a special mode in the Movie Clip Editor.
user: What is Common Problems and how is it used in Blender Python scripting?

assistant: ### Unsupported Graphics Driver Error

This means your graphics card and driver do not have the minimum required OpenGL 3.3 version needed by Blender.

Installing the latest version of the correct driver can help upgrade the OpenGL version, though some graphics cards
are simply too old to run the latest Blender. In such cases, using Blender 2.79 or earlier is the only option.
Starting with Blender 2.8 (which added EEVEE), there is less support for older graphics hardware.

### Crash on Startup

Try running Blender from the [command line](../../../advanced/command_line/index.html), to see if any helpful error messages
are printed.

On Windows, graphics drivers can sometimes get corrupted or incorrectly replaced by Windows Update. In this case, it
can help to uninstall all graphics drivers (there may be multiple sets installed from Intel, AMD and NVIDIA) and
perform a clean installation with drivers from the manufacturer’s website.

### Poor Performance

- Update your graphics drivers (see above).
- On laptops, make sure you are using a dedicated GPU (see above).
- Try lowering quality settings in Preferences ‣ System ‣ Memory & Limits.
- Try undoing settings in your graphics drivers, if you made any changes there.

### Render Errors

See [EEVEE](../../../render/eevee/limitations/index.html) and [Cycles](../../../render/cycles/gpu_rendering.html) documentation
respectively.

### Wrong Selection in 3D Viewport

See [Invalid Selection, Disable Anti-Aliasing](../../3d_view.html#troubleshooting-3dview-invalid-selection).

### Virtual Machines

Running Blender inside a virtual machine is known to have problems when OpenGL drawing calls are forwarded to the host
operating system.

To resolve this, configure the system to use PCI passthrough.

Some VM hosts may require turning on GPU paravirtualization. Some GPU vendors restrict this function to higher-priced
cards or models.
user: Describe Bpy.Types.Blenddatalibraries from the Blender manual or Python API, including usage steps and snippets.

assistant: pressed blend file. import bpy filepath = "//new_library.blend" # Write selected objects and their data to a blend file. data_blocks = set ( bpy . context . selected_objects ) bpy . data . libraries . write ( filepath , data_blocks ) # Write all meshes starting with a capital letter and # set them with fake-user enabled so they aren&#39;t lost on re-saving. data_blocks = { mesh for mesh in bpy . data . meshes if mesh . name [: 1 ] . isupper ()} bpy . data . libraries . write ( filepath , data_blocks , fake_user = True ) # Write all materials, textures and node groups to a library. data_blocks = { * bpy . data . materials , * bpy . data . textures , * bpy . data . node_groups } bpy . data . libraries . write ( filepath , data_blocks ) Inherited Properties ¶ bpy_struct.id_data Inherited Functions ¶ bpy_struct.as_pointer bpy_struct.driver_add bpy_struct.driver_remove bpy_struct.get bpy_struct.id_properties_clear bpy_struct.id_properties_ensure bpy_struct.id_properties_ui bpy_struct.is_property_hidden bpy_struct.is_property_overridable_library bpy_struct.is_property_readonly bpy_struct.is_property_set bpy_struct.items bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values References ¶ BlendData.libraries Next BlendDataLights(bpy_struct) Previous BlendDataLattices(bpy_struct) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page BlendDataLibraries(bpy_struct) BlendDataLibraries BlendDataLibraries.tag() BlendDataLibraries.remove() BlendDataLibraries.bl_rna_get_subclass() BlendDataLibraries.bl_rna_get_subclass_py() BlendDataLibraries.load() BlendDataLibraries.write() Inherited Properties Inherited Functions References
user: Give a detailed overview of TextureNodeValToRGB(TextureNode): syntax, arguments, return values, common patterns.

assistant: # TextureNodeValToRGB(TextureNode)

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

*class* bpy.types.TextureNodeValToRGB(*TextureNode*)
:   color_ramp
    :   Type:
        :   [`ColorRamp`](bpy.types.ColorRamp.html#bpy.types.ColorRamp "bpy.types.ColorRamp"), (readonly)

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

assistant: [image reference removed]

Actions with and without a Manual Frame Range in Dope Sheet.

It is possible to manually specify the intended useful frame range of an action via a panel
available in the [Dope Sheet](../editors/dope_sheet/introduction.xhtml) or the [NLA Editor](../editors/nla/sidebar.xhtml)
when a channel or NLA track is selected.

Manual Frame Range
:   Manually specify the intended playback frame range for the action
    (this range is used by some tools, but does not affect animation evaluation).
    The manual frame range feature can be toggled with the checkbox.

    When the range is set, it is used instead of the actual range occupied by key frames
    when adding a new track based on the action to NLA. It can also be used by exporters
    to determine the range of frames to export.

    The range is displayed in the background of the editor as diagonal hash fill, to
    distinguish it from the solid fill of the current playback range.

    The frame values are most commonly expected to be integers, but can be fractional.

Cyclic Animation
:   Specifies that the action is intended to be cyclic over the specified range. The first and last
    frames of the range should represent the same pose of the cycle one loop apart, i.e. the range
    should include the duplicated initial key of the loop.

### Slot

The properties of the action slot that is used by the currently selected item in the channel list.

Name
:   The name of the slot.

Type
:   The data-block type that the slot is intended to animate.

### Custom Properties

Create and manage your own properties to store data in the action’s data block.
See the [Custom Properties](../files/custom_properties.xhtml#files-data-blocks-custom-properties) page for more information.
user: Describe Advanced from the Blender manual or Python API, including usage steps and snippets.

assistant: Brush Type
:   Defines the basic behavior and the available settings. Through the settings of
    a brush type, brushes can be created that produce vastly different effects.

    The *Essentials* asset library contains brushes for each of the brush types. Their preview image
    and description should give a good idea of the effect the brush produces, with the particular
    combination of brush type and settings. Because of this, they are usually the more useful starting
    point for custom brushes than the mere brush type is, which is why the brush type is part of the
    *Advanced* brush settings.

    Brushes and Brush Types of each mode:

    - [Sculpt](../sculpting/brushes/brushes.html)
    - [Vertex Paint](../vertex_paint/brushes.html)
    - [Weight Paint](../weight_paint/brushes.html)
    - [Texture Paint](../texture_paint/brushes.html)

Accumulate
:   Causes stroke dabs to accumulate on top of each other.

Front Faces Only
:   When enabled, the brush only affects vertices that are facing the viewer.

Affect Alpha 2D Painting Only
:   When this is disabled, it prevents changes to the alpha channel while painting (Only in 3D Viewport).

Anti-Aliasing 2D Painting Only
:   Toggles [Anti-Aliasing](../../glossary/index.html#term-Anti-Aliasing) around the brush,
    this is useful if you are working with pixel art or low resolution textures.

Auto-Masking Sculpt Mode
:   The auto-masking toggles in the brush settings are the same as the sculpt mode auto-masking settings.
    The difference is that these toggles can be customized per brush to create specific brush behaviors.

Sculpt Plane Sculpt Mode
:   Use this menu to set the plane in which the sculpting takes place.
    In other words, the primary direction that the vertices will move.

    Area Plane:
    :   The movement takes place in the direction of average normal for all active vertices within the brush area.
        Essentially, this means that the direction is dependent on the surface beneath the brush.

    View Plane:
    :   Sculpting in the plane of the current 3D Viewport.

    X, Y, Z Plane:
    :   The movement takes place in the positive direction of one of the global axes.

Original Sculpt Mode
:   Normal
    :   When locked it keeps using the normal of the surface where stroke was initiated,
        instead of the surface normal currently under the cursor.

    Plane
    :   When locked keep using the plane origin of surface where stroke was initiated,
        instead of the surface plane currently under the cursor.
user: Provide the full official documentation entry for SequenceTimelineChannel(bpy_struct), preserving all code examples.

assistant: # SequenceTimelineChannel(bpy_struct)

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

*class* bpy.types.SequenceTimelineChannel(*bpy_struct*)
:   lock
    :   Type:
        :   boolean, default False

    mute
    :   Type:
        :   boolean, default False

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Limit Size
:   Limit the maximum resolution for pictures used in textured display to save memory.
    The limit options are specified in a square of pixels
    (e.g: the option 256 means a texture of 256×256 pixels). This is useful for game engineers,
    whereas the texture limit matches paging blocks of the textures in the target graphic card memory.

Anisotropic Filtering
:   Sets the level of anisotropic filtering.
    This improves the quality of textures that are rendered at the cost of performance.

Clip Alpha
:   Clip alpha below this threshold in the 3D Viewport.
    Note that, the default is set to a low value to prevent issues on some GPUs.

Image Display Method
:   Method to render images; the following options are supported:

    Automatic:
    :   Automatically use *GLSL* which runs on the GPU for performance but falls back to
        the CPU for large images which might be slow when loaded with the GPU.

    2D Texture:
    :   Uses CPU for display transform and render images as a 2D texture.

    GLSL:
    :   Fastest method using GLSL for display transform and render images as a 2D texture.
user: Provide the full official documentation entry for O, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [**Object**](glossary/index.xhtml#term-Object) - [**Object Center**](glossary/index.xhtml#term-Object-Center) - [Object Constraints](animation/constraints/introduction.xhtml#index-1)   - [Action Constraint](animation/constraints/relationship/action.xhtml#index-0)   - [Armature Constraint](animation/constraints/relationship/armature.xhtml#index-0)   - [Camera Solver Constraint](animation/constraints/motion_tracking/camera_solver.xhtml#index-0)   - [Child Of Constraint](animation/constraints/relationship/child_of.xhtml#index-0)   - [Clamp To Constraint](animation/constraints/tracking/clamp_to.xhtml#index-0)   - [Copy Location Constraint](animation/constraints/transform/copy_location.xhtml#index-0)   - [Copy Rotation Constraint](animation/constraints/transform/copy_rotation.xhtml#index-0)   - [Copy Scale Constraint](animation/constraints/transform/copy_scale.xhtml#index-0)   - [Copy Transforms Constraint](animation/constraints/transform/copy_transforms.xhtml#index-0)   - [Damped Track Constraint](animation/constraints/tracking/damped_track.xhtml#index-0)   - [Floor Constraint](animation/constraints/relationship/floor.xhtml#index-0)   - [Follow Path Constraint](animation/constraints/relationship/follow_path.xhtml#index-0)   - [Follow Track Constraint](animation/constraints/motion_tracking/follow_track.xhtml#index-0)   - [Geometry Attribute Constraint](animation/constraints/relationship/geometry_attribute.xhtml#index-0)   - [Inverse Kinematics Constraint](animation/constraints/tracking/ik_solver.xhtml#index-0)   - [Limit Distance Constraint](animation/constraints/transform/limit_distance.xhtml#index-0)   - [Limit Location Constraint](animation/constraints/transform/limit_location.xhtml#index-0)   - [Limit Rotation Constraint](animation/constraints/transform/limit_rotation.xhtml#index-0)   - [Limit Scale Constraint](animation/constraints/transform/limit_scale.xhtml#index-0)   - [Locked Track Constraint](animation/constraints/tracking/locked_track.xhtml#index-0)   - [Maintain Volume Constraint](animation/constraints/transform/maintain_volume.xhtml#index-0)   - [Object Solver Constraint](animation/constraints/motion_tracking/object_solver.xhtml#index-0)   - [Pivot Constraint](animation/constraints/relationship/pivot.xhtml#index-0)   - [Shrinkwrap Constraint](animation/constraints/relationship/shrinkwrap.xhtml#index-0)   - [Spline IK Constraint](animation/constraints/tracking/spline_ik.xhtml#index-0)   - [Stretch To Constraint](animation/constraints/tracking/stretch_to.xhtml#index-0)   - [Track To Constraint](animation/constraints/tracking/track_to.xhtml#index-0)   - [Transform Cache Constraint](animation/constraints/transform/transform_cache.xhtml#index-0)   - [Transformation Constraint](animation/constraints/transform/transformation.xhtml#index-0) | - [**Object Origin**](glossary/index.xhtml#term-Object-Origin) - [**Octahedron**](glossary/index.xhtml#term-Octahedron) - [**OpenGL**](glossary/index.xhtml#term-OpenGL) - [**Operator**](glossary/index.xhtml#term-Operator) - [**Overscan**](glossary/index.xhtml#term-Overscan) |
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

Blender lets you animate almost any property, going from the X coordinate of an object to the
transparency of a material. The evolution of a property’s value over time is described by
a *function curve*, or F-Curve for short.

An important aspect of F-Curves is that they can interpolate. This saves you the effort of
manually configuring a value on every single frame, which would be highly impractical.
Instead, you define just a few values on key frames, and let the curve calculate the
values on all the other frames.

[[image reference removed]](../../../_images/editors_graph-editor_fcurves_introduction_f-curves-concept.png)

Example of interpolation.

The example curve on the right has two such keyframes (indicated by black dots):
one on frame 0 with value 0, and another on frame 25 with value 10.
The curve automatically calculates the values for the other frames,
such as for frame 5 where the value is 2.
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

Once an armature is [skinned](../skinning/index.xhtml) by the needed object(s),
you need a way to configure the armature into positions known as poses.
Basically, by transforming the bones, you deform or transform the skinned object(s).
However, you will notice that you cannot do this in *Edit Mode* –
remember that *Edit Mode* is used to edit the default, base, or “rest” position of an armature.
You may also notice that you cannot use *Object Mode* either, as here you can only transform whole objects.

So, armatures have a third mode dedicated to the process of posing known as *Pose Mode*.
In rest position (as edited in *Edit Mode*), each bone has its own position/rotation/scale to neutral values
(i.e. 0.0 for position and rotation, and 1.0 for scale). Hence, when you edit a bone in *Pose Mode*,
you create an offset in the transform properties, from its rest position.
This may seem quite similar if you have worked with [relative shape keys](../../shape_keys/index.xhtml)
or [Delta Transformations](../../../scene_layout/object/properties/transforms.xhtml#bpy-types-object-delta).

Even though it might be used for completely static purposes,
posing is heavily connected with animation features and techniques.
So if you are not familiar at all with animation in Blender,
it might be a good idea to read the [animation chapter](../../index.xhtml) first,
and then come back here.
user: Give a detailed overview of View: syntax, arguments, return values, common patterns.

assistant: ### Backdrop

[image reference removed]

Backdrop panel.

The backdrop is the output of a Viewer node in the background of the Compositor.
For example, when `Shift`-`Ctrl`-`LMB` on an Image node, it displays a preview of the image,
or on a Mix node, will show the result of the mixing.
You can toggle the backdrop by clicking the checkbox in the *Backdrop* panel title
or by clicking on the *Backdrop* button in the header.

Channels
:   The color channels to display of the backdrop image.

Zoom `Alt`-`V` `V`
:   Sets the size of the backdrop image.

Offset
:   Change the screen space position of the backdrop.

Move `Alt`-`MMB`
:   Changes the position of the backdrop.

Fit
:   Scales the backdrop to fit the size of the Compositor.

Reset Backdrop
:   Sets back to the default values of Zoom to 1 and Offset to 0.
user: Give a detailed overview of FunctionNodeAlignRotationToVector(FunctionNode): syntax, arguments, return values, common patterns.

assistant: # FunctionNodeAlignRotationToVector(FunctionNode)

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

*class* bpy.types.FunctionNodeAlignRotationToVector(*FunctionNode*)
:   Orient a rotation along the given direction

    axis
    :   Axis to align to the vector

        - `X`
          X – Align the X axis with the vector.
        - `Y`
          Y – Align the Y axis with the vector.
        - `Z`
          Z – Align the Z axis with the vector.

        Type:
        :   enum in [`'X'`, `'Y'`, `'Z'`], default `'X'`

    pivot_axis
    :   Axis to rotate around

        - `AUTO`
          Auto – Automatically detect the best rotation axis to rotate towards the vector.
        - `X`
          X – Rotate around the local X axis.
        - `Y`
          Y – Rotate around the local Y axis.
        - `Z`
          Z – Rotate around the local Z axis.

        Type:
        :   enum in [`'AUTO'`, `'X'`, `'Y'`, `'Z'`], default `'AUTO'`

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

assistant: |  |  |
| --- | --- |
| - [`bpy.context.particle_settings`](bpy.context.html#bpy.context.particle_settings "bpy.context.particle_settings") - [`BlendData.particles`](bpy.types.BlendData.html#bpy.types.BlendData.particles "bpy.types.BlendData.particles") - [`BlendDataParticles.new`](bpy.types.BlendDataParticles.html#bpy.types.BlendDataParticles.new "bpy.types.BlendDataParticles.new") | - [`BlendDataParticles.remove`](bpy.types.BlendDataParticles.html#bpy.types.BlendDataParticles.remove "bpy.types.BlendDataParticles.remove") - [`ParticleSystem.settings`](bpy.types.ParticleSystem.html#bpy.types.ParticleSystem.settings "bpy.types.ParticleSystem.settings") |
user: Explain Wrap Methods in complete detail according to the official Blender documentation.

assistant: ### Nearest Surface Point

This will select the nearest point over the surface of the shrunk target.

### Project

[image reference removed]

Project mode.

This will project vertices along a chosen axis until they touch the shrink target.
Vertices that never touch the shrink target are left in their original position.

Limit
:   This is a distance limit between original vertex and surface.
    If the distance is larger than this limit vertex would not be projected onto the surface.

Subdivision Levels
:   This applies a (temporary) *Catmull-Clark* subdivision to the modified object’s geometry,
    before computing the wrap.

Axis
:   Along which local axis of the modified object the projection is done.
    These options can be combined with each other, yielding a “median axis” of projection.
    If none are selected, the normal direction is used.

Negative/Positive
:   This allows you to select the allowed direction(s) of the shrink along the selected axis.
    If both options are enabled, both ways are evaluated and the closest hit is selected.

Face Cull
:   Allows you to prevent any projection over the “front side”
    (respectively the “back side”) of the target’s faces. The “side” of a face is determined
    by its normal (front being the side “from where” the normal “originates”).

Invert Cull
:   If *Cull Faces* is enabled, and *Negative* direction along axis is allowed,
    this option can be used to invert the *Front* or *Back* cull choice
    for the *Negative* direction. This is useful when projecting in both directions.

Auxiliary Target
:   An additional object to project over.

### Nearest Vertex

[image reference removed]

Nearest Vertex mode.

This will snap vertices to the nearest vertex of the shrunk target. It adds no extra options.

This method doesn’t support the *Snap Mode* setting.

### Target Normal Project

[image reference removed]

Target Normal Project mode.

This mode is similar to *Nearest Surface Point*, but produces a much smoother
projection in return for being significantly slower.

Instead of finding the closest point, it searches for the nearest point
that has its interpolated smooth normal pointing towards or away from the original vertex position.
Non-manifold boundary edges are specially handled as infinitely thin cylinders
that emit normals in all perpendicular directions; ignores flat shading.
user: What is Copy/Paste and how is it used in Blender Python scripting?

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

Frame Offset
:   Offsets the pasted keyframes horizontally so that…

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

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

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

    No Offset
    :   …they stay at their original frames.

Value Offset
:   Offsets the pasted keyframes vertically so that…

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

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

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

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

    No Offset
    :   …they keep their original values.

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

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

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

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

Flipped
:   If you copied keyframes from one or more pairs of
    [symmetrically opposite bones](../../../animation/armatures/bones/editing/naming.xhtml),
    enabling this option will paste the keyframes of the left bones into the curves of the right ones
    and vice versa. In addition, the values are inverted, effectively mirroring the animation.
user: What is Opacity Modifier and how is it used in Blender Python scripting?

assistant: # Opacity Modifier

The *Opacity* Modifier change the opacity (alpha) value of the stroke points.

The alpha value in Grease Pencil is stored per-point.
The modifier can alter these values to go from totally transparent points to totally opaque points.
user: Show practical ways to work with LineStyleGeometryModifier_Blueprint(LineStyleGeometryModifier) in a Blender add-on or script – include code.

assistant: # LineStyleGeometryModifier_Blueprint(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_Blueprint(*LineStyleGeometryModifier*)
:   Produce a blueprint using circular, elliptic, and square contour strokes

    backbone_length
    :   Amount of backbone stretching

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    random_backbone
    :   Randomness of the backbone stretching

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

    random_center
    :   Randomness of the center

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

    random_radius
    :   Randomness of the radius

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

    rounds
    :   Number of rounds in contour strokes

        Type:
        :   int in [1, 1000], default 0

    shape
    :   Select the shape of blueprint contour strokes

        - `CIRCLES`
          Circles – Draw a blueprint using circular contour strokes.
        - `ELLIPSES`
          Ellipses – Draw a blueprint using elliptic contour strokes.
        - `SQUARES`
          Squares – Draw a blueprint using square contour strokes.

        Type:
        :   enum in [`'CIRCLES'`, `'ELLIPSES'`, `'SQUARES'`], default `'CIRCLES'`

    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_Blueprint.type "bpy.types.LineStyleGeometryModifier_Blueprint.type")
user: Provide the full official documentation entry for Selecting Objects, preserving all code examples.

assistant: # Selecting Objects

This page discusses selection tools that are specific to the 3D Viewport.
The generic selection tools are described in the
[Interface](../../interface/selecting.xhtml) section.

The 3D Viewport has two keys that affect selection:

Select by Origin `Ctrl`
:   Selects objects by their [origin](../../scene_layout/object/origin.xhtml)
    rather than their geometry.

Selection Menu `Alt`
:   Shows a menu in case there are multiple objects under the mouse cursor,
    making it easier to select the one you want.

These keys can be combined to get a selection menu based on object origins.

The mode-specific selection pages are listed below.
user: How do I use Sepia Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Sepia Node

[image reference removed]

The *Sepia* node applies a warm, brownish color tint to the image, emulating the look of
vintage photographs or old film prints.
It can be used to create nostalgic, cinematic, or stylized color grades that mimic
chemical sepia toning processes used in traditional photography.
user: Give a detailed overview of Selecting Bones: syntax, arguments, return values, common patterns.

assistant: By clicking on a bone’s body, you will select it
(and hence you will implicitly select its root and tip).

Using `Shift`-click, you can add to/remove from the selection.

You also have some *advanced selection* options, based on their relations.

Pick Shortest Path `Ctrl`-click
:   Selects the path from the active bone to the bone under the mouse.

### Deselecting Connected Bones

There is a subtlety regarding connected bones.

When you have several connected bones selected, if you deselect one bone,
its tip will be deselected, but not its root, if it is also the tip of another selected bone.

To understand this, look at Fig. [Bone deselection in a selected chain.](#fig-rig-bone-select-deselect).

Bone deselection in a selected chain.

|  |  |
| --- | --- |
| ../../../_images/animation_armatures_bones_selecting_whole-chain.png   A selected chain. | ../../../_images/animation_armatures_bones_selecting_two-bones.png   Two selected bones. |

After `Shift`-clicking “Bone.003”:

- “Bone.003” ‘s tip (which is same as “Bone.004” ‘s root) is deselected.
- “Bone” is “Bone.003” ‘s parent. Therefore, “Bone.003” ‘s root is the same as the tip of “Bone”.
  Since “Bone” is still selected, its tip is selected. Thus the root of “Bone.003” remains selected.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`CollisionModifier.settings`](bpy.types.CollisionModifier.html#bpy.types.CollisionModifier.settings "bpy.types.CollisionModifier.settings") | - [`Object.collision`](bpy.types.Object.html#bpy.types.Object.collision "bpy.types.Object.collision") |
user: Provide the full official documentation entry for limbs.arm, preserving all code examples.

assistant: Will create a fully featured bendy and stretchy arm depending on the user-defined options.

Requirement: A chain of three connected bones (upper_arm, forearm, hand).

[image reference removed]

Arm required bones.

IK Wrist Pivot
:   Generates an extra child of the hand IK control that rotates around the tail of the hand bone.

Rotation Axis (Automatic, X, Z)
:   Defines the bend axis for the IK chain. FK chains will have a totally free degree of rotation on all axes.

Limb Segments (integer)
:   Defines the number of additional tweak controls each limb bone will have on the final rig.

B-Bone Segments (integer)
:   Defines the number of b-bone segments each tweak control will be split into.

Custom IK Pivot
:   Generates an extra control for the end of the IK limb that allows rotating it around an arbitrarily placed pivot.

Assign FK Layers
:   If enabled, allows placing the FK chain in different bone collections from the IK bones.

Assign Tweak Layers
:   If enabled, allows placing the Tweak controls in different bone collections from the IK bones.
user: Explain NodeSocketColor(NodeSocketStandard) in complete detail according to the official Blender documentation.

assistant: # NodeSocketColor(NodeSocketStandard)

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

*class* bpy.types.NodeSocketColor(*NodeSocketStandard*)
:   RGBA color socket of a node

    default_value
    :   Input value used for unconnected socket

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

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # OpenColorIO

Blender comes with a standard OpenColorIO configuration that
contains a number of useful display devices and view transforms.

However, OpenColorIO is also designed to give a consistent user experience across
[multiple applications](https://opencolorio.org/#supported_apps),
and for this, a single shared configuration file can be used.
Blender will use the standard `OCIO` environment variable to read an OpenColorIO configuration
other than the default Blender one. More information about how to set up such a workflow
can be found on the [OpenColorIO website](https://opencolorio.org/).

There is also a `BLENDER_OCIO` environment variable to change the configuration
for Blender only. It is recommended to use `OCIO` when possible for compatibility
with other software and pipelines that may not be aware of `BLENDER_OCIO`. However
sometimes there are incompatibilities in configuration files that make it difficult
to share them across applications.
user: Give a detailed overview of Examples: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

The difference between *F1* and *Smooth F1* can be used to create beveled Voronoi cells.

[image reference removed]

Creating a hammered metal shader using the *Voronoi Texture* node.
user: Show practical ways to work with General Conventions in a Blender add-on or script – include code.

assistant: - Use a three-space indentation.
- Limit line length to 120 characters.
- Use italics for button and menu names.
- Avoid using Unicode characters unless strictly necessary.
- Prefer simple sentence structures for clarity.
- Avoid heavily wrapped text (shorter paragraphs and clear sentences are recommended).