PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of FBX: syntax, arguments, return values, common patterns.

assistant: # FBX

The *FBX* (Filmbox) format is widely used for exchanging 3D data between applications,
especially for animated characters and complex scene data. It is supported by software
such as Autodesk Maya, 3ds Max, Cinema 4D, and game engines like Unity and Unreal Engine.

Blender’s FBX importer supports a broad range of FBX features and is designed to be
fast, memory-efficient, and highly compatible with both modern and legacy FBX files.
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

The Shrinkwrap modifier in Nearest Surface Point mode.

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

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

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

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

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

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

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

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

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

Vertex Group
:   The vertex group to control whether and how much each vertex is displaced to its target position.
    If a vertex is not a member of this group, it is not displaced (same as weight 0).
user: Provide the full official documentation entry for Driver Settings, preserving all code examples.

assistant: ### Type

There are two categories of drivers:

- **Built-in functions** (*Average*, *Sum*, *Min* and *Max*)

  The driven property will have the value of the average, sum, lowest or highest (respectively)
  of the values of the referenced *Driver Variables*.
  If there is only one driver variable, these functions will yield the same result.
- **Custom** (*Scripted Expression*).

  An arbitrary Python expression that can refer to the *Driver Variables* by name. See [Expressions](#expressions).

### Driver Value

The current result of the driver setup. Useful for debug purposes.

### Variables

See [Driver Variables](#driver-variables).

### Update Dependencies

Forces an update for the Driver Value dependencies.

### Show in Drivers Editor

Opens the fully featured [Drivers Editor](../../editors/drivers_editor.xhtml).
This button only appears in the popover version of the Drivers panel.
user: Provide the full official documentation entry for VIEW3D_AST_brush_gpencil_paint(AssetShelf), preserving all code examples.

assistant: # VIEW3D_AST_brush_gpencil_paint(AssetShelf)

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

*class* bpy.types.VIEW3D_AST_brush_gpencil_paint(*AssetShelf*)
:   *classmethod* brush_type_poll(*context*, *asset*)

    *static* draw_popup_selector(*layout*, *context*, *brush*, *show_name=True*)

    *static* get_shelf_name_from_context(*context*)

    *classmethod* has_tool_with_brush_type(*context*, *brush_type*)

    *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 Compositor in Blender? Include parameters, examples, warnings and best practices.

assistant: The Compositor works smoothly with multi-view images.
The compositing of a view is completed before the remaining views start to be composited.
The pipeline is the same as the single-view workflow, with the difference that you can use images,
movies or image sequences in any of the supported multi-view formats.

[image reference removed]

Compositor, backdrop and Split Viewer node.

The views to render are defined in the current scene views,
in a similar way as you define the composite output resolution in the current scene render panel,
regardless of the Image nodes resolutions or Render Layers from different scenes.

Switch View Node
:   If you need to treat the views separately, you can use
    the [Switch View node](../../../../compositing/types/utilities/switch_stereo_view.html)
    to combine the views before an Output node.
user: Provide the full official documentation entry for NodeSocketMenu(NodeSocketStandard), preserving all code examples.

assistant: # NodeSocketMenu(NodeSocketStandard)

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

*class* bpy.types.NodeSocketMenu(*NodeSocketStandard*)
:   Menu socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   enum in []

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Python developers may wish to integrate Blender scripts which don’t center around Blender.

Possible uses include:

- Visualizing data by rendering images and animations.
- Image processing using Blender’s compositor.
- Video editing (using Blender’s sequencer).
- 3D file conversion.
- Development, accessing `bpy` from Python IDE’s and debugging tools for example.
- Automation.
user: What is Paint Modes and how is it used in Blender Python scripting?

assistant: - [Sculpt Mode](../../../sculpt_paint/sculpting/index.html)
- [Texture Paint Mode](../../../sculpt_paint/texture_paint/index.html)
- [Vertex Paint Mode](../../../sculpt_paint/vertex_paint/index.html)
- [Weight Paint Mode](../../../sculpt_paint/weight_paint/index.html)
user: Show practical ways to work with Surface in a Blender add-on or script – include code.

assistant: Surface
:   The curve surface is an optional mesh that is used to anchor the curves, and behave as a scalp for hair grooming.
    When adding a new Curves object via the **Add Menu** the active object is automatically set as the surface.

    To set a new surface press `Ctrl`-`P` and select *Object (Attach Curves to Surface)*
    in the *Set Parent To* pop-up menu. This option can be seen as part of the Curves settings in the Properties
    Editor.

    [image reference removed]

Surface UV Map
:   The name of the attribute on the surface mesh used to define the attachment of each curve.
user: Describe TextureNodeTexNoise(TextureNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # TextureNodeTexNoise(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.TextureNodeTexNoise(*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: Show practical ways to work with Corners of Vertex Node in a Blender add-on or script – include code.

assistant: # Corners of Vertex Node

[image reference removed]

Selects a neighboring face corner of a vertex and outputs its index.

This node is a bit special because it operates in two different domains.
First, it evaluates a *Weight* for each corner in the geometry.
Then, for each item in the context domain, it will:

- Pick a vertex from the geometry based on the *Vertex Index*.
- Find the face corners adjacent to this vertex.
- Sort these corners by their associated weight.
- Pick a corner from the above sorted list based on the *Sort Index*,
  where 0 means the corner with the lowest weight,
  1 means the corner with the second-lowest weight and so on.
- Output the geometry-wide index of this corner.
user: What is Line Art and how is it used in Blender Python scripting?

assistant: # Line Art

[image reference removed]

Line Art material properties.

Material Mask
:   Material masks are a way to provide Line Art extra information about faces that caused the occlusion.
    So edges occluded by those faces can be selected to have different styles.

Masks
:   The layer to include faces of the current material.

Levels
:   Faces with this material will behave as if it has set number of layers in occlusion.

Intersection Priority
:   Assigns an intersection priority value for this material.
    Note that this priority takes precedent over [Object](../../scene_layout/object/properties/line_art.xhtml#bpy-types-objectlineart-intersection-priority)
    or [Collection](../../scene_layout/collections/collections.xhtml#bpy-types-collection-lineart-intersection-priority) priority values.
    The intersection line will be included into the object with the higher intersection priority value.
user: Provide the full official documentation entry for Knife Project, preserving all code examples.

assistant: # Knife Project

Knife Project is a non-interactive tool where you can use objects to cookie-cut into
one or more meshes rather than hand drawing the line. The outline of the selected objects
that *are not* in Edit Mode is projected along the view axis onto the meshes that *are*
in Edit Mode, and then cuts into the faces there. Afterwards, the resulting geometry
inside the cut gets selected.

Keep in mind that Knife Project works from the current view’s perspective. For best results, make sure
to rotate your view to exactly the position you require before using this tool. Orthographic views such
as Right, Front, and Top are commonly used for this.

To use Knife Project, select the objects to be cut, switch to *Edit Mode*,
select the cutting objects in the Outliner (`Ctrl`-`LMB`),
and choose Mesh ‣ Knife Project.

If Blender switches back to *Object Mode* when selecting the cutting objects,
make sure that Edit ‣ Lock Object Modes is checked in the topbar.
Alternatively, if you have only one cutting object, you can select it in the
viewport with `Ctrl`-`LMB`.
user: Describe Power of Lights from the Blender manual or Python API, including usage steps and snippets.

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: Provide the full official documentation entry for UV Warp Modifier, preserving all code examples.

assistant: # UV Warp Modifier

The *UV Warp* modifier transforms an object’s UV map based on values or two objects.
Its purpose is to give you direct control over the object’s UVs in the 3D Viewport,
allowing you to directly move, rotate, and scale existing UV coordinates
using defined values or a controller object or bone.
user: Explain GeometryNodeGreasePencilToCurves(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeGreasePencilToCurves(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.GeometryNodeGreasePencilToCurves(*GeometryNode*)
:   Convert Grease Pencil layers into curve instances

    *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: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeForeachGeometryElementOutput.input_items`](bpy.types.GeometryNodeForeachGeometryElementOutput.html#bpy.types.GeometryNodeForeachGeometryElementOutput.input_items "bpy.types.GeometryNodeForeachGeometryElementOutput.input_items") - [`NodeGeometryForeachGeometryElementInputItems.new`](bpy.types.NodeGeometryForeachGeometryElementInputItems.html#bpy.types.NodeGeometryForeachGeometryElementInputItems.new "bpy.types.NodeGeometryForeachGeometryElementInputItems.new") | - [`NodeGeometryForeachGeometryElementInputItems.remove`](bpy.types.NodeGeometryForeachGeometryElementInputItems.html#bpy.types.NodeGeometryForeachGeometryElementInputItems.remove "bpy.types.NodeGeometryForeachGeometryElementInputItems.remove") |
user: How do I use Elastic Deform in Blender? Include parameters, examples, warnings and best practices.

assistant: # Elastic Deform

Used to simulate realistic deformations such as grabbing or twisting of [Elastic](../../../glossary/index.xhtml#term-Elastic) objects.
For example, this tool works great for modeling the shape of organic objects such as humans or animals.
When pressing `Ctrl`, the brush deforms vertices along the normal of the active vertex.
user: What is LoopColors(bpy_struct) and how is it used in Blender Python scripting?

assistant: # LoopColors(bpy_struct)

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

*class* bpy.types.LoopColors(*bpy_struct*)
:   Collection of vertex colors

    active
    :   Active vertex color layer

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

    active_index
    :   Active vertex color index

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

    new(*\**, *name='Col'*, *do_init=True*)
    :   Add a vertex color layer to Mesh

        Parameters:
        :   - **name** (*string**,* *(**optional**,* *never None**)*) – Vertex color name
            - **do_init** (*boolean**,* *(**optional**)*) – Whether new layer’s data should be initialized by copying current active one

        Returns:
        :   The newly created layer

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

    remove(*layer*)
    :   Remove a vertex color layer

        Parameters:
        :   **layer** ([`MeshLoopColorLayer`](bpy.types.MeshLoopColorLayer.html#bpy.types.MeshLoopColorLayer "bpy.types.MeshLoopColorLayer"), (never None)) – The layer to remove

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

assistant: # NodeGeometryForeachGeometryElementInputItems(bpy_struct)

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

*class* bpy.types.NodeGeometryForeachGeometryElementInputItems(*bpy_struct*)
:   Collection of input items

    new(*socket_type*, *name*)
    :   Add an item at the end

        Parameters:
        :   - **socket_type** (enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items)) – Socket Type, Socket type of the item
            - **name** (*string**,* *(**never None**)*) – Name

        Returns:
        :   Item, New item

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

    remove(*item*)
    :   Remove an item

        Parameters:
        :   **item** ([`ForeachGeometryElementInputItem`](bpy.types.ForeachGeometryElementInputItem.html#bpy.types.ForeachGeometryElementInputItem "bpy.types.ForeachGeometryElementInputItem"), (never None)) – Item, The item to remove

    clear()
    :   Remove all items

    move(*from_index*, *to_index*)
    :   Move an item to another position

        Parameters:
        :   - **from_index** (*int in* *[**0**,* *inf**]*) – From Index, Index of the item to move
            - **to_index** (*int in* *[**0**,* *inf**]*) – To Index, Target index for the item

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

assistant: Receives the outputs of the node group. You can have multiple of these nodes in your tree to keep it clean,
outputting each result right where it’s produced (rather than dragging long links all across your graph).

The output slots can be edited in the *Group* tab of the *Sidebar*.
user: Describe Dual Mesh Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Dual Mesh Node

[image reference removed]

The *Dual Mesh Node* converts a mesh into its dual, i.e. faces are turned into
vertices and vertices are turned into faces. This also means that attributes
which were on the face domain are transferred to the point domain in the dual mesh.
user: Give a detailed overview of Brush Assets: syntax, arguments, return values, common patterns.

assistant: Brushes are used as assets, and stored in [asset libraries](../../files/asset_libraries/introduction.xhtml). This makes the
brushes shared across project files. All available brush assets can be displayed in the
[Asset Browser](../../editors/asset_browser.xhtml), which also provides ways to organize them.

Blender comes bundled with a number of brushes in the Essentials asset library. These can be customized into all
kinds of custom brushes by duplicating them (see [Brush Editing](brush_management.xhtml)).

While it’s possible to have brush data-blocks that are local to the file and not marked as assets, such brushes cannot
be activated for actual painting or sculpting. Use the Mark as Asset operator to make them brush assets that can be
activated.
user: Describe Pop-Up Toolbar from the Blender manual or Python API, including usage steps and snippets.

assistant: Pressing `Shift`-`Spacebar` will pop up a small toolbar right at
your cursor for faster access.
The shortcuts for selecting the tools are displayed on the right.

Alternatively, you can map this action to `Spacebar` in the Keymap Preferences.
Then you’ll be able use `Spacebar` like a modifier key
(similar to holding `Ctrl` or `Shift`).
For example, you can press `Spacebar` `T` for Transform,
`Spacebar` `D` for Annotate, `Spacebar` `M` for Measure and so on.
See [Spacebar Action](../editors/preferences/keymap.xhtml#keymap-blender-default-spacebar-action).
user: Give a detailed overview of Object Gpencil Type Items: syntax, arguments, return values, common patterns.

assistant: # Object Gpencil Type Items

EMPTY:
:   Blank.

    Create an empty Grease Pencil object.

STROKE:
:   Stroke.

    Create a simple stroke with basic colors.

MONKEY:
:   Monkey.

    Construct a Suzanne Grease Pencil object.

---

LINEART_SCENE:
:   Scene Line Art.

    Quickly set up Line Art for the entire scene.

LINEART_COLLECTION:
:   Collection Line Art.

    Quickly set up Line Art for the active collection.

LINEART_OBJECT:
:   Object Line Art.

    Quickly set up Line Art for the active object.
user: Explain CompositorNodeColorMatte(CompositorNode) in complete detail according to the official Blender documentation.

assistant: # CompositorNodeColorMatte(CompositorNode)

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

*class* bpy.types.CompositorNodeColorMatte(*CompositorNode*)
:   Create matte using a given color, for green or blue screen footage

    *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")

    update()

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

assistant: Curve defining how the shutter opens and closes.
The X axis is time, Y values of 0 mean fully closed shutter, Y values of 1 mean fully opened shutter.
The default mapping is set to when shutter opens and closes instantly.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Data Type
:   The type of data stored in the grid (e.g. *Float*, *Integer*, *Boolean*, or *Vector*).
    Determines the expected data type of the *Grid* input and ensures that the
    grid is stored correctly in the volume container.
user: Provide the full official documentation entry for Scale Elements Node, preserving all code examples.

assistant: # Scale Elements Node

[image reference removed]

Scales the selected faces or edges, letting you specify a scaling factor and pivot point for each one.
Connected faces/edges are scaled together using their average factor and pivot point.
user: Explain ID Mask Node in complete detail according to the official Blender documentation.

assistant: # ID Mask Node

[image reference removed]

The *ID Mask Node* creates a mask for a particular object or material in the render.
It relies on the *Object Index* or *Material Index* [render pass](../../../render/layers/passes.xhtml),
which is only available when rendering with Cycles.
user: What is Follow Track Constraint and how is it used in Blender Python scripting?

assistant: # Follow Track Constraint

The *Follow Track* constraint makes an object imitate the movement of a
[motion tracking marker](../../../movie_clip/tracking/clip/marker.xhtml). This makes the object appear at the
same position in the render as where the marker appears in the motion-tracked video.

By default, the object follows the 2D motion of the marker in the video on a plane in the 3D world.
However, it’s also possible to make the object follow the reconstructed 3D position of the marker.
The latter requires setting up at least eight markers and clicking [Solve Camera/Object Motion](../../../movie_clip/tracking/clip/editing/track.xhtml#bpy-ops-clip-solve-camera).
user: Describe Curve of Point Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Curve of Point Node

[image reference removed]

The *Curve of Point* node retrieves the index of the curve a control point is part of.
This node is conceptually similar to the [Face of Corner Node](../../mesh/topology/face_of_corner.html).
user: Describe 3D Viewport Keys from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| `MMB` | Orbit View |
| `Shift`-`MMB` | Pan View |
| `Ctrl`-`MMB` | Zoom View |
| `Tab` | Toggle Edit mode. |
| `Ctrl`-`Tab` | Toggle Pose mode for armatures, or show a [mode](../../editors/3dview/modes.xhtml) switching pie menu for others. |
| `1` - `3` | In Edit Mode, switch between editing vertices (`1`), edges (`2`), or faces (`3`).  Hold `Shift` to toggle one of these without disabling the others.  Hold `Ctrl` to alter how the selection is transformed from the old mode to the new.  See [Mesh Selection Modes](../../modeling/meshes/selecting/introduction.xhtml) for details. |
| `AccentGrave` | Show 3D Viewport navigation pie menu. |
| `Ctrl`-`AccentGrave` | Toggle gizmos. |
| `Shift`-`AccentGrave` | Start [Fly/Walk Navigation](../../editors/3dview/navigate/walk_fly.xhtml#dview-fly-walk). |
user: Explain Limitations in complete detail according to the official Blender documentation.

assistant: - OpenVDB excels at representing sparse volumes, that aren’t necessarily
  concentrated within a tight bounding box but may be spread out through space.
  However, in Blender, these are still rendered as dense volumes
  which is not ideal for performance and memory usage. This will be improved in future releases.
- OpenVDB files can also store level sets and points.
  While level set grids can be read, there is no current support for rendering them as surfaces.
  Importing OpenVDB points is not supported.
user: Provide the full official documentation entry for Text Strip, preserving all code examples.

assistant: # Text Strip

The Text strip allows you to directly display text in the Sequence editor.
The strip will display the text inserted in its text field on the final sequence.

[image reference removed]

Text effect.
user: Give a detailed overview of Viewport: syntax, arguments, return values, common patterns.

assistant: Samples
:   The number of samples to use in the 3D Viewport.
    When setting this to zero the viewport will be resampled continuously.

Temporal Reprojection
:   Reduces noise while moving the viewport or during animation playback. Can leave some ghosting.

Jittered Shadows
:   Enable jittered shadows on the viewport.
    Jittered shadows are always enabled for final renders.
    This also affects any transparent shadows.
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

Masks can be created in the *Image* and *Movie Clip* editors, by changing the mode to *Mask* in the header.
This will add various tools and properties to the editor panels,
while hiding others that are not needed for interacting with masks.

Masks have many purposes. They can be used in a motion tracking workflow to mask out,
or influence a particular object in the footage.
They can be used for manual rotoscoping to pull a particular object out of the footage,
or as a rough matte for green-screen keying. Masks are independent from a particular image of movie clip,
and so they can just as well be used for creating motion graphics or other effects in the Compositor.

[image reference removed]

Using the Mask node to isolate an object in compositing.

While the *Movie Clip Editor* and *Image Editor* are used to edit masks,
the *Compositor* and *Sequencer* are just using already created mask.

Masks can be animated over the time so that they follow some object from the footage,
e.g. a running actor. This can be achieved with shape keys or parenting the mask to tracking markers.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Color
:   RGB color from image. If the image has transparency, the color is premultiplied if the Alpha output is used,
    and unpremultiplied (straight) otherwise.

Alpha
:   Alpha channel from image.
user: Show practical ways to work with Interface in a Blender add-on or script – include code.

assistant: ### Header

Node Tree Sub-Type
:   Geometry Nodes can have multiple contexts depending on the intended function of the node group.
    Changing the context adjusts the user interface to best fit the needs of the selected context.

    Modifier:
    :   Used to create node groups that will be used by the [Geometry Nodes Modifier](../modeling/modifiers/geometry_nodes.html).

    Tool:
    :   Used to create node groups that will be used to create [Node-Based Tools](../modeling/geometry_nodes/tools.html).

View
:   Standard view menu.

Select
:   Menu for [Selecting Nodes](../interface/controls/nodes/selecting.html).

Add
:   Menu for adding new [Geometry Nodes](../modeling/geometry_nodes/index.html).

Node
:   Menu for [Editing Nodes](../interface/controls/nodes/editing.html).

---

Geometry Node Group
:   [Data-Block Menu](../interface/controls/templates/data_block.html) for creating and selecting node groups.

/ Pinned
:   The pin button will keep the current node group selection fixed,
    instead of using the [Active Modifier](../modeling/modifiers/introduction.html#modifier-stack-active).
    When a node group is pinned, it will remain visible in the Geometry Node editor
    even when another object or modifier is selected elsewhere.

---

Parent Node Tree
:   Jumps up a node group level. See [Edit Group](../interface/controls/nodes/groups.html#bpy-ops-node-tree-path-parent) for details.

Snapping
:   Snapping options. See [Arranging Nodes](../interface/controls/nodes/arranging.html) for details.

Overlays
:   See [Overlays](../interface/controls/nodes/node_editors.html#bpy-types-spacenodeoverlay-show-overlays).

### Toolbar

Select
:   See [Selecting Nodes](../interface/controls/nodes/selecting.html).

Annotate
:   See [Annotations](../interface/annotate_tool.html).

Links Cut
:   See [Cut Links](../interface/controls/nodes/editing.html#bpy-ops-node-links-cut).

### Sidebar

#### Node

This tab gives access to the active node’s properties.

#### Tool

This tab gives access to the active tool’s settings.

#### View

This tab allows managing annotations.

#### Group

This tab allows you to edit the current node group’s inputs and outputs.
user: What is Avoid Problematic Footage and how is it used in Blender Python scripting?

assistant: The 2D stabilizer can not work miracles; some flaws simply can not be fixed satisfactory.
Notorious issues are motion blur, rolling shutter, pumping autofocus and moving compression artifacts.
Especially if you do succeed with basic stabilization, such image flaws become yet the more noticeable and annoying.
When on set or on location, it might be tempting to “fix matters in post production”.
Resist that deception, it rarely works out well.

- Prefer a short exposure time to avoid motion blur.
  While motion blur is good to render filmed movements more smooth and natural,
  it seriously impedes the ability to track features precisely.
  As a guideline, try to get at least to 1/250 s.
- Prefer higher frame rates. The more *temporal resolution* the stabilizer has to work on, the better the results.
  If you have the option to choose between progressive and interlaced modes, by all means use interlaced
  and deinterlace the footage to the *doubled frame rate*. This can be done with
  the [yadif](https://ffmpeg.org/ffmpeg-filters.html#yadif-1) filter of FFmpeg: use the mode 1 (`send_field`).
- Beware of the [Rolling Shutter](../../../../../glossary/index.html#term-Rolling-Shutter) effect. Avoid fast lateral movements.
  If you can, prefer a camera which produces less rolling shutter.
  Also, using a higher frame rate reduces the amount of rolling shutter; another reason to prefer
  interlaced over progressive for the purpose at hand.
- Switch off autofocus.
  Better plan your movement beforehand, set a fixed focus and rely on depth of field through using a small aperture.
  Pumping movements might not be so noticeable to the human observer, but the feature tracking tends to slide away
  on defocused image elements; fixing this manually after the fact can cause a huge waste of time.
- Increase the lighting level, at least use a higher sensitivity.
  This helps to set a fast shutter speed plus a small aperture.
  Better lighting and good exposure also help to reduce the impact of compression artifacts.
  If you can, also select a codec with less data reduction, better color space, etc.
  Inevitably, we’re loosing some quality through the interpolation necessary for stabilization.
  Plus we’re loosing some quality due to color space conversion.
user: What is Options and how is it used in Blender Python scripting?

assistant: [image reference removed]

Track To constraint.

[Target](../interface/common.xhtml#rigging-constraints-interface-common-target)
:   The object or bone to point towards.

Track Axis
:   The local axis of the owner that should point at the target.
    For bones, this should typically be Y.

    A negative axis will make the owner point away from the target instead.

Up
:   The local axis of the owner that should point upwards in the world.

Target Z
:   Align the owner’s *Up* axis as closely as possible to the target’s Z axis
    instead of the global one.

[Target/Owner](../interface/common.xhtml#rigging-constraints-interface-common-space)
:   The spaces for evaluating the target and owner transforms.

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Offset
:   Determines the brick offset of the various rows.

Frequency
:   How often rows are offset; a value of 2 gives an even/uneven pattern of rows.

Squash
:   Factor to adjust the brick’s width for particular rows determined by the *Frequency*

Frequency
:   How often rows consist of “squished” bricks.
user: Explain Set Mesh Normal Node in complete detail according to the official Blender documentation.

assistant: # Set Mesh Normal Node

[image reference removed]

The *Set Mesh Normal* node stores a normal vector for each mesh element.

This can be used to control shading appearance and influence subsequent operations that rely on surface normals.
user: Give a detailed overview of CompositorNodeHueSat(CompositorNode): syntax, arguments, return values, common patterns.

assistant: # CompositorNodeHueSat(CompositorNode)

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

*class* bpy.types.CompositorNodeHueSat(*CompositorNode*)
:   Apply a color transformation in the HSV color model

    *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")

    update()

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

assistant: Connects two disconnected control points.
The selection must be loose points, or the first/last point of a curve, then press `F`.
If the points belong to different curves, these are joined by a segment to become a single curve.

|  |  |
| --- | --- |
| ../../../_images/modeling_curves_editing_control-points_two-curves.png   Two curves before. | ../../../_images/modeling_curves_editing_curve_make-segment.png   Curve after joining. |

Note that you can only join curves of the same type (i.e. Bézier with Bézier, NURBS with NURBS).
Additionally, you can close a curve by toggling cyclic.
user: Provide the full official documentation entry for Best Practice, preserving all code examples.

assistant: # Best Practice

When writing your own scripts Python is great for new developers to pick up and become productive,
but you can also pick up bad practices or at least write scripts that are not easy for others to understand.
For your own work this is of course fine,
but if you want to collaborate with others or have your work included with Blender there are practices we encourage.
user: How do I use Example in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Bilateral smoothed Ambient Occlusion.
[blend-file example](https://archive.blender.org/wiki/2015/uploads/2/2a/Bilateral_blur_example_01.blend)

|  |  |
| --- | --- |
| ../../../../_images/compositing_types_filter_bilateral-blur_example-1-render.jpg   Render result. | ../../../../_images/compositing_types_filter_bilateral-blur_example-1-composite.jpg   Composite. |
user: Give a detailed overview of E: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [**Edge**](glossary/index.xhtml#term-Edge) - [**Edge Loop**](glossary/index.xhtml#term-Edge-Loop) - [**Edge Ring**](glossary/index.xhtml#term-Edge-Ring) - [Editors](editors/index.xhtml#index-0)   - [3D Viewport](editors/3dview/introduction.xhtml#index-0)   - [Asset Browser](editors/asset_browser.xhtml#index-0)   - [Compositor](editors/compositor.xhtml#index-0)   - [Dope Sheet](editors/dope_sheet/introduction.xhtml#index-0)   - [Drivers Editor](editors/drivers_editor.xhtml#index-0)   - [File Browser](editors/file_browser.xhtml#index-0)   - [Geometry Node Editor](editors/geometry_node.xhtml#index-0)   - [Graph Editor](editors/graph_editor/introduction.xhtml#index-0)   - [Image Editor](editors/image/introduction.xhtml#index-0)   - [Info Editor](editors/info_editor.xhtml#index-0)   - [Movie Clip Editor](editors/clip/introduction.xhtml#index-0)   - [NLA Editor](editors/nla/introduction.xhtml#index-0)   - [Outliner](editors/outliner/introduction.xhtml#index-0)   - [Preferences](editors/preferences/introduction.xhtml#index-0)   - [Properties](editors/properties_editor.xhtml#index-0)   - [Python Console](editors/python_console.xhtml#index-0)   - [Shader Editor](editors/shader_editor.xhtml#index-0)   - [Spreadsheet](editors/spreadsheet.xhtml#index-0)   - [Text Editor](editors/text_editor.xhtml#index-0)   - [Texture Node Editor](editors/texture_node/introduction.xhtml#index-0)   - [Timeline](editors/timeline.xhtml#index-0)   - [UV Editor](editors/uv/introduction.xhtml#index-0)   - [Video Sequencer](editors/video_sequencer/introduction.xhtml#index-0) | - [**Elastic**](glossary/index.xhtml#term-Elastic) - [**Elasticity**](glossary/index.xhtml#term-Elasticity) - [**Empty**](glossary/index.xhtml#term-Empty) - [**Euler**](glossary/index.xhtml#term-Euler) - [**Euler Rotation**](glossary/index.xhtml#term-Euler-Rotation) - [Extensions](advanced/extensions/getting_started.xhtml#index-0), [[1]](advanced/extensions/index.xhtml#index-0) |
user: What is Setup and how is it used in Blender Python scripting?

assistant: Baking requires a mesh to have a UV map, and either a Color Attribute
or an Image Texture node with an image to be baked to.
The [Active](../../glossary/index.html#term-Active) [Image Texture](../shader_nodes/textures/image.html)
node or [Color Attribute](../../sculpt_paint/vertex_paint/index.html) is used as the baking target.

Use Render Bake in intensive light/shadow solutions,
such as AO or soft shadows from area lights. If you bake AO for the main objects,
you will not have to enable it for the full render, saving render time.
Cycles uses the render settings (samples, bounces, …) for baking.
This way the quality of the baked textures should match the result you get from the rendered scene.