PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe NodeSocketVector4D(NodeSocketStandard) from the Blender manual or Python API, including usage steps and snippets.

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

    default_value
    :   Input value used for unconnected socket

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

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Material Operators and how is it used in Blender Python scripting?

assistant: # Material Operators

bpy.ops.material.copy()
:   Copy the material settings and nodes

bpy.ops.material.new()
:   Add a new material

bpy.ops.material.paste()
:   Paste the material settings and nodes
user: Describe MulticamStrip(EffectStrip) from the Blender manual or Python API, including usage steps and snippets.

assistant: # MulticamStrip(EffectStrip)

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

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

    animation_offset_end
    :   Animation end offset (trim end)

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

    animation_offset_start
    :   Animation start offset (trim start)

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

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

    multicam_source
    :   Type:
        :   int in [0, 127], default 0

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain ShaderNodeTexGabor(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeTexGabor(ShaderNode)

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

*class* bpy.types.ShaderNodeTexGabor(*ShaderNode*)
:   Generate Gabor noise

    color_mapping
    :   Color mapping settings

        Type:
        :   [`ColorMapping`](bpy.types.ColorMapping.html#bpy.types.ColorMapping "bpy.types.ColorMapping"), (readonly, never None)

    gabor_type
    :   The type of Gabor noise to evaluate

        - `2D`
          2D – Use the 2D vector (X, Y) as input. The Z component is ignored..
        - `3D`
          3D – Use the 3D vector (X, Y, Z) as input.

        Type:
        :   enum in [`'2D'`, `'3D'`], default `'2D'`

    texture_mapping
    :   Texture coordinate mapping settings

        Type:
        :   [`TexMapping`](bpy.types.TexMapping.html#bpy.types.TexMapping "bpy.types.TexMapping"), (readonly, never None)

    *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: What is Using Assets and how is it used in Blender Python scripting?

assistant: As a general rule, **an asset can be used by dragging it from the Asset Browser to the desired location**.
Objects and worlds can be dragged from the Asset Browser into the scene.
Materials can be dragged onto the object that should use them.
Geometry nodes can also be dragged onto objects to add a [Geometry Nodes Modifier](../modeling/modifiers/geometry_nodes.xhtml).
The use of pose assets is different, and is described in [Pose Library](../animation/armatures/posing/editing/pose_library.xhtml).

When you drag a collection, it will be added as an
[instance](../scene_layout/object/properties/instancing/collection.xhtml) – that is, a single object representing
the entire collection, meaning the contents aren’t visible in the [Outliner](outliner/introduction.xhtml)
and can’t be edited. You can change this in the following ways:

- Use [Make Instances Real](../scene_layout/object/editing/apply.xhtml#bpy-ops-object-duplicates-make-real) to replace the object by the collection contents.
- Alternatively: delete the object, find the collection in the Outliner’s *Blender File*
  [Display Mode](outliner/interface.xhtml#bpy-types-spaceoutliner-display-mode), and click Link to Scene in its context menu.

There are several things that can happen when an asset is used,
depending on the [Import Method](#bpy-types-fileassetselectparams-import-method).

Note that all regular Blender operations are available after the asset has been added to the current file.
For example, you could choose to link an object to the scene; this will also link its mesh and its materials.
Then you can make the object itself local
(Object ‣ Relations ‣ Make Local… ‣ Selected Objects),
while keeping the mesh and materials linked to the asset files. This will result in a local,
and thus editable, object, and keep the mesh and materials automatically up to date with
any changes in the asset library.
user: Show practical ways to work with Stack in a Blender add-on or script – include code.

assistant: # Stack

The list of constraints affecting an object or bone is called the *Constraint Stack*.
It’s evaluated from top to bottom, and reordering it can drastically change the outcome.

[image reference removed]

Moving constraints is done by dragging their handle  with `LMB`.
user: Show practical ways to work with CompositorNodeLumaMatte(CompositorNode) in a Blender add-on or script – include code.

assistant: # CompositorNodeLumaMatte(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.CompositorNodeLumaMatte(*CompositorNode*)
:   Create a matte based on luminance (brightness) difference

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

assistant: [image reference removed]

Active Spline panel.

Feather Offset
:   The method used for calculating the offset of the mask spline feather.

    Even:
    :   Preserves the thickness of the feather, but can give undesirable loops of the feather curve.

    Smooth:
    :   Gives a nicer and smoother shape,
        but can also give an undesirable sharp feather when a curve segment forms an S-shape.

Weight Interpolation
:   The type of weight (thickness of feather) interpolation between points.
    *Linear* or *Ease* (i.e. changes occur slowly at the beginning and at the end).

Cyclic
:   If the spline is closed or not.

Fill
:   Creates splines with filled areas.
    If disabled, Blender will create curves with a thickness to mask out thin objects such as wires or hair.

Self Intersection Check
:   Prevent the feather (not the curve itself) from intersecting with itself.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Image
:   Standard color input.

X, Y
:   Used to move the input image horizontally and vertically.

Angle
:   Used to rotate an image around its center.
    Positive values rotate counter-clockwise and negative ones clockwise.

Scale
:   Used to resize the image. The scaling is relative, meaning a value of 0.5
    gives half the size and a value of 2.0 gives twice the size of the original image.

### Sampling

Filter
:   Determines how pixel values are interpolated when scaling or transforming images.

    Nearest:
    :   Uses the value of the closest pixel with no smoothing.
        This is the fastest method and is well-suited for pixel art or low-resolution images
        where sharp, blocky edges are desirable.
        In animations, motion appears in single-pixel steps, which can cause visible jittering.

    Bilinear:
    :   Averages the values of surrounding pixels to create a smoother result than *Nearest*.
        Provides a good balance between performance and visual quality.

    Bicubic:
    :   Computes a weighted average of a larger neighborhood of pixels for even smoother results.
        Ideal for photographic images or gradients where preserving fine detail is important.

    Anisotropic:
    :   Adjusts interpolation based on the direction and scale of the transformation.
        Helps reduce blurring or aliasing when scaling at steep angles or uneven resolutions,
        especially useful in textures viewed at oblique angles or in detailed 3D projections.

Extension X/Y
:   The extension mode applied to the X axis.

    Clip:
    :   Areas outside of the image are filled with transparency.

    Extend:
    :   Areas outside of the image are filled with the closest boundary pixel in the image.

    Repeat:
    :   Areas outside of the image are filled with repetitions of the image.
user: Explain Sample Curve Node in complete detail according to the official Blender documentation.

assistant: # Sample Curve Node

[image reference removed]

The *Sample Curve* calculates a point on a curve at a certain distance from the start of the curve,
specified by the length or factor inputs. It also outputs data retrieved from that position on the curve.
The sampled values are linearly interpolated from the values at the evaluated curve points
at each side of the sampled point.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Tone Compositor Only
:   Standard:
    :   The Combined curve is applied to each channel individually, which may result in a change of hue.

    Filmlike:
    :   Keeps the hue constant.

Channel
:   The curve to show.

    C:
    :   Combined

    R:
    :   Red

    G:
    :   Green

    B:
    :   Blue

Curve
:   A Bézier curve that maps each input level (X axis) to an output level (Y axis).
    For the curve controls, see [Curve widget](../../../../interface/controls/templates/curve.html#ui-curve-widget).
user: Give a detailed overview of Evaluate Closure: syntax, arguments, return values, common patterns.

assistant: # Evaluate Closure

[image reference removed]

The *Evaluate Closure* node executes a connected [Closure Zone](../../../interface/controls/nodes/types/utilities/closure/closure.html).
It acts as the *call site* of the closure, running its internal node graph and returning the resulting values.

Closures enable dynamic and customizable node groups by allowing users to pass procedural logic into another node tree.
When the *Evaluate Closure* node runs, the connected closure is evaluated within the current context, matching its input
and output sockets by name.

Common uses for the *Evaluate Closure* node include:

- Allowing user-defined behaviors inside procedural systems (e.g. custom scattering, placement rules, or shading logic).
- Injecting logic into reusable node groups for advanced effects.
- Providing optional customization inputs for high-level node-based tools.
user: Describe LineStyleThicknessModifier(LineStyleModifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # LineStyleThicknessModifier(LineStyleModifier)

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

subclasses —
[`LineStyleThicknessModifier_AlongStroke`](bpy.types.LineStyleThicknessModifier_AlongStroke.html#bpy.types.LineStyleThicknessModifier_AlongStroke "bpy.types.LineStyleThicknessModifier_AlongStroke"), [`LineStyleThicknessModifier_Calligraphy`](bpy.types.LineStyleThicknessModifier_Calligraphy.html#bpy.types.LineStyleThicknessModifier_Calligraphy "bpy.types.LineStyleThicknessModifier_Calligraphy"), [`LineStyleThicknessModifier_CreaseAngle`](bpy.types.LineStyleThicknessModifier_CreaseAngle.html#bpy.types.LineStyleThicknessModifier_CreaseAngle "bpy.types.LineStyleThicknessModifier_CreaseAngle"), [`LineStyleThicknessModifier_Curvature_3D`](bpy.types.LineStyleThicknessModifier_Curvature_3D.html#bpy.types.LineStyleThicknessModifier_Curvature_3D "bpy.types.LineStyleThicknessModifier_Curvature_3D"), [`LineStyleThicknessModifier_DistanceFromCamera`](bpy.types.LineStyleThicknessModifier_DistanceFromCamera.html#bpy.types.LineStyleThicknessModifier_DistanceFromCamera "bpy.types.LineStyleThicknessModifier_DistanceFromCamera"), [`LineStyleThicknessModifier_DistanceFromObject`](bpy.types.LineStyleThicknessModifier_DistanceFromObject.html#bpy.types.LineStyleThicknessModifier_DistanceFromObject "bpy.types.LineStyleThicknessModifier_DistanceFromObject"), [`LineStyleThicknessModifier_Material`](bpy.types.LineStyleThicknessModifier_Material.html#bpy.types.LineStyleThicknessModifier_Material "bpy.types.LineStyleThicknessModifier_Material"), [`LineStyleThicknessModifier_Noise`](bpy.types.LineStyleThicknessModifier_Noise.html#bpy.types.LineStyleThicknessModifier_Noise "bpy.types.LineStyleThicknessModifier_Noise"), [`LineStyleThicknessModifier_Tangent`](bpy.types.LineStyleThicknessModifier_Tangent.html#bpy.types.LineStyleThicknessModifier_Tangent "bpy.types.LineStyleThicknessModifier_Tangent")

*class* bpy.types.LineStyleThicknessModifier(*LineStyleModifier*)
:   Base type to define line thickness modifiers

    name
    :   Name of the modifier

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Normalize All in complete detail according to the official Blender documentation.

assistant: For each point, this tool makes sure that the sum of the weights across all vertex groups is equal to 1.
It normalizes all of the vertex groups, except for locked groups, which keep their weight values untouched.

Lock Active
:   Keep the values of the active group while normalizing all the others.
user: Show practical ways to work with Tune Image Node in a Blender add-on or script – include code.

assistant: # Tune Image Node

[image reference removed]

The *Tune Image* node provides a quick and intuitive way to enhance an image’s overall appearance
by adjusting key visual parameters such as contrast, clarity, and sharpness.
It is designed as a compact, all-in-one correction tool for fine-tuning rendered or composited images
without requiring multiple separate nodes.
user: How do I use Install from a Package Manager in Blender? Include parameters, examples, warnings and best practices.

assistant: Some Linux distributions may have a specific package for Blender in their repositories.

Installing Blender via the distribution’s native mechanisms ensures consistency with other packages on the system and
may provide other features (given by the package manager), such as listing of packages, update notifications and
automatic menu configuration. Be aware, though, that the package may be outdated compared to the latest official
release, or not include some features of Blender. For example, some distributions do not build Blender with Cycles GPU
rendering support, for licensing or other reasons.

If there is a specific package for your distribution, you may choose what is preferable and most convenient.
Otherwise, the official binary is available on [blender.org](https://www.blender.org/download/).
user: Show practical ways to work with Sidebar in a Blender add-on or script – include code.

assistant: # Sidebar

The Sidebar can be toggled with the menu item View ‣ Sidebar
or with the shortcut `N`.

The image below shows two Video Sequencers, one in Preview mode and one in Sequencer mode,
both with their Sidebar open.

[image reference removed]
user: Give a detailed overview of Passes: syntax, arguments, return values, common patterns.

assistant: # Passes

A *Pass* is a type of intermediate rendering information that’s extracted as a separate image.
Examples include the diffuse colors of the objects in the scene, the light distribution,
the depth map, and the normal map.

These images can be accessed using the [Render Layers Node](../../compositing/types/input/scene/render_layers.html)
in the [Compositor](../../editors/compositor.html) and combined in a custom way that replaces the standard one.
user: Show practical ways to work with S in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [**Saturation**](glossary/index.html#term-Saturation) - [**Scanline**](glossary/index.html#term-Scanline) - [**Scene Referenced**](glossary/index.html#term-Scene-Referenced) - [**Seed**](glossary/index.html#term-Seed) - [**Session**](glossary/index.html#term-Session) - Shader Nodes   - [Color Ramp](render/shader_nodes/color/color_ramp.html#index-0)   - [Combine XYZ](render/shader_nodes/utilities/vector/combine_xyz.html#index-0)   - [Math](render/shader_nodes/utilities/math/math.html#index-0)   - [Menu Switch](render/shader_nodes/utilities/menu_switch.html#index-0)   - [Mix Vector](render/shader_nodes/utilities/vector/mix_vector.html#index-0)   - [Separate XYZ](render/shader_nodes/utilities/vector/separate_xyz.html#index-0) | - [**Shading**](glossary/index.html#term-Shading) - [**Smoothing**](glossary/index.html#term-Smoothing) - [**Specular Light**](glossary/index.html#term-Specular-Light) - [**SSS**](glossary/index.html#term-SSS) - [**Straight Alpha**](glossary/index.html#term-Straight-Alpha) - [**Subdiv**](glossary/index.html#term-Subdiv) - [**Subdividing**](glossary/index.html#term-Subdividing) - [**Subdivision Surface**](glossary/index.html#term-Subdivision-Surface) - [**Subsurface Scattering**](glossary/index.html#term-Subsurface-Scattering) - [**Swing**](glossary/index.html#term-Swing) - [**Swing and Twist**](glossary/index.html#term-Swing-and-Twist) |
user: Describe Locked Track Constraint from the Blender manual or Python API, including usage steps and snippets.

assistant: # Locked Track Constraint

The *Locked Track* constraint makes an object or bone point towards a certain target.
It’s typically called “Look At” or “Aim” in other 3D software.

The word “locked” means that the object or bone can only rotate around one axis.
The orientation of this axis always stays the same, and the other two axes always
stay in their original plane.

One example use case is distant tree billboards, which should turn to face the camera
while also staying upright. Another example is a compass on a table with a nearby magnet:
the needle spins horizontally to point at the magnet, but it can never point up or down.
user: Provide the full official documentation entry for Workflow, preserving all code examples.

assistant: The process for working with standard particles is:

1. Create the mesh which will emit the particles.
2. Create one or more Particle Systems to emit from the mesh. Many times, multiple
   particle systems interact or merge with each other to achieve the overall desired effect.
3. Tailor each Particle System’s settings to achieve the desired effect.
4. Animate the base mesh and other particle meshes involved in the scene.
5. Define and shape the path and flow of the particles.
6. For [Hair](hair/index.xhtml) particle systems: Sculpt the emitter’s flow
   (cut the hair to length and comb it for example).
7. Make final render and do physics simulation(s), and tweak as needed.

### Creating a Particle System

[image reference removed]

Adding a particle system.

To add a new particle system to an object, go to the *Particles* tab of the Properties
editor and click the  button. An object can have many Particle Systems.

Each particle system has separate settings attached to it.
These settings can be shared among different particle systems, so one does not have to copy
every setting manually and can use the same effect on multiple objects.

#### Types of Particle Systems

[image reference removed]

Particle System Types.

After you have created a particle system,
the Properties fills with many panels and buttons.
But do not panic! There are two different types of particle systems,
and you can change between these two with the *Type* selector:
Emitter and Hair.

The settings in the *Particle System* tab are partially different for each system type.
user: Show practical ways to work with Scene in a Blender add-on or script – include code.

assistant: Camera
:   Used to select which camera is used as the active camera.
    You can also set the active camera in the 3D Viewport with `Ctrl`-`Numpad0`.

Background Scene
:   Allows you to use a scene as a background,
    this is typically useful when you want to focus on animating the foreground for example,
    without background elements getting in the way.

    This scene can have its own animation, physics simulations, etc,
    but you will have to select it from the *Scene* data-block menu, if you want to edit any of its contents.

    Background Scenes can themselves have a Background Scene (they’re recursively included).
    So you can always make additions to existing scenes by using them as a background
    to a newly created scene where your additions are made.

Active Clip
:   Selects a [Movie Clip](../../movie_clip/index.xhtml) that can be used by
    [Motion Tracking Constraints](../../animation/constraints/motion_tracking/index.xhtml) or a camera’s [Background Images](../../render/cameras.xhtml#bpy-types-camerabackgroundimage).
user: Explain Network in complete detail according to the official Blender documentation.

assistant: Allow Online Access
:   Allow Blender to access the internet.

    Add-ons that follow this setting will only connect to the internet if enabled.
    However, Blender cannot prevent third-party add-ons from violating this rule.

Time Out
:   The time (in seconds) that online operations may wait before timing out.

    Use the systems default when zero.

Connection Limit
:   The maximum number of simultaneous connections an online operation may make.

    Do not limit the number of connections when zero.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

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: What is Bpy.Types.Idoverridelibrarypropertyoperation and how is it used in Blender Python scripting?

assistant: ertyOperation.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Explain Tool Settings in complete detail according to the official Blender documentation.

assistant: Visibility Area
:   Determines whether all vertices inside or outside the selected area should be affected.

    Inside:
    :   All vertices and connected elements inside the selection area will be hidden.

    Outside:
    :   All vertices and connected elements outside the selection area will be hidden.
user: Give a detailed overview of MESH_UL_uvmaps(UIList): syntax, arguments, return values, common patterns.

assistant: # MESH_UL_uvmaps(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.MESH_UL_uvmaps(*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: Show practical ways to work with Track To Constraint in a Blender add-on or script – include code.

assistant: # Track To Constraint

The *Track To* constraint makes an object or bone point towards a certain target,
then roll to make a certain local axis point upwards.
It’s typically called “Look At” or “Aim” in other 3D software.

If the constraint owner is almost directly above the target, the roll around
the tracking axis will become unstable. For this scenario, it’s recommended to
use the [Damped Track Constraint](damped_track.xhtml) instead.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Strength
:   Strength of the normal mapping effect.

    [image reference removed]

    Strength is set to 0, 0.5, 1, 2 (from left to right).

Color
:   RGB color that encodes the normal map in the specified space.
user: Describe Bounce Control from the Blender manual or Python API, including usage steps and snippets.

assistant: The maximum number of light bounces can be controlled manually.
While ideally this should be infinite,
in practice a smaller number of bounces may be sufficient,
or some light interactions may be intentionally left out for faster convergence.
The number of diffuse reflection,
glossy reflection and transmission bounces can also be controlled individually.

Light paths are terminated probabilistically when specifying a minimum number of light bounces
lower than the maximum. In that case, paths longer than minimum will be randomly stopped when
they are expected to contribute less light to the image.
This will still converge to the same image, but renders faster while possibly being noisier.
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: Bundles are useful in many workflows:

- **Simplified interfaces** – group inputs into a single socket for clarity.
- **Physics simulations** – package all entities and constraints for a solver.
- **Declarative systems** – store complex structured data for evaluation later.
- **Texture sets** – combine PBR maps (Base Color, Roughness, Normal) into one socket.
user: Show practical ways to work with Visual Transform in a Blender add-on or script – include code.

assistant: Apply the result of each selected object’s constraints to that object’s own transformation.
This will make the objects keep their location, rotation, and scale even if their
constraints are disabled or deleted.
user: How do I use SpaceClipOverlay(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # SpaceClipOverlay(bpy_struct)

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

*class* bpy.types.SpaceClipOverlay(*bpy_struct*)
:   Settings for display of overlays in the Movie Clip editor

    show_cursor
    :   Display 2D cursor

        Type:
        :   boolean, default True

    show_overlays
    :   Display overlays like cursor and annotations

        Type:
        :   boolean, default True

    *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 Multiply Strip and how is it used in Blender Python scripting?

assistant: # Multiply Strip

The *Multiply* effect multiplies two colors.
Blender uses values between (0.0 to 1.0) for the colors.
This operation does not have to be normalized, the multiplication of two terms
between (0.0 to 1.0) always gives a result between (0.0 to 1.0).

(With the “traditional” representation of three bytes, like RGB(124, 255, 56),
the multiplications give far too high results, like RGB(7316, 46410, 1848),
that have to be normalized (brought back) by dividing them by 256
to fit in the range of (0 to 255)…)

This effect has two main usages:

With a Mask

A mask is a black-and-white picture which, after multiplication with a “normal” image,
only show this one in the white areas of the mask (everything else is black).

The opening title sequence to James Bond movies,
where the camera is facing down the barrel of a gun at James, is a good example of this effect.

With Uniform Colors

Multiplying a color with a “normal” image allows you to soften some hues of this one
(and so – symmetrically – to enhance the others).

For example, if you have a brown pixel RGB(0.50, 0.29, 0.05), and
you multiply it with a cyan filter (uniform color RGB(0.0, 1.0, 1.0)), you will get a color RGB(0.0, 0.29, 0.05).
Visually, the result is to zero the reds and bring up (by “symmetry” – the real values remain unchanged!)
the blues and greens. Physically, it is the same effect as shining a cyan light onto a chocolate bar. Emotionally,
vegetation becomes more lush, water becomes more Caribbean and inviting, skies become friendlier.
user: Give a detailed overview of Operator Example: syntax, arguments, return values, common patterns.

assistant: A common use of custom properties is for Python based `Operator`
classes. Test this code by running it in the text editor, or by clicking the
button in the 3D View-port’s Tools panel. The latter will show the properties
in the Redo panel and allow you to change them.

```
import bpy

class OBJECT_OT_property_example(bpy.types.Operator):
    bl_idname = "object.property_example"
    bl_label = "Property Example"
    bl_options = {'REGISTER', 'UNDO'}

    my_float: bpy.props.FloatProperty(name="Some Floating Point")
    my_bool: bpy.props.BoolProperty(name="Toggle Option")
    my_string: bpy.props.StringProperty(name="String Value")

    def execute(self, context):
        self.report(
            {'INFO'}, "F: {:.2f}  B: {!s}  S: {!r}".format(
                self.my_float, self.my_bool, self.my_string,
            )
        )
        print('My float:', self.my_float)
        print('My bool:', self.my_bool)
        print('My string:', self.my_string)
        return {'FINISHED'}

class OBJECT_PT_property_example(bpy.types.Panel):
    bl_idname = "object_PT_property_example"
    bl_label = "Property Example"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'
    bl_category = "Tool"

    def draw(self, context):
        # You can set the property values that should be used when the user
        # presses the button in the UI.
        props = self.layout.operator('object.property_example')
        props.my_bool = True
        props.my_string = "Shouldn't that be 47?"

        # You can set properties dynamically:
        if context.object:
            props.my_float = context.object.location.x
        else:
            props.my_float = 327

bpy.utils.register_class(OBJECT_OT_property_example)
bpy.utils.register_class(OBJECT_PT_property_example)

# Demo call. Be sure to also test in the 3D Viewport.
bpy.ops.object.property_example(
    my_float=47,
    my_bool=True,
    my_string="Shouldn't that be 327?",
)
```
user: Describe Enable Output Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Enable Output Node

[image reference removed]

The *Enable Output* node toggles the visibility and value
of a socket for a [Node Group](../../../interface/controls/nodes/groups.xhtml) outputs.
It can be used to conditionally show or hide outputs from a node group depending on an input value or condition.
user: How do I use Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: Max Bounces
:   Maximum number of times light from the light is allowed to [Bounce](../../glossary/index.xhtml#term-Light-Bounces).
    Limited by [scene-wide bounce settings](render_settings/light_paths.xhtml#bpy-types-cyclesrendersettings-max-bounces).

Cast Shadow
:   By disabling this option, light from lights will not be blocked by objects in between.
    This can speed up rendering by not having to trace rays to the light source.

Multiple Importance Sample
:   By default lights use only direct light sampling. For area lights and sharp glossy reflections, however,
    this can be noisy,
    and enabling this option will enable indirect light sampling to be used in addition to reduce noise.

Shadow Caustics
:   Mark a light as a refractive caustic caster. This setting can be used in conjunction with the
    [Cast and Receive caustics object settings](object_settings/object_data.xhtml#bpy-types-cyclesobjectsettings-is-caustics-caster)
    to selectively speed up refractive caustic rendering of select objects.

Portals Area Lights
:   Area lights can also function as light portals to help sample the environment light,
    and significantly reduce noise in interior scenes.
    Note that rendering with portals is usually slower, but as it converges more quickly, less samples are required.

    Light portals work by enabling the *Portal* option, and placing areas lights in
    windows, door openings, and any place where light will enter the interior.

    In outdoor scenes most rays do not bounce much and just fly off into the sky and therefore,
    light portals are not helpful for outdoor scenes.

    [image reference removed]

    [image reference removed]

    White Room model by Jay Hardy.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Guide Curves
:   Base curves that new curves are interpolated between.

Guide Up
:   Optional up vector that is typically a surface normal. Supplying an up vector will improve
    the quality of the interpolation, making it aware of the surface shape which it otherwise
    wouldn’t have a way to know about.

Guide Group ID
:   Splits guides into separate groups. New curves interpolate existing curves from a single group.
    This input can be useful for generating hair parts by stopping curves in different sections
    (with different group IDs) from affecting each other.

Points
:   The positions of the first root control points of the newly generated interpolated curves.

Points Up
:   Optional up vector that is typically a surface normal.

Point Group ID
:   The curve group to interpolate in.

Max Neighbors
:   Maximum amount of close guide curves that are taken into account for interpolation.
user: Give a detailed overview of Report from within Blender: syntax, arguments, return values, common patterns.

assistant: It is recommended to initiate your bug report from within Blender. Doing so allows Blender to automatically populate
a number of fields in the bug report template including your computer configuration, operating system, and specific
Blender build.

To initiate a bug report:

- Select Topbar ‣ Help ‣ Report a Bug from the menu. This will open your default web browser to
  the bug reporting page on blender.org with some of your information prepopulated.
- Give the bug a clear, easy-to-understand title - try to avoid long run-on sentences.
- Enter details about the steps to reproduce the bug. Bugs that are not consistently reproducible may be more
  difficult to track down, so provide any additional information that you can. Make sure to fill in the **Short
  description of error** and the **Exact steps for others to reproduce the error** sections.
- Attach any pictures if you feel they will help the developers understand the issue more clearly. Videos can also be
  attached, but please only do so if it is absolutely required to show the issue.
- If a crash occurs, attach a crash log as discussed below: [Attaching a Crash Log](#attaching-a-crash-log).
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Tools can have their own settings, which are available from multiple places:

- The Tool ‣ Active Tool panel in the Sidebar `N`.
- The *Active Tool* tab in the [Properties editor](../editors/properties_editor.xhtml).
- The *Tool Settings* region below the area header.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: By default, the node has no input sockets.
Inputs can be added by dragging an output from another node onto the blank socket area,
or by adding new inputs in the *Images/Layers* panel.

Each input corresponds to an image that will be written to disk.
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: Closures define outputs that return values to the node tree in which they are evaluated.
Outputs can be created by dragging a socket from within the zone into the blank socket on the closure’s output, or by
adding sockets manually in the node’s properties.
user: Describe SubtractStrip(EffectStrip) from the Blender manual or Python API, including usage steps and snippets.

assistant: # SubtractStrip(EffectStrip)

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

*class* bpy.types.SubtractStrip(*EffectStrip*)
:   Subtract Strip

    input_1
    :   First input for the effect strip

        Type:
        :   [`Strip`](bpy.types.Strip.html#bpy.types.Strip "bpy.types.Strip"), (never None)

    input_2
    :   Second input for the effect strip

        Type:
        :   [`Strip`](bpy.types.Strip.html#bpy.types.Strip "bpy.types.Strip"), (never None)

    input_count
    :   Type:
        :   int in [0, inf], default 0, (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: Explain Transform Brushes in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Recognizable by their yellow icon and cursor.
These brushes generally move, pinch and magnify the mesh.

Pinch/Magnify
:   Brush Type: [Pinch](pinch.xhtml)

    Shortcut: `P`

    Pulls vertices towards the center of the brush. Useful for polishing angles and creases. Alternatively pushes them
    away from the center.

Grab
:   Brush Type: [Grab](grab.xhtml)

    Shortcut: `G`

    Moves vertices along with the mouse. An essential brush for building shapes and adjusting proportions.

Grab 2D
:   Brush Type: [Grab](grab.xhtml)

    Similar to Grab but with an infinitely projected falloff. Useful for grabbing broader shapes and giving a similar
    feel to using Liquify tools in image painting applications.

Grab Silhouette
:   Brush Type: [Grab](grab.xhtml)

    Similar to Grab but only affects vertices with the normal facing sideways away from the view. Very useful for
    adjusting outer silhouettes of thin objects.

Elastic Grab
:   Brush Type: [Elastic Deform](elastic_deform.xhtml)

    Used to simulate realistic deformations from grabbing of [Elastic](../../../glossary/index.xhtml#term-Elastic) objects.

Elastic Snake Hook
:   Brush Type: [Snake Hook](snake_hook.xhtml)

    Similar to Elastic Grab but rotates affected geometry based on the stroke direction.

Snake Hook
:   Brush Type: [Snake Hook](snake_hook.xhtml)

    Shortcut: `K`

    Pulls vertices along with the stroke to create long, snake-like forms. Geometry is rotated and magnified to allow
    continuous pulling. Much more useful while having [Dyntopo](../introduction/adaptive.xhtml#dyntopo-introduction) enabled.

Pull
:   Brush Type: [Snake Hook](snake_hook.xhtml)

    Iteratively picks up and lets go of geometry like the Snake Hook, but much softer. Useful for subtle small scale
    deforming over longer strokes.

Thumb
:   Brush Type: [Thumb](thumb.xhtml)

    Same as *Grab* but moves vertices along the surface direction. Useful for preserving specific surfaces.

Pose
:   Brush Type: [Pose](pose.xhtml)

    Simulating an armature-like deformations. Useful for quick posing and transformations.

Nudge
:   Brush Type: [Nudge](nudge.xhtml)

    Similar as *Thumb* but dynamically picks up vertices like the *Snake Hook*.
    Useful for nudging something along the mesh surface.

Twist
:   Brush Type: [Rotate](rotate.xhtml)

    Rotates vertices within the brush in the direction the cursor is moved.

Relax Slide
:   Brush Type: [Relax Slide](slide_relax.xhtml)

    Slides the topology of the mesh in the direction of the stroke
    while preserving the geometrical shape of the mesh. Alternatively smooths the mesh on ‘Shift’.
    Also useful for redistributing topology where it is needed.

Relax Pinch
:   Brush Type: [Relax Slide](slide_relax.xhtml)

    Similar to the Relax Slide brush but pinches/relaxes geometry instead.

Boundary
:   Brush Type: [Boundary](boundary.xhtml)

    Transform specifically mesh boundaries with various deformations.