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

assistant: # TextureNodeScale(TextureNode)

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

*class* bpy.types.TextureNodeScale(*TextureNode*)
:   *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: Explain Template Scripts in complete detail according to the official Blender documentation.

assistant: While app templates can use Python scripts,
they simply have access to the same APIs available for add-ons and any other scripts.

As noted above, you may optionally have an `__init__.py` in your app template.
This has the following advantages:

- Changes can be made to the startup or preferences, without having to distribute a blend-file.
- Changes can be made dynamically.

  You could for example – configure the template to check the number of processors,
  operating system and memory, then set values based on this.
- You may enable add-ons associated with your template.

On activation a `register` function is called, `unregister` is called when another template is selected.

As these only run once, any changes to defaults must be made via handler.
Two handlers you are likely to use are:

- `bpy.app.handlers.load_factory_preferences_post`
- `bpy.app.handlers.load_factory_startup_post`

These allow you to define your own “factory settings”, which the user may change,
just as Blender has it’s own defaults when first launched.

This is an example `__init__.py` file which defines defaults for an app template to use.

```
import bpy
from bpy.app.handlers import persistent

@persistent
def load_handler_for_preferences(_):
    print("Changing Preference Defaults!")
    from bpy import context

    prefs = context.preferences
    prefs.use_preferences_save = False

    kc = context.window_manager.keyconfigs["blender"]
    kc_prefs = kc.preferences
    if kc_prefs is not None:
        kc_prefs.select_mouse = 'RIGHT'
        kc_prefs.spacebar_action = 'SEARCH'
        kc_prefs.use_pie_click_drag = True

    view = prefs.view
    view.header_align = 'BOTTOM'

@persistent
def load_handler_for_startup(_):
    print("Changing Startup Defaults!")

    # Use smooth faces.
    for mesh in bpy.data.meshes:
        for poly in mesh.polygons:
            poly.use_smooth = True

    # Use material preview shading.
    for screen in bpy.data.screens:
        for area in screen.areas:
            for space in area.spaces:
                if space.type == 'VIEW_3D':
                    space.shading.type = 'MATERIAL'
                    space.shading.use_scene_lights = True

def register():
    print("Registering to Change Defaults")
    bpy.app.handlers.load_factory_preferences_post.append(load_handler_for_preferences)
    bpy.app.handlers.load_factory_startup_post.append(load_handler_for_startup)

def unregister():
    print("Unregistering to Change Defaults")
    bpy.app.handlers.load_factory_preferences_post.remove(load_handler_for_preferences)
    bpy.app.handlers.load_factory_startup_post.remove(load_handler_for_startup)
```
user: Give a detailed overview of Linear Workflow: syntax, arguments, return values, common patterns.

