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

assistant: Cycles only

A Light Group provides a limited *Combined* render pass where the scene is only illuminated by
certain lights. Multiple such passes can then be combined in compositing to construct a full render
with all the lights. The most straightforward way is to simply *Add* them together using
the [Mix Color Node](../../compositing/types/color/mix_color.xhtml), but by making more complex combinations,
it’s possible to change the color and intensity of individual lights without having to re-render.

To assign a Light object to a new or existing Light Group, use the panel
Object ‣ Shading ‣ Light Group ([details](../cycles/object_settings/object_data.xhtml#bpy-types-object-lightgroup)).

To assign the World background to a Light Group, use the panel
World ‣ Settings ‣ Light Group ([details](../cycles/world_settings.xhtml#bpy-types-world-lightgroup)).

Name
:   The name of the light group.

### Light Group Sync

These operators are available from the  button to the right of the
Light Group list.

Add Used Lightgroups
:   Create Light Groups for any lights that reference a non-existing one.

Remove Unused Lightgroups
:   Delete any Light Groups that are not referenced by any lights.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Smooth Modifier.

Affect
:   Combination of stroke/points properties that will be affected by the smooth factor.

    Position:
    :   Smooth affect the point location.

    Strength:
    :   Smooth affect the point strength (opacity).

    Thickness:
    :   Smooth affect the point thickness.

    UV:
    :   Smooth affect the point UV rotation.

Factor
:   Strength of the smooth effect.

Repeat
:   The number of smoothing iterations, equivalent to executing the Smooth tool multiple times.
    High values can reduce the animation performance (FPS).

Keep Shape
:   When enabled, the smoothing algorithm will try to maintain as close as possible the overall
    shape of the original stroke.

Smooth Ends
:   Smooth the ends of the strokes.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: What is Clock and how is it used in Blender Python scripting?

assistant: The simulation is tied to the animation system, with support for sub-steps.
It will only be evaluated while the animation frame changes, and is cached like
the existing physics simulations in Blender.
user: Provide the full official documentation entry for Channels Region, preserving all code examples.

assistant: [image reference removed]

The Channels region.

This region is found on the left side of time-based editors like
the [Dope Sheet Editor](../../dope_sheet/introduction.xhtml) and the Graph Editor.
It shows a tree of items (objects, bones…) and their animated properties,
with the latter also being called “channels.” Each channel has an associated F-curve
describing how its value changes over time.

The rows are color-coded as follows:

- Dark blue: scenes, objects
- Light blue: [actions](../../../animation/actions.xhtml), [shape keys](../../../animation/shape_keys/index.xhtml) etc.
- Green: channel groups
- Gray: channels

Search `Ctrl`-`F`
:   Lets you filter the channels by typing a part of their name. Click the Invert button to instead
    show channels that *don’t* include the search text.

### Channels

The headers contain the following toggle buttons:

/ Pin
:   Keep the row and its children visible even when selecting a different object.

/ Hide
:   Hides the keyframes and curve associated with the channel.

/ Modifiers
:   Deactivates the modifiers of the curve.

/ Mute
:   Deactivates the curve, making the animation behave as though it doesn’t exist.

/ Lock `Tab`
:   Prevent the curve from being edited.

### Selection

- Select single header: click `LMB`
- Add/Remove single header to/from selection: click `Ctrl`-`LMB`
- Select range: click `Shift`-`LMB`
- Select All: `A`
- Deselect All: press `Alt`-`A` or double-tap `A`
- Box Select: drag `LMB`
- Box Add: drag `Shift`-`LMB`
- Box Remove: drag `Ctrl`-`LMB`
- Select all keyframes in the channel: double-click `LMB` on its header.

### Editing

- Rename (anything but a channel): double-click `LMB`
- Delete selected: `X` or `Delete`
- Lock selected: `Tab`

#### Sliders

[image reference removed]

The Action editor showing sliders.

If you enable View ‣ Show Sliders, the region will show a
value slider next to each channel. Changing such a slider will change the value
of the curve at the current frame, creating a keyframe if one doesn’t already exist.
user: Provide the full official documentation entry for Disconnecting Sockets, preserving all code examples.

assistant: ### Interactively

Drag the link away from its input socket and let it go, keeping it unconnected.

### Mute Links

Activate the menu item or hold the key combination,
then draw a line across one or more links to mute/unmute them.
A muted link acts as though it’s no longer there; this also means the input fields
for specifying fixed values become visible again.

When muting links on the input side of a [reroute node](types/layout/reroute.xhtml),
the links on its output side will be muted too.

[image reference removed]

### Cut Links

Activate the menu item or hold the key combination,
then draw a line across one or more links to delete them.

Detach Links `Alt`-`LMB` drag
:   Use Detach Links to cut all the links attached to the selected nodes
    and move the nodes to a new location.
user: Give a detailed overview of Bpy.Types.Nodeinternalsockettemplate: syntax, arguments, return values, common patterns.

assistant: r.output_template TextureNodeCompose.input_template TextureNodeCompose.output_template TextureNodeCoordinates.input_template TextureNodeCoordinates.output_template TextureNodeCurveRGB.input_template TextureNodeCurveRGB.output_template TextureNodeCurveTime.input_template TextureNodeCurveTime.output_template TextureNodeDecompose.input_template TextureNodeDecompose.output_template TextureNodeDistance.input_template TextureNodeDistance.output_template TextureNodeGroup.input_template TextureNodeGroup.output_template TextureNodeHueSaturation.input_template TextureNodeHueSaturation.output_template TextureNodeImage.input_template TextureNodeImage.output_template TextureNodeInvert.input_template TextureNodeInvert.output_template TextureNodeMath.input_template TextureNodeMath.output_template TextureNodeMixRGB.input_template TextureNodeMixRGB.output_template TextureNodeOutput.input_template TextureNodeOutput.output_template TextureNodeRGBToBW.input_template TextureNodeRGBToBW.output_template TextureNodeRotate.input_template TextureNodeRotate.output_template TextureNodeScale.input_template TextureNodeScale.output_template TextureNodeSeparateColor.input_template TextureNodeSeparateColor.output_template TextureNodeTexBlend.input_template TextureNodeTexBlend.output_template TextureNodeTexClouds.input_template TextureNodeTexClouds.output_template TextureNodeTexDistNoise.input_template TextureNodeTexDistNoise.output_template TextureNodeTexMagic.input_template TextureNodeTexMagic.output_template TextureNodeTexMarble.input_template TextureNodeTexMarble.output_template TextureNodeTexMusgrave.input_template TextureNodeTexMusgrave.output_template TextureNodeTexNoise.input_template TextureNodeTexNoise.output_template TextureNodeTexStucci.input_template TextureNodeTexStucci.output_template TextureNodeTexVoronoi.input_template TextureNodeTexVoronoi.output_template TextureNodeTexWood.input_template TextureNodeTexWood.output_template TextureNodeTexture.input_template TextureNodeTexture.output_template TextureNodeTranslate.input_template TextureNodeTranslate.output_template TextureNodeValToNor.input_template TextureNodeValToNor.output_template TextureNodeValToRGB.input_template TextureNodeValToRGB.output_template TextureNodeViewer.input_template TextureNodeViewer.output_template Next NodeJoinBundle(NodeInternal) Previous NodeInternal(Node) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page NodeInternalSocketTemplate(bpy_struct) NodeInternalSocketTemplate NodeInternalSocketTemplate.identifier NodeInternalSocketTemplate.name NodeInternalSocketTemplate.type NodeInternalSocketTemplate.bl_rna_get_subclass() NodeInternalSocketTemplate.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: What is Auto-Save Preferences and how is it used in Blender Python scripting?

assistant: By default, a new Blender installation is set to auto-save changes to preferences, so you don’t accidentally lose a
change you have made. To disable this behavior, perform these steps:

1. Open the Preferences dialog
2. Click on the small menu at the lower left (shown by 3 lines)
3. Uncheck the box next to “*Auto-Save Preferences*”
4. Click the “*Save Preferences*” button that will appear in the lower left of the dialog. **Don’t forget this step,
   as the change will not be saved otherwise.**

To enable auto-save once again, simply follow steps 1-3 above and check the box in step 3.
user: What is Shutter Curve and how is it used in Blender Python scripting?

assistant: Curve defining how the shutter opens and closes.
The X axis is time, Y values of 0 mean fully closed shutter, Y values of 1 mean fully opened shutter.
The default mapping is set to when shutter opens and closes instantly.
user: What is Kuwahara Node and how is it used in Blender Python scripting?

assistant: # Kuwahara Node

[image reference removed]

The Kuwahara node implements the Kuwahara filter as well as its anisotropic
variant. The Kuwahara filter is a smoothing filter that tries to preserve the
edges in the image. The smoothing effect of the anisotropic variant is similar
to brush strokes, so the node can be used to create stylized painting effects.
user: Provide the full official documentation entry for Normal Selection Node, preserving all code examples.

assistant: # Normal Selection Node

[image reference removed]

The *Normal Selection* node creates a selection of elements whose normals point
in a specified direction within a given angular threshold.
It is useful for selecting geometry that faces a certain way, such as upward-facing
surfaces, walls, or elements oriented toward a light or camera.
user: Explain Relative Paths in complete detail according to the official Blender documentation.

assistant: Many blend-files reference external images or other linked blend-files.
A path tells Blender where to look for these files.
If the external files are moved, the blend-file that references them will not look right.

When you specify one of these external files, the default option is to make the path relative.
Blender stores a partial path evaluated relative to the directory location of the referencing blend-file.
This choice helps when you need to reorganize folders or move your files.

With a relative path, you can move the blend-file to a new location provided
the externally linked files are moved along with it.
For example, you could send someone a folder that contains a blend-file
and a subfolder of external images that it references.

When relative paths are supported, the File Browser provides a *Relative Path* checkbox,
when entering the path into a text field, use a double slash prefix (`//`) to make it so.

Relative paths are the default but this can be changed
in the [File](../../editors/preferences/file_paths.xhtml) tab of the *Preferences*.
user: Describe Node Integer Math Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Node Integer Math Items

**Functions**

ADD:
:   Add.

    A + B.

SUBTRACT:
:   Subtract.

    A - B.

MULTIPLY:
:   Multiply.

    A \* B.

DIVIDE:
:   Divide.

    A / B.

MULTIPLY_ADD:
:   Multiply Add.

    A \* B + C.

---

ABSOLUTE:
:   Absolute.

    Non-negative value of A, abs(A).

NEGATE:
:   Negate.

    -A.

POWER:
:   Power.

    A power B, pow(A,B).

**Comparison**

MINIMUM:
:   Minimum.

    The minimum value from A and B, min(A,B).

MAXIMUM:
:   Maximum.

    The maximum value from A and B, max(A,B).

SIGN:
:   Sign.

    Return the sign of A, sign(A).

**Rounding**

DIVIDE_ROUND:
:   Divide Round.

    Divide and round result toward zero.

DIVIDE_FLOOR:
:   Divide Floor.

    Divide and floor result, the largest integer smaller than or equal A.

DIVIDE_CEIL:
:   Divide Ceiling.

    Divide and ceil result, the smallest integer greater than or equal A.

---

FLOORED_MODULO:
:   Floored Modulo.

    Modulo that is periodic for both negative and positive operands.

MODULO:
:   Modulo.

    Modulo which is the remainder of A / B.

---

GCD:
:   Greatest Common Divisor.

    The largest positive integer that divides into each of the values A and B, e.g. GCD(8,12) = 4.

LCM:
:   Least Common Multiple.

    The smallest positive integer that is divisible by both A and B, e.g. LCM(6,10) = 30.
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: As the modifier is only a container its actual options are configured in the *Physics Properties* tab.
See the [Dynamic Paint Physics Properties](../../../physics/dynamic_paint/index.xhtml) for more information.
user: What is Animating with Grease Pencil and how is it used in Blender Python scripting?

assistant: The main goal of Grease Pencil is to offer a 2D animation tool full immersed in a 3D environment.

[image reference removed]

Sample animation showing Grease Pencil object keyframes in the Dope Sheet with onion skinning enabled.

In Blender, Grease Pencil objects can be animated in many ways:

Moving as a whole object
:   Changing their position, orientation or size in time;

Drawing frame by frame
:   Drawing one frame at a time (traditional animation).

Deforming them
:   Animating their points;

Inherited animation
:   Causing the object to move based on the movement of another object
    (e.g. its parent, hook, armature, etc.). Useful for cut-out animation for example.

For a complete overview of animation in Blender please refer to
the [Animation & Rigging](../../animation/index.xhtml) chapter.
user: Explain Vector Displacement Node in complete detail according to the official Blender documentation.

assistant: # Vector Displacement Node

[image reference removed]

The *Vector Displacement* node is used to displace the surface along arbitrary directions,
unlike the regular Displacement node which only displaces along the surface normal.

It is typically used to apply vector displacement maps created by other sculpting
software. Vector displacement maps can fully represent the high resolution detail to
be applied on a smooth base mesh, unlike regular displacement maps.

By default, Blender only uses [Bump Mapping](../../../glossary/index.xhtml#term-Bump-Mapping) to render displacement.
However with true displacement, the rendered geometry will be physically displaced. To use true displacement
the [Displacement method](../../eevee/material_settings.xhtml#bpy-types-material-displacement-method) must be set accordingly.
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: The outputs of the *Evaluate Closure* node depend on its current configuration:

- **When a closure is connected** – Each output corresponds to an output socket of the *Closure Zone* with the same name.
- **When no closure is connected** – Outputs are defined manually through the *Output Items* section of the Sidebar.
user: Provide the full official documentation entry for MatCaps, preserving all code examples.

assistant: This panel manages [MatCap](../../glossary/index.xhtml#term-MatCap) image files
which can used to light the view when [MatCap](../../render/workbench/lighting.xhtml#render-workbench-matcap) shading is enabled.

Two kinds of images are supported for MatCaps. Regular image files and
multilayered OpenEXR files. When using multilayered OpenEXR files,
the layer named “diffuse” will be used as a diffuse pass, the layer named “specular”
will be used as a specular pass. Regular images will be handled as “diffuse” and
will not support specular highlighting.

The diffuse pass is multiplied with the base color of the objects and the specular pass is added on top.
MatCaps, that only have a diffuse pass tend to look very metallic,
with a separate specular pass it is possible to simulate a wider variety of materials.
user: Give a detailed overview of Active Spline: syntax, arguments, return values, common patterns.

assistant: # Active Spline

The *Active Spline* panel contains the properties of the active surface.

[image reference removed]

Active Spline panel.

Cyclic U/V
:   When enabled, the last row/column of the surface will be connected back to the first,
    creating a closed loop.

Bézier U/V
:   When enabled, the surface will be generated as a series of Bézier splines instead of a
    NURBS curve in the row/column direction.

Endpoint U/V
:   Controls whether the surface touches the borders of its control point grid.

    [image reference removed]

    Surface with *Endpoint U* enabled.

Order U/V
:   A higher *Order* gives each control point a broader influence along its
    row/column. This makes the surface smoother, but also makes it follow
    the shape of the control grid less closely.
    See [NURBS Curves Order](../../curves/properties/active_spline.xhtml#modeling-curve-order).

    [image reference removed]

    Surfaces with *Order U* set to 2 (top) and 4 (bottom).

    If *Bézier* is enabled, *Order* determines the number of control points per spline.

    The *Order* for a certain direction cannot be higher than the number of control
    points along that direction.

Resolution U/V
:   Determines the preview density of the generated surface mesh. The higher this number,
    the more vertices there will be and the smoother the surface will look.

    This setting only affects the active surface. To change the resolution of all surfaces
    in the object, you can use the [Resolution Preview U/V](shape.xhtml#bpy-types-curve-resolution-v) setting in the
    *Shape* panel instead.

    If the *Render U/V* values in the *Shape* panel are nonzero, they will override these
    *Resolution U/V* values during rendering.

Smooth
:   Whether to apply [smooth shading](../../meshes/editing/mesh/shading.xhtml#modeling-meshes-editing-normals-shading)
    to the generated surface mesh.
user: Explain Utility Brushes in complete detail according to the official Blender documentation.

assistant: [image reference removed]

No clear color assignment.
These brushes are general purpose brushes or specific.

Density
:   Brush Type: [Density](simplify.html)

    Cleans up geometry by collapsing short edges. Specifically for use with [Dyntopo](../introduction/adaptive.html#dyntopo-introduction).

Mask
:   Brush Type: [Mask](mask.html)

    Shortcut: `M`

    Paints a selection on parts of the mesh to be unaffected by other brushes.

Draw Face Sets
:   Brush Type: [Draw Face Sets](draw_facesets.html)

    Paint new, smooth or extend existing Face Sets.

Erase Multires Displacement
:   Brush Type: [Erase Multires Displacement](multires_displacement_eraser.html)

    Remove displacement information on a Multiresolution modifier.

Smear Multires Displacement
:   Brush Type: [Smear Multires Displacement](multires_displacement_smear.html)

    Smear displacement information on a Multiresolution modifier.
user: Explain Create New Preferences in complete detail according to the official Blender documentation.

assistant: Language
:   The language used in the user interface. The list is broken up into categories determining how complete the
    translations are. More language preferences can be set in the
    [Translation Preferences](../../editors/preferences/interface.html#prefs-interface-translation).

Theme
:   Choose between a light or dark theme for Blender. Themes can be customized more in the
    [Preferences](../../editors/preferences/themes.html). Additional themes can be installed by visiting the
    [Blender Extensions Platform](https://extensions.blender.org/). This is optional, and will require internet
    access.

Keymap
:   Presets for the default [keymap](../../editors/preferences/keymap.html) for Blender. Note that this manual assumes that
    you use the default “Blender” keymap.

    Blender:
    :   This is the default keymap. Read more about this keymap [here](../../interface/keymap/blender_default.html).

    Blender 2.7x:
    :   This keymap is intended to match an older series of Blender versions and is designed for people upgrading who do
        not want to learn the updated keymap.

    Industry Compatible:
    :   This keymap is intended to match common commercial creation software and is intended for people who use many
        different such applications. Read more about this keymap [here](../../interface/keymap/industry_compatible.html).

Mouse Select
:   Controls which mouse button, either right or left, is used to select items in Blender. The default is for selection
    to use the left button.

Spacebar Action
:   Controls the action of `Spacebar`.
    These and other shortcuts can be modified in the [keymap preferences](../../editors/preferences/keymap.html).

    Play:
    :   Starts/stops [animation playback](../../animation/index.html).
        This option is good for animation or video editing work.

    Tools:
    :   Opens the Toolbar underneath the cursor to quickly change the active tool. This option is good if doing a lot of
        modeling or rigging.

    Search:
    :   Opens up the [Menu Search](../../interface/operators.html#bpy-ops-wm-search-menu). This option is good for someone who is new to Blender
        and is unfamiliar with its menus and shortcuts.

Save New Preferences
:   Saves the preferences set above and opens the regular [Splash Screen](../../interface/window_system/splash.html#splash).
user: Provide the full official documentation entry for Usage, preserving all code examples.

assistant: First define the base of the object by dragging with `LMB`.
Next, release `LMB` and move the mouse to define the height of the object.
Finally, click `LMB` to confirm the shape of the object.

You can use the following hotkeys to temporarily change a setting
(for as long as the key is held):

|  |  |
| --- | --- |
| `Ctrl` | Toggles snapping. |
| `Alt` | Toggles the *Origin* setting. |
| `Shift` | Toggles the *Aspect* setting. |
user: What is Separate Cylindrical Node and how is it used in Blender Python scripting?

assistant: # Separate Cylindrical Node

[image reference removed]

The *Separate Cylindrical* node converts a vector from Cartesian coordinates (X, Y, Z)
into cylindrical coordinates (R, Φ, Z) and outputs each component separately. It is the inverse of the
[Combine Cylindrical](combine_cylindrical.html) node.

This node is useful for analyzing geometry or generating procedural effects that depend on
radial distance, angular position, or height – for example, creating spiral deformations,
cylindrical gradients, or radial masks.
user: Explain Unified Settings in complete detail according to the official Blender documentation.

assistant: Some settings (e.g. size, strength, color), indicated with ,
allow for using a per-mode setting instead of the individual brush setting.
These settings are shared across all brushes of a given mode (e.g. Sculpt Mode)
but do not overwrite the individual brush value.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Image/Color
:   Standard color input.

Hue
:   The hue rotation offset, from 0 (-180°) to 1 (+180°). Note that
    0 and 1 have the same result.

Saturation
:   A value of 0 removes color from the image, making it black-and-white.
    A value greater than 1.0 increases saturation.

Value
:   The value shift. 0 makes the color black, 1 keeps it the same, and higher
    values make it brighter.

Factor
:   The amount of influence the node exerts on the image.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Curve
:   Standard geometry input with a curve component.

Selection
:   A boolean field input for each curve indicating whether it is trimmed or not.

Start
:   The factor or length used to determine where to start each output spline.

End
:   The factor or length used to determine where to end each output spline.
user: Give a detailed overview of Example: syntax, arguments, return values, common patterns.

assistant: The example below creates a cone at each vertex of a “cube,” aligned to the neighboring edge
that’s the most vertical.

First, we calculate a “verticality score” for each of the cube’s edges. To do this, we subtract the
positions of its vertices to get its direction vector, which we normalize and use to calculate
the dot product with the Z axis. The absolute value of that gives us a number between 0 and 1,
where 0 means fully horizontal and 1 means fully vertical.

Because the edges will be sorted by ascending weight, we set weight = 1 - verticality.
This way, the most vertical connected edge of each vertex will have the lowest weight
and come first in the list.

Next, in the point domain, we need to calculate the rotation of each cone.
By using the [Align Rotation to Vector Node](../../utilities/rotation/align_rotation_to_vector.xhtml),
the problem gets simplified and we only need to calculate a direction vector.

The direction vector of each cone is the centerpoint of the most vertical neighboring edge
minus the position of the vertex. Finding that most vertical neighboring edge is where the
*Edges of Vertex* node comes in: for each vertex, it sorts the connected edges by their
weight and pick the first one (because the Sort Index is 0). Once we have the edge’s index,
we use the [Evaluate at Index Node](../../utilities/field/evaluate_at_index.xhtml) to retrieve its
centerpoint.

With the rotations of the cones calculated, we use the
[Instance on Points Node](../../instances/instance_on_points.xhtml) to create them.

[image reference removed]

Example node setup. (Right-click and choose “Open image in new tab” to see a larger version.)

[image reference removed]

The resulting geometry.
user: Explain Spin in complete detail according to the official Blender documentation.

assistant: # Spin

The *Spin* tool extrudes (or duplicates it if the selection is manifold) the selected elements,
rotating around a specific point and axis.

Use the tool to create the sort of objects that you would produce on a lathe
(this tool is often called “lathe” tool or “sweep” tool in the literature, for this reason).
In fact, it does a sort of circular extrusion of your selected elements,
centered on the 3D cursor, and around the axis perpendicular to the working view…

- The point of view will determine around which axis the extrusion spins…
- The position of the 3D cursor will be the center of the rotation.
user: What is GeometryNodeSplitEdges(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeSplitEdges(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.GeometryNodeSplitEdges(*GeometryNode*)
:   Duplicate mesh edges and break connections with the surrounding 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: Provide the full official documentation entry for Install from blender.org, preserving all code examples.

assistant: Download the Linux version for your architecture and decompress the file to the desired location (e.g. `~/software`
or `/usr/local`).

Blender can now be launched by double-clicking the executable.

When using this method of installation, it is possible to have multiple versions of Blender installed.

For ease of access, you may wish to add a menu entry and create blend-file associations for the file-browser. This can
be done by [Registering Blender](../../editors/preferences/system.xhtml#bpy-ops-preferences-associate-blend).

To make the installation and configuration fully self-contained, set up a [Portable Installation](../../advanced/blender_directory_layout.xhtml#portable-installation).
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Start
:   Position of the first control point.

End
:   Position of the second control point.
    This is only available in the *Points* mode.

Direction
:   Direction the line is going in.
    The length of this vector does not matter.
    This is only available in the *Direction* mode.

Length
:   Length of the line.
    This is only available in the *Direction* mode.
user: Describe Curvature 3D from the Blender manual or Python API, including usage steps and snippets.

assistant: # Curvature 3D

A modifier based on radial curvatures of the underlying 3D surface.
The [curvature](https://en.wikipedia.org/wiki/Curvature) of a 2D curve
at a point is a measure of how quickly the curve turns at the point.
The quicker the turn is, the larger the curvature is at the point.
The curvature is zero if the curve is a straight line.
Radial curvatures are those computed for a 2D curve that appears at the cross section
between the 3D surface and a plane defined by the view point (camera location)
and the normal direction of the surface at the point.

For radial curvatures to be calculated (and therefore for this modifier to have any effect),
the *Face Smoothness* option has to be turned on and the object needs to have *Smooth Shading*.

Curvature Min, Max
:   The limits of the mapping.
    If the current point of the stroke is at *Min Curvature* or less from the target,
    it will take the start point of the mapping. And conversely,
    if it is at *Max Curvature* or more from the target, it will take the end-point value of the mapping.

[[image reference removed]](../../../../../../_images/render_freestyle_parameter-editor_line-style_modifiers_color_curvature-3d_example.png)

Curvature 3D modifier demo by T.K.
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Render_freestyle_modifier_curvature_3d.blend)).
user: Provide the full official documentation entry for Simplify, preserving all code examples.

assistant: # Simplify

Common Settings

Max Subdivision
:   Maximum number of subdivision by the Subdivision Surface modifiers.

Child Particles
:   Show only a subset of all child hairs and particles.

Texture Limit
:   Automatically scales textures down so that they are no larger than the values chosen.
    This can help reduce computer memory resources when rendering large scenes with huge textures.
user: Give a detailed overview of Transform: syntax, arguments, return values, common patterns.

assistant: # Transform

[[image reference removed]](../../../../_images/animation_armatures_bones_editing_transform_panel.png)

The Transform panel for armatures in Edit Mode.

We will not detail here the various transformations of bones, nor things like axis locking, pivot points, and so on,
as they are common to most object editing, and already described in
the [mesh section](../../../../scene_layout/object/editing/transform/control/index.html).
The same goes for mirroring,
as it is nearly the same as with [mesh editing](../../../../modeling/meshes/editing/mesh/mirror.html).
Just keep in mind that bones’ roots and tips behave more or less like meshes’ vertices,
and bones themselves act like edges in a mesh.

As you know, bones can have two types of relationships: They can be parented,
and in addition connected. Parented bones behave in *Edit Mode* exactly as if they
had no relations. They can be moved, rotated, scaled, etc. without affecting their descendants.
However, connected bones must always have parent’s tips connected to child’s roots,
so by transforming a bone, you will affect all its connected parent/children/siblings.

While with other transform tools, the “local axes” means the object’s axes,
here they are the bone’s own axes (when you lock to a local axis,
by pressing the relevant key twice, the constraint is applied along the selected bone’s local axis,
not the armature object’s axis).

Finally, you can edit in the *Transform* panel in the Sidebar region
the positions and radius of both joints of the active selected bone,
as well as its [roll rotation](bone_roll.html#armature-bone-roll).
user: What is Skin Modifier and how is it used in Blender Python scripting?

assistant: # Skin Modifier

The *Skin* modifier uses vertices and edges to create a skinned surface,
using a per-vertex radius to better define the shape.
The output is mostly quads, although some triangles will appear around intersections.

It is a quick way to generate base meshes for sculpting and/or smooth organic shapes with
arbitrary topology.
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

Transformations refer to a number of operations that can be performed on
a selected Object or Mesh that alters its position or characteristics.

Each object can be moved, rotated and scaled in *Object Mode*.
However, not all of these transformations have an effect on all objects.
For example, scaling a camera has no effect on the render dimensions.

Basic transformations include:

- [Move](move.xhtml)
- [Rotate](rotate.xhtml)
- [Scale](scale.xhtml)

These three transforms are the three big ones. However, more advanced transformations can be found
in the [Advanced Transformations](index.xhtml) section.

For making other changes to the geometry of editable objects, you should use *Edit Mode*.

Once you have added a basic object, you remain in *Object Mode*.
You can switch between *Object Mode* and *Edit Mode* by pressing `Tab`.
The object’s wireframe should now appear orange.
This means that the object is now selected and active.
user: Give a detailed overview of Camera: syntax, arguments, return values, common patterns.

assistant: Gizmo settings for [cameras](../../../render/cameras.html).

Lens
:   Show the gizmo to adjust the focal length (for Perspective cameras)
    or orthographic scale (for Orthographic cameras).

Focus Distance
:   Enable the gizmo for adjusting the focus distance. To see this gizmo,
    you need to enable the Viewport Display ‣ Limits checkbox
    in the camera’s properties (green camera icon).
user: Explain Sample Nearest Node in complete detail according to the official Blender documentation.

assistant: # Sample Nearest Node

[image reference removed]

The *Sample Nearest* node retrieves the [index](../read/input_index.xhtml)
of the geometry element in its input geometry that is closest to the input position.

This node is similar to the [Geometry Proximity Node](geometry_proximity.xhtml),
but it outputs the index of the closest element instead of its distance from the current location.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Points
:   Standard geometry input. The position of the points of this geometry affect the transforms of
    each instance output.

Selection
:   Whether to instance on each point. True values mean an instance will be generated on the point,
    false values mean the point will be skipped.

Instance
:   The geometry to instance on each selected point. This can contain real geometry, or multiple instances,
    which can be useful when combined with the *Pick Instance* option.

Pick Instances
:   If enabled, instead of adding the entire geometry from the *Instance* input on every point,
    choose an instance from the instance list of the geometry based on the *Instance Index* input.
    This option is intended to be used with the [Collection Info Node](../input/scene/collection_info.xhtml).

Instance Index
:   The selection of index for every selected point, only used when *Pick Instances* is true.
    By default the point [ID](../geometry/read/id.xhtml) is used,
    or the [index](../geometry/read/input_index.xhtml) if that doesn’t exist.
    Negative values or values that are too large are wrapped around to the other end of
    the instance list.

Rotation
:   The [Euler](../../../glossary/index.xhtml#term-Euler) rotation for every instance. This can use the rotation output of nodes like
    [Distribute Points on Faces](../point/distribute_points_on_faces.xhtml)
    and [Curve to Points](../curve/operations/curve_to_points.xhtml). An Euler rotation
    can also be created from a direction vector like the [normal](../geometry/read/normal.xhtml)
    with the [Align Rotation to Vector Node](../utilities/rotation/align_rotation_to_vector.xhtml).

Scale
:   The size of each generated instance.
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

View Layers allow you to separate a render into multiple layers, which can then be composited together.
This is useful for rendering scene elements independently—such as characters, lighting variations, or background
elements—without duplicating the entire scene or re-rendering everything after each change.

For example, you can:

- Apply different compositing effects to foreground and background elements.
- Render characters separately from the environment for post-processing.
- Generate multiple lighting passes without modifying the original scene setup.

View Layers also improve performance and flexibility during iteration by letting you re-render only the layers
that have changed.

[image reference removed]

View Layers and collections.

Each View Layer references a combination of [Collections](../../scene_layout/collections/introduction.html),
which define the visibility, selectability, and contribution of scene objects in the final render.
Multiple View Layers can use the same or different collections, allowing for tailored layer setups.
user: Give a detailed overview of Select Mirror: syntax, arguments, return values, common patterns.

assistant: # Select Mirror

Select Mirror flips a selection to the opposite side of the mesh.

Axis
:   Choose on which axis the selection will occur. The axis is based on the meshes origin.
    Therefore, if the origin is not centered within the mesh, the selection will have varying results.

Extend
:   The new selection will include the mirrored selection as well as the original.

[image reference removed]

(From left to right) initial selection, after Select Mirror on the X axis, with Extend.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`BlendData.screens`](bpy.types.BlendData.html#bpy.types.BlendData.screens "bpy.types.BlendData.screens") - [`Context.screen`](bpy.types.Context.html#bpy.types.Context.screen "bpy.types.Context.screen") | - [`Window.screen`](bpy.types.Window.html#bpy.types.Window.screen "bpy.types.Window.screen") - [`WorkSpace.screens`](bpy.types.WorkSpace.html#bpy.types.WorkSpace.screens "bpy.types.WorkSpace.screens") |
user: Give a detailed overview of Weight Paint: syntax, arguments, return values, common patterns.

assistant: *Mesh skin weighting* is used to control how much a bone deforms the mesh of a character.
To visualize and paint these weights, Blender uses a color ramp (from blue to green, and from yellow to red).
Enabling the checkbox will enable an alternate map using a ramp starting with an empty range.
Now you can create your custom map using the common color ramp options.
For detailed information see the [Color ramps](../../interface/controls/templates/color_ramp.html) page.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Curve
:   Standard geometry input, containing curves.

Selection
:   Whether or not to change the value on each control point. True values mean the value will be changed,
    false values mean the value will remain the same.

Tilt
:   The tilt angle for each control point.
user: Explain Documentation Todo List in complete detail according to the official Blender documentation.

assistant: # Documentation Todo List

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

It is recommended to also check the [documentation workboard](https://projects.blender.org/blender/documentation/projects) since this will contain larger initiatives and
structured work efforts, as well as laying out priorities.
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: How the UVs are warped is determined by the difference between the transforms (location, rotation and scale)
of the *from* and *to* objects.

If the *to* object has the same transforms as the *from* object, the UVs will not be changed.

Assuming the *UV Axis* of the modifier is X/Y and the scale of the objects is (1, 1, 1), if the *to* object is
one unit away from the *from* object on the X axis, the UVs will be transformed on the U axis (horizontally)
by one full UV space (the entire width of the image).
user: Give a detailed overview of VIEWLAYER_UL_linesets(UIList): syntax, arguments, return values, common patterns.

assistant: # VIEWLAYER_UL_linesets(UIList)

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

*class* bpy.types.VIEWLAYER_UL_linesets(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *icon*, *_active_data*, *_active_propname*, *index*)

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

assistant: Below are some common curves you can use to achieve desired effects.

[image reference removed]

From left to right: 1. Lighten shadows 2. Negative 3. Decrease contrast 4. Posterize.

### Color Correction using Curves

[image reference removed]

Color correction with curves.

In this example, the image has too much red in it,
so we run it through an *RGB Curves* node and reduce the Red channel.

The documentation for the [Mix Color Node](../../../../compositing/types/color/mix_color.xhtml) has an additional
example about fixing overexposure.

### Color Correction using Black/White Levels

[image reference removed]

Color correction with Black/White Levels.

Manually adjusting the RGB curves for color correction can be difficult.
Another option for color correction is to use the Black and White Levels instead,
which really might be their main purpose.

In this example,
the White Level is set to the color of a bright spot of the sand in the background,
and the Black Level to the color in the center of the fish’s eye.
To do this efficiently it is best to bring up the Image Editor showing the original input image.
You can then use the levels’ color picker to easily choose
the appropriate colors from the input image, zooming into pixel level if necessary.
The result can be fine-tuned with the R, G, and B curves like in the previous example.

The curve for C is used to compensate for the increased contrast that is a side effect of
setting Black and White Levels.

### Effects

[image reference removed]

Changing colors by inverting the red channel.
user: Provide the full official documentation entry for Deform Curves on Surface Node, preserving all code examples.

assistant: # Deform Curves on Surface Node

[image reference removed]

The *Deform Curves on Surface* node translates and rotates each curve based on the
difference in its root position. The root position is defined by UV coordinates stored
on each curve and the [UV Map](../../../../glossary/index.xhtml#term-UV-Map) selected for the purpose in the
[Curves surface settings](../../../curves_new/properties.xhtml#bpy-types-curves-surface).

The transformation is calculated based on the difference of the original mesh
(before shape keys and modifiers are evaluated), and the final mesh.

Unlike other geometry nodes, this node has quite a few implicit inputs:

- The original and evaluated mesh are retrieved from the modifier object’s [surface](../../../curves_new/properties.xhtml#bpy-types-curves-surface)
  property. This means the node only works for curves objects.
- The original and evaluated UV map are also retrieved from the object’s surface property.
- A 3D vector attribute named `rest_position`, used for calculating tangents for rotating
  curves that are consistent with the tangents calculated on the original mesh (the rotation
  needs to be calculated from the normal and tangent of the original and evaluated meshes).
- A 2D vector attribute on the curve domain named `surface_uv_coordinate` to store the
  location of the root positions on the surface mesh’s UV map.

In future development, this node will be generalized so the setup is more flexible.

Parts of the internal operation are similar to the [Sample UV Surface Node](../../mesh/sample/sample_uv_surface.xhtml).
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Collection
:   Collection to get the properties from.

Separate Children
:   Output each child of the collection as a separate instance. The list of instances will be sorted
    alphabetically with the objects and child collections sorted together. This can be used with
    the *Pick Instance* option in the [Instance on Points Node](../../instances/instance_on_points.xhtml) to
    choose between collection children at each point.

Reset Children
:   Remove the transform of each of the collection’s children when converting them to instances.
    This is useful in order to keep child objects visually separate in the viewport,
    while keeping every instance located directly at the location of the point it was added for.