PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Curve
:   Poly spline generated from the inputs.

Center
:   The center of the arc described by the three points. *Points* mode only.

Normal
:   The normal direction of the plane described by the three points,
    pointing towards the positive Z axis. *Points* mode only.

Radius
:   The radius of the arc described by the three points. *Points* mode only.
user: Give a detailed overview of Path Layout: syntax, arguments, return values, common patterns.

assistant: `./autosave`
:   Autosave blend-file location. (Windows only, temp directory used for other systems.)

    Located in user directories.

`./config`
:   User configuration and session info.

    Located in user directories.

    `./config/startup.blend`
    :   Blend file to load on startup.

    `./config/userpref.blend`
    :   User preferences.

    `./config/bookmarks.txt`
    :   File Browser bookmarks.

    `./config/recent-files.txt`
    :   Recent file menu list.

    `./config/{APP_TEMPLATE_ID}/startup.blend`
    :   Startup file for an application template.

    `./config/{APP_TEMPLATE_ID}/userpref.blend`
    :   User preferences file for an application template.

`./datafiles`
:   Data files loaded at runtime.

    Located in both user and system directories. User data files either override
    or add to system data files.

    `./datafiles/colormanagement`
    :   Default OpenColorIO configuration.

    `./datafiles/fonts`
    :   User interface fonts.

    `./datafiles/studiolights`
    :   Studio light images for 3D viewport.

`./extensions`
:   Extension repositories.

    Located in both user and system directories. Repositories are loaded from
    both directories.

`./scripts`
:   Add-ons, presets, templates, user interface, startup scripts.

    Located in both user and system directories. Scripts are loaded from
    both directories.

    `./scripts/addons/*.py`
    :   Python add-ons which may be enabled in the Preferences include import/export format support,
        render engine integration and many handy utilities.

    `./scripts/addons/modules/*.py`
    :   Modules for add-ons to use
        (added to Python’s `sys.path`).

    `./scripts/addons_core/*.py`
    :   The add-ons directory which is used for bundled add-ons.

    `./scripts/addons_core/modules/*.py`
    :   Modules for `addons_core` to use (added to Python’s `sys.path` when it found).

    `./scripts/modules/*.py`
    :   Python modules containing our core API and utility functions for other scripts to import
        (added to Python’s `sys.path`).

    `./scripts/startup/*.py`
    :   Scripts which are automatically imported on startup.

        `./scripts/startup/bl_app_templates_user/{APP_TEMPLATE_ID}`
        :   Application templates installed in user directories.

        `./scripts/startup/bl_app_templates_system/{APP_TEMPLATE_ID}`
        :   Application templates automatically loaded from system directories.

    `./scripts/presets/{preset}/*.py`
    :   Presets used for storing user-defined settings for cloth, render formats, etc.

    `./scripts/templates_py/*.py`
    :   Example scripts which can be accessed from Text Editor ‣ Templates ‣ Python.

    `./scripts/templates_osl/*.osl`
    :   Example OSL shaders which can be accessed from
        Text Editor ‣ Templates ‣ Open Shading Language.

`./python`
:   Bundled Python distribution.

    Located in system directories.
user: Explain Separate in complete detail according to the official Blender documentation.

assistant: Creates a new point cloud object from the currently selected points.

This is useful for breaking a larger scan or dataset into manageable segments
or organizing different regions of points into separate objects.
user: What is Connecting Sockets and how is it used in Blender Python scripting?

assistant: `LMB`-click on a socket and drag. “Connect to Output” will see a line coming out of it; this is called a *link*.
Keep dragging and connect the link to an input socket of another node, then release the `LMB`.

While multiple links can route out of an output socket, typically a single link can be attached to an input socket,
that is unless the input is a multi-socket input with looks like a pill shaped socket.

To swap multiple links of a similar type, press and hold `Alt` while moving a link.
This feature also works when adding a new link into a pre-existing socket.

To reposition the outgoing links of a node, rather than adding a new one,
hold `Ctrl` while dragging from an output socket.
This works for single as well as for multiple outgoing links.

Nodes that have no connections can be inserted on a link
by just move the node over the link and release when the link is highlighted.