assistant: Different [Color Spaces](../../glossary/index.xhtml#term-Color-Space)
are needed for rendering, display and storage of images.

Rendering and compositing is best done in a *scene linear* color space,
which corresponds more closely to nature, and makes computations more physically accurate.
Blender primarily works with scene linear colors for materials, lighting, geometry and
compositing.

However, these values do not directly correspond to human perception or the way display devices
work. Image files are also often stored in different color spaces for more efficient compression.

For a correct linear workflow, it is important to assign the correct color spaces for images
and displays. Blender will then perform conversion to and from scene linear colors.

[image reference removed]

An example of a linear workflow.
user: What is Geometry and how is it used in Blender Python scripting?

assistant: Display UVs
:   Display selected and active object’s UVs.

UV Face Opacity
:   Opacity of faces. Useful to differentiate between UV islands. Can also be reduced when
    texture painting to prevent faces from tinting the texture’s colors.
user: What is Tool Settings and how is it used in Blender Python scripting?

assistant: [image reference removed]

Curve Stroke panel.

Type
:   Type of curve to use for drawing.

    Poly:
    :   Bézier Curve with straight line segments (auto handles).

    Bézier:
    :   Tolerance
        :   Lower values give a result that is closer to the drawing stroke,
            while higher values give more smoothed results.

        Method
        :   Refit:
            :   Incrementally refits the curve (gives best results).

            Split:
            :   Splits the curve until the tolerance is met (gives a better drawing performance).

        Detect Corners
        :   Detects corners while drawing based on a specified angle;
            Any angles above the specified value are considered corners.
            If a corner is detected, the curve uses non-aligned handles
            for the corner resulting in a more crisp corner.

Taper Start, End
:   Taper factor for the radius of the start and end points along the curve.

Radius Min
:   Minimum radius when the minimum pressure is applied (also the minimum when tapering).

Max
:   Radius to use when the maximum pressure is applied (or when a tablet is not used).

Use Pressure
:   Uses stylus pressure to control the radius of the curve.

Depth
:   Controls where and how the curves are drawn.

    Cursor:
    :   Uses the depth under the cursor to draw curves.

    Surface:
    :   Used to draw on top of other objects.

        Project Onto Selected
        :   Only project the strokes onto selected objects.

        Offset
        :   Distance to offset the curve from the surface.

        Absolute Offset
        :   Applies a fixed offset (does not scale by the curve radius).

        Only First
        :   Only uses the start of the stroke for the depth.

        Plane
        :   The orientation plane to draw on, available when *Only First* is enabled.

            Normal to Surface:
            :   Draws aligned to the surface.

            Tangent to Surface:
            :   Draws perpendicular to the surface.

            View:
            :   Draws aligned to the viewport.

Curve 2D
:   Project the curve on the Z axis.

As NURBS
:   Draw curves as a NURBS curve with Bézier knot mode, instead of a Bézier curve.
user: Explain FunctionNodeInputVector(FunctionNode) in complete detail according to the official Blender documentation.

assistant: # FunctionNodeInputVector(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.FunctionNodeInputVector(*FunctionNode*)
:   Provide a vector value that can be connected to other nodes in the tree

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

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

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

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

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

Different thickness profile samples.

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

### Brush Asset

Picks the brush asset used by the tool.

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

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

### Brush Settings

Parameters to control to look of the stroke.

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

### Color

Settings to determine the color of strokes.

See [Color](../tool_settings/color.html)
user: How do I use SkinModifier(Modifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # SkinModifier(Modifier)

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

*class* bpy.types.SkinModifier(*Modifier*)
:   Generate Skin

    branch_smoothing
    :   Smooth complex geometry around branches

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

    use_smooth_shade
    :   Output faces with smooth shading rather than flat shaded

        Type:
        :   boolean, default False

    use_x_symmetry
    :   Avoid making unsymmetrical quads across the X axis

        Type:
        :   boolean, default True

    use_y_symmetry
    :   Avoid making unsymmetrical quads across the Y axis

        Type:
        :   boolean, default False

    use_z_symmetry
    :   Avoid making unsymmetrical quads across the Z axis

        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: What is Creating an Extensions Repository and how is it used in Blender Python scripting?

assistant: # Creating an Extensions Repository

Third party sites that wish to support extensions in Blender can do so in several ways, in order of complexity:

- [Static](static_repository.html):
  Host a static JSON file listing all the packages of your repository.
- [Dynamic](dynamic_repository.html):
  Serve the JSON file on-demand based on the Blender version and platform.
- [Platform](https://projects.blender.org/infrastructure/extensions-website):
  Fork the entire Extensions Website to create your own.
user: Give a detailed overview of Volume: syntax, arguments, return values, common patterns.

assistant: A volume shader can be applied to the entirely world, filling the entire space.

Currently this is most useful for night time or other dark scenes,
as the world surface shader or sun lights will have no effect if a volume shader is used.
This is because the world background is assumed to be infinitely far away,
which is accurate enough for the sun for example.
However, for modeling effects such as fog or atmospheric scattering,
it is not a good assumption that the volume fills the entire space,
as most of the distance between the sun and the earth is empty space.
For such effects it is be better to create a volume object surrounding the scene.
The size of this object will determine how much light is scattered or absorbed.
user: Provide the full official documentation entry for F-Curves, preserving all code examples.

assistant: These settings control how [F-Curves](../graph_editor/fcurves/index.html)
look and their default behavior.

Unselected Opacity
:   Controls the opacity of unselected [F-Curves](../graph_editor/fcurves/index.html) against
    the background of the Graph Editor.

Default Smoothing Mode
:   Controls the behavior of [automatic curve handles](../graph_editor/fcurves/properties.html#editors-graph-fcurves-settings-handles)
    for newly created F-Curves.

Default Interpolation
:   Controls the default [Interpolation](../graph_editor/fcurves/properties.html#editors-graph-fcurves-settings-interpolation)
    for newly created keyframes.

Default Handles
:   Controls the default [Handle](../graph_editor/fcurves/properties.html#editors-graph-fcurves-settings-handles) for newly created F-Curves.

XYZ to RGB
:   Color for X, Y, or Z animation curves (location, scale or rotation)
    is the same as the color for the X, Y, and Z axis.

Channel Group Colors
:   Display groups and channels with colors matching their corresponding groups.

Only Show Selected F-Curve Keyframes
:   Only shows the keyframes markers on the selected curves.

F-Curve High Quality Drawing
:   Display F-Curves using [Anti-Aliasing](../../glossary/index.html#term-Anti-Aliasing) and other effects (disable for a better performance).
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Geometry
:   The geometry to retrieve the attribute from.

Value
:   A field to evaluate on the source *Geometry*. The values are then retrieved from specific
    indices for the output.

Index
:   Which index to use when retrieving the data from the input *Value* field. Any index can be
    connected, resulting in a “shuffling” of the values.
user: Explain Slide Vertices in complete detail according to the official Blender documentation.

assistant: # Slide Vertices

Vertex Slide will transform a vertex along one of its adjacent edges.
Use `Shift`-`V` to activate tool.
The nearest selected vertex to the mouse cursor will be the control one.
Move the mouse along the direction of the desired edge to specify the vertex position.
Then press `LMB` to confirm the transformation.

Even `E`
:   By default, the offset value of the vertices is a percentage of the edges length along which they move.
    When Even mode is active, the vertices are shifted by an absolute value.

Flipped `F`
:   When Flipped is active, vertices move the same distance from adjacent vertices,
    instead of moving from their original position.

Clamp `Alt` or `C`
:   Toggle clamping the slide within the edge extents.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/modeling_meshes_editing_vertex_slide-vertices_example-1.png   Selected vertex. | ../../../../_images/modeling_meshes_editing_vertex_slide-vertices_example-2.png   Positioning vertex interactively. | ../../../../_images/modeling_meshes_editing_vertex_slide-vertices_example-3.png   Repositioned vertex. |
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Rim Visual Effect.

Rim Color
:   Defines the rim light color.

Mask Color
:   Defines a color to keep unaltered.

Blend Mode
:   The mask blending operation to perform. See [Color Blend Modes](../../glossary/index.html#term-Color-Blend-Modes).

Offset X, Y
:   Control the color mask displacement in pixels on the X and Y axis.

### Blur

Blur X, Y
:   Control the blur scale in pixels on the X and Y axis.

Samples
:   Number of blur samples (0 disabled the blur effect).
user: Give a detailed overview of Mask From Face Sets Boundary: syntax, arguments, return values, common patterns.

assistant: Generates a mask based on the face set islands of the mesh. The settings of the operation can be changed
in the [Adjust Last Operation](../../../interface/undo_redo.xhtml) panel.

Mode
:   Choose how the newly created mask is mixed with the existing one. By default it will replace the old mask via
    “Mix”.

Mix Factor
:   The factor of the mix effect. Choose how strong the new mask is applied on the existing one.

Automask Settings
:   The same settings as the [Auto-Masking](../controls.xhtml) settings are applied.

Propagation Steps
:   Same as [Auto-Masking](../controls.xhtml).
user: Provide the full official documentation entry for Extrude Individual Faces, preserving all code examples.

assistant: # Extrude Individual Faces

This tool allows you to extrude a selection of multiple faces as individuals, instead of as a region.
The faces are extruded along their own normals, rather than their average.
This has several consequences: first, “internal” edges
(i.e. edges between two selected faces) are no longer deleted (the original faces are).

|  |  |  |
| --- | --- | --- |
| ../../../../_images/modeling_meshes_editing_face_extrude-individual-faces_multi.png   Selection of multiple faces. | ../../../../_images/modeling_meshes_editing_face_extrude-individual-faces_multi-region.png   Extruded using extrude region. | ../../../../_images/modeling_meshes_editing_face_extrude-individual-faces_multi-individual.png   Extruded using Extrude Individual. |
user: Explain GeometryNodeInstancesToPoints(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeInstancesToPoints(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.GeometryNodeInstancesToPoints(*GeometryNode*)
:   Generate points at the origins of instances.
    Note: Nested instances are not affected by this node

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

assistant: This example shows you how setup a *Path Animation*.

1. Add an object you want to animate and a path along which this object will move.
   In this example it’s the *Monkey* and the *Bézier Circle*.
2. To parent the monkey to the Bézier circle, first select the monkey then the curve
   (so that the curve is the active object), press `Ctrl`-`P` and select *Follow Path*.
   It will automatically animate *Evaluation Time* and activate *Follow* option
   in the *Path Animation* panel.
3. Select the monkey and
   [Clear Origin](../../../scene_layout/object/editing/clear.xhtml) to reset its offset.
4. You can change the orientation of the monkey by changing
   the [Tracking Axis](../../../scene_layout/object/properties/relations.xhtml).

|  |  |
| --- | --- |
| ../../../_images/modeling_curves_properties_path-animation_example-1.png   Monkey parented to the Bézier Circle. | ../../../_images/modeling_curves_properties_path-animation_example-2.png   The final result. |
user: Describe Example Use from the Blender manual or Python API, including usage steps and snippets.

assistant: Below is an example of subscription to changes in the active object’s location.

```
import bpy

# Any Python object can act as the subscription's owner.
owner = object()

subscribe_to = bpy.context.object.location

def msgbus_callback(*args):
    # This will print:
    # Something changed! (1, 2, 3)
    print("Something changed!", args)

bpy.msgbus.subscribe_rna(
    key=subscribe_to,
    owner=owner,
    args=(1, 2, 3),
    notify=msgbus_callback,
)
```

Some properties are converted to Python objects when you retrieve them. This
needs to be avoided in order to create the subscription, by using
`datablock.path_resolve("property_name", False)`:

```
subscribe_to = bpy.context.object.path_resolve("name", False)
```

It is also possible to create subscriptions on a property of all instances of a
certain type:

```
subscribe_to = (bpy.types.Object, "location")
```

bpy.msgbus.clear_by_owner(*owner*)
:   Clear all subscribers using this owner.

bpy.msgbus.publish_rna(*key*)
:   Parameters:
    :   **key** ([`bpy.types.Property`](bpy.types.Property.html#bpy.types.Property "bpy.types.Property") | [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") | tuple[[`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct"), str]) –

        Represents the type of data being subscribed to

        Arguments include
        - A property instance.
        - A struct type.
        - A tuple representing a (struct, property name) pair.

    Notify subscribers of changes to this property
    (this typically doesn’t need to be called explicitly since changes will automatically publish updates).
    In some cases it may be useful to publish changes explicitly using more general keys.

bpy.msgbus.subscribe_rna(*key*, *owner*, *args*, *notify*, *\**, *options=set()*)
:   Register a message bus subscription. It will be cleared when another blend file is
    loaded, or can be cleared explicitly via [`bpy.msgbus.clear_by_owner()`](#bpy.msgbus.clear_by_owner "bpy.msgbus.clear_by_owner").

    Parameters:
    :   - **key** ([`bpy.types.Property`](bpy.types.Property.html#bpy.types.Property "bpy.types.Property") | [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") | tuple[[`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct"), str]) –

          Represents the type of data being subscribed to

          Arguments include
          - A property instance.
          - A struct type.
          - A tuple representing a (struct, property name) pair.
        - **owner** (*Any*) – Handle for this subscription (compared by identity).
        - **options** (*set**[**str**]*) –

          Change the behavior of the subscriber.

          - `PERSISTENT` when set, the subscriber will be kept when remapping ID data.
user: Show practical ways to work with faces.super_face in a Blender add-on or script – include code.

assistant: Will create a face system based on the bones child to the parent that has the property set on it.

Requirement: All the face bones bundled in the `faces.super_face` sample had to be present and
child of the master bone that has the Rigify type *face* property set.
user: What is Average Island Scale and how is it used in Blender Python scripting?

assistant: Using the *Average Island Scale* tool, will scale each
UV island so that they are all approximately the same scale.

Non-Uniform
:   Reduces average texture stretching within islands by scaling the U and V axes independently.

Shear
:   Reduces average texture shearing within islands by shearing the U axis.
user: Show practical ways to work with Brush Types in a Blender add-on or script – include code.

assistant: See [Brush Type](../brush/brush_settings.xhtml#sculpt-tool-settings-brush-type).

Available brush types are listed here, together with brushes from the
*Essentials* asset library using them.

Paint Vertex
:   Brushes: Paint Hard, Paint Soft, Paint Hard Pressure, Paint Soft Pressure, Airbrush

    Paints a specified color over the object.

Blur
:   Brushes: Blur

    Smooths out the colors of adjacent vertices. In this mode the Color
    Value is ignored. The strength defines how much the colors are blurred.

Average
:   Brushes: Average

    Smooths color by painting the average resulting color from all colors under the brush.

Smear
:   Brushes: Smear

    Smudges colors by grabbing the colors under the brush and “dragging” them.
    This can be imagined as a finger painting tool.
user: Describe Technical Terms from the Blender manual or Python API, including usage steps and snippets.

assistant: In general, the technical terms used in computer graphics are quite new or even downright neologisms invented for the
needs, so they do not always have a translation in your language. Moreover, a large part of Blender users use its
English interface.

As a result, unless a term has an evident translation, you should preferably use the English one, *putting it in
italic*. You can then find a translation for it, which you will use from times to times (e.g. to avoid
repetitions…). This is also valid in the other way: even when a term has a straightforward translation, do not
hesitate to use its English version from times to times, to get the reader used with it…

If a term is definitively not translatable, simply use the English one, but make sure its glossary entry is
translated.

In the glossary, the English term is written first (to maintain alphabetic order) with the translated entry following
in parenthesis, when appropriate.
user: Explain StringAttribute(Attribute) in complete detail according to the official Blender documentation.

assistant: # StringAttribute(Attribute)

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

*class* bpy.types.StringAttribute(*Attribute*)
:   Geometry attribute that stores strings

    data
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`StringAttributeValue`](bpy.types.StringAttributeValue.html#bpy.types.StringAttributeValue "bpy.types.StringAttributeValue"), (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Video Editing App Template from the Blender manual or Python API, including usage steps and snippets.

assistant: # Video Editing App Template

The *Video Editing* app template provides a ready-to-use setup for a complete video editing workspace.

[image reference removed]

The default Video Editing app template.
user: What is NodeTreeInterfaceSocketVector2D(NodeTreeInterfaceSocket) and how is it used in Blender Python scripting?

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

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 2 items in [-inf, inf], default (0.0, 0.0)

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 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: Describe SCENE_UL_gltf2_filter_action(UIList) from the Blender manual or Python API, including usage steps and snippets.

assistant: # SCENE_UL_gltf2_filter_action(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.SCENE_UL_gltf2_filter_action(*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: Provide the full official documentation entry for Options, preserving all code examples.

assistant: Type
:   This procedural texture has five noise types on which the resulting pattern can be based
    and they are selectable from a select menu at the top of the tab. The five types are:

    - Hetero Terrain
    - Fractal Brownian Motion (fBm)
    - Hybrid Multifractal
    - Ridged Multifractal
    - Multifractal

    These noise types determine the manner in which Blender layers successive copies of the same
    pattern on top of each other at varying contrasts and scales.

Examples with Basis: Voronoi: F1, Dimension: 0.5, Lacunarity: 0.15, Octave: 2.0.

|  |  |  |  |  |
| --- | --- | --- | --- | --- |
| ../../../../_images/render_materials_legacy-textures_types_musgrave_heteroterrain.jpg   Hetero Terrain. | ../../../../_images/render_materials_legacy-textures_types_musgrave_fbm.jpg   Fractal Brownian Motion. | ../../../../_images/render_materials_legacy-textures_types_musgrave_hybridmultifractal.jpg   Hybrid Multifractal. | ../../../../_images/render_materials_legacy-textures_types_musgrave_ridgedmultifractal.jpg   Ridged Multifractal. | ../../../../_images/render_materials_legacy-textures_types_musgrave_multifractal.jpg   Multifractal. |

The main noise types have four characteristics:

Dimension
:   Fractal dimension controls the contrast of a layer relative to the previous layer in the texture.
    The higher the fractal dimension, the higher the contrast between each layer,
    and thus the more detail shows in the texture.

Lacunarity
:   Lacunarity controls the scaling of each layer of the Musgrave texture,
    meaning that each additional layer will have a scale that is the inverse of the value which shows on the button.
    i.e. Lacunarity = 2 –> Scale = 1/2 original.

Octaves
:   Octave controls the number of times the original noise pattern is overlaid on itself and
    scaled/contrasted with the fractal dimension and lacunarity settings.

Intensity
:   Light intensity. Called *Offset* for *Hetero Terrain*.

The *Hybrid Multifractal* and *Ridged Multifractal* types have these additional settings:

Offset
:   Both have a “Fractal Offset” button that serves as a “sea level”
    adjustment and indicates the base height of the resulting bump map.
    Bump values below this threshold will be returned as zero.

Gain
:   Setting which determines the range of values created by the function.
    The higher the number, the greater the range.
    This is a fast way to bring out additional details in a texture where extremes are normally clipped off.
user: Explain Filter in complete detail according to the official Blender documentation.

assistant: # Filter

These options control which types of data are included in the final render for the current view layer.

Include
:   Environment Cycles, EEVEE
    :   Disables rendering the *Environment* render pass in the final render.

    Surfaces Cycles, EEVEE
    :   Disables rendering object materials in the final render.

    Curves Cycles, EEVEE
    :   Disables rendering curve strands in the final render.

    Volume Cycles, EEVEE
    :   Disables rendering [Volumes](../../modeling/volumes/index.xhtml) in the final render.

    Grease Pencil Cycles, EEVEE
    :   Render Grease Pencil objects on current layer

Use
:   Motion Blur Cycles, EEVEE
    :   Render motion blur for current layer,
        if enabled in the [Render Settings](../cycles/render_settings/motion_blur.xhtml#bpy-types-rendersettings-use-motion-blur).
user: Describe Action Panel from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

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

When the editor is in [Action Editor](modes/action.xhtml) mode,
or in Dope Sheet mode with a channel selected that belongs to an action,
this panel allows changing some settings of that action.
See [Action Properties](../../animation/actions.xhtml#actions-properties) for details.
user: How do I use OperatorProperties(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # OperatorProperties(bpy_struct)

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

*class* bpy.types.OperatorProperties(*bpy_struct*)
:   Input properties of an operator

    bl_system_properties_get(*\**, *do_create=False*)
    :   DEBUG ONLY. Internal access to runtime-defined RNA data storage, intended solely for testing and debugging purposes. Do not access it in regular scripting work, and in particular, do not assume that it contains writable data

        Parameters:
        :   **do_create** (*boolean**,* *(**optional**)*) – Ensure that system properties are created if they do not exist yet

        Returns:
        :   The system properties root container, or None if there are no system properties stored in this data yet, and its creation was not requested

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

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

assistant: 1. Open Blender and go to [Add-ons](../../editors/preferences/addons.xhtml) section of the [Preferences](../../editors/preferences/index.xhtml).
2. Search “VR Scene Inspection” and check the *Enable Add-on* checkbox.
user: Provide the full official documentation entry for Custom Brush Shortcuts, preserving all code examples.

assistant: To give a brush a shortcut, simply right click it in the asset shelf or brush selector popup, and
select *Assign Shortcut*. To modify or remove an existing shortcut, select *Change Shortcut* or
*Remove Shortcut* accordingly.
user: Describe Edge Crease from the Blender manual or Python API, including usage steps and snippets.

assistant: This operator interactively sets the [Edge Crease](../mesh/transform/basic.xhtml#modeling-edges-crease-subdivision) amount
by moving the mouse (or typing a value with the keyboard).
Selecting more than one edge will adjust the mean (average) crease value.
A negative value will subtract from the actual crease value, if present.
To clear the crease edge property, enter a value of -1.
user: Show practical ways to work with Color Fields in a Blender add-on or script – include code.

assistant: [image reference removed]

Color fields. With and without alpha.

The color field stores a color value.
Clicking on it with `LMB` opens the [Color Picker](../templates/color_picker.xhtml).

Color fields with an alpha channel are divided in half: on the left, the color is shown without an alpha channel,
and on the right, it’s shown with an alpha channel over a checker pattern.

Colors can be copied to other color fields by dragging and dropping.

Hovering over a color property will display a large swatch preview of the color
and the color’s hexadecimal, RGBA, and HSVA values.
user: Describe Input from the Blender manual or Python API, including usage steps and snippets.

assistant: If you have a compact keyboard without a separate number pad, enable
Preferences ‣ Input ‣ Keyboard ‣ Emulate Numpad. This gives you the 3D view shortcuts regularly
used on the number pad.

If you do not have a middle mouse button, you can enable
Preferences ‣ Input ‣ Mouse ‣ Emulate 3 Button Mouse. This allows you to hold the `Alt`
or `OSKey` key while dragging with the mouse, to orbit.

See [Configuring Peripherals](hardware.xhtml) for more information about these options, and see
[Input Preferences](../../editors/preferences/input.xhtml) for details on configuring their settings.
user: Describe Brush Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: # Brush Settings

Radius
:   This option controls the radius of the brush, measured in pixels.
    `F` allows you to change the brush size interactively by
    dragging the mouse and then `LMB` (the texture of the brush should be visible inside the circle).
    Typing a number then enter while using `F` allows you to enter the size numerically.

    (Size Pressure)
    :   Adjusts the radius based on the stylus pressure when using a [Graphics Tablet](../../../../getting_started/configuration/hardware.html#hardware-tablet).

Strength
:   Controls how much each application of the brush affects the model.
    For example, higher values cause the *Randomize* brush to add noise to the strokes more quickly,
    and cause the *Smooth* brush to soften the strokes more quickly.

    You can change the brush strength interactively by pressing `Shift`-`F`
    in the 3D Viewport and then moving the brush and then `LMB`.
    You can enter the size numerically also while in `Shift`-`F` sizing.

    (Strength Pressure)
    :   Adjusts the strength based on the stylus pressure when using a [Graphics Tablet](../../../../getting_started/configuration/hardware.html#hardware-tablet).

Use Falloff
:   When enabled, use Strength falloff for the brush.
    Brush Strength decays with the distance from the center of the brush.

Sculpt Strokes
:   Filters the effect of the brush over the strokes.
    Applies to *Smooth* and *Randomize* brushes only.

    Affect Position
    :   Toggles the brush effect on the position of the stroke points.

    Affect Strength
    :   Toggles the brush effect on the strength (alpha) of the stroke points.

    Affect Thickness
    :   Toggles the brush effect on the thickness of the stroke points.

    Affect UV
    :   Toggles the brush effect on the UV rotation of the stroke points.

Direction
:   The influence direction of the brush. This can be Add or Subtract.
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

Vertex Painting is a simple way of painting color onto an object, by directly
manipulating the color of vertices, rather than textures, and is fairly straightforward.
Vertex Painting stores the color information as a
[Color Attribute](../../modeling/meshes/properties/object_data.xhtml#modeling-meshes-properties-object-data-color-attributes)
which can be used by different render engines.

Color attribute’s can be managed in the pallette pop-over in the middle of the header.

[image reference removed]

Vertex Painting Mode.

When a vertex is painted, the color of the vertex is modified according to
the settings of the brush. The color of all visible planes and edges attached to
the vertex are then modified with a gradient to the color of the other connected vertices.
Note that the color of occluded faces is not modified.
user: Explain Lasso Gestures in complete detail according to the official Blender documentation.

assistant: Dragging creates a freeform area that follows the cursor defined by where `LMB` was pressed and where `LMB`
is released.

### Controls

Move `Spacebar`
:   Hold to reposition the selection area.

### Tool Settings

Stabilize Stroke
:   Helps to reduce jitter of the strokes while drawing by delaying and correcting the location of points.

    Radius
    :   Minimum distance from the last point before the stroke continues.

    Factor
    :   A smooth factor, where higher values result in smoother strokes
        but the drawing sensation feels as if you were pulling the stroke.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Fresnel
:   Dielectric Fresnel weight, useful for example for layering diffuse and
    glossy shaders to create a plastic material. This is like the Fresnel node,
    except that the input of this node is in the often more convenient 0.0 to 1.0 range.

Facing
:   Weight that blends from the first to the second shader
    as the surface goes from facing the viewer to viewing it at a grazing angle.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Density Grid
:   The resulting float grid representing the density of the mesh.
    Voxels inside the mesh will have higher density values, while voxels
    outside the mesh will approach zero. The smooth transition is defined by
    the *Gradient Width* parameter.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Grease Pencil
:   The Grease Pencil object with multiple layers to combine.

Selection
:   Operate of a subset of layers by setting the field layer index value to *true*.
    By default, all layers are selected.

Group ID
:   The index numbers of the layer to be merged.
    This input is only visible when using *By Group ID* Mode.