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

assistant: This section lists useful generic operations which can be used.

### Key Bindings for Pop-Ups

Menus and panels can be assigned key shortcuts,
even if they’re only accessible from submenus elsewhere.

Open a Pop-up Menu (`wm.call_menu`)
:   Open any menu on key press.

Open a Pie Menu (`wm.call_menu_pie`)
:   Open any pie menu on key press.

Open a Panel (`wm.call_panel`)
:   Open a pop-up panel (also known as a pop-over).

#### Menu & Panel Identifiers

To find the `name` of a menu,
enable the preference Interface ‣ Display ‣ Python Tooltips.

Then hover the cursor over the popover button or menu item.
For submenus you will need to use the back arrow to prevent the submenu from opening and gaining focus.

### Key Bindings for Properties

There are many properties you might want to bind a key with.
To avoid having to define operators for each property,
there are generic operators for this purpose:

Operators for adjusting properties begin with `wm.context_`.

Some of these include:

- `wm.context_toggle` toggle a Boolean property.
- `wm.context_cycle_enum` cycle an enum property forwards or backwards.
- `wm.context_menu_enum` show a pop-up menu for an enum property.
- `wm.context_pie_enum` show a pie menu for an enum property.
- `wm.context_scale_float` scale a number (used for increasing / decreasing brush size for example).
- `wm.context_toggle_enum` toggle between two options of an enum.
- `wm.context_modal_mouse` moving the cursor to interactively change a value.