Make Links `J`
:   Select multiple nodes with open sockets, then use the Make Links to create links between them.
    Use Make Links again if there are other nodes which can be connected.

Make and Replace Links `Shift`-`J`
:   *Make and Replace Links* works similarly to *Make Links*, but it will replace existing links if any exist.
user: Explain In Object Mode in complete detail according to the official Blender documentation.

assistant: The pivot point becomes the center of the bounding box *around the selected objects’
origin points*, not their geometry.

This means that, if you have a single object selected, the pivot point is the same
as the object’s [origin point](../../../../scene_layout/object/origin.xhtml) – which can be customized
and doesn’t have to be in the center. In the example below, the orange rectangle
has it in a corner instead.

[image reference removed]

Single object rotation.

If you have multiple objects selected, the pivot point becomes the center
of an imaginary box around their origins.

The image below shows the difference between Bounding Box Center
and [Median Point](median_point.xhtml).
The latter calculates the average position of the origins,
meaning that the pivot point shifts towards the area with the most objects.

[image reference removed]

Difference between “Bounding Box Center” (left) and “Median Point” (right).
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Geometry
:   The input geometry containing the hair curves to displace.

Factor
:   Scales the overall displacement strength.
    A value of 0.0 applies no displacement, while 1.0 applies the full displacement vector.

Shape
:   Defines how the displacement factor changes along the length of each curve.
    A value of 0.0 applies a constant displacement, while 0.5 results in a linear falloff from root to tip.

Object Space
:   The object whose transform defines the coordinate space of the displacement.
    If unset, displacement is applied in the modifier’s local space.

Displace Vector
:   The vector used to determine the direction and magnitude of the displacement.
    This can be driven by fields or other procedural inputs.

### Surface Normal

When enabled, displaces the curves along the normal of a surface, allowing for effects like
“pushing” or “lifting” hair away from a mesh.

Can be enabled from the header.

Surface Input Type
:   Determines how the surface data is provided for sampling the normals.
    The geometry input takes priority over the object input.

    Object:
    :   Use an object reference to sample surface normals.

    Geometry:
    :   Use a geometry input to sample normals directly.

Surface
:   The surface object used to sample the normals for displacement.

Surface UV Map
:   The UV map used when sampling the surface normals for displacement.

Surface Normal Displacement
:   Amount of displacement applied along the sampled surface normal.
    Can be positive or negative depending on the desired direction.
user: Provide the full official documentation entry for Camera Info Node, preserving all code examples.

assistant: # Camera Info Node

[image reference removed]

The *Camera Info* node outputs the information about the selected camera object.

It can be used to customize geometry based on the camera’s parameters,
for example when building camera-based visual effects or aligning geometry with the camera view.
user: Give a detailed overview of Defocus Node: syntax, arguments, return values, common patterns.

assistant: # Defocus Node

[image reference removed]

The *Defocus Node* blurs areas of an image based on a Z depth map or mask input.

