PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain GeometryNodeSetMeshNormal(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeSetMeshNormal(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.GeometryNodeSetMeshNormal(*GeometryNode*)
:   Store a normal vector for each mesh element

    domain
    :   Attribute domain to store free custom normals

        Type:
        :   enum in [Attribute Domain Only Mesh No Edge Items](bpy_types_enum_items/attribute_domain_only_mesh_no_edge_items.html#rna-enum-attribute-domain-only-mesh-no-edge-items), default `'POINT'`

    mode
    :   Storage mode for custom normal data

        - `SHARPNESS`
          Sharpness – Store the sharpness of each face or edge. Similar to the “Shade Smooth” and “Shade Flat” operators..
        - `FREE`
          Free – Store custom normals as simple vectors in the local space of the mesh. Values are not necessarily updated automatically later on as the mesh is deformed..
        - `TANGENT_SPACE`
          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..

        Type:
        :   enum in [`'SHARPNESS'`, `'FREE'`, `'TANGENT_SPACE'`], default `'SHARPNESS'`

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

assistant: [image reference removed]

Combining this node with the [Sample Index Node](sample_index.html) gives a setup that
can retrieve the closest attribute value from another geometry. This is the same behavior as the
*Transfer Attribute* node in versions of Blender before 3.4.
user: Provide the full official documentation entry for Toolbar, preserving all code examples.

assistant: # Toolbar

Curve Edit Mode tools:

[Select](../../../interface/selecting.xhtml#tool-select-tweak)
:   Select or move.

    [Select Box](../../../interface/selecting.xhtml#tool-select-box)
    :   Select objects by dragging a box.

        All objects that intersect the box will be selected.

    [Select Circle](../../../interface/selecting.xhtml#tool-select-circle)
    :   Select objects by dragging a circle. All objects that intersect the path of
        the circle will be selected.

    [Select Lasso](../../../interface/selecting.xhtml#tool-select-lasso)
    :   Select objects by drawing a lasso.

Cursor
:   Change the location of the 3D Cursor.

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

    [Scale Cage](../../../scene_layout/object/tools/scale_cage.xhtml#tool-scale-cage)
    :   Change the scale of an object by controlling its cage.

Transform
:   Tool to adjust the objects translation, rotations and scale.

[Annotate](../../../interface/annotate_tool.xhtml#tool-annotate-freehand)
:   Draw free-hand annotation.

    [Annotate Line](../../../interface/annotate_tool.xhtml#tool-annotate-line)
    :   Draw straight line annotation.

    [Annotate Polygon](../../../interface/annotate_tool.xhtml#tool-annotate-polygon)
    :   Draw a polygon annotation.

    [Annotate Eraser](../../../interface/annotate_tool.xhtml#tool-annotate-eraser)
    :   Erase previous drawn annotations.

[Measure](../../../editors/3dview/toolbar/measure.xhtml#tool-measure)
:   Measure distances in the scene.

[Draw](draw.xhtml#bpy-ops-curve-draw)
:   Free-hand drawing of new curves.

[Curve Pen](pen.xhtml#bpy-ops-curve-pen)
:   Construct and edit splines.

[Extrude](../editing/control_points.xhtml#modeling-curves-extrude)
:   Extrude the curve by adding new control points.

[Radius](../editing/curve.xhtml#modeling-curve-radius)
:   Control the radius value of the control points.

[Tilt](../editing/control_points.xhtml#modeling-curve-tilt)
:   Control the rotation value of the control points around the curve’s axis.

Randomize
:   Move selected control points in pseudo-random directions.
user: Provide the full official documentation entry for Installing on Windows, preserving all code examples.

assistant: # Installing on Windows

Check the [Downloading Blender](index.xhtml) page to find the minimum requirements and the
different versions that are available for Blender (if you have not done so yet).

Download the zip-file or Windows Installer File.
user: How do I use Interface in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Panel layout (Blur effect as an example).

The visual effects panels and interface are similar to modifiers.
Each effect shares the same basic interface components similar to modifiers for meshes.

See [Modifiers Interface](../../modeling/modifiers/introduction.xhtml#bpy-types-modifier-show) for more information.
user: Provide the full official documentation entry for Spline Resolution Node, preserving all code examples.

assistant: # Spline Resolution Node

[image reference removed]

The *Spline Resolution* outputs the number of evaluated curve points that will be generated for
every control point on the spline. This node works for NURBS, Bézier, and Catmull Rom splines.

For poly splines, there is a one-to-one correspondence between original points and evaluated points,
so the resolution does not have an effect.

On Bézier splines, the resolution does not have an effect on segments between vector handles,
since there are no extra evaluated points between the neighboring control points.

The node to set this data is the [Set Spline Resolution Node](../write/set_spline_resolution.html).
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`Bone.color`](bpy.types.Bone.html#bpy.types.Bone.color "bpy.types.Bone.color") - [`EditBone.color`](bpy.types.EditBone.html#bpy.types.EditBone.color "bpy.types.EditBone.color") | - [`PoseBone.color`](bpy.types.PoseBone.html#bpy.types.PoseBone.color "bpy.types.PoseBone.color") |
user: Provide the full official documentation entry for Force Fields, preserving all code examples.

assistant: Soft body vertices interact with all the [Force Fields](../../forces/force_fields/index.xhtml)
applied (usually to particles) in the layer, such as wind, force fields,
and what ever physics field effect is on a common layer.

### Soft Body Field Weights

The *Soft Body Field Weights* panel allows you to control how much influence
each type of external force field has on the soft body system.

Effector Collection
:   Limit effectors to a specified group. Only effectors in this group will have an effect on the current system.

Gravity
:   Control how much the Global Gravity has an effect on the system.

All
:   Scale all of the effector weights.
user: Explain Units in complete detail according to the official Blender documentation.

assistant: Unit System
:   The unit system to use for user interface controls.

    None:
    :   Use units that have with no relation to the real world,
        practically this is the same as *Metric* just without unit names.

    Metric:
    :   Use the metric unit system in this scene.

    Imperial:
    :   Use the imperial unit system in this scene.

Unit Scale
:   Scale factor to use when converting between internal units and values displayed in the user interface.
    This can be changed when modeling at microscopic or astronomical scales.

Separate Units
:   When using *Metric* or *Imperial*, display properties as multiple values.
    For example, `2.285m` will become `2m 28.5cm`.

Rotation
:   Unit to use for displaying/editing rotation values.

    Degrees:
    :   Use degrees for angles in the user interface.

    Radians:
    :   Use radians for angles in the user interface.

Length
:   Unit that will be used to display length values.

    Adaptive:
    :   The unit used for a specific value depends on the magnitude of the value.
        For example, some values might be displayed as `23cm` while others are
        displayed as `10km`.

    Meters/Centimeters/Feet:
    :   A fixed unit that will be used for all lengths in the user interface.

Mass
:   See *Length*.

Time
:   See *Length*.

Temperature
:   See *Length*.

Imperial Length Units

| Full Name | Short Name(s) | Scale of a Meter |
| --- | --- | --- |
| thou | `mil` | 0.0000254 |
| inch | `"`, `in` | 0.0254 |
| foot, feet | `'`, `ft` | 0.3048 |
| yard | `yd` | 0.9144 |
| chain | `ch` | 20.1168 |
| furlong | `fur` | 201.168 |
| mile | `mi`, `m` | 1609.344 |

Metric Length Units

| Full Name | Short Name(s) | Scale of a Meter |
| --- | --- | --- |
| micrometer | `um` | 0.000001 |
| millimeter | `mm` | 0.001 |
| centimeter | `cm` | 0.01 |
| decimeter | `dm` | 0.1 |
| meter | `m` | 1.0 |
| dekameter | `dam` | 10.0 |
| hectometer | `hm` | 100.0 |
| kilometer | `km` | 1000.0 |
user: Provide the full official documentation entry for Radial Tiling Node, preserving all code examples.

assistant: # Radial Tiling Node

[[image reference removed]](../../../../_images/node-types_ShaderNodeRadialTiling.png)

The *Radial Tiling Node* provides the ability to divide a 2D cartesian input coordinate system
into as many radial segments as specified by the *Sides* input.
Each segment has its own affinely transformed segment coordinate system,
which can be used to tile textures in a radially symmetric manner.
user: Show practical ways to work with Hints in a Blender add-on or script – include code.

assistant: - The simulation is only calculated for positive frames
  in between the *Start* and *End* frames of the *Cache* panel, whether you bake or not.
  So if you want a simulation that is longer than the default frame range, you have to change the *End* frame.
- When an animation is played, each physics system writes each frame to the cache.
  Note that for the cache to fill up,
  one has to start the playback before or on the frame that the simulation starts.
- The cache is cleared automatically on changes. But not on all changes,
  so it may be necessary to delete it manually, e.g. if you change a force field.
- The system is protected against changes after baking.
  If for example the mesh changes the simulation is not calculated anew.
- The bake result can be cleared by clicking on the *Delete Bake* button in the simulation cache settings.
- A simulation can only be edited in Particle Edit Mode when it has been baked in memory.
  And cannot be edited if the Disk Cache is used.
- If you are not allowed to write to the required subdirectory caching will not take place,
  e.g. if your blend-file path is very long and your operating system
  has a limit on the path length that is supported.
- Be careful with the sequence of modifiers in the modifier stack.
  You may have a different number of faces in the 3D Viewport and
  for rendering (e.g. when using subdivision surface), if so,
  the rendered result may be very different from what you see in
  the 3D Viewport.
user: What is Random Rotation Node and how is it used in Blender Python scripting?

assistant: # Random Rotation Node

[image reference removed]

The *Random Rotation* node generates random rotation values within a specified angular range.
It can be used to randomize the orientation of instances, particles, or elements of a geometry.
user: Give a detailed overview of Example: syntax, arguments, return values, common patterns.

assistant: Here is an example of various effects achieved using *Vertex Weight Edit* modifier
(together with the [Vertex Weight Proximity](weight_proximity.xhtml) modifier)
to generate weights used by the [Displace](../deform/displace.xhtml) modifier.

*Curve Map* variations.

|  |
| --- |
| ../../../_images/modeling_modifiers_modify_weight-edit_mapping-concave.jpg   Concave-type mapping curve. |
| ../../../_images/modeling_modifiers_modify_weight-edit_distance-edge.jpg   No mapping curve (linear). |
| ../../../_images/modeling_modifiers_modify_weight-edit_mapping-convex.jpg   Convex-type mapping curve. |

[image reference removed]

Vertices with a computed weight below 0.1 removed from the vertex group.

[The blend-file](https://archive.blender.org/wiki/2015/index.php/File:ManModifiersWeightVGroupEx.blend),
TEST_2 scene.
user: Give a detailed overview of Stiffness: syntax, arguments, return values, common patterns.

assistant: Tension
:   How much the material resists stretching.

Compression
:   How much the material resists compression.

Structural
:   Overall stiffness of the cloth (only in linear bending model).

Shear
:   How much the material resists shearing.

Bending
:   Wrinkle coefficient. Higher creates more large folds.
user: How do I use ASSETBROWSER_UL_metadata_tags(UIList) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ASSETBROWSER_UL_metadata_tags(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.ASSETBROWSER_UL_metadata_tags(*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: Describe Brush Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: # Brush Settings

[image reference removed]

Brush settings panel.

Information on brush settings for every mode can be found in these pages:

[Brush](../../brush/brush_settings.html)
:   General and advanced settings.

[Texture](../../brush/texture.html)
:   Color and mask texture settings.

[Stroke](../../brush/stroke.html)
:   Stroke methods and settings.

[Falloff](../../brush/falloff.html)
:   Falloff curves and settings.

[Cursor](../../brush/cursor.html)
:   Cursor and appearance settings.
user: Give a detailed overview of Tracks: syntax, arguments, return values, common patterns.

assistant: New Blender versions can sometimes introduce breaking changes in Blender’s
Python API or even change how entire features work. If this affects your
extension, you may want to maintain two “tracks” of your extension concurrently:
one for Blender “old” and one for Blender “new”.

You can use version numbering to accomplish this in a reasonably clear way. For
example, if your extension is currently on version 1.2.1, and you wish to
release a new version for the breaking changes in Blender “new”, you can release
that new version as version 1.3.0. Then if you need to make bug fixes in the
version of the extension for Blender “old”, you can still increment the patch
number to 1.2.2, 1.2.3, etc. In effect, 1.2.x and 1.3.x are two different
“tracks” of the extension, each of which can continue to get new releases.

Alternatively, you can increment the major version number for the tracks,
particularly if you expect to do more than just bug fixes for the older tracks.
Either way, we strongly recommend against only incrementing the patch version
for these kinds of updates: you never know when you might need to make a bug fix
release.
user: Provide the full official documentation entry for Performance, preserving all code examples.

assistant: # Performance

Properties that affect render speeds or memory consumption.
There are several presets available to help choose between different trade offs:

Default:
:   Balances memory saving and faster rendering settings.

Faster Render:
:   Uses settings to render faster at the cost of higher memory consumption.

Lower Memory:
:   Uses settings to decrease memory considered at the cost of slower renders.
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

Force fields offer a way to influence a simulation, in example to add extra movement.
[Particles](../../particles/index.xhtml), [Soft Bodies](../../soft_body/index.xhtml),
[Rigid Bodies](../../rigid_body/index.xhtml), and [Cloth objects](../../cloth/index.xhtml)
can all be affected by forces fields.
Force fields automatically affect everything.
To remove a simulation or particle system from their influence,
simply turn down the influence of that type of force field in its Field Weights panel.

- All types of objects and particles can generate fields,
  but only curve object can bear a [Curve Guide](types/curve_guide.xhtml) field.
- Force fields can also be generated from particles.
  See [Particle Physics](../../particles/emitter/physics/index.xhtml).
- The objects need to share at least one common layer to have an effect.

You may limit the effect on particles to a group of objects
(see the [Particle Physics](../../particles/emitter/physics/index.xhtml) page).
user: How do I use Specular BSDF in Blender? Include parameters, examples, warnings and best practices.

assistant: # Specular BSDF

[image reference removed]

EEVEE Only

The *Specular* BSDF
combines multiple layers into a single easy to use node.

It is similar to the [Principled BSDF](principled.xhtml) node
but uses the *specular* workflow instead of the metallic.
It has far fewer parameters and supports less features. Both might be merged into one node in the future.

The specular workflow functions by specifying the facing (along normal) reflection color.
The result may not be physically plausible because there is no energy conservation.
user: Show practical ways to work with Volume Coefficients in a Blender add-on or script – include code.

assistant: # Volume Coefficients

[image reference removed]

The *Volume Coefficients* node models three physical processes in a volume:
Absorption, Scattering and Emission, represented by their coefficients.
Typical usage is to plug in values from real-world measurements.
user: How do I use CompositorNodeTree(NodeTree) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CompositorNodeTree(NodeTree)

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

*class* bpy.types.CompositorNodeTree(*NodeTree*)
:   Node tree consisting of linked nodes used for compositing

    use_viewer_border
    :   Use boundaries for viewer nodes and composite backdrop

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: When Normalize is enabled, the power of sun lights is specified in Watts per square meter.
The power of point lights, spot lights, and area lights is specified in Watts.

But this is not the electrical Watts that consumer light bulbs are rated at.
It is [Radiant Flux or Radiant Power](https://en.wikipedia.org/wiki/Radiant_flux) which is also measured in Watts.
It is the energy radiated from the light in the form of visible light.

If you want to set the power to real world values, you have to convert the wattage of consumer bulbs
or LED lights to radiant flux, but it is not a straightforward process.
The wattage of bulbs means the electrical power required to power them. LED lights have
a “Watt equivalent” which is neither the electrical power they require nor the amount of light they put out.
Some consumer lights specify [lumens or luminous flux](https://en.wikipedia.org/wiki/Lumen_(unit))
which is the radiant flux weighted with the wavelengths perceived by the human eye.

To save you from doing the conversion, here is a table of typical power values for point, spot, and area lights:

| Real world light | Power | Suggested Light Type |
| --- | --- | --- |
| Candle | 0.05 W | Point |
| 800 lm LED bulb | 2.1 W | Point |
| 1000 lm light bulb | 2.9 W | Point |
| 1500 lm PAR38 floodlight | 4 W | Area, Disk |
| 2500 lm fluorescent tube | 4.5 W | Area, Rectangle |
| 5000 lm car headlight | 22 W | Spot, size 125 degrees |

And a table of typical Strength values for sun lights:

| Sun type | Strength |
| --- | --- |
| Clear sky | 1000 W/m2 |
| Cloudy sky | 500 W/m2 |
| Overcast sky | 200 W/m2 |
| Moonlight | 0.001 W/m2 |

These values will produce much brighter or dimmer lights than you would expect,
because our eyes adapt while a render engine does not. So to compensate,
adjust the *Exposure* in Render ‣ Film.

To get realistic results, remember to also set the light size and color to realistic values.
The color of your lights will also influence how bright they appear to the human visual system.
If you leave the power unchanged, a green light will seem the brightest, red darker and blue the darkest.
Thus you might want to manually compensate for these perceived differences.
user: Explain Fill Holes in complete detail according to the official Blender documentation.

assistant: Fills each hole in the selected geometry with a face.

Sides
:   The maximum number of sides: if a hole has more edges than this number,
    it will not be filled. You can set this limit to 0 to fill all holes.
user: Give a detailed overview of Restore Curve Segment Length: syntax, arguments, return values, common patterns.

assistant: # Restore Curve Segment Length

The *Restore Curve Segment Length* node restores the original length of each curve segment
based on a reference position, typically from a pre-deformation state.
It is useful for correcting unwanted stretching or compression that occurs after
curve deformations, simulations, or procedural modifications.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

Much like in real-life skeletons, Bones are the building blocks of Armatures.
Each bone has a resting position, orientation, and length – and all of these
can be changed while posing or animating.

You can change the way bones are displayed in the armature’s
[Viewport Display](../properties/display.xhtml) settings.
user: Give a detailed overview of NodeTreeInterfaceSocketFloatFactor(NodeTreeInterfaceSocket): syntax, arguments, return values, common patterns.

assistant: # NodeTreeInterfaceSocketFloatFactor(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketFloatFactor(*NodeTreeInterfaceSocket*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

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

assistant: # ViewerPathElem(bpy_struct)

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

subclasses —
[`EvaluateClosureNodeViewerPathElem`](bpy.types.EvaluateClosureNodeViewerPathElem.html#bpy.types.EvaluateClosureNodeViewerPathElem "bpy.types.EvaluateClosureNodeViewerPathElem"), [`ForeachGeometryElementZoneViewerPathElem`](bpy.types.ForeachGeometryElementZoneViewerPathElem.html#bpy.types.ForeachGeometryElementZoneViewerPathElem "bpy.types.ForeachGeometryElementZoneViewerPathElem"), [`GroupNodeViewerPathElem`](bpy.types.GroupNodeViewerPathElem.html#bpy.types.GroupNodeViewerPathElem "bpy.types.GroupNodeViewerPathElem"), [`IDViewerPathElem`](bpy.types.IDViewerPathElem.html#bpy.types.IDViewerPathElem "bpy.types.IDViewerPathElem"), [`ModifierViewerPathElem`](bpy.types.ModifierViewerPathElem.html#bpy.types.ModifierViewerPathElem "bpy.types.ModifierViewerPathElem"), [`RepeatZoneViewerPathElem`](bpy.types.RepeatZoneViewerPathElem.html#bpy.types.RepeatZoneViewerPathElem "bpy.types.RepeatZoneViewerPathElem"), [`SimulationZoneViewerPathElem`](bpy.types.SimulationZoneViewerPathElem.html#bpy.types.SimulationZoneViewerPathElem "bpy.types.SimulationZoneViewerPathElem"), [`ViewerNodeViewerPathElem`](bpy.types.ViewerNodeViewerPathElem.html#bpy.types.ViewerNodeViewerPathElem "bpy.types.ViewerNodeViewerPathElem")

*class* bpy.types.ViewerPathElem(*bpy_struct*)
:   Element of a viewer path

    type
    :   Type of the path element

        Type:
        :   enum in [`'ID'`, `'MODIFIER'`, `'GROUP_NODE'`, `'SIMULATION_ZONE'`, `'VIEWER_NODE'`, `'REPEAT_ZONE'`, `'FOREACH_GEOMETRY_ELEMENT_ZONE'`, `'EVALUATE_CLOSURE'`], default `'ID'`, (readonly)

    ui_name
    :   Name that can be displayed in the UI for this element

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.ViewerPathElem.type "bpy.types.ViewerPathElem.type")
user: Show practical ways to work with Dt Method Loop Items in a Blender add-on or script – include code.

assistant: # Dt Method Loop Items

TOPOLOGY:
:   Topology.

    Copy from identical topology meshes.

NEAREST_NORMAL:
:   Nearest Corner and Best Matching Normal.

    Copy from nearest corner which has the best matching normal.

NEAREST_POLYNOR:
:   Nearest Corner and Best Matching Face Normal.

    Copy from nearest corner which has the face with the best matching normal to destination corner’s face one.

NEAREST_POLY:
:   Nearest Corner of Nearest Face.

    Copy from nearest corner of nearest face.

POLYINTERP_NEAREST:
:   Nearest Face Interpolated.

    Copy from interpolated corners of the nearest source face.

POLYINTERP_LNORPROJ:
:   Projected Face Interpolated.

    Copy from interpolated corners of the source face hit by corner normal projection.
user: How do I use FunctionNodeSeparateTransform(FunctionNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # FunctionNodeSeparateTransform(FunctionNode)

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

*class* bpy.types.FunctionNodeSeparateTransform(*FunctionNode*)
:   Split a transformation matrix into a translation vector, a rotation, and a scale vector

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: On Windows there are a few ways to update Blender. This section covers the most common approaches.

### Updating from a Windows Installer File

When an update for Blender is released, it can be downloaded directly from the
[Blender website](https://www.blender.org/download/). The Windows installer can then be run to install the updated
version of Blender. To remove a previously installed version of Blender, use Windows settings or control panel to
uninstall the desired version.

### Updating from a Zip

When an update for Blender is released, it can be downloaded directly from the
[Blender website](https://www.blender.org/download/) and extracted to the desired folder, where you can
double-click the executable to run Blender. For more information on creating a portable version of Blender, see the
section [Install from Zip](#install-from-zip).

Note, you do not have to overwrite your existing Blender installation. It’s perfectly possible to have multiple
versions installed side by side.

### Updating from the Microsoft Store

When an update for Blender is available on the Microsoft Store, it will be downloaded and installed automatically.
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| ../../../_images/modeling_modifiers_generate_edge-split_example-1.png   Flat shading. | ../../../_images/modeling_modifiers_generate_edge-split_example-2.png   Smooth shading. |
| ../../../_images/modeling_modifiers_generate_edge-split_example-3.png   Smooth shading with Edge Split. | ../../../_images/modeling_modifiers_generate_edge-split_example-4.png   Smooth shading with Edge Split and Subdivision Surface. |
user: Provide the full official documentation entry for Inherited Properties, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Constraint.name`](bpy.types.Constraint.html#bpy.types.Constraint.name "bpy.types.Constraint.name") - [`Constraint.type`](bpy.types.Constraint.html#bpy.types.Constraint.type "bpy.types.Constraint.type") - [`Constraint.is_override_data`](bpy.types.Constraint.html#bpy.types.Constraint.is_override_data "bpy.types.Constraint.is_override_data") - [`Constraint.owner_space`](bpy.types.Constraint.html#bpy.types.Constraint.owner_space "bpy.types.Constraint.owner_space") - [`Constraint.target_space`](bpy.types.Constraint.html#bpy.types.Constraint.target_space "bpy.types.Constraint.target_space") - [`Constraint.space_object`](bpy.types.Constraint.html#bpy.types.Constraint.space_object "bpy.types.Constraint.space_object") - [`Constraint.space_subtarget`](bpy.types.Constraint.html#bpy.types.Constraint.space_subtarget "bpy.types.Constraint.space_subtarget") | - [`Constraint.mute`](bpy.types.Constraint.html#bpy.types.Constraint.mute "bpy.types.Constraint.mute") - [`Constraint.enabled`](bpy.types.Constraint.html#bpy.types.Constraint.enabled "bpy.types.Constraint.enabled") - [`Constraint.show_expanded`](bpy.types.Constraint.html#bpy.types.Constraint.show_expanded "bpy.types.Constraint.show_expanded") - [`Constraint.is_valid`](bpy.types.Constraint.html#bpy.types.Constraint.is_valid "bpy.types.Constraint.is_valid") - [`Constraint.active`](bpy.types.Constraint.html#bpy.types.Constraint.active "bpy.types.Constraint.active") - [`Constraint.influence`](bpy.types.Constraint.html#bpy.types.Constraint.influence "bpy.types.Constraint.influence") - [`Constraint.error_location`](bpy.types.Constraint.html#bpy.types.Constraint.error_location "bpy.types.Constraint.error_location") - [`Constraint.error_rotation`](bpy.types.Constraint.html#bpy.types.Constraint.error_rotation "bpy.types.Constraint.error_rotation") |
user: How do I use limbs.super_finger in Blender? Include parameters, examples, warnings and best practices.

assistant: Will create a bendy and stretchy finger chain with a master control bone that controls the rotation of
all joints through its scale.

Requirement: A chain of at least two connected bones.

Bend Rotation Axis (Automatic, X, Y, Z, -X, -Y, -Z)
:   Defines the automatic rotation axis to be linked to the scale of the master bone.

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

IK Control
:   Generates a very simple IK mechanism with only one control.

    IK starts its work with the shape of the finger defined by FK controls and adjusts it
    to make the fingertip touch the IK control. It is designed as a tool to temporarily keep
    the fingertip locked to a surface it touches, rather than a fully featured posing system.

    To improve performance, the switchable parent for the IK control contains only one option beside None.
    Thus it is advised to add a ‘held object’ control using the [basic.raw_copy](basic.xhtml#rigify-rigs-basic-pivot)
    rig to act as the common parent for the fingers with a fully functional parent switch.

IK Local Location
:   Specifies the value of the Local Location option for IK controls, which decides if the location
    channels are aligned to the local control orientation or world.

Assign Tweak Layers
:   If enabled, allows placing the Tweak controls in different bone collections from the main controls.

Assign Extra IK Layers
:   If enabled, allows placing the extra IK control in different bone collections from the main controls.
user: Give a detailed overview of Compositor: syntax, arguments, return values, common patterns.

assistant: Device
:   The device used for compositing.

    CPU:
    :   Use the CPU for compositing.

    GPU:
    :   Use the GPU for compositing.

Precision GPU
:   The precision of compositor intermediate result.

    Auto:
    :   Use full precision for final renders, half precision otherwise.

    Full:
    :   Use full precision for final renders and viewport.

### Denoise Nodes

Denoising Device
:   The device to use to process [Denoise nodes](../../../compositing/types/filter/denoise.xhtml) in the compositor.

    Auto:
    :   Use the same device used by the compositor to process the denoise node.

    CPU:
    :   Use the CPU to process the denoise node.

    GPU:
    :   Use the GPU to process the denoise node if available, otherwise fallback to CPU.

Preview Quality
:   The quality used by [Denoise nodes](../../../compositing/types/filter/denoise.xhtml) during viewport
    and interactive compositing of a render if their quality is set to *Follow Scene*.

    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.

Final Quality
:   The quality used by [Denoise nodes](../../../compositing/types/filter/denoise.xhtml) during the final
    render if their quality is set to *Follow Scene*.

    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 GeometryNodeSeparateComponents(GeometryNode), preserving all code examples.

assistant: # GeometryNodeSeparateComponents(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.GeometryNodeSeparateComponents(*GeometryNode*)
:   Split a geometry into a separate output for each type of data in the geometry

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Material Selection Node

[image reference removed]

The *Material Selection* node provides a selection for meshes that use this material.
Since the `material_index` is stored on each face, the output will be implicitly interpolated to
a different domain when necessary. For example, every vertex connected to
a selected face will be selected.
user: Provide the full official documentation entry for Resizing, preserving all code examples.

assistant: [image reference removed]

You can resize areas by dragging their borders with `LMB`.
Move your mouse cursor over the border between two areas,
so that the cursor changes to a double-headed arrow, and then click and drag.
Hold `Ctrl` to snap the size of areas to convenient sizes.
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

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

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

[image reference removed]

An example of a composition.

[image reference removed]

An example of color correction.
user: Show practical ways to work with In-Betweens in a Blender add-on or script – include code.

assistant: # In-Betweens

[image reference removed]

In-Betweens Tools.

There are several tools for editing poses in an animation.

There are also in *Pose Mode* a bunch of armature-specific editing options/tools,
like [auto-bones naming](../../bones/editing/naming.xhtml#armature-editing-naming-bones),
[properties switching/enabling/disabling](../../bones/editing/properties.xhtml#armature-bone-properties), etc.,
that were already described in the armature editing pages. See the links above…
user: Show practical ways to work with Warp Modifier in a Blender add-on or script – include code.

assistant: # Warp Modifier

The *Warp* modifier can be used to warp parts of a mesh to a new location in
a very flexible way, by using two objects to select the “from” and “to” regions.

[image reference removed]

A Warp modifier applied to a grid mesh.

This modifier is a bit tricky to understand at first.
It requires two points, specified by the two target objects’ origins.
The “from” point designates a point in space that is pulled toward the “to” point.
It is akin to using
the [Proportional Editing](../../../editors/3dview/controls/proportional_editing.html) in Edit Mode.
user: Give a detailed overview of Examples: syntax, arguments, return values, common patterns.

assistant: ### Blur Alpha

[image reference removed]

An example of blurring the alpha channel.

In this first example, we take the Alpha channel and blur it,
and then combine it back with the colors. When placed in a scene,
the edges of it will blend in, instead of having a hard edge.
This is almost like [Anti-Aliasing](../../../glossary/index.xhtml#term-Anti-Aliasing) but in a three-dimensional sense.
Use this node setup, when adding CG elements to live action to remove any hard edges.
Animating this effect on a broader scale will make the object appear to “phase” in and out,
as an “out-of-phase” time-traveling sync effect.

### Increase Luminance

[image reference removed]

An example of the scaling the Luminance channel.

This example has a *Math (Multiply)* node increasing the luminance channel (Y)
of the image to make it brighter.
user: What is Generate Hair Curves and how is it used in Blender Python scripting?

assistant: # Generate Hair Curves

The *Generate Hair Curves* node procedurally creates new hair curves on the surface of a mesh.
It generates curves from scratch at sampled point locations rather than using existing hair data.
For cases where curves should interpolate or follow existing guides, use the
[Interpolate Hair Curves](interpolate_hair_curves.xhtml) node instead.
user: Provide the full official documentation entry for Modifiers, preserving all code examples.

assistant: ### Common Options

Mix
:   The modifier output can be mixed with the base property using the usual methods
    (see for example the [Mix compositing node](../../../../compositing/types/color/mix_color.html)).

Influence
:   How much the result of this modifier affects the current property.

Color Ramp
:   Each modifier has [color ramp](../../../../interface/controls/templates/color_ramp.html#ui-color-ramp-widget) that maps the property to a stroke color.

### Types

- [Along Stroke](modifiers/color/along_stroke.html)
- [Crease Angle](modifiers/color/crease_angle.html)
- [Curvature 3D](modifiers/color/curvature_3d.html)
- [Distance from Camera](modifiers/color/distance_from_camera.html)
- [Distance from Object](modifiers/color/distance_from_object.html)
- [Material](modifiers/color/material.html)
- [Noise](modifiers/color/noise.html)
- [Tangent](modifiers/color/tangent.html)
user: What is Sidebar and how is it used in Blender Python scripting?

assistant: ### Options

The Options panel in the Sidebar region contains the same [settings](../render/materials/settings.xhtml)
that are also available in the Material tab in the Properties.
They differ depending on the selected render engine.
The settings are duplicated to make it possible to edit the entire material from the Shader editor.