PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is Options and how is it used in Blender Python scripting?

assistant: [[image reference removed]](../../../_images/modeling_modifiers_generate_remesh_panel.png)

The Remesh modifier.

Mode
:   There are three basic modes available in the *Remesh* modifier.
    The output topology is almost identical between the three modes, what changes is the smoothing.

    Blocks
    :   There is no smoothing at all.

    Smooth
    :   Output a smooth surface.

    Sharp
    :   Similar to *Smooth*, but preserves sharp edges and corners.

        Sharpness
        :   Higher values produce edges more similar to the input, while lower values filter out noise.

    Voxel
    :   Uses an OpenVDB to generate a new manifold mesh from the current geometry
        while trying to preserve the mesh’s original volume.

        Adaptivity
        :   Reduces the final face count by simplifying geometry where detail is not needed.
            This introduce triangulation to faces that do not need as much detail.

        Smooth Shading
        :   Outputs faces with [Smooth Shading](../../../scene_layout/object/editing/shading.html#bpy-ops-object-shade-smooth) instead of flat shading.

Octree Depth
:   Sets the resolution of the output. Low values will generate larger faces relative to the input,
    higher values will generate a denser output.

Scale
:   The result can be tweaked further by this, lower values effectively decrease the output resolution.

Remove Disconnected
:   Filter out small disconnected pieces of the output.

    Thin parts of the input mesh can become loose, and generate small isolated bits of mesh.
    This option will remove those.

    Threshold
    :   Use this to control how small a disconnected component must be to be removed.

Smooth Shading
:   Output faces with smooth shading rather than flat shading.
    The smooth/flat shading of the input faces is not preserved.
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

Modifiers are automatic operations that affect an object’s geometry in a non-destructive way.
With modifiers, you can perform many effects automatically that would otherwise be too tedious to do manually
(such as subdivision surfaces) and without affecting the base geometry of your object.

They work by changing how an object is displayed and rendered, but not the geometry which you can edit directly.
You can add several modifiers to a single object to form [The Modifier Stack](#the-modifier-stack)
and *Apply* a modifier if you wish to make its changes permanent.

They can be added to the active object using the [Add Modifier](../../scene_layout/object/editing/modifiers.xhtml#bpy-ops-object-modifier-add) operator,
the “Add Modifier” button at the top of Modifiers tab in the [Properties Editor](../../editors/properties_editor.xhtml),
or using `Shift`-`A` in the same tab.
New modifiers are always added at the bottom of the [stack](#modifier-stack) (i.e. will be applied last).

There are many built-in modifiers but Blender also allows users
to make their own modifiers through [Geometry Nodes](../geometry_nodes/index.xhtml).
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: [image reference removed]

A chain created from a single link.
[Sample blend-file](https://archive.blender.org/wiki/2015/index.php/File:Dev-ArrayModifier-Chain01.blend).

[image reference removed]

A tentacle created with an Array Modifier followed by a Curve Modifier.

The segment in the foreground is the base mesh for the tentacle; the tentacle is capped by two
specially-modeled objects deformed by the same Curve object as the main part of the tentacle.
[Sample blend-file](https://archive.blender.org/wiki/2015/index.php/File:Manual-Modifier-Array-Tentacle01.blend).

### Fractal

|  |  |
| --- | --- |
| ../../../_images/modeling_modifiers_generate_array_example-fractal-1.jpg   Multi-level array animated with motion blur. | ../../../_images/modeling_modifiers_generate_array_example-fractal-2.png   Fractal created with multiple arrays. [Sample blend-file](https://archive.blender.org/wiki/2015/index.php/File:Dev-ArrayModifier-Fractal01.blend). |
user: What is Toolbar and how is it used in Blender Python scripting?

assistant: [image reference removed]

Expanded tool group.

The Toolbar contains buttons for the various tools.
Buttons with a small triangle in their bottom right corner are tool groups
which can be opened by holding `LMB` on them for a moment
(or dragging `LMB` to open them instantly).

Hovering your cursor over a tool for a short time will show its name,
while hovering longer will show the full tooltip.

Resizing the Toolbar horizontally will display the icons with two columns.
Expanding it further will display the icon and its text.
user: Explain Curvature 3D in complete detail according to the official Blender documentation.

assistant: # Curvature 3D

A modifier based on radial curvatures of the underlying 3D surface.
The [curvature](https://en.wikipedia.org/wiki/Curvature) of a 2D curve
at a point is a measure of how quickly the curve turns at the point.
The quicker the turn is, the larger the curvature is at the point.
The curvature is zero if the curve is a straight line.
Radial curvatures are those computed for a 2D curve that appears at the cross section
between the 3D surface and a plane defined by the view point (camera location)
and the normal direction of the surface at the point.

For radial curvatures to be calculated (and therefore for this modifier to have any effect),
the *Face Smoothness* option has to be turned on and the object needs to have *Smooth Shading*.

Curvature Min, Max
:   The limits of the mapping.
    If the current point of the stroke is at *Min Curvature* or less from the target,
    it will take the start point of the mapping. And conversely,
    if it is at *Max Curvature* or more from the target, it will take the end-point value of the mapping.

[image reference removed]

Curvature 3D modifier demo by T.K.
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Render_freestyle_modifier_curvature_3d.blend)).
user: How do I use Recovering Save Versions in Blender? Include parameters, examples, warnings and best practices.

assistant: By default Blender keeps an additional backup when saving files.
So saving renames the previously saved file with a `.blend1` extension instead of overwriting it.

This file can be used to revert to a previous state.

See [Save Versions](../editors/preferences/save_load.xhtml#bpy-types-preferencesfilepaths-save-version) to configure the number of versions kept.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Geometry
:   Standard geometry input.

Selection
:   Whether to change the material index for each face.
    True values mean the material index will be changed, false values mean it will remain the same.

Material Index
:   The new material index.
user: Provide the full official documentation entry for Strip Modifiers, preserving all code examples.

assistant: # Strip Modifiers

[image reference removed]

Modifiers are used to make adjustments to the image, like contrast,
brightness, saturation, color balance and applying masks.

You can add these modifiers directly to a media strip,
or you can use them within an [Adjustment Layer](strips/adjustment.xhtml)
strip, making them apply to several media strips in one go.

Linear Modifiers
:   Calculates modifiers in [linear color space](../../../render/color_management/color_spaces.xhtml#color-management-linear-space) instead of the
    [Sequencer color space](../../../render/color_management/color_spaces.xhtml#bpy-types-colormanagedsequencercolorspacesettings-name).

    Calculating modifiers in linear space will match the image processing of the compositor.
    In most cases, this should be enabled; working in a non-linear workflow could have unpredictable results.
user: Show practical ways to work with B in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [**Baking**](glossary/index.html#term-Baking) - [**Bevel**](glossary/index.html#term-Bevel) - [**Bézier**](glossary/index.html#term-Bezier) - [**Bit Depth**](glossary/index.html#term-Bit-Depth) - [**Blend Modes**](glossary/index.html#term-Blend-Modes) - [**Blender Session**](glossary/index.html#term-Blender-Session) - [**Bone**](glossary/index.html#term-Bone) - [**Bone Collection**](glossary/index.html#term-Bone-Collection) | - [**Boolean**](glossary/index.html#term-Boolean) - [**Bounding Box**](glossary/index.html#term-Bounding-Box) - [**Bounding Volume Hierarchy**](glossary/index.html#term-Bounding-Volume-Hierarchy) - bssrdf()   - [built-in function](render/cycles/osl/index.html#id0) - built-in function   - [bssrdf()](render/cycles/osl/index.html#id0) - [**Bump Mapping**](glossary/index.html#term-Bump-Mapping) - [**BVH**](glossary/index.html#term-BVH) |
user: Give a detailed overview of TextureNodeTexMagic(TextureNode): syntax, arguments, return values, common patterns.

assistant: # TextureNodeTexMagic(TextureNode)

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

*class* bpy.types.TextureNodeTexMagic(*TextureNode*)
:   *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Bevel Node

Cycles Only

[image reference removed]

The Bevel shader node can be used for rendering rounded corners.
Like bump mapping, this does not modify the actual geometry, only the shading is affected.
Slight rounding on edges helps to capture specular highlights that you would also see in the real world.

Note that this is a very expensive shader, and may slow down renders
by 20% even if there is a lot of other complexity in the scene.
For that reason, we suggest to mainly use this for baking or
still frame renders where render time is not as much of an issue.
The [Bevel Modifier](../../../modeling/modifiers/generate/bevel.xhtml) is a faster option when it works,
but sometimes fails on complex or messy geometry.
user: Show practical ways to work with Editing Masks in a Blender add-on or script – include code.

assistant: # Editing Masks

The tools and panels available to edit masks are the same in both editors.
Editing of mask splines happens in a way similar to editing Bézier curves or paths in GIMP or other curve editors.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`BlendData.fonts`](bpy.types.BlendData.html#bpy.types.BlendData.fonts "bpy.types.BlendData.fonts") - [`BlendDataFonts.load`](bpy.types.BlendDataFonts.html#bpy.types.BlendDataFonts.load "bpy.types.BlendDataFonts.load") - [`BlendDataFonts.remove`](bpy.types.BlendDataFonts.html#bpy.types.BlendDataFonts.remove "bpy.types.BlendDataFonts.remove") - [`GeometryNodeStringToCurves.font`](bpy.types.GeometryNodeStringToCurves.html#bpy.types.GeometryNodeStringToCurves.font "bpy.types.GeometryNodeStringToCurves.font") - [`TextCurve.font`](bpy.types.TextCurve.html#bpy.types.TextCurve.font "bpy.types.TextCurve.font") | - [`TextCurve.font_bold`](bpy.types.TextCurve.html#bpy.types.TextCurve.font_bold "bpy.types.TextCurve.font_bold") - [`TextCurve.font_bold_italic`](bpy.types.TextCurve.html#bpy.types.TextCurve.font_bold_italic "bpy.types.TextCurve.font_bold_italic") - [`TextCurve.font_italic`](bpy.types.TextCurve.html#bpy.types.TextCurve.font_italic "bpy.types.TextCurve.font_italic") - [`TextStrip.font`](bpy.types.TextStrip.html#bpy.types.TextStrip.font "bpy.types.TextStrip.font") |
user: How do I use Select Loop Inner-Region in Blender? Include parameters, examples, warnings and best practices.

assistant: *Select Loop Inner-Region* selects all faces that are inside a closed loop of edges.
While it is possible to use this operator in *Vertex* and *Face* selection modes, results may be unexpected.
Note that if the selected loop of edges is not closed,
then all connected edges on the mesh will be considered inside the loop.

[image reference removed]

Loop to Region.

[image reference removed]

This tool handles multiple loops fine, as you can see.

[image reference removed]

This tool handles “holes” just fine as well.
user: How do I use Tool Settings in Blender? Include parameters, examples, warnings and best practices.

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.xhtml).

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

Thickness Profile
:   Use a [curve widget](../../../../interface/controls/templates/curve.xhtml) 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.xhtml) for more information.

See [Draw Brushes](../brushes/draw.xhtml) 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.xhtml) for details.

### Color

Settings to determine the color of strokes.

See [Color](../tool_settings/color.xhtml)
user: What is Named Layer Selection Node and how is it used in Blender Python scripting?

assistant: # Named Layer Selection Node

[image reference removed]

The *Named Layer Selection* node outputs a Boolean field whose index value is true
for [Grease Pencil layers](../../../../grease_pencil/properties/layers.xhtml) whose name matches a string input.
user: Provide the full official documentation entry for Tool Settings, preserving all code examples.

assistant: Mode
:   The operation to apply to the face set.

    Grow Face Set:
    :   Grows the face sets boundary by one face based on mesh topology.
        This is also available as a [shortcut operator](../editing/face_sets.html#bpy-ops-sculpt-face-set-edit)
        via `Ctrl`-`W`.

    Shrink Face Set:
    :   Shrinks the face sets boundary by one face based on mesh topology.
        This is also available as a [shortcut operator](../editing/face_sets.html#bpy-ops-sculpt-face-set-edit)
        via `Ctrl`-`Alt`-`W`.

    Delete Geometry:
    :   Deletes the faces that are assigned to the face set.

    Fair Positions:
    :   Creates a perfectly flat and smooth geometry patch from the face set.
        This is the ideal way to trim parts of your mesh
        if the vertex count is too high for other operations,
        or the vertex IDs must not be altered
        (Like when using [Multires](../../../modeling/modifiers/generate/multiresolution.html) sculpting).

    Fair Tangency:
    :   Creates a smooth as possible geometry patch from the face set
        by minimizing changes in vertex [tangents](../../../glossary/index.html#term-Tangent).
        This is ideal for creating smooth curved surfaces on complex topology,
        where just using the smooth brush will not lead to desired results

    |  |  |  |
    | --- | --- | --- |
    | ../../../_images/sculpt-paint_sculpt_fairing_none.png   Before fairing. | ../../../_images/sculpt-paint_sculpt_fairing_positions.png   After using Fair Positions. | ../../../_images/sculpt-paint_sculpt_fairing_tangency.png   After using Fair Tangency. |

Strength
:   The amount of effect the filter has on the mesh.
    This setting is only available for the fairing operations.

Modify Hidden
:   Apply the edit operation to hidden face sets.
user: Describe GeometryNodeSampleNearestSurface(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeSampleNearestSurface(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.GeometryNodeSampleNearestSurface(*GeometryNode*)
:   Calculate the interpolated value of a mesh attribute on the closest point of its surface

    data_type
    :   Type:
        :   enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items), default `'FLOAT'`

    *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: Provide the full official documentation entry for Loop Cut, preserving all code examples.

assistant: # Loop Cut

The *Loop Cut* tool is a modal tool version of the [Loop Cut and Slide](../editing/edge/loopcut_slide.html#bpy-ops-mesh-loopcut-slide) operator.
This tool splits a loop of faces by inserting new edge loops intersecting the chosen edge.
user: What is String Node and how is it used in Blender Python scripting?

assistant: # String Node

[image reference removed]

The *String* input node creates a single string. It can be connected to attribute name sockets
to make using the same attribute name in multiple places more convenient.
user: Show practical ways to work with Unwrap in a Blender add-on or script – include code.

assistant: Blender offers several ways of mapping UVs.
The simpler projection methods use formulas that map 3D space onto 2D space,
by interpolating the position of points toward a point, axis or plane through a surface.
The more advanced methods can be used with more complex models, and have more specific uses.

- [Unwrap](../editing/uv.html#bpy-ops-uv-unwrap)
- [Smart UV Project](../editing/uv.html#bpy-ops-uv-smart-project)
- [Lightmap Pack](../editing/uv.html#bpy-ops-uv-lightmap-pack)
- [Follow Active Quads](../editing/uv.html#bpy-ops-uv-follow-active-quads)
- [Cube Projection](../editing/uv.html#bpy-ops-uv-cube-project)
- [Cylinder Projection](../editing/uv.html#bpy-ops-uv-cylinder-project)
- [Sphere Projection](../editing/uv.html#bpy-ops-uv-sphere-project)
user: Provide the full official documentation entry for Control, preserving all code examples.

assistant: Catmull-Clark subdivision rounds off edges, and often this is not what you want.
There are several solutions that allow you to control the subdivision.

### Weighted Edge Creases

Weighted edge creases for subdivision surfaces allows you to change the way
the *Subdivision Surface* modifier subdivides the geometry to give the edges a smooth or sharp appearance.

[image reference removed]

A subdivided cube with creased edges.

The crease weight of selected edges can be changed in the *Transform* panel, Sidebar of the 3D Viewport.
The scale-like dedicated tool `Shift`-`E` can also be used to adjust the crease weight.
A higher value makes the edge “stronger” and more resistant to the smoothing effect of subdivision surfaces.

### Edge Loops

[image reference removed]

Subdivision Level 2 cube, the same with an extra Edge Loop, and the same with six extra Edge Loops.

The *Subdivision Surface* modifier demonstrates why good, clean topology is so important.
As you can see in the figure, it has a drastic effect on a default cube.
Until you add in additional loops (with e.g. [Loop Cut and Slide](../../meshes/editing/edge/loopcut_slide.xhtml#bpy-ops-mesh-loopcut-slide)),
the shape is almost unrecognizable as a cube.

A mesh with deliberate topology has good placement of edge loops, which allow the placement of more loops
(or their removal) to control the sharpness/smoothness of the resultant mesh.
user: Give a detailed overview of Graph View: syntax, arguments, return values, common patterns.

assistant: # Graph View

The graph or curves view has numerous purposes based on the color of the lines.
The red and green lines on the graph show you the speed of the trackers at a given frame.
Green is vertical movement, Red is horizontal. Therefore the first frames will always be at zero.

The blue line is the line that comes out when you click on the film strip is the average per-frame error.
This curve is available only after pressing camera solve and is not editable.
This is the one line that you want to be as flat as possible and as closer to zero as you can.
The high points will show you where in your shot you are having inaccurate tracking.

Frames outside of scene frame range are darkened.

[image reference removed]

Graph View.
user: Describe Export from the Blender manual or Python API, including usage steps and snippets.

assistant: ### General

Format: ASCII
:   Formats the file using the simple a ASCII format.
    This option might be helpful if the program that
    will later import the file does not support the binary file format.

Include: Selected Only
:   Only selected objects are exported.
    Instanced objects, for example collections that are instanced in the scene,
    are considered ‘selected’ when their instancer is selected.

Scale
:   Value by which to scale the exported objects in relation to the world’s origin.

Forward Axis, Up Axis
:   Since many applications use a different axis for ‘Up’, 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, it’s common for applications to use Y as the up axis, in that case -Z Forward, Y Up is needed.

### Geometry

UV Coordinates
:   Write out the active UV layers coordinates from Blender.

Vertex Normals
:   Write out Blender’s face and vertex normals (depending on the faces smooth setting).

    Mostly this isn’t needed since most applications will calculate their
    own normals but to match Blender’s normal map textures you will need to write these too.

Vertex Colors
:   The color space that the color data in the ply-file was saved in.

    None:
    :   Does not import vertex color data.

    sRGB:
    :   Vertex colors in the file are in sRGB [Color Space](../../glossary/index.xhtml#term-Color-Space)

    Linear:
    :   Vertex colors in the file are in Linear [Color Space](../../glossary/index.xhtml#term-Color-Space)

Triangulated Mesh
:   All [N-gons](../../glossary/index.xhtml#term-N-gon) with four or more vertices will be triangulated.
    Meshes in the scene will not be affected.
    Behaves like [Triangulate Modifier](../../modeling/modifiers/generate/triangulate.xhtml) with the following settings:

    - N-gon Method: “Beauty”
    - Quad-method: “Shortest Diagonal”
    - Min vertices: 4

Apply Modifiers
:   Export objects using the evaluated mesh, meaning the resulting mesh after all
    [Modifiers](../../modeling/modifiers/index.xhtml) have been calculated.
user: Explain Operator Properties in complete detail according to the official Blender documentation.

assistant: Most operators have properties that can be adjusted to refine their result.
First run the operator (which will use its default settings),
then adjust the properties in the [Adjust Last Operation](undo_redo.xhtml#bpy-ops-screen-redo-last) region.
user: Describe – Material Preview from the Blender manual or Python API, including usage steps and snippets.

assistant: Render the 3D Viewport with [EEVEE](../../../render/eevee/introduction.xhtml) and an HDRI environment.
This mode is particularly suited for previewing materials and painting textures.
You can select different lighting conditions to test your materials.

### Lighting

Scene Lights
:   Use the lights in the scene. When disabled (or when the scene contains no lights),
    a virtual light is used instead.

Scene World
:   Use the World of the scene.
    When disabled, a world will be constructed with the following options:

    HDRI Environment
    :   The environment map used to light the scene.

    Rotation
    :   The rotation of the environment on the Z axis.

        World Space Lighting
        :   Makes the lighting rotation fixed and not follow the camera.

    Strength
    :   Light intensity of the environment.

    World Opacity
    :   Opacity of the HDRI as a background image in the viewport.

    Blur
    :   Factor to unfocus the HDRI.
        Note that this does not change the diffusion of the lighting,
        only the appearance of the background.

Render Pass
:   Instead of the combined render, show a specific
    [render pass](../../../render/layers/passes.xhtml).
    Useful to analyze and debug geometry, materials and lighting.

Compositor
:   When to preview the result of [compositing](../../../compositing/introduction.xhtml) in the 3D Viewport.

    Disabled:
    :   Never show the compositing output.

    Camera:
    :   Only show the compositing output when in [Camera View](../navigate/camera_view.xhtml),
        which gives the best vantage point for previewing the final result.

    Always:
    :   Always show the compositing output.
user: Show practical ways to work with Conclusions in a Blender add-on or script – include code.

assistant: Add-ons can encapsulate certain functionality neatly for writing tools
to improve your workflow or for writing utilities for others to use.

While there are limits to what Python can do within Blender,
there is certainly a lot that can be achieved without having to dive into Blender’s C/C++ code.

The example given in the tutorial is limited, but shows the Blender API used
for common tasks that you can expand on to write your own tools.

### Further Reading

Blender comes with commented templates which are accessible from the Text editor’s header.
If you have specific areas you want to see example code for, this is a good place to start.

Here are some sites you might like to check on after completing this tutorial.

- [Blender/Python API Overview](https://docs.blender.org/api/current/info_overview.html) –
  For more background details on Blender/Python integration.
- [How to Think Like a Computer Scientist](https://runestone.academy/ns/books/published/thinkcspy/index.html) –
  Great info for those who are still learning Python.
- [Blender Development](https://developer.blender.org/) –
  Blender Development, general information and helpful links.
- [Blender Developer Forum](https://devtalk.blender.org/tag/python) –
  Forum where people ask Python development questions.
user: Show practical ways to work with MovieReconstructedCamera(bpy_struct) in a Blender add-on or script – include code.

assistant: # MovieReconstructedCamera(bpy_struct)

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

*class* bpy.types.MovieReconstructedCamera(*bpy_struct*)
:   Match-moving reconstructed camera data from tracker

    average_error
    :   Average error of reconstruction

        Type:
        :   float in [-inf, inf], default 0.0, (readonly)

    frame
    :   Frame number marker is keyframed on

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

    matrix
    :   Worldspace transformation matrix

        Type:
        :   [`mathutils.Matrix`](mathutils.html#mathutils.Matrix "mathutils.Matrix") of 4 \* 4 items in [-inf, inf], default ((0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0)), (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Selection Paint, preserving all code examples.

assistant: # Selection Paint

Paint curves or control paints to use as masks for the other tools.
The selection visibility can be controlled by the *Selection Opacity* option in the Viewport Overlays.

By default the selection sets a new selection. The selection paint can be extended
by holding `Shift` and it can be subtracted by holding `Ctrl` while painting.
user: Show practical ways to work with File and Paths in a Blender add-on or script – include code.

assistant: At Preferences ‣ File Paths you can set options such as what *Image Editor* (GIMP, Krita…) and
*Animation Player* to use.

The [Temporary Directory](../../advanced/blender_directory_layout.html#temp-dir) sets where to store files such as temporary renders and auto-saves.

See [File Preferences](../../editors/preferences/file_paths.html) for details.
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

Transformations refer to a number of operations that can be performed on
a selected Object or Mesh that alters its position or characteristics.

Each object can be moved, rotated and scaled in *Object Mode*.
However, not all of these transformations have an effect on all objects.
For example, scaling a camera has no effect on the render dimensions.

Basic transformations include:

- [Move](move.xhtml)
- [Rotate](rotate.xhtml)
- [Scale](scale.xhtml)

These three transforms are the three big ones. However, more advanced transformations can be found
in the [Advanced Transformations](index.xhtml) section.

For making other changes to the geometry of editable objects, you should use *Edit Mode*.

Once you have added a basic object, you remain in *Object Mode*.
You can switch between *Object Mode* and *Edit Mode* by pressing `Tab`.
The object’s wireframe should now appear orange.
This means that the object is now selected and active.
user: Provide the full official documentation entry for Store Named Grid Node, preserving all code examples.

assistant: # Store Named Grid Node

[image reference removed]

The *Store Named Grid* node stores a voxel grid inside a volume geometry under a specified name.
This allows multiple grids (such as *density*, *temperature*, or *velocity*) to
be contained within a single volume object and accessed later using the
[Get Named Grid](../read/get_named_grid.html) node.

If a grid with the same name already exists in the input volume, it will be replaced by the new grid.
This makes it possible to update or overwrite grids during a geometry node
evaluation, for example when generating or modifying simulation fields.
user: Show practical ways to work with GeometryNodeMeshFaceSetBoundaries(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeMeshFaceSetBoundaries(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.GeometryNodeMeshFaceSetBoundaries(*GeometryNode*)
:   Find edges on the boundaries between groups of faces with the same ID value

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Image or Movie in complete detail according to the official Blender documentation.

assistant: # Image or Movie

The term *Image Texture* simply means that a graphic image,
which is a pixel grid composed of R, G, B, and sometimes Alpha values.
It is used as the input source to the texture.
As with other types of textures, this information can be used in a number of ways,
not only as a simple “decal”.

*Video textures* are a some kind of Image textures and
based on movie file or sequence of successive numbered separate images.
They are added in the same way that image textures are.

When the Texture Type *Image or Movie* is selected, three new panels present
themselves allowing to control most aspects of how image textures are applied:
*Image*, *Image Sampling*, and *Image Mapping*.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Geometry
:   Standard geometry input.

Selection
:   The selection of elements to sort, if left blank, all elements are sorted.
    Non-selected elements will keep their current indices.

Group ID
:   Elements with the same group ID are sorted together.
    If this is not a field, the node has no effect.

Sort Weight
:   The sorted values used to do the reordering.
    If this is not a field, the node has no effect.
user: How do I use Visualization in Blender? Include parameters, examples, warnings and best practices.

assistant: They all become a color-coded strip in the Video Sequencer:

- Scene strip: Light green.
- Clip strip: Dark blue.
- Mask strip: Red.
- Movie strip: Aquamarine.
- Image strip: Purple.
- Sound strip: Turquoise.

Each of the effect strips has its own color.

Besides each of these default colors you can also assign individual strips an alternative color in
the [Strip Properties](../../../../editors/video_sequencer/sequencer/sidebar/strip.html#bpy-ops-sequencer-strip-color-tag-set).
user: Describe GREASE_PENCIL_UL_attributes(UIList) from the Blender manual or Python API, including usage steps and snippets.

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: How do I use Socket Syncing in Blender? Include parameters, examples, warnings and best practices.

assistant: Closure nodes use socket names to match their inputs and outputs.
If two closure nodes are connected but have mismatched signatures, Blender can offer to sync them automatically.

- Sync happens automatically when a node is connected for the first time.
- Existing sockets are never changed automatically to avoid overwriting user data.
- A  button (*Sync Sockets*) button appears in the node header when a mismatch is detected, allowing manual synchronization.
user: Explain CompositorNodeCurveRGB(CompositorNode) in complete detail according to the official Blender documentation.

assistant: # CompositorNodeCurveRGB(CompositorNode)

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

*class* bpy.types.CompositorNodeCurveRGB(*CompositorNode*)
:   Perform level adjustments on each color channel of an image

    mapping
    :   Type:
        :   [`CurveMapping`](bpy.types.CurveMapping.html#bpy.types.CurveMapping "bpy.types.CurveMapping"), (readonly)

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use PointerProperty(Property) in Blender? Include parameters, examples, warnings and best practices.

assistant: # PointerProperty(Property)

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

*class* bpy.types.PointerProperty(*Property*)
:   RNA pointer property to point to another RNA struct

    fixed_type
    :   Fixed pointer type, empty if variable type

        Type:
        :   [`Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct"), (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Scripting & Security in Blender? Include parameters, examples, warnings and best practices.

assistant: # Scripting & Security

The ability to include Python scripts within blend-files is valuable for advanced tasks
such as rigging and automation. However, it poses a security risk since
Python does not restrict what a script can do.
Therefore, you should only run scripts from sources you know and trust.
Automatic execution is disabled by default;
however, some blend-files need this to function properly.

When a blend-file tries to execute a script and is not allowed, a dialog will appear.
In it, you can choose to *Allow Execution* or to *Ignore* the scripts.

[image reference removed]

An Auto-run warning in the Info editor’s header.
user: Provide the full official documentation entry for Scripted Expression, preserving all code examples.

assistant: [image reference removed]

A security warning in the Drivers panel.

[image reference removed]

An Auto-run warning in the Info editor’s header.

By default Blender will restrict execution of Python scripts.

If using a *Scripted Expression* Driver Type that doesn’t follow
the [Simple Expressions](drivers_panel.xhtml#drivers-simple-expressions)
subset, you will have to open the file as *Trusted Source*,
or set *Auto Run Python Scripts* in Preferences ‣ Save & Load ‣ Blender Files.

|  |  |
| --- | --- |
| ../../_images/animation_drivers_troubleshooting_autorun-file-browser.png   The Trusted Source checkbox in the File Browser. | ../../_images/animation_drivers_troubleshooting_autorun-user-preference.png   The Auto Run Python Scripts checkbox in the Preferences. |
user: Explain SDF Grid Mean Node in complete detail according to the official Blender documentation.

assistant: # SDF Grid Mean Node

[image reference removed]

The *SDF Grid Mean* node applies mean (box) filter smoothing to amSigned Distance Field (SDF) grid.
This operation averages voxel values within a local neighborhood to smooth
out small variations and noise while preserving the overall shape of the field.

The filter works as a fast, separable averaging operation—sometimes called a
*box filter*—and is well suited for general-purpose smoothing or softening of
SDF data after boolean, voxelization, or other volumetric operations.
user: Show practical ways to work with Navigating in a Blender add-on or script – include code.

assistant: Navigating the node editors is done with the use of both mouse movement and keyboard shortcuts.

Pan `MMB`
:   Move the view up, down, left and right.

Zoom `Ctrl`-`MMB`, `Wheel`
:   Move the camera forwards and backwards.

Frame Selected `NumpadPeriod`
:   Adjusts the zooms to fit only the selected nodes in the view.

Frame All `Home`
:   Adjusts the zoom to fit all nodes in the view.
user: Explain Rigidbody Constraint Type Items in complete detail according to the official Blender documentation.

assistant: # Rigidbody Constraint Type Items

FIXED:
:   Fixed.

    Glue rigid bodies together.

POINT:
:   Point.

    Constrain rigid bodies to move around common pivot point.

HINGE:
:   Hinge.

    Restrict rigid body rotation to one axis.

SLIDER:
:   Slider.

    Restrict rigid body translation to one axis.

PISTON:
:   Piston.

    Restrict rigid body translation and rotation to one axis.

GENERIC:
:   Generic.

    Restrict translation and rotation to specified axes.

GENERIC_SPRING:
:   Generic Spring.

    Restrict translation and rotation to specified axes with springs.

MOTOR:
:   Motor.

    Drive rigid body around or along an axis.