It is typically used to emulate depth of field ([DOF](../../../../glossary/index.html#term-DOF)) using a post-processing method with a Z-buffer input.
But also allows to blur images that are not based on Z depth too.
user: How do I use Header in Blender? Include parameters, examples, warnings and best practices.

assistant: Shader Type
:   The type of data whose shader nodes are being edited:

    Object:
    :   Edit shader nodes for the active object’s [Material](../render/materials/index.xhtml).

    World:
    :   Edit shader nodes for the [World background](../render/lights/world.xhtml).

    Line Style:
    :   Edit shader nodes for Freestyle [Line Styles](../render/freestyle/view_layer/line_style/index.xhtml)

Use Nodes Line Style
:   Use shader nodes to define the texture for the freestyle line style.

Slot
:   The *Slot* menu can be used to select
    the active [material slot](../render/materials/assignment.xhtml#bpy-types-materialslot) on the active object.
    The material selector to the right of it can change the material that is in the selected slot.

/ Pinned
:   Keeps the current material selection visible in the Shader editor
    even when another object or material is selected elsewhere.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Mode
:   Storage mode for custom normal data:

    Sharpness:
    :   Store the sharpness of each face or edge. Similar to the “Shade Smooth” and “Shade Flat” operators.

    Free:
    :   Store custom normals as simple vectors in the local space of the mesh.
        This is efficient and fast to evaluate but does not support deformation.

    Tangent Space:
    :   Store normals in a deformation dependent custom transformation space.
        This method is slower, but can be better when subsequent operations
        change the mesh without handling normals specifically.

Domain Free mode
:   [Attribute domain](../../attributes_reference.xhtml#attribute-domains) to store free custom normals.

    Point:
    :   Store normals per vertex.

    Face:
    :   Store normals per face.

    Face Corner:
    :   Store normals per face corner, this domain is necessary to bake
        existing mixed sharp and smooth edges into the custom normal vectors.
user: Give a detailed overview of Normalization: syntax, arguments, return values, common patterns.

assistant: Often, kernels are normalized so that the sum of all values equals 1.
This prevents overall brightening or darkening of the image.
For example, dividing each element of a blur kernel by the total sum of all values ensures
consistent brightness after convolution.
user: Show practical ways to work with Transferring UV Maps in a Blender add-on or script – include code.

assistant: You can copy a UV map from one mesh to another in several ways. If the meshes have
the exact same topology and only differ in vertex positions, you can use
[Copy UV Maps](../../../../scene_layout/object/editing/link_transfer/link_data.xhtml#bpy-ops-object-join-uvs). If they have (approximately) the same surface
but different topology, you can instead use
[Transfer Mesh Data](../../../../scene_layout/object/editing/link_transfer/transfer_mesh_data.xhtml).
user: Show practical ways to work with Interface in a Blender add-on or script – include code.

assistant: [image reference removed]

Panel layout (Thickness modifier as an example).

Each modifier’s interface shares the same basic components like modifiers for meshes.

See [Modifiers Interface](../../modeling/modifiers/introduction.xhtml#bpy-types-modifier-show) for more information.

### Applying Modifiers

Applying a modifier makes the effects of the modifier “real”;
converts the strokes to match the applied modifier’s results, and deletes the modifier.

When applying a modifier to an object that shares Object Data between multiple objects,
the object must first be made a [Single User](../../files/data_blocks.xhtml#data-system-datablock-make-single-user)
which can be performed by confirming the pop-up message.

Apply (Active Keyframe) `Ctrl`-`A`
:   Applies the modifier for the current keyframe.

Apply (All Keyframes)
:   Applies the modifier for all keyframes.

### Influence Filters

Most Grease Pencil modifiers share a set of options that control where the modifier is applied.
These filters restrict the modifier’s effect to specific layers, materials, or geometry components.

For each filter, you can invert the selection by clicking
the  (Invert) icon next to the control.

Layer / Group
:   Restricts the effect to points or strokes of the specified [layer](../properties/layers.xhtml).
    Alternatively, to filter by layer groups, click the  icon.

Layer Pass
:   Restricts the effect to points or strokes in layers with a matching
    [Pass Index](../properties/layers.xhtml#bpy-types-greasepencillayer-pass-index).

Material
:   Restricts the effect to points or strokes using the specified material.

Material Pass
:   Restricts the effect to points or strokes whose material has a matching
    [Pass Index](../materials/properties.xhtml#bpy-types-materialgpencilstyle-pass-index).

Vertex Group
:   Restricts the effect to points or strokes assigned to a specific vertex group.

Custom Curve
:   When enabled, applies a custom falloff curve to control how the modifier’s influence varies
    along each stroke from start to end.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`MaskLayer.splines`](bpy.types.MaskLayer.html#bpy.types.MaskLayer.splines "bpy.types.MaskLayer.splines") - [`MaskSplines.active`](bpy.types.MaskSplines.html#bpy.types.MaskSplines.active "bpy.types.MaskSplines.active") | - [`MaskSplines.new`](bpy.types.MaskSplines.html#bpy.types.MaskSplines.new "bpy.types.MaskSplines.new") - [`MaskSplines.remove`](bpy.types.MaskSplines.html#bpy.types.MaskSplines.remove "bpy.types.MaskSplines.remove") |
user: How do I use Forward Compatibility in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Loss of Data

Forward compatibility is inherently harder to ensure, and loss of feature should always be expected
when opening a blend-file saved with a more recent version of Blender.

A warning is shown in the UI when editing a more recent blend-file.
Trying to overwrite it (with a simple ‘Save’ operation) will also show a confirmation popup,
as this could make that loss of data permanent.

### Complete Incompatibility

When Blender switches to a new major version release (e.g. from 3.x to 4.0), there can also be major
changes that will make the blend-file fully incompatible with older versions of Blender.

In such cases, older Blender will fail opening (or appending/linking from) the newer blend-file, with a
message stating which minimal version is needed to open it.

In such cases, the last LTS release of the previous release cycle will be kept compatible with the newer
file format version, and will be usable as converter between both versions.

For example, Blender 3.6 LTS can open files from Blender 4.x, and will perform the necessary conversion
such that when re-saved from 3.6, the files become compatible with all 3.x Blender versions.
user: Provide the full official documentation entry for GeometryNodeInputMeshFaceArea(GeometryNode), preserving all code examples.

assistant: # GeometryNodeInputMeshFaceArea(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.GeometryNodeInputMeshFaceArea(*GeometryNode*)
:   Calculate the surface area of a mesh’s faces

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

Python is an interpreted, interactive, object-oriented programming language.
It incorporates modules, exceptions, dynamic typing, very high-level dynamic data types, and classes.
Python combines remarkable power with very clear syntax.

Python scripts are a versatile way to extend Blender functionality.
Most areas of Blender can be scripted, including animation, rendering, import and export,
object creation and automating repetitive tasks.

To interact with Blender, scripts can make use of
the tightly integrated API.
user: Describe Special Characters from the Blender manual or Python API, including usage steps and snippets.

assistant: This is a limited character map to insert characters which aren’t available from the keyboard.
Many other special characters can be “composed”, see [Accent Characters](#accent-characters).
If you need others, you will have to copy-paste them from an external editor or character map program.
user: How do I use ShaderNodeTexIES(ShaderNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ShaderNodeTexIES(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.ShaderNodeTexIES(*ShaderNode*)
:   Match real world lights with IES files, which store the directional intensity distribution of light sources

    filepath
    :   IES light path

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

    ies
    :   Internal IES file

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

    mode
    :   Whether the IES file is loaded from disk or from a text data-block

        - `INTERNAL`
          Internal – Use internal text data-block.
        - `EXTERNAL`
          External – Use external .ies file.

        Type:
        :   enum in [`'INTERNAL'`, `'EXTERNAL'`], default `'INTERNAL'`

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

assistant: With caustics disabled, glass shadows may appear too dark,
and with filter glossy the caustics might be too soft.
We can make a glass shader that will use a Glass BSDF when viewed *directly*,
and a Transparent BSDF when viewed *indirectly*. The Transparent BSDF can be used for
transparent shadows to find light sources straight through surfaces,
and will give properly-colored shadows, but without the caustics.
The Light Path node is used to determine when to use which of the two shaders.

[image reference removed]

Optimized glass shader.

Above we can see the node setup used for the glass transparency trick;
on the left the render has dark shadows due to missing caustics,
and on the right the render with the trick.

|  |  |
| --- | --- |
| <../../../_images/render_cycles_optimizations_reducing-noise_glass-too-much-shadow.jpg>   Default Glass BSDF. | <../../../_images/render_cycles_optimizations_reducing-noise_glass-trick.jpg>   Optimized Glass Shader. |
user: Describe Set Curve Type from the Blender manual or Python API, including usage steps and snippets.

assistant: Sets the spline type for the splines in the stroke component that are in the selection.

Type
:   Specifies the target spline type. For more details on spline types, see the
    [Spline Types](../../../modeling/curves/structure.xhtml#curve-spline-types) documentation.

    Bézier:
    :   Converts the spline to a Bézier type.
        - Poly splines are converted with vector handles.
        - NURBS or Catmull Rom splines are converted with automatic handles.

    NURBS:
    :   Converts the spline to a NURBS type.

    Poly:
    :   Converts the spline to a poly type.

    Catmull Rom:
    :   Converts the spline to a Catmull Rom type.

Handles
:   Includes handle information during the conversion process.
user: Explain Selecting Text in complete detail according to the official Blender documentation.

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

assistant: # Fileselect Params Sort Items

FILE_SORT_ALPHA:
:   Name.

    Sort the file list alphabetically.

FILE_SORT_EXTENSION:
:   Extension.

    Sort the file list by extension/type.

FILE_SORT_TIME:
:   Modified Date.

    Sort files by modification time.

FILE_SORT_SIZE:
:   Size.

    Sort files by size.

ASSET_CATALOG:
:   Asset Catalog.

    Sort the asset list so that assets in the same catalog are kept together. Within a single catalog, assets are ordered by name. The catalogs are in order of the flattened catalog hierarchy..
user: What is Blender Goes Open Source and how is it used in Blender Python scripting?

assistant: Thanks to this business model, NaN was able to fund a booth at a renowned computer graphics conference in Los Angeles,
SIGGRAPH (Special Interest Group on Computer Graphics and Interactive Techniques). As a consequence, Blender attracted
two rounds of funding totaling some five and a half million US dollars. Despite this investment, a harsh economic
climate, excess spending, and troubled relations between NaN and its investors meant that the company closed in early
2002.

With NaN’s demise, Blender’s development ceased. Unable to buy the rights from NaN’s backers, Roosendaal opted for a
novel plan. In May of 2002, he started a non-profit, the Blender Foundation, with the intention of making Blender
[open-source](https://opensource.org/). His hope was to create a public monument to Blender, and give everyone who
had worked on the Blender project the chance to use it for their portfolios. In July of the same year, he launched the
first-ever crowdfunding campaign: Free Blender. Thanks to Blender’s community of 250,000 users, the Blender Foundation
was able to raise one hundred and ten thousand euros in just seven weeks — sufficient to regain Blender from its
investors.

On Sunday, October 13th, 2002, Blender was released under the terms of the [GNU General Public License](https://www.gnu.org/licenses/gpl.html), the strictest possible open-source contract. Not only would Blender be
free, but its source code would remain free, forever, to be used for any purpose whatsoever.

The success of Free Blender cleared the way for a style of development that has become Blender’s defining strength.
While Blender’s evolution is partly driven by grant-funded developers and guided by a core team at the Blender
Foundation, Amsterdam, its greatest advantage is a global community of dedicated volunteers. Thanks to their efforts,
Blender is able to iterate rapidly and respond to the needs of artists and makers. Such nimbleness and creativity
would be much harder within the confines of a traditional business model.
user: Explain NodeSocketVectorAcceleration4D(NodeSocketStandard) in complete detail according to the official Blender documentation.

assistant: # NodeSocketVectorAcceleration4D(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.NodeSocketVectorAcceleration4D(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

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.xhtml), 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.xhtml) and [Cycles](../../../render/cycles/gpu_rendering.xhtml) documentation
respectively.

### Wrong Selection in 3D Viewport

See [Invalid Selection, Disable Anti-Aliasing](../../3d_view.xhtml#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 Tool Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: You can configure the brush main settings exposed on the Tool Settings for convenience.
For the draw brushes configuration and settings see:
[Draw Brush](../brushes/draw.xhtml).

Subdivisions
:   The number of stroke points between each stroke edge.

Thickness Profile
:   Use a [curve widget](../../../../interface/controls/templates/curve.xhtml) to define the stroke thickness
    from the start (left) to end (right) of the stroke.

    Use Curve
    :   When enabled, the stroke use a curve profile to control the thickness along the line.

Different thickness profile samples.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_line_thickness-profile-01.png | ../../../../_images/grease-pencil_modes_draw_tools_line_thickness-profile-02.png | ../../../../_images/grease-pencil_modes_draw_tools_line_thickness-profile-03.png |

### Brush Asset

Picks the brush asset used by the tool.

See [Brush Asset](../tool_settings/brushes.xhtml) for more information.

See [Draw Brushes](../brushes/draw.xhtml) for a detailed list of all draw brushes and their options.

### Brush Settings

Parameters to control to look of the stroke.

See [Draw Brushes](../brushes/draw.xhtml) for details.

### Color

Settings to determine the color of strokes.

See [Color](../tool_settings/color.xhtml)
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Noise Modifier.

Position
:   Strength of the noise effect over the point location.

Strength
:   Strength of the noise effect over the point strength (opacity).

Thickness
:   Strength of the noise effect over the point thickness.

UV
:   Strength of the noise effect over the point UV rotation.

Noise Scale
:   Control the noise frequency scale.

Noise Offset
:   Moves the noise along the strokes.

Seed
:   [Seed](../../../glossary/index.xhtml#term-Seed) used by the pseudo-random number generator.

### Randomize

When enabled, the noise uses a random value over time.

Mode
:   Steps:
    :   New random value at defined steps.

        Step
        :   Number of frames before using a new random value.

    Keyframes:
    :   New random value only on keyframes.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Geometry
:   Standard geometry input.

Selection
:   A boolean field input for each element indicating whether to store the attribute value for the given index.
    If the attribute does not exist, unselected parts are filled with zero values;
    otherwise, only the selected parts are filled.

Value
:   The input field to evaluate.

Name
:   The name to give the stored data.
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: Geometry
:   The resulting geometry with curled hair curves.

### Guide Map

Guide Index
:   The guide index map used for the operation.
    If this node created a new guide map, it is stored and output here
    for use in subsequent nodes.
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

Rendering is the process of turning a 3D scene into a 2D image.
Blender includes three render engines with different strengths:

- [EEVEE](eevee/index.xhtml) is a physically based realtime renderer.
- [Cycles](cycles/index.xhtml) is a physically based path tracer.
- [Workbench](workbench/index.xhtml) is designed for layout, modeling and previews.

More renderers from third-party developers are available as
[add-ons](../editors/preferences/extensions.xhtml).
Each renderer has its own render settings to control render quality and performance.

What the render looks like is defined by [cameras](cameras.xhtml),
[lights](lights/index.xhtml) and [materials](materials/index.xhtml).
These are shared between EEVEE and Cycles, however some features are only supported in one or the other.

Renders can be split up into [layers and passes](layers/index.xhtml), which can then
be [composited](../compositing/index.xhtml) together for creative control, or to combine
with real footage. [Freestyle](freestyle/index.xhtml) can be used to
add non-photorealistic line rendering.

Blender supports interactive 3D viewport rendering for all render engines, for quick iteration
on lighting and shading. Once this is done, the final quality image or animation can
be rendered and [output](output/index.xhtml).
user: Describe Batch Rename from the Blender manual or Python API, including usage steps and snippets.

assistant: The *Batch Rename* operator can rename many data-block names at once.
This uses a pop-up dialog with operations and their options to change the name.
These actions are applied in order, from first to last.

Data Source
:   Where to look for the data-blocks that are intended to be renamed.

    Selected:
    :   Operates on the currently selected objects.

    All:
    :   Operates on all data in the blend file.

Data Type
:   The [data-block type](../data_blocks.xhtml#data-system-datablock-types) to perform the batch rename operations on.

### Operations

The *Batch Rename* has several sub Operations to change the data names.
The default operation is *Find/Replace* however, other operations can be added
to change the data names further.
Below all the operations gives a message in the status bar on how many data-blocks were renamed.

#### Find/Replace

*Find/Replace* searches for a particular text in the names and optionally replaces it with a new text.
[Regular Expressions](https://en.wikipedia.org/wiki/Regular_expression)
can be used as a powerful way to tailor the *Find*/*Replace* texts
and can be enabled using the icon to the right of the text fields.

Find
:   The text to search for in names.

Replace
:   The text to replace for in matching names found from the *Find* text.

Case Sensitive
:   Search results must exactly match the case of the *Find* text.

#### Set Name

*Set Name* works the most similar to [Rename Active Item](#rename-active-item)
by renaming the current data-block without having to do a find and replace operation.

Method
:   New:
    :   Disregards the current name replacing it with the “new” name.

    Prefix:
    :   Adds text to the beginning of the current name.
        This is useful for tools that look for special text in the prefix of a data-block name.

    Suffix:
    :   Adds text to the end of the current name.
        This is useful for tools that look for special text in the suffix of a data-block name.

Name
:   Defines the new name or the text to add as a prefix/suffix.

#### Strip Characters

*Strip Characters* cleans up names by removing certain
character types from either the beginning or the end of the name.

Characters
:   Spaces:
    :   Strips any space characters from the name, e.g. “Living Room “ becomes “Living Room”.

    Digits:
    :   Strips any numerical characters from the name, e.g. `cube.001` becomes `cube.`.

    Punctuation:
    :   Strips any punctuation characters (`,.?!:;` etc.) from the name, e.g. `cube?` becomes `cube`.

Strip From
:   Start:
    :   Strips any leading characters in the name.

    End:
    :   Strips any trailing characters in the name.

#### Change Case

*Change Case* modifies the case of names to be one of the following:

Convert To
:   Upper Case:
    :   Changes all text to be in upper case, e.g. `cube.001` becomes `CUBE.001`.

    Lower Case:
    :   Changes all text to be in lower case, e.g. `CUBE.001` becomes `cube.001`.

    Title Case:
    :   Changes all text to be in title case, e.g. `living room` becomes `Living Room`.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Image
:   Noisy image input.

Albedo
:   Optional albedo render pass to better preserve detail.
    For Cycles, it is recommended to use the Denoising Albedo render pass,
    which is available when enabling the Denoising Data passes.

Normal
:   Optional normal render pass to better preserve detail.
    For Cycles, it is recommended to use the Denoising Normal render pass,
    which is available when enabling the Denoising Data passes.

HDR
:   Preserve colors outside the 0 to 1 range.

Prefilter
:   None:
    :   Does not apply any prefiltering to the input passes. This option retains the most detail and
        is the fastest, but assumes the input passes are noise free which may require a high sample
        count. If the input passes are not noise free, then noise will remain in the image after denoising.

    Fast:
    :   Assumes the input passes are not noise free, yet does not apply prefiltering to the input passes.
        This option is faster than *Accurate* but produces a blurrier result.

    Accurate:
    :   Prefilters the input passes before denoising to reduce noise. This option usually produces
        more detailed results than *Fast* with increased processing time.

Quality
:   Follow Scene:
    :   Use the [scene’s quality setting](../../../render/eevee/render_settings/performance.xhtml#bpy-types-rendersettings-compositor-denoise-preview-quality).

    High:
    :   Produces the highest quality output at the cost of long processing times.

    Balanced:
    :   Balanced between performance and quality, typically processing in half the time as *High*,
        while retaining most of the quality.

    Fast:
    :   Produces an output quickly at a noticeable cost of quality.
user: Provide the full official documentation entry for Library Overrides, preserving all code examples.

assistant: Bone collections can be added using library overrides. For this to work, both
the armature Object and the Armature itself need to be overridden.

### Limitations

There are a few limitations when it comes to bone collections & overrides:

- Only bone collections that are local to the current blend file can be edited.
- Bone collections that already existed on the linked-in Armature are read-only,
  and only their visibility can be toggled. Those visibility changes won’t be
  saved, though.
- Custom properties of overridden bone collections cannot be edited in the
  properties panel. Python access is fine; this is just a current limitation of
  Blender’s UI code.

### How It Works

Bone collections added via overrides are ‘anchored’ to the preceding
collection, by name. Here is an example. The *italic* collections are defined on
the linked Armature in `armature.blend`. The **bold** ones are added by
overrides in `armature_shot_47.blend`.

- *FK Controls*
- *IK Controls*
- **Left Pinky** (anchored to “IK Controls”)
- **Right Pinky** (anchored to “Left Pinky”)

Now if the Armature in `armature.blend` gets updated with two more collections
it might look like this:

- *FK Controls*
- *IK Controls*
- *Face Controls*
- *Face Detail Controls*

After reloading `armature_shot_47.blend`, it will look like this:

- *FK Controls*
- *IK Controls*
- **Left Pinky** (still anchored to “IK Controls”)
- **Right Pinky** (still anchored to “Left Pinky”)
- *Face Controls*
- *Face Detail Controls*
user: What is MulticamStrip(EffectStrip) and how is it used in Blender Python scripting?

assistant: # MulticamStrip(EffectStrip)

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

*class* bpy.types.MulticamStrip(*EffectStrip*)
:   Sequence strip to perform multicam editing

    animation_offset_end
    :   Animation end offset (trim end)

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

    animation_offset_start
    :   Animation start offset (trim start)

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

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

    multicam_source
    :   Type:
        :   int in [0, 127], default 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: How do I use Selecting Objects in Blender? Include parameters, examples, warnings and best practices.

assistant: # Selecting Objects

Selection determines which elements will be the target of our actions.
Selections work on the current scene visible objects.
Blender has advanced selection methods. Both in *Object Mode* and in *Edit Mode*.
user: Describe Tool-specific Nodes from the Blender manual or Python API, including usage steps and snippets.

assistant: The following nodes are only supported in the *Tool* context:

- [3D Cursor Node](input/scene/3d_cursor.xhtml)
- [Mouse Position Node](input/scene/mouse_position.xhtml)
- [Viewport Transform Node](input/scene/viewport_transform.xhtml)
- [Active Element Node](geometry/read/active_element.xhtml)
- [Selection Node](geometry/read/selection.xhtml)
- [Set Selection Node](geometry/write/set_selection.xhtml)
- [Face Set Node](mesh/read/face_set.xhtml)
- [Set Face Set Node](mesh/write/set_face_set.xhtml)
user: How do I use Spreadsheet Operators in Blender? Include parameters, examples, warnings and best practices.

assistant: # Spreadsheet Operators

bpy.ops.spreadsheet.add_row_filter_rule()
:   Add a filter to remove rows from the displayed data

bpy.ops.spreadsheet.change_spreadsheet_data_source(*\**, *component_type=0*, *attribute_domain_type=0*)
:   Change visible data source in the spreadsheet

    Parameters:
    :   - **component_type** (*int in* *[**0**,* *32767**]**,* *(**optional**)*) – Component Type
        - **attribute_domain_type** (*int in* *[**0**,* *32767**]**,* *(**optional**)*) – Attribute Domain Type

bpy.ops.spreadsheet.fit_column()
:   Resize a spreadsheet column to the width of the data

bpy.ops.spreadsheet.remove_row_filter_rule(*\**, *index=0*)
:   Remove a row filter from the rules

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

bpy.ops.spreadsheet.reorder_columns()
:   Change the order of columns

bpy.ops.spreadsheet.resize_column()
:   Resize a spreadsheet column

bpy.ops.spreadsheet.toggle_pin()
:   Turn on or off pinning

    File:
    :   [startup/bl_operators/spreadsheet.py:21](https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_operators/spreadsheet.py#L21)
user: What is Strip Modifiers and how is it used in Blender Python scripting?

assistant: # Strip Modifiers

[image reference removed]

Modifiers are used to make adjustments to the image, like contrast,
brightness, saturation, color balance and applying masks.

You can add these modifiers directly to a media strip,
or you can use them within an [Adjustment Layer](strips/adjustment.xhtml)
strip, making them apply to several media strips in one go.

Linear Modifiers
:   Calculates modifiers in [linear color space](../../../render/color_management/color_spaces.xhtml#color-management-linear-space) instead of the
    [Sequencer color space](../../../render/color_management/color_spaces.xhtml#bpy-types-colormanagedsequencercolorspacesettings-name).

    Calculating modifiers in linear space will match the image processing of the compositor.
    In most cases, this should be enabled; working in a non-linear workflow could have unpredictable results.
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Index
:   Index number of the particle (from 0 to number of particles).

Random
:   A random per-particle value in the range from 0 to 1.
    It can for example be used in combination with a color ramp, to randomize the particle color.

Age
:   Age of the particle in frames.

Lifetime
:   Total lifespan of the particle in frames.

Location
:   Location of the particle.

Size
:   Size of the particle.

Velocity
:   Velocity of the particle.

Angular Velocity
:   Angular velocity of the particle.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`FunctionNodeFormatString.format_items`](bpy.types.FunctionNodeFormatString.html#bpy.types.FunctionNodeFormatString.format_items "bpy.types.FunctionNodeFormatString.format_items") |  |
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Dimensions
:   The dimensions of the space to evaluate the noise in.

    1D:
    :   The *W* input is used as seed.

    2D:
    :   The X and Y components of the *Vector* input are used as seed.

    3D:
    :   The *Vector* input is used as seed.

    4D:
    :   Both the *Vector* input and the *W* input are used as seed.