See [bpy.ops.wm](https://docs.blender.org/api/current/bpy.ops.wm.html) for a complete list.

Each of these operators has a `data_path` setting to reference the property to change.

To find the `data_path`, basic Python knowledge is needed.

For example, you can use the Python Console to access a Boolean property you wish to map to a key:

```
bpy.context.object.show_name
```

To bind this to a key, add a new keymap item using the operator `wm.context_toggle`
with `data_path` set to `object.show_name` (notice the `bpy.context` prefix is implicit).

See [bpy.context](https://docs.blender.org/api/current/bpy.context.html)
for other context attributes.

The Python API documentation can be used to find properties
or you may use the Python Console’s auto-complete to inspect available properties.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Enable
:   A boolean field controlling whether the connected output socket is visible and active.
    When *False*, the corresponding output socket in the group is hidden.

Value
:   The value to pass to the output when it is enabled.
    This input can be any supported data type depending on the node’s *Data Type* property.
user: What is NURBS and how is it used in Blender Python scripting?

assistant: One of the characteristics of a NURBS object is the *knot vector*.
This is a sequence of numbers used to determine the influence of the control points on the curve.
While you cannot edit the knot vectors directly,
you can influence them through the *Endpoint* and *Bézier* options in the Active Spline panel.
Note that, the *Endpoint* and *Bézier* settings only apply to open NURBS curves.

[image reference removed]

Active Spline: NURBS Spline.

Cyclic U
:   See [Common Options](#spline-common-options).

Bézier U
:   Makes the NURBS curve act like a Bézier curve.
    The NURBS control points act like *Free* handles of Bézier curve.

Endpoint U
:   Makes the curve contact the end control points.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_active-spline_nurbs-default.png   Default NURBS curve. | ../../../_images/modeling_curves_properties_active-spline_nurbs-endpoint.png   A NURBS curve with Endpoint enabled. |

Order U
:   The order of the NURBS curve determines the area of influence of the control points over the curve.
    Higher order values means that a single control point has a greater
    influence over a greater relative proportion of the curve.
    The valid range of *Order* values is 2-6 depending on the number of control points present in the curve.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_active-spline_nurbs-default.png   NURBS curves with orders of 4. | ../../../_images/modeling_curves_properties_active-spline_nurbs-order.png   NURBS curves with orders of 2. |

Resolution U
:   See [Common Options](#spline-common-options).

Smooth
:   See [Common Options](#spline-common-options).
user: Provide the full official documentation entry for Color Palette, preserving all code examples.

assistant: Color Palettes are a way of storing a brush’s color so that it can be used at a later time.
This is useful when working with several colors at once.

Palette
:   A [Data-Block Menu](../../interface/controls/templates/data_block.html#ui-data-block) to select a palette.

(New Pallet Color)
:   Adds the current brush’s primary *Color* to the palette.

(Delete Pallet Color)
:   Removes the currently selected color from the palette.

/ (Move Pallet Color)
:   Moves the selected color up/down one position.

(Sort By)
:   Sort Colors by Hue, Saturation, Value, Luminance.

Color List
:   Each color that belongs to the palette is presented in a list.
    Clicking on a color will change the brush’s primary *Color* to that color.
user: Give a detailed overview of Vertex Paint Mode: syntax, arguments, return values, common patterns.

assistant: Vertex Paint Mode is selected from the *Mode* menu in the 3D Viewport header.
Once Vertex Paint Mode is activated, the Toolbar of the 3D Viewport will change to Vertex Paint Mode specific panels.

[image reference removed]

3D Viewport Mode selector set to Vertex Paint Mode.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Color
:   Color of the surface, or physically speaking, the probability that light is refracted for each wavelength.

Roughness
:   Influences sharpness of the refraction; perfectly sharp at 0.0 and smoother with higher values.

Normal
:   Normal used for shading; if nothing is connected the default shading normal is used.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Type
:   *Bands* or *Rings* shaped waves.

Bands/Rings Direction
:   The axis the bands or rings propagate from i.e. which axis they are perpendicular to.
    When using *Bands* a *Diagonal* axis is an option and when using *Rings* the rings
    can propagate outwards from a single point by using *Spherical* direction.

Wave Profile
:   Controls the look of the wave type.

    Saw:
    :   Uses a sawtooth profile.

    Sine:
    :   Uses the standard sine profile.
user: Show practical ways to work with Display Settings in a Blender add-on or script – include code.

assistant: The face sets display can be toggled as a [viewport overlay](../../../editors/3dview/display/overlays.xhtml).
In the overlay popover, the opacity of the face sets overlay can be adjusted
to make it more or less visible on the mesh.
user: Provide the full official documentation entry for Notes on Scripted Expressions, preserving all code examples.

assistant: When a driver uses a *Scripted Expression*, Blender can evaluate it without using
the fully featured Python interpreter if it is simple enough.
This means that drivers are fast to evaluate with simple divisions, additions and other “simple” expressions.
The built-in functions are always evaluated natively.

See [Simple Expressions](drivers_panel.html#drivers-simple-expressions)
for a comprehensive list of expressions that can be evaluated natively.

When the expression is not simple, it will be evaluated using Python.
As a consequence, the driver will be slower and there is a security risk
if the author of the Python code is unknown.
This is an important thing to take into consideration for heavy scenes and
when sharing files with other people.
See also: [Auto run](../../advanced/scripting/security.html).
user: Provide the full official documentation entry for Orbit, preserving all code examples.

assistant: Rotate the view around the point of interest by clicking and dragging
`MMB` on the viewport’s area.

`RMB` cancels the orbit operation.

The `Alt` key has several effects on orbiting:

- Clicking a point with `Alt`-`MMB` will make it the point of interest:
  it becomes the central point which the view orbits around.
- Holding `Alt` and then dragging with `MMB` in a certain direction
  will [align](viewpoint.xhtml) the view to an axis
  and make it orthographic.
- Dragging with `MMB` and then holding `Alt`
  will perform an orbit while also snapping to the world axes,
  as well as the diagonals between them.

To change the viewing angle in discrete steps, use `Numpad8` and `Numpad2`
to go up and down, or `Numpad4` and `Numpad6` for left and right.
You can also press `Numpad9` to switch to the opposite side of the view
(rotates the camera 180° around the Z axis).
user: Describe Specular BSDF from the Blender manual or Python API, including usage steps and snippets.

assistant: # Specular BSDF

[image reference removed]

EEVEE Only

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

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

The specular workflow functions by specifying the facing (along normal) reflection color.
The result may not be physically plausible because there is no energy conservation.
user: What is Output and how is it used in Blender Python scripting?

assistant: There are two ways to render out your audio.
You can either have it encoded with a video file or in its own audio file.
Read more on how to select a proper [audio format](../../../../render/output/properties/output.html#render-output-video-encoding-audio)
and how to start [rendering](../../../../render/output/index.html).
user: Show practical ways to work with Bounces in a Blender add-on or script – include code.

assistant: In reality light will bounce a huge number of times due to the speed of light being very high.
In practice more bounces will introduce more noise, and it might be good to use something like
the Limited Global Illumination preset in the [Light Paths](../render_settings/light_paths.xhtml#render-cycles-integrator-light-paths)
Section that uses *fewer* bounces for different shader types.
Diffuse surfaces typically can get away with fewer bounces,
while glossy surfaces need a few more,
and transmission shaders such as glass usually need the most.

|  |  |  |
| --- | --- | --- |
| ../../../_images/render_cycles_optimizations_reducing-noise_0bounce.jpg   No bounces. | ../../../_images/render_cycles_optimizations_reducing-noise_2bounce.jpg   Two bounces at max. | ../../../_images/render_cycles_optimizations_reducing-noise_4bounce.jpg   Four bounces at max. |

Also important is to use shader colors that do **not** have components of value 1.0 or
values near that; try to keep the maximum value to 0.8 or less and make your lights brighter.
In reality, surfaces are rarely perfectly reflecting all light,
but there are of course exceptions; usually glass will let most light through,
which is why we need more bounces there. High values for the color components tend to
introduce noise because light intensity then does not decrease much as it bounces off each
surface.
user: Show practical ways to work with Extrude Mesh Node in a Blender add-on or script – include code.

assistant: # Extrude Mesh Node

[image reference removed]

The *Extrude Mesh Node* generates new edges or faces on the selected geometry elements
and moves them by a certain offset.

The operations are similar to the [extrude tools](../../../meshes/editing/mesh/extrude.html)
in mesh edit mode, though there are some differences. Most importantly, the node never keeps the back-faces
of the extrusion in place, they are always removed. Attribute propagation rules may also be different.
user: Show practical ways to work with Lens in a Blender add-on or script – include code.

assistant: Focal Length
:   The focal length with which the movie was shot.
    It can be set in millimeters or pixels.

Optical Center
:   Defines the optical center (also known as the *principal point*) of the lens used by the camera.
    In most cases this coincides with the center of the image, but certain lenses may have
    an offset optical center. Refer to the specifications of camera or lens used if needed.

    The values are given in normalized image coordinates.

Lens Distortion
:   Mathematical function to convert distorted to undistorted coordinates.

    Polynomial:
    :   Polynomial radial distortion. Uses three distortion coefficients: K1, K2, and K3.

    Division:
    :   It defines high distortions, which makes this model suitable much better for cameras with fisheye lenses.
        Use two distortion coefficients: K1, K2.

    Nuke:
    :   Distortion model used by the Nuke compositor. Use two distortion coefficients K1, K2.

    Brown:
    :   Brown-Conrady is one of most advanced mathematical lens distortion models.
        Used to model both radial and tangential distortion. Can use up to four
        radial distortion coefficients: K1 - K4 and up to two tangential distortion coefficients: P1 and P2.

Coefficients
:   Coefficients are used to compensate for lens distortion when the movie was shot.
    Currently these values can be tweaked by hand only (there are no calibration tools yet)
    using tools available in Distortion mode. To do this tweak K1 until the solving is the closest to
    the known focal length (but also take grid and annotations into account
    to prevent “impossible” distortion).

    Radial Distortion Coefficients (K1 - K4)
    :   The coefficients in lens distortion models work independent from each other.
        Positive values will give a barrel distortion while negative values give a pincushion distortion.
        With a mixture of both negative and positive coefficients you can define more complicated
        mustache distortions or other complex distortions, that are less common but not rare.

        [image reference removed]

        Example of radial distortion for positive and negative K coefficients.

    Tangential Distortion Coefficients (P1, P2)
    :   Works independent and allow to compensate for situations when the sensor is not
        perpendicular to a group of lens. The optical center (also called principal point)
        will be shifted (distorted) from the center of the sensor.
        P1 is used to compensate for sensor rotation in Z (vertical) axes,
        while P2 is for compensating sensor rotation in X (horizontal) axes.
        Such distortions can be found in sources from cameras with a sensor stabilization system.

        [image reference removed]

        Example of tangential distortion for P coefficients.
user: Give a detailed overview of Examples: syntax, arguments, return values, common patterns.

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

[[image reference removed]](../../../_images/compositing_types_color_rgb-curves_example-common-use.png)

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

### Color Correction using Curves

[[image reference removed]](../../../_images/compositing_types_color_rgb-curves_example-rgb.png)

Color correction with curves.

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

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

### Color Correction using Black/White Levels

[[image reference removed]](../../../_images/compositing_types_color_rgb-curves_black-white-levels.png)

Color correction with Black/White Levels.

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

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

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

### Effects

[[image reference removed]](../../../_images/compositing_types_color_rgb-curves_ex.png)

Changing colors by inverting the red channel.
user: Describe Known Limitations from the Blender manual or Python API, including usage steps and snippets.

assistant: - Highly memory demanding: All mesh objects in a view layer are loaded at once.
- Only faced mesh objects are supported.
- No edges at face intersections are detected yet.
- Freestyle rendering results do not have any Z depth information.
- Panoramic cameras are not supported.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Image
:   Standard color input.

Factor
:   Controls the amount of influence the node exerts on the output image.

Type
:   The Soften, Laplace, Sobel, Prewitt and Kirsch all perform edge detection
    (in slightly different ways) based on vector calculus and set theory equations.

    Soften:
    :   Slightly blurs the image.

    Box Sharpen:
    :   Increases the contrast, especially at edges.

    Diamond Sharpen:
    :   Less aggressive than box sharpen, reducing sharpening artifacts.

    Laplace:
    :   Edge highlighting filter susceptible to highlighting visual noise.

    Sobel:
    :   Creates a negative image that highlights edges.

    Prewitt:
    :   Produces a similar results to Sobel.

    Kirsch:
    :   Gives better blending than Sobel or Prewitt, when approaching an edge.

    Shadow:
    :   Performs a relief, emboss effect, darkening outside edges.
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: To use Open Shading Language (OSL) in Blender, follow these steps:

1. **Enable OSL Rendering**

   In the Render Properties enable
   [Open Shading Language](../render_settings/index.xhtml#bpy-types-cyclesrendersettings-shading-system).
2. **Add a Script Node**

   In the Shader Editor add [Script Node](../../shader_nodes/utilities/script.xhtml) then in the node’s properties:

   - Set the *Mode* to *Internal* to use a Blender text data-block, or
   - Set it to *External* to load a shader file from disk (either .osl or compiled .oso).

   For the internal mode, create a new text data-block in the Text Editor,
   then write or paste your OSL code there.

   Blender will compile the OSL source file automatically.
   If the source is .osl, it will be compiled into .oso bytecode.
   Compilation errors will be shown in the system console.
3. **Use Shader Outputs**

   Once compiled, the node’s outputs will reflect the `output` parameters defined in the OSL code.
   These outputs can be connected to any part of the material node tree.
user: Describe Collection Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Collection Node

[image reference removed]

The *Collection* input node outputs a single collection. It can be connected to other collection sockets
to make using the same collection in multiple places more convenient.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeMenuSwitch.active_item`](bpy.types.GeometryNodeMenuSwitch.html#bpy.types.GeometryNodeMenuSwitch.active_item "bpy.types.GeometryNodeMenuSwitch.active_item") - [`GeometryNodeMenuSwitch.enum_items`](bpy.types.GeometryNodeMenuSwitch.html#bpy.types.GeometryNodeMenuSwitch.enum_items "bpy.types.GeometryNodeMenuSwitch.enum_items") | - [`NodeMenuSwitchItems.new`](bpy.types.NodeMenuSwitchItems.html#bpy.types.NodeMenuSwitchItems.new "bpy.types.NodeMenuSwitchItems.new") - [`NodeMenuSwitchItems.remove`](bpy.types.NodeMenuSwitchItems.html#bpy.types.NodeMenuSwitchItems.remove "bpy.types.NodeMenuSwitchItems.remove") |
user: Describe Face Sets from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Face sets are used to group your mesh into differently colored faces,
which can then be quickly hidden or shown like mentioned above.
They can also be used for fast mask creation via the [Mask Expand](../editing/expand.xhtml#bpy-ops-sculpt-expand).
[Face Set Expand](../editing/expand.xhtml#face-set-expand) is also useful for creating, editing and joining face sets.

More options can be found in the `Alt`-`W` pie menu.

[image reference removed]

Otherwise Face Sets can be created/edited with the
[Draw Face Sets](../brushes/draw_facesets.xhtml) brush,
[Mask Gesture Tools](../tools/mask_tools.xhtml).
They can also be edited with the
[Edit Face Set](../tools/edit_face_set.xhtml) tool.

Internally, face sets are stored using the `sculpt_face_set` [Attributes](../../../modeling/geometry_nodes/attributes_reference.xhtml).
user: Describe Switch Direction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Switch Direction

This tool allows you to switch the direction of the selected bones
(i.e. their root will become their tip, and vice versa).

Switching the direction of a bone will generally break the chain(s) it belongs to.
However, if you switch a whole (part of a) chain, the switched bones will still be parented/connected,
but in “reversed order”. See the Fig. [Switching example.](#fig-rig-properties-switch).

Switching example.

|  |  |
| --- | --- |
| ../../../../_images/animation_armatures_bones_editing_switch-direction_example-1.png   An armature with one selected bone, and one selected chain of three bones, just before switching. | ../../../../_images/animation_armatures_bones_editing_switch-direction_example-2.png   The selected bones have been switched. Bone.005 is no more connected nor parented to anything. The chain of switched bones still exists, but reversed (now Bone.002 is its root, and Bone is its tip). Bone.003 is now a free bone. |
user: Show practical ways to work with Roll in a Blender add-on or script – include code.

assistant: Rotate the viewport camera around its viewing direction in 15° discrete steps by default.
See the [rotation angle](../../preferences/navigation.xhtml#bpy-types-preferencesview-rotation-angle) preference to configure.

To reset the roll, you can first align the view to the global X axis
using `Numpad3`, then orbit to get back to the regular perspective view.

`RMB` cancels the roll operation.
user: How do I use Other Options in Blender? Include parameters, examples, warnings and best practices.

assistant: `--disable-depsgraph-on-file-load`
:   Background mode: Do not systematically build and evaluate ViewLayers’ dependency graphs
    when loading a blend-file in background mode (`-b` or `-c` options).

    Scripts requiring evaluated data then need to explicitly ensure that
    an evaluated depsgraph is available
    (e.g. by calling `depsgraph = context.evaluated_depsgraph_get()`).

    NOTE: this is a temporary option, in the future depsgraph will never be
    automatically generated on file load in background mode.

`--disable-liboverride-auto-resync`
:   Do not perform library override automatic resync when loading a new blend-file.

    NOTE: this is an alternative way to get the same effect as when setting the
    `No Override Auto Resync` User Preferences Debug option.

`--debug-ffmpeg`
:   Enable debug messages from FFmpeg video input and output.

`--debug-cycles`
:   Enable debug messages from Cycles.
user: What is Enabling Add-on and how is it used in Blender Python scripting?

assistant: This add-on is enabled by default, in case it is not:

1. Open Blender and go to [Add-ons](../../editors/preferences/addons.html) section of the [Preferences](../../editors/preferences/index.html).
2. Search “glTF 2.0” and check the *Enable Add-on* checkbox.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeSimulationOutput.active_item`](bpy.types.GeometryNodeSimulationOutput.html#bpy.types.GeometryNodeSimulationOutput.active_item "bpy.types.GeometryNodeSimulationOutput.active_item") - [`GeometryNodeSimulationOutput.state_items`](bpy.types.GeometryNodeSimulationOutput.html#bpy.types.GeometryNodeSimulationOutput.state_items "bpy.types.GeometryNodeSimulationOutput.state_items") | - [`NodeGeometrySimulationOutputItems.new`](bpy.types.NodeGeometrySimulationOutputItems.html#bpy.types.NodeGeometrySimulationOutputItems.new "bpy.types.NodeGeometrySimulationOutputItems.new") - [`NodeGeometrySimulationOutputItems.remove`](bpy.types.NodeGeometrySimulationOutputItems.html#bpy.types.NodeGeometrySimulationOutputItems.remove "bpy.types.NodeGeometrySimulationOutputItems.remove") |
user: Provide the full official documentation entry for Orientation, preserving all code examples.

assistant: Scene orientation tools can be used for orienting object to bundles.

Floor
:   See [Set Origin](../editing/reconstruction.xhtml#bpy-ops-clip-set-origin).

Wall
:   See [Set Floor](../editing/reconstruction.xhtml#bpy-ops-clip-set-plane).

Set Origin
:   See [Set Floor](../editing/reconstruction.xhtml#bpy-ops-clip-set-plane).

Set X, Y Axis
:   See [Set X/Y Axis](../editing/reconstruction.xhtml#bpy-ops-clip-set-axis).

Set Scale
:   See [Set Scale](../editing/reconstruction.xhtml#bpy-ops-clip-set-scale).

Apply Scale
:   See [Apply Solution Scale](../editing/reconstruction.xhtml#bpy-ops-clip-apply-solution-scale).

Distance
:   Distance in active scene units which is used by Set/Apply scale.
user: How do I use Undo & Redo in Blender? Include parameters, examples, warnings and best practices.

assistant: # Undo & Redo

The tools listed below will let you roll back an accidental action,
redo your last action, or let you choose to recover to a specific point,
by picking from a list of recent actions recorded by Blender.
user: Describe Header from the Blender manual or Python API, including usage steps and snippets.

assistant: Shader Type
:   The type of data whose shader nodes are being edited:

    Object:
    :   Edit shader nodes for the active object’s [Material](../render/materials/index.xhtml).

    World:
    :   Edit shader nodes for the [World background](../render/lights/world.xhtml).

    Line Style:
    :   Edit shader nodes for Freestyle [Line Styles](../render/freestyle/view_layer/line_style/index.xhtml)

Use Nodes Line Style
:   Use shader nodes to define the texture for the freestyle line style.

Slot
:   The *Slot* menu can be used to select
    the active [material slot](../render/materials/assignment.xhtml#bpy-types-materialslot) on the active object.
    The material selector to the right of it can change the material that is in the selected slot.

/ Pinned
:   Keeps the current material selection visible in the Shader editor
    even when another object or material is selected elsewhere.
user: Give a detailed overview of Move, Rotate, Scale: syntax, arguments, return values, common patterns.

assistant: # Move, Rotate, Scale

Once you have a selection of one or more elements, you can move `G`,
rotate `R` or scale `S` them, like many other things in Blender,
as described in the [Manipulation in 3D Space](../../../../../scene_layout/object/editing/transform/introduction.xhtml) section.
To move, rotate and scale selected components, either use the *Move*, *Rotate*, and *Scale* buttons,
the [transform gizmos](../../../../../editors/3dview/display/gizmo.xhtml),
or the shortcuts: `G`, `R`, and `S` respectively.

After moving a selection, the options in the [Adjust Last Operation](../../../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel allow you to
fine-tune your changes, limit the effect to certain axes, turn Proportional Editing on and off, etc.
Of course, when you move an element of a given type (e.g. an edge),
you also modify the implicitly related elements of other kinds (e.g. vertices and faces).

Pressing `G` twice enters either *Edge Slide* or *Vertex Slide* tool depending on the selection.
You also have in *Edit Mode* an extra option when using these basic manipulations:
the [Proportional Editing](../../../../../editors/3dview/controls/proportional_editing.xhtml).
user: How do I use Bundle Dependencies in Blender? Include parameters, examples, warnings and best practices.

assistant: For add-ons to be bundled as extensions, they must be self-contained.
That means they must come with all its dependencies. In particular 3rd party Python modules.

There are a few options for this:

Bundle with [Python Wheels](python_wheels.html#extensions-python-wheels).
:   This is the recommended way to bundle dependencies.

Bundle other add-ons together.
:   This is recommended if an add-on depends on another add-on.

    Make sure that both the individual and the combined add-on
    check for already registered types (Operators, Panels, …).
    This avoids duplication of operators and panels on the interface
    if the add-ons are installed as a bundle and individually.

Bundle with [Vendorize](https://pypi.org/project/vendorize)
:   This can be used as a way to bundle a pure Python dependencies as a sub-module.

    This has the advantage of avoiding version conflicts although it requires some work to setup each package.
user: Explain Fluid in complete detail according to the official Blender documentation.

assistant: # Fluid

[image reference removed]

Fluid Physics settings.

Fluid particles are similar to Newtonian ones but this time particles are influenced by
internal forces like pressure, surface tension, viscosity, springs, etc.
From liquids to slime, goo to sand and wispy smoke the number of possible use cases is endless.

Blender particle fluids use the SPH techniques to solve the particles fluid equations.
Smoothed-particle hydrodynamics (SPH) is a computational method used for simulating fluid flows.
It has been used in many fields of research, including astrophysics, ballistics, vulcanology,
and oceanography. It is a mesh-free Lagrangian method (where the coordinates move with the fluid),
and the resolution of the method can easily be adjusted with respect to variables such as the density.
user: Give a detailed overview of Saving your Composite Image: syntax, arguments, return values, common patterns.

assistant: The *Render* button renders a single frame or image.
Save your image using [Save Image](../editors/image/editing.xhtml#bpy-ops-image-save).
The image will be saved using the image format settings on the Render panel.

To save a sequence of images, for example,
if you input a movie clip or used a Time node with each frame in its own file,
use the *Animation* button and its settings. If you might want to later overlay them,
be sure to use an image format that supports an Alpha channel (such as `PNG`).
If you might want to later arrange them front to back or create a depth of field effect,
use a format that supports a Z-depth channel (such as `EXR`).

To save a composition as a movie clip (all frames in a single file),
use an `AVI` or `QuickTime` format, and use the *Animation* button and its settings.
user: How do I use Startup Scene in Blender? Include parameters, examples, warnings and best practices.

assistant: # Startup Scene

After closing the [splash screen](../../interface/window_system/splash.xhtml),
the startup scene is displayed in the 3D Viewport (if no other blend-file was loaded).
This startup scene can be [customized](../../interface/window_system/topbar.xhtml#startup-file).

[image reference removed]

The startup scene.
user: What is Using Operators and how is it used in Blender Python scripting?

assistant: # Using Operators

Blender’s operators are tools for users to access, that can be accessed with Python too which is very useful.
Still operators have limitations that can make them cumbersome to script.

The main limits are:

- Can’t pass data such as objects, meshes or materials to operate on (operators use the context instead).
- The return value from calling an operator is the success (if it finished or was canceled),
  in some cases it would be more logical from an API perspective to return the result of the operation.
- Operators’ poll function can fail where an API function would raise an exception giving details on exactly why.
user: Provide the full official documentation entry for Examples, preserving all code examples.

assistant: [image reference removed]

Input is Mesh Plane. First [Subdivide Mesh Node](../mesh/operations/subdivide_mesh.xhtml) add some
faces for capture color with [Random Value Node](../utilities/random_value.xhtml)
used as hue in [Combine Color Node](../color/combine_color.xhtml) on this.
Now second [Subdivide Mesh Node](../mesh/operations/subdivide_mesh.xhtml) split each face on a lot of new.
Each one new duplicates original attribute.
Blur Attribute node mixes all attributes for each face. Due to this, the result is smoothed.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`ImageStrip.elements`](bpy.types.ImageStrip.html#bpy.types.ImageStrip.elements "bpy.types.ImageStrip.elements") - [`MovieStrip.elements`](bpy.types.MovieStrip.html#bpy.types.MovieStrip.elements "bpy.types.MovieStrip.elements") | - [`Strip.strip_elem_from_frame`](bpy.types.Strip.html#bpy.types.Strip.strip_elem_from_frame "bpy.types.Strip.strip_elem_from_frame") - [`StripElements.append`](bpy.types.StripElements.html#bpy.types.StripElements.append "bpy.types.StripElements.append") |
user: Explain ThemeRegionsChannels(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # ThemeRegionsChannels(bpy_struct)

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

*class* bpy.types.ThemeRegionsChannels(*bpy_struct*)
:   back
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    text
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    text_selected
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.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: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Color
:   Color of the hair.

Offset
:   Controls the way the light is rotated (angular shift) for the reflection/transmission.

    [image reference removed]

    Reflection Offset.

    [image reference removed]

    Transmission Offset.

Roughness U/V
:   Controls the roughness in the direction light is skewed, and perpendicular to it.

    |  |  |
    | --- | --- |
    | ../../../_images/render_shader-nodes_shader_hair_reflect-roughness-uv.png   Roughness when using the Reflection Component. | ../../../_images/render_shader-nodes_shader_hair_trans-roughness-uv.png   Roughness when using the Transmission Component. |

Tangent
:   Input tangent.
user: What is Id Type Items and how is it used in Blender Python scripting?

assistant: # Id Type Items

ACTION:
:   Action.

ARMATURE:
:   Armature.

BRUSH:
:   Brush.

CACHEFILE:
:   Cache File.

CAMERA:
:   Camera.

COLLECTION:
:   Collection.

CURVE:
:   Curve.

CURVES:
:   Curves.

FONT:
:   Font.

GREASEPENCIL:
:   Grease Pencil.

GREASEPENCIL_V3:
:   Grease Pencil v3.

IMAGE:
:   Image.

KEY:
:   Key.

LATTICE:
:   Lattice.

LIBRARY:
:   Library.

LIGHT:
:   Light.

LIGHT_PROBE:
:   Light Probe.

LINESTYLE:
:   Line Style.

MASK:
:   Mask.

MATERIAL:
:   Material.

MESH:
:   Mesh.

META:
:   Metaball.

MOVIECLIP:
:   Movie Clip.

NODETREE:
:   Node Tree.

OBJECT:
:   Object.

PAINTCURVE:
:   Paint Curve.

PALETTE:
:   Palette.

PARTICLE:
:   Particle.

POINTCLOUD:
:   Point Cloud.

SCENE:
:   Scene.

SCREEN:
:   Screen.

SOUND:
:   Sound.

SPEAKER:
:   Speaker.

TEXT:
:   Text.

TEXTURE:
:   Texture.

VOLUME:
:   Volume.

WINDOWMANAGER:
:   Window Manager.

WORKSPACE:
:   Workspace.

WORLD:
:   World.
user: Provide the full official documentation entry for Radial Tiling Node, preserving all code examples.

assistant: # Radial Tiling Node

[image reference removed]

The *Radial Tiling Node* provides the ability to divide a 2D cartesian input coordinate system
into as many radial segments as specified by the *Sides* input.
Each segment has its own affinely transformed segment coordinate system,
which can be used to tile textures in a radially symmetric manner.
user: Give a detailed overview of GeometryNodeBoundBox(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeBoundBox(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.GeometryNodeBoundBox(*GeometryNode*)
:   Calculate the limits of a geometry’s positions and generate a box mesh with those dimensions

    *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 LineStyleGeometryModifier_Polygonalization(LineStyleGeometryModifier) and how is it used in Blender Python scripting?

assistant: # LineStyleGeometryModifier_Polygonalization(LineStyleGeometryModifier)

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

*class* bpy.types.LineStyleGeometryModifier_Polygonalization(*LineStyleGeometryModifier*)
:   Modify the stroke geometry so that it looks more ‘polygonal’

    error
    :   Maximum distance between the original stroke and its polygonal approximation

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Geometry Modifier Type Items](bpy_types_enum_items/linestyle_geometry_modifier_type_items.html#rna-enum-linestyle-geometry-modifier-type-items), default `'2D_OFFSET'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleGeometryModifier_Polygonalization.type "bpy.types.LineStyleGeometryModifier_Polygonalization.type")
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Segment Length
:   The distance between the current point and its previous point on the same curve.
    This can be used for evaluating curve smoothness, detecting segment stretching,
    or applying deformation relative to curve length.

Segment Direction
:   A normalized vector pointing from the previous point toward the current point.
    It represents the local tangent direction of the curve segment.

Neighbor Index
:   The index of the previous neighboring point along the curve.
    This can be used to reference or sample attributes from adjacent points.
user: Explain ShaderNodeTree(NodeTree) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeTree(NodeTree)

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

*class* bpy.types.ShaderNodeTree(*NodeTree*)
:   Node tree consisting of linked nodes used for materials (and other shading data-blocks)

    get_output_node(*target*)
    :   Return active shader output node for the specified target

        Parameters:
        :   **target** (enum in [`'ALL'`, `'EEVEE'`, `'CYCLES'`]) –

            Target

            - `ALL`
              All – Use shaders for all renderers and viewports, unless there exists a more specific output.
            - `EEVEE`
              EEVEE – Use shaders for EEVEE renderer.
            - `CYCLES`
              Cycles – Use shaders for Cycles renderer.

        Returns:
        :   Node

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

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

assistant: # NodeCustomGroup(Node)

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

*class* bpy.types.NodeCustomGroup(*Node*)
:   Base node type for custom registered node group types

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

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

assistant: Materials with emission shaders can be configured to use
Multiple Importance Sampling ([Material Settings](../material_settings.xhtml)).
This means that they will get rays sent directly towards them,
rather than ending up there based on rays randomly bouncing around.
For very bright mesh light sources, this can reduce noise significantly.
However, when the emission is not particularly bright,
this will take samples away from other brighter light sources for which it is important to find them this way.

The optimal setting here is difficult to guess; it may be a matter of trial and error,
but often it is clear that a somewhat glowing object may be only contributing light locally,
while a mesh light used as a light would need this option enabled.
Here is an example where the emissive spheres contribute little to the lighting,
and the image renders with slightly less noise by disabling Multiple Importance on them.

|  |  |
| --- | --- |
| ../../../_images/render_cycles_optimizations_reducing-noise_sample-lamp.jpg   Multiple Importance off. | ../../../_images/render_cycles_optimizations_reducing-noise_no-sample-lamp.jpg   Multiple Importance on. |

The world background also has a *Multiple Importance* ([Settings](../world_settings.xhtml#render-cycles-integrator-world-settings)) option.
This is mostly useful for environment maps that have small bright spots in them, rather than being smooth.
This option will then, in a preprocess, determine the bright spots, and send light rays directly towards them. Again,
enabling this option may take samples away from more important light sources if it is not needed.