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

assistant: Target Geometry
:   Geometry that rays are tested against.

Attribute
:   An optional field input evaluated on the *Target Geometry* that will be interpolated at the hit points.
    The resulting values are outputted with the *Attribute* output.

Interpolation
:   How attributes of the target mesh are mapped to the attribute values on the result geometry.

    Interpolated:
    :   Vertex and corner attributes are interpolated smoothly, with a bilinear function.

    Nearest:
    :   Choose the value of the closest vertex without interpolating.

Source Position
:   The position from where to start each ray. By default, this is the same as
    if the [Position Node](../read/position.html) was connected.

Ray Direction
:   Direction of each ray from the starting position.
    The field is evaluated on the geometry from the context of the field evaluation, not the *Target Geometry*.

Ray Length
:   Maximum distance a ray can travel before being considered “no hit”.
user: Give a detailed overview of Working with Rigid Bodies: syntax, arguments, return values, common patterns.

assistant: Several object operators exist for working with rigid bodies,
these operators can be found in the [Rigid Body](../../scene_layout/object/editing/rigid_body.xhtml) object menu.
These operators include functions to add/remove rigid bodies, modify their properties,
and add [Rigid Body Constraints](constraints/index.xhtml).
user: Provide the full official documentation entry for Fly/Walk Navigation, preserving all code examples.

assistant: # Fly/Walk Navigation

The standard navigation controls are sometimes limiting,
especially for large environments such as architectural models.
In these cases, it may be preferable to use first person controls instead,
where you can look around while “standing” in one place
rather than orbiting around a central viewpoint.

Blender offers two such alternative navigation methods: Flying and Walking.
You can initiate either method from the View ‣ Navigation
menu. You can also initiate your preferred one (configured
in the [Preferences](../../preferences/navigation.xhtml))
by pressing `Shift`-`AccentGrave`.

[image reference removed]

View Navigation.

Common use cases for Fly/Walk include:

Navigating
:   This can be a quick way to navigate a large scene.

Positioning a camera
:   When activated from a camera view `Numpad0`,
    the camera will move along with you.

Recording camera movement
:   You can record the path you take by entering a camera view, enabling
    [Auto Keying](../../../animation/animation_editors.xhtml#bpy-types-toolsettings-use-keyframe-insert-auto),
    starting animation playback, and finally activating Fly/Walk navigation.
    The path will be recorded as camera keyframes which can then be
    used for rendering.

    Animation playback can’t be controlled while Fly/Walk navigation is active,
    so when you’re done recording, you first need to exit the navigation
    with `LMB` before you can stop playback.
user: Describe Blend-File Preview from the Blender manual or Python API, including usage steps and snippets.

assistant: Blender saves by default a small preview of current scene in the blend-file.
This will show in the *Thumbnail* view of the [File Browser](../../editors/file_browser.html).

During its installation, Blender also adds a small tool to your OS,
that will allow your system file browser to show those previews as file thumbnails as well.

### macOS

The Blender Thumbnail extension can be disabled in the System Settings under “Login Items & Extensions”,
within the Quick Look category.
user: Show practical ways to work with Pull Requests in a Blender add-on or script – include code.

assistant: # Pull Requests

This page describes the tools used for code contribution and review.

Reviews are a key measure to assure changes are of a good quality. They help preventing bugs, design consistencies, or
potential maintenance problems. And having your work reviewed also generally keeps you on your toes.
user: How do I use Image Menu in Blender? Include parameters, examples, warnings and best practices.

assistant: Transform
:   Move Origin `Ctrl`-`Period`
    :   Moves the origin of the image strip without changing the strip’s content position.

        This is useful for adjusting the reference point for transformations like rotation, scaling, or further
        positioning. For example, shifting the origin to a corner of the image allows rotations to pivot around that
        corner, rather than the default center.

Clear
:   Resets the position, rotation, or scale of the selected images.

Apply
:   Scale to Fit
    :   Resizes the selected images so that they’re as large as possible while still
        fitting completely inside the video. They don’t get cropped, and their aspect ratio
        stays the same.

    Scale to Fill
    :   Resizes the selected images to that they fill the entire video space.
        They may get cropped, but their aspect ratio stays the same.

    Stretch to Fill
    :   Resizes the selected images to match the video dimensions.
        They don’t get cropped, but their aspect ratio may change.
user: What is Examples and how is it used in Blender Python scripting?

assistant: # Examples

To start with cloth, the first thing you need, of course, is some fabric. So,
let us delete the default cube and add a plane. In order to get some good floppy and flexible fabric,
you will need to subdivide it several times, about eight is a good number.
So `Tab` into *Edit Mode* and subdivide the mesh a couple of times.

Now, we will make this cloth by going to the Physics tab.
Scroll down until you see the *Cloth* panel, and press the *Cloth* button.
Now, a lot of settings will appear, most of which we will ignore for now.

That is all you need to do to set your cloth up for animating,
but if you playback the animation, the drop of your newly created fabric will be quite unspectacular.
That is what we will cover in the next two sections about pinning and colliding.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.cloth`](bpy.context.html#bpy.context.cloth "bpy.context.cloth") | - [`ParticleSystem.cloth`](bpy.types.ParticleSystem.html#bpy.types.ParticleSystem.cloth "bpy.types.ParticleSystem.cloth") |
user: Provide the full official documentation entry for Import VDB Node, preserving all code examples.

assistant: # Import VDB Node

[image reference removed]

The *Import VDB* node loads volumetric data from a .vdb file
and outputs it as a [Volume](../../../volumes/introduction.xhtml) geometry.
All grids present in the file are loaded and included in the resulting volume.

This node is useful for importing simulation data or procedural volumes created in external software.
user: Provide the full official documentation entry for Shape, preserving all code examples.

assistant: Most of the settings in the *Shape* panel are shared with those of
[Curves](../curves/properties/shape.html)
data-blocks, please refer to those for details.

Fast Editing
:   Does not fill the letters in Edit Mode, only show their outline.
user: Explain VOLUME_UL_grids(UIList) in complete detail according to the official Blender documentation.

assistant: # VOLUME_UL_grids(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.VOLUME_UL_grids(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *grid*, *_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: Give a detailed overview of MovieClipProxy(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # MovieClipProxy(bpy_struct)

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

*class* bpy.types.MovieClipProxy(*bpy_struct*)
:   Proxy parameters for a movie clip

    build_100
    :   Build proxy resolution 100% of the original footage dimension

        Type:
        :   boolean, default False

    build_25
    :   Build proxy resolution 25% of the original footage dimension

        Type:
        :   boolean, default False

    build_50
    :   Build proxy resolution 50% of the original footage dimension

        Type:
        :   boolean, default False

    build_75
    :   Build proxy resolution 75% of the original footage dimension

        Type:
        :   boolean, default False

    build_record_run
    :   Build record run time code index

        Type:
        :   boolean, default False

    build_undistorted_100
    :   Build proxy resolution 100% of the original undistorted footage dimension

        Type:
        :   boolean, default False

    build_undistorted_25
    :   Build proxy resolution 25% of the original undistorted footage dimension

        Type:
        :   boolean, default False

    build_undistorted_50
    :   Build proxy resolution 50% of the original undistorted footage dimension

        Type:
        :   boolean, default False

    build_undistorted_75
    :   Build proxy resolution 75% of the original undistorted footage dimension

        Type:
        :   boolean, default False

    directory
    :   Location to store the proxy files

        Type:
        :   string, default “”, (never None, blend relative `//` prefix supported)

    quality
    :   JPEG quality of proxy images

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

    timecode
    :   - `NONE`
          None – Ignore generated timecodes, seek in movie stream based on calculated timestamp.
        - `RECORD_RUN`
          Record Run – Seek based on timestamps read from movie stream, giving the best match between scene and movie times.
        - `FREE_RUN_NO_GAPS`
          Record Run No Gaps – Effectively convert movie to an image sequence, ignoring incomplete or dropped frames, and changes in frame rate.

        Type:
        :   enum in [`'NONE'`, `'RECORD_RUN'`, `'FREE_RUN_NO_GAPS'`], default `'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: Provide the full official documentation entry for Collections Menu, preserving all code examples.

assistant: The *Collections* menu provides tools for organizing and managing objects within collections.
Collections are used to group objects for easier scene organization,
visibility control, and rendering management.
Objects can belong to one or multiple collections, allowing flexible structuring of complex scenes.

Move to Collection `M`
:   Moves the selected objects to a different collection.
    The menu allows choosing an existing collection, creating a new one,
    or moving the objects to the *Scene Collection* (the root level of the scene).
    Once moved, the objects are removed from their previous collection unless they are also linked elsewhere.

Link to Collection `Shift`-`M`
:   Links the selected objects to an additional collection without removing them from their existing collections.
    This allows the same object to appear in multiple collections simultaneously,
    useful for managing shared elements across different scene layers or views.
    A new collection can also be created from the menu.

Create New Collection `Ctrl`-`G`
:   Creates a new collection and adds the selected object(s) to it.
    The name of the new collection can be specified in
    the *Create New Collection* [Adjust Last Operation](../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.
    This collection is not linked to the active scene.

Remove from Collection `Ctrl`-`Alt`-`G`
:   Remove the selected objects from a collection. If the object belongs to more than one collection,
    a pop-up lets you select the collection and an option to remove it from all collections.

Remove from All Collections `Shift`-`Ctrl`-`Alt`-`G`
:   Remove the selected objects from all collections.

Add Selected to Active Objects Collection `Shift`-`Ctrl`-`G`
:   Adds the selected objects to one of the collections active object belongs to.
    Optionally add to "All Collections"
    to ensure selected objects are included in the same collections as the active object.

Remove Selected from Active Collection `Shift`-`Alt`-`G`
:   Causes the selected objects to be removed from the collections to which the active object belongs.

Hide Other Collections `Ctrl`-`H`
:   Hides collections which were not selected.
user: What is Toolbar and how is it used in Blender Python scripting?

assistant: # Toolbar

Curves Edit Mode tools:

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

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

        All objects that intersect the box will be selected.

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

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

Cursor
:   Change the location of the 3D Cursor.

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

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

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

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

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

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

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

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

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

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

[Tilt](../editing/control_points.xhtml#modeling-curves-tilt)
:   Control the rotation value of the control points around the curve’s axis.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: ### Import

Target
:   The motion capture data type.

    Armature:
    :   The bvh-file contains an animated rigged skeleton such as a walking motion capture.

    Object:
    :   The bvh-file contains a static (not animated) mesh object such as a character model.

#### Transform

Scale
:   Factor to increase the physical size of the BVH.

Rotation
:   Rotation order of the BVH.

Forward / Up
:   Since many applications use a different axis for pointing upwards, these are axis conversion for these settings,
    Forward and up axes – By mapping these to different axes you can convert rotations
    between applications default up and forward axes.

    Blender uses Y forward, Z up (since the front view looks along the +Y direction).
    For example, its common for applications to use Y as the up axis, in that case -Z forward, Y up is needed.

#### Animation

Start Frame
:   The start frame, in Blender, to start playback of the BVH animation.

Scale FPS
:   Scales the frame rate from the BVH file to the scene frame rate set in Blender,
    otherwise each BVH frame maps directly to a frame in Blender.

Loop
:   Cycles the animation playback.

Update Scene FPS
:   Set the scene’s frame rate to match the frame rate of the BVH file.

Update Scene Duration
:   Extend the scene’s duration to match the BVH’s duration.

### Export

#### Transform

Scale
:   Factor to increase the physical size of the BVH.

Rotation
:   Rotation order of the BVH.

Root Translation Only
:   Only write the translation animation channels for the root bone.

#### Animation

Start / End
:   Sets the range of animation to export to the BVH file.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.view_layer`](bpy.context.html#bpy.context.view_layer "bpy.context.view_layer") - [`Context.view_layer`](bpy.types.Context.html#bpy.types.Context.view_layer "bpy.types.Context.view_layer") - [`Depsgraph.view_layer`](bpy.types.Depsgraph.html#bpy.types.Depsgraph.view_layer "bpy.types.Depsgraph.view_layer") - [`Depsgraph.view_layer_eval`](bpy.types.Depsgraph.html#bpy.types.Depsgraph.view_layer_eval "bpy.types.Depsgraph.view_layer_eval") - [`ID.override_hierarchy_create`](bpy.types.ID.html#bpy.types.ID.override_hierarchy_create "bpy.types.ID.override_hierarchy_create") - [`IDOverrideLibrary.resync`](bpy.types.IDOverrideLibrary.html#bpy.types.IDOverrideLibrary.resync "bpy.types.IDOverrideLibrary.resync") - [`LayerCollection.has_selected_objects`](bpy.types.LayerCollection.html#bpy.types.LayerCollection.has_selected_objects "bpy.types.LayerCollection.has_selected_objects") - [`Object.hide_get`](bpy.types.Object.html#bpy.types.Object.hide_get "bpy.types.Object.hide_get") - [`Object.hide_set`](bpy.types.Object.html#bpy.types.Object.hide_set "bpy.types.Object.hide_set") - [`Object.holdout_get`](bpy.types.Object.html#bpy.types.Object.holdout_get "bpy.types.Object.holdout_get") - [`Object.indirect_only_get`](bpy.types.Object.html#bpy.types.Object.indirect_only_get "bpy.types.Object.indirect_only_get") | - [`Object.select_get`](bpy.types.Object.html#bpy.types.Object.select_get "bpy.types.Object.select_get") - [`Object.select_set`](bpy.types.Object.html#bpy.types.Object.select_set "bpy.types.Object.select_set") - [`Object.visible_get`](bpy.types.Object.html#bpy.types.Object.visible_get "bpy.types.Object.visible_get") - [`RenderEngine.register_pass`](bpy.types.RenderEngine.html#bpy.types.RenderEngine.register_pass "bpy.types.RenderEngine.register_pass") - [`RenderEngine.update_render_passes`](bpy.types.RenderEngine.html#bpy.types.RenderEngine.update_render_passes "bpy.types.RenderEngine.update_render_passes") - [`Scene.statistics`](bpy.types.Scene.html#bpy.types.Scene.statistics "bpy.types.Scene.statistics") - [`Scene.view_layers`](bpy.types.Scene.html#bpy.types.Scene.view_layers "bpy.types.Scene.view_layers") - [`ViewLayers.new`](bpy.types.ViewLayers.html#bpy.types.ViewLayers.new "bpy.types.ViewLayers.new") - [`ViewLayers.remove`](bpy.types.ViewLayers.html#bpy.types.ViewLayers.remove "bpy.types.ViewLayers.remove") - [`Window.view_layer`](bpy.types.Window.html#bpy.types.Window.view_layer "bpy.types.Window.view_layer") |
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

In the example above, we start with a grid of 1000x1000 square faces serving as “pixels.”
Then, we group these faces into patches by assigning them a group ID sampled from a Voronoi texture,
and move each resulting instance by a random amount along the Z axis.

Note that, because the texture outputs floating point values between 0 and 1 while the group ID
is an integer, all the values would be rounded to 0 or 1 and we would only get two groups.
To get more variation, we multiply the texture value by 1000.
user: Describe Viewport Overlays from the Blender manual or Python API, including usage steps and snippets.

assistant: # Viewport Overlays

Clicking  (Show Overlays) toggles all overlays in the 3D Viewport.

The drop-down button displays a popover with more detailed settings, which are described below.

Depending on the current [object interaction mode](../modes.xhtml),
there may be a second button with yet more settings, which are also described here.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Image
:   Standard color input.

Samples
:   The number of samples used to compute the blur.
    The more samples the smoother the result, but at the expense of more compute time.
    The actual number of samples is two to the power of this input, so it increases exponentially.

Center
:   The position at which the transformations pivot around.
    Defined in normalized coordinates, so 0 means lower left corner and 1 means upper right corner of the image.

Rotation
:   The amount of rotation that the blur spans.

Scale
:   The amount of scaling that the blur spans.

### Translation

Amount
:   The amount of translation that the blur spans in the specified direction relative to the size of the image.
    Negative values indicate translation in the opposite direction.

Direction
:   The angle that defines the direction of the translation.
user: Give a detailed overview of Mask: syntax, arguments, return values, common patterns.

assistant: # Mask

This page details the mask related shortcut operators and menu operators in sculpt mode.
Other related information to masks can also be found at the bottom of the page.

Masks can be edited across all visible faces.
Using `A` opens a pie menu to choose the most common operations.
user: Describe Select More/Less from the Blender manual or Python API, including usage steps and snippets.

assistant: Their purpose, based on the currently selected control points, is to reduce or enlarge this selection.

More
:   For each selected control point, select *all* its linked points (i.e. one or two…).

Less
:   For each selected control point, if *all* points linked to this point are selected, keep this one selected.
    Otherwise, deselect it.

This implies two points:

1. When *all* control points of a curve are selected, nothing will happen
   (as for *Less*, all linked points are always selected, and of course, *More* cannot add any).
   Conversely, the same goes when no control points are selected.
2. Second, these tools will never “go outside” of a curve
   (they will never “jump” to another curve in the same object).
user: How do I use Set Sharpness by Angle in Blender? Include parameters, examples, warnings and best practices.

assistant: Sets the [sharp edge attribute](../../../geometry_nodes/attributes_reference.html#geometry-nodes-builtin-attributes)
based on the angle between neighboring faces.

Angle
:   Maximum angle between face normals that will be considered as smooth.

Extend
:   Add new sharp edges without clearing existing sharp edges.
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.xhtml#ui-curve-widget).
user: Describe Distance from Camera from the Blender manual or Python API, including usage steps and snippets.

assistant: # Distance from Camera

The *Distance from Camera* modifier alters the base property with a new one
from a given range using the distance to the active *camera*.

Range Min, Max
:   The limits of the mapping from “distance to camera” to “property in mapping”.
    If the current point of the stroke is at *Range Min* or less from the active camera or the object,
    it will take the start value. And conversely,
    if it is at *Range Max* or more from the camera/object, it will take the end value.
    These values are in the current scene’s units, not in pixels!

Fill Range by Selection
:   Set the min/max range values from the distances between the current selected mesh vertices and
    the camera or the target.
user: Provide the full official documentation entry for Control Points, preserving all code examples.

assistant: Like all curves in Blender, the curve in this widget is defined using *control points*.

Add
:   Click `LMB` anywhere on the curve where there is not already a control point.

Move
:   Drag the point with `LMB`.

Remove
:   Select the point and click the  button at the bottom right.
    Alternatively, press `X`.
user: Provide the full official documentation entry for ConsoleLine(bpy_struct), preserving all code examples.

assistant: # ConsoleLine(bpy_struct)

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

*class* bpy.types.ConsoleLine(*bpy_struct*)
:   Input line for the interactive console

    body
    :   Text in the line

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

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

    type
    :   Console line type when used in scrollback

        Type:
        :   enum in [`'OUTPUT'`, `'INPUT'`, `'INFO'`, `'ERROR'`], default `'OUTPUT'`

    *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.ConsoleLine.type "bpy.types.ConsoleLine.type")
user: What is Screen Tracing and how is it used in Blender Python scripting?

assistant: These settings control the behavior of the screen space ray-tracing.
They are only visible if *Screen-Trace* is the active tracing *Method*.

Precision
:   Higher values increase precision of the screen space ray-tracing but lower the maximum trace distance.
    Increased precision also increases performance cost.

Thickness
:   How thick to consider the pixels of the depth buffer during the tracing.
    Higher values will stretch the reflections and add flickering. Lower values may make the ray miss surfaces.
user: Show practical ways to work with Line Gestures in a Blender add-on or script – include code.

assistant: Dragging creates a line. The resulting action acts upon everything on the highlighted side of the line. The area acted
upon is extended in both directions of the viewport.

### Controls

Flip `F`
:   Toggles the side of the line that the tool affects.

Snap `Ctrl`
:   Hold to constrain the rotation of the line to user-specified intervals. Defaults to 5 degree increments,
    customizable via the Snapping menu indicated by the magnet icon in the header.

Move `Spacebar`
:   Hold to reposition the line.

### Tool Settings

Limit to Segment
:   The affected area will not extend the length of the drawn line.
    This helps defining a smaller area instead of extending the line infinitely long.
user: How do I use Deploying Blender in Production in Blender? Include parameters, examples, warnings and best practices.

assistant: # Deploying Blender in Production

This page contains tips for setting up Blender in environments
such as animation studios and schools.

These environments often have special requirements regarding
security, automated deployment and customization.
user: Describe Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Surface

Sampling
:   Controls the sampling method for the world material. Selecting Auto or Manual enables
    *Multiple Importance Sampling* while None disables it. *Multiple Importance Sampling*
    is a method to sample the background texture such that lighter parts are favored,
    creating an importance map. It will produce less noise in the render in trade of artifacts ([Fireflies](../../glossary/index.html#term-Fireflies)).
    Enable this when using an image texture with small area lights (like the sun),
    otherwise noise can take a long time to converge.

    Below is a comparison between *Multiple Importance Sample* off and on.
    Both images are rendered for 25 seconds (Off: 1,500 samples, On: 1,000 samples).

    |  |  |
    | --- | --- |
    | ../../_images/render_cycles_world-settings_mis-off.jpg   Multiple Importance Sample off. | ../../_images/render_cycles_world-settings_mis-on.jpg   Multiple Importance Sample on. |

Map Resolution
:   Sets the resolution of the importance map.
    A higher resolution will better detect small features in the map and give more accurate sampling
    but conversely will take up more memory and render slightly slower.
    Higher values also may produce less noise when using high-res images.

Max Bounces
:   Maximal number of bounces the background light will contribute to the render.

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

### Volume

Sampling Method
:   Distance:
    :   For dense volumes lit from far away *Distance* sampling is more efficient in most cases.
        Usually this shouldn’t be used for World volumes.

    Equiangular:
    :   If you have got a light inside or near the volume then *equiangular* sampling is better.

    Multiple Importance:
    :   If you have a combination of both, then the multiple importance sampling will be better.

Interpolation
:   Interpolation method to use for the volume.

    Linear:
    :   Simple interpolation which gives good results for thin volumes.

    Cubic:
    :   Smoothed high-quality interpolation needed for more dense volumes, but slower.

Step Size Biased
:   Distance between volume shader samples for world volume shaders.
    Only enabled when Render ‣ Volumes ‣ Biased is enabled.
    See [Volume Render Settings](render_settings/volumes.html) for more information.

### Light Group

Light Group Cycles only
:   Select the [Light Group](../layers/passes.html#bpy-types-viewlayer-active-lightgroup-index) to add the
    current *World Surface Shader* too.

    Add Light Group
    :   If the name input into the *Light Group* field does not align with an existing
        Light Group, then pressing this button will create a *Light Group* with that name
        and assign this *World Shader* to it.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Grid
:   The resulting grid with all active tiles converted into individual voxels.

    For fog volumes, this means that interior sparse tiles are expanded into
    voxels with individually adjustable values. For SDF grids, this produces a
    fully dense voxel representation suitable for precise sampling and editing.
user: How do I use Merge in Blender? Include parameters, examples, warnings and best practices.

assistant: At Center
:   Moves selected UVs to their average position.

At Cursor
:   Moves selection UVs to 2D cursor location.

### By Distance

Merges selected UVs within the specified *Merge Distance*.

Merge Distance
:   Maximum distance between merged vertices.

Unselected
:   Merge selected to other unselected vertices.

Shared Vertex
:   Merge UVs that correspond to the same mesh vertex, even if they have different UV coordinates.
user: Give a detailed overview of GREASE_PENCIL_UL_attributes(UIList): syntax, arguments, return values, common patterns.

assistant: # GREASE_PENCIL_UL_attributes(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.GREASE_PENCIL_UL_attributes(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *attribute*, *_icon*, *_active_data*, *_active_propname*, *_index*)

    filter_items(*_context*, *data*, *property*)

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

assistant: In some configurations of the node, especially for low values of *Randomness*,
rendering artifacts may occur. This happens due to the same reasons described
in the [Notes section](white_noise.html#shader-white-noise-notes) in the White Noise Texture page
and can be fixed in a similar manner as described there.
user: How do I use Image Editor in Blender? Include parameters, examples, warnings and best practices.

assistant: View Menu
:   After you render your scene with Stereo 3D you will be able to see
    the rendered result in the combined stereo 3D or to inspect the individual views.
    This works for Viewer nodes, render results or opened images.

    [image reference removed]

    Stereo 3D and view menu.

Views Format
:   When you drag and drop an image into the Image Editor, Blender will open it as an individual images at first.
    If your image was saved with one of the Stereo 3D formats, you can change how
    Blender should interpret the image by switching the mode to Stereo 3D,
    turning on *Use Multi-View* and picking the corresponding stereo method.

    [image reference removed]

    Views formats and stereo 3D.
user: Explain Tool Settings in complete detail according to the official Blender documentation.

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

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

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

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

Different thickness profile samples.

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

### Brush Asset

Picks the brush asset used by the tool.

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

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

### Brush Settings

Parameters to control to look of the stroke.

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

### Color

Settings to determine the color of strokes.

See [Color](../tool_settings/color.html)
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Grid
:   The input grid to advect. Must have a uniform voxel scale.

Velocity
:   The vector grid defining the flow direction and magnitude at each voxel.
    The *Velocity* field determines how grid values are transported through
    space.

Time Step
:   The time step used for advection, in seconds.
    Larger values result in faster motion but may reduce accuracy or stability.

Integration Scheme
:   The numerical integration method used to trace voxel positions through the
    velocity field:

    Semi-Lagrangian:
    :   First-order semi-Lagrangian integration. Fastest and most stable but
        introduces noticeable numerical diffusion (blurring).

    Midpoint:
    :   Second-order midpoint integration. Balances speed and accuracy, suitable
        for most cases.

    Runge-Kutta 3:
    :   Third-order Runge-Kutta integration. Provides higher accuracy with
        moderate computational cost.

    Runge-Kutta 4:
    :   Fourth-order Runge-Kutta integration. Highest accuracy single-step
        scheme, ideal for detailed simulations but slower to compute.

    MacCormack:
    :   MacCormack scheme with implicit diffusion control. Reduces numerical
        dissipation while maintaining stability.

    BFECC:
    :   Back and Forth Error Compensation and Correction. An advanced scheme that
        minimizes dissipation and maintains sharper features.

Limiter
:   The limiting strategy used to reduce overshoot or undershoot artifacts
    in high-order advection schemes:

    None:
    :   No limiting applied. Fastest but can introduce artifacts in regions with
        steep gradients.

    Clamp:
    :   Clamps values to the range of the original neighborhood, preventing
        overshooting and undershooting while preserving stability.

    Revert:
    :   Reverts to first-order integration in cases where clamping would be
        necessary. More conservative and stable than clamping alone.
user: How do I use NodeTreeInterfaceSocketMenu(NodeTreeInterfaceSocket) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeTreeInterfaceSocketMenu(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketMenu(*NodeTreeInterfaceSocket*)
:   Menu socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   enum in []

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: Start opening up your project file, in this case `turntable.blend` from the *Creature Factory 2*
Open Movie Workshop series from the Blender Institute by Andy Goralczyk.

[image reference removed]

Turntable Creature Factory 2.
user: Describe Relax Slide from the Blender manual or Python API, including usage steps and snippets.

assistant: # Relax Slide

This brush deforms the topology of the mesh
while minimizing changes to the geometrical shape of the mesh.
By default it will drag geometry, but this can be changed in the *Deformation* settings.

This brush is especially useful for redistributing topology to areas that require more detail,
or sliding geometry to somewhere where they should be.

Holding `Shift` changes the brush effect to Relax geometry,
creating an even distribution of topology.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The Vertex Weight Proximity modifier panel.

Vertex Group
:   The vertex group to affect.

Target Object
:   The object from which to compute distances.

Proximity Mode
:   Object Distance
    :   Use the distance between the modified mesh object and the target object as
        weight for all vertices in the affected vertex group.

    Geometry Distance
    :   Use the distance between each vertex and the target object, or its geometry.

        Vertex
        :   This will set each vertex’s weight from its distance to the nearest vertex of the target object.

        Edge
        :   This will set each vertex’s weight from its distance to the nearest edge of the target object.

        Face
        :   This will set each vertex’s weight from its distance to the nearest face of the target object.

Lowest
:   Distance mapping to 0.0 weight.

Highest
:   Distance mapping to 1.0 weight.

Normalize Weights
:   Scale the weights in the vertex group to keep the relative weight
    but the lowest and highest values follow the full 0 - 1 range.

### Falloff

Type
:   Type of mapping.

    Linear
    :   No mapping.

    Custom Curve
    :   Allows you to manually define the mapping using a curve.

    Sharp, Smooth, Root and Sphere
    :   These are classical mapping functions, from spikiest to roundest.

    Random
    :   Uses a random value for each vertex.

    Median Step
    :   Creates binary weights (0.0 or 1.0), with 0.5 as cutting value.

Invert
:   Inverts the falloff.

### Influence

Those settings are the same for the three *Vertex Weight* modifiers,
see the [Vertex Weight Edit modifier](weight_edit.xhtml#modeling-modifiers-weight-edit-influence-mask-options) page.
user: How do I use Insert Unicode in Blender? Include parameters, examples, warnings and best practices.

assistant: Opens a dialog box to input the entry of any Unicode character by entering its hexadecimal code point value.

See Wikipedia for a [List of Unicode characters](https://en.wikipedia.org/wiki/List_of_Unicode_characters)
which list there respective hexadecimal code point values.
user: Provide the full official documentation entry for Render, preserving all code examples.

assistant: SMAA Threshold
:   Threshold for the edge detection algorithm used to correct aliasing for the final render,
    Higher values may result in loss of detail due to excessive blurring.

SSAA Samples
:   Number of samples used for super-sampling anti-aliasing in the final render.
    Higher values produce smoother lines but increase render time.

Motion Blur Steps
:   Controls accuracy of [motion blur](../../glossary/index.xhtml#term-Motion-Blur), more steps result in longer render time.
    Only used when [Motion Blur](../cycles/render_settings/motion_blur.xhtml#bpy-types-rendersettings-use-motion-blur) is enabled.
    Set to 0 to disable motion blur for Grease Pencil objects.
user: Explain Dashed Line in complete detail according to the official Blender documentation.

assistant: By enabling the *Dashed Line* checkbox,
you can specify three pairs of dash and gap lengths.
Dash values define the lengths of dash strokes,
while gap values specify intervals between two dashes.

If a zero gap is specified,
then the corresponding dash is ignored even if it has a nonzero value.

Dashes are treated as separate strokes, meaning that you can apply line caps,
as well as color, alpha and thickness modifiers.

Dash 1, 2, 3
:   Length of the specified dash for dashed lines.

Gap 1, 2, 3
:   Length of the specified gap for dashed lines.
user: Provide the full official documentation entry for Camera and Object Motion Solving, preserving all code examples.

assistant: Blender not only supports the solving of camera motion, including tripod shots,
but also the solving of object motion in relation to the motion of the camera.
In addition to that there is the Plane Track, which solves the motion of all markers on one plane.
user: Provide the full official documentation entry for Material, preserving all code examples.

assistant: The Viewport Display panel in the Material Properties has several settings that
are used by the Workbench Engine.

Color
:   The color when rendering the material.
    The alpha channel can be used to render the object transparent.

Metallic
:   Changes the amount of specular lighting. This is only available when
    *Specular Lighting* in the [Options](options.html) is enabled.

Roughness
:   Changes the amount of roughness for specular lighting. This is only available when
    *Specular Lighting* in the [Options](options.html) is enabled.
user: Give a detailed overview of Mark/Clear Sharp: syntax, arguments, return values, common patterns.

assistant: Signifies the selected edge(s) as being “sharp”.
This edge attribute can either be set (mark) or unset (clear).

This influences the rendering of [Normals](../../structure.html#modeling-meshes-structure-normals)
to appear flat if smooth shading is enabled for the connecting face or object.
This attribute can also be used by many modifiers or operators to mask their effect.

Internally, this uses the [sharp edge attribute](../../../geometry_nodes/attributes_reference.html#geometry-nodes-builtin-attributes).