PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use LineStyleGeometryModifier_SinusDisplacement(LineStyleGeometryModifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # LineStyleGeometryModifier_SinusDisplacement(LineStyleGeometryModifier)

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

*class* bpy.types.LineStyleGeometryModifier_SinusDisplacement(*LineStyleGeometryModifier*)
:   Add sinus displacement to stroke backbone geometry

    amplitude
    :   Amplitude of the sinus displacement

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    phase
    :   Phase of the sinus displacement

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

    type
    :   Type of the modifier

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

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

    wavelength
    :   Wavelength of the sinus displacement

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Density Grid
:   The resulting float grid representing the density of the mesh.
    Voxels inside the mesh will have higher density values, while voxels
    outside the mesh will approach zero. The smooth transition is defined by
    the *Gradient Width* parameter.
user: What is Info Editor and how is it used in Blender Python scripting?

assistant: # Info Editor

The Info editor logs the executed operators as well as errors, warnings,
and informational messages. You can select an entry by clicking it,
optionally holding `Shift` to add it to the existing selection.

[image reference removed]

Info Editor.
user: What is SkinModifier(Modifier) and how is it used in Blender Python scripting?

assistant: # SkinModifier(Modifier)

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

*class* bpy.types.SkinModifier(*Modifier*)
:   Generate Skin

    branch_smoothing
    :   Smooth complex geometry around branches

        Type:
        :   float in [0, 1], default 0.0

    use_smooth_shade
    :   Output faces with smooth shading rather than flat shaded

        Type:
        :   boolean, default False

    use_x_symmetry
    :   Avoid making unsymmetrical quads across the X axis

        Type:
        :   boolean, default True

    use_y_symmetry
    :   Avoid making unsymmetrical quads across the Y axis

        Type:
        :   boolean, default False

    use_z_symmetry
    :   Avoid making unsymmetrical quads across the Z axis

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of About Image-Based Texturing: syntax, arguments, return values, common patterns.

assistant: Texture images take up precious memory space,
often being loaded into a special video memory bank that is very fast and very expensive,
so it is often very small. So, keep the images as small as possible.
A 64×64 image takes up only one fourth the memory of a 128×128 image.

For photorealistic rendering of objects in animations, often larger image textures are used,
because the object might be zoomed in on in camera moves. In general, you want to use
a texture sized proportionally to the number of pixels that it will occupy in the final render.
Ultimately, you only have a certain amount of physical RAM to hold an image texture and
the model and to provide workspace when rendering your image.

For the most efficient memory usage, image textures should be square, with dimensions as powers of 2,
such as 32×32, 64×64, 128×128, 256×256, 1024×1024, 2048×2048, and 4096×4096.

If you can reuse images across different meshes, this greatly reduces memory requirements.
You can reuse images if you map those areas of the meshes that “look alike” to a layout that
uses the common image.

When using file textures, it is very important that you have
[Mapped the UVs](../../../../modeling/meshes/uv/unwrapping/index.html)
of the mesh, and they are laid out appropriately.

You do not have to UV map the *entire* mesh.
The sphere above on the left has some faces mapped,
but other faces use procedural materials and textures.
Only use UV textures for those portions of your mesh where you want very graphic,
precise detail. For example,
a model of a vase only needs UV texture for the rim where decorative artwork is incorporated.
A throw pillow does not need a different image for the back as the front;
in fact many throw pillows have a fabric (procedural material) back.

As another example, you should UV map both eyes of a head to the same image
(unless you want one bloodshot and the other clear).
Mapping both sides of a face to the same image might not be advisable,
because the location of freckles and skin defects are not symmetrical.
You could of course change the UV map for one side of the face to slightly offset,
but it might be noticeable.
Ears are another example where images or section of an image can be mapped to similar faces.
user: What is TextureNodeTexDistNoise(TextureNode) and how is it used in Blender Python scripting?

assistant: # TextureNodeTexDistNoise(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.TextureNodeTexDistNoise(*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: What is Proxy and how is it used in Blender Python scripting?

assistant: # Proxy

As projects involve increasingly high-resolution footage,
the performance of the video preview can decrease drastically.
To combat this, Blender can generate proxies – copies of the original footage stored at a
lower quality and/or resolution – to maintain a smooth editing experience without
compromising visual fidelity in the end result.

The quickest way to set up proxies for videos is to simply select a
[Proxy Render Size](../../preview/sidebar.xhtml#bpy-types-spacesequenceeditor-proxy-render-size)
in the *View* tab (visible when the editor is in *Preview* or
*Sequencer & Preview* mode). This will automatically enable the selected
proxy resolution in all the strips and start generating the downscaled video files.

You can use the *Proxy* tab if you want to configure proxies in more detail
(or create proxies for image sequences).
user: Give a detailed overview of Selection Modes: syntax, arguments, return values, common patterns.

assistant: Selection modes limits selection operators to certain curve domains.
This feature is makes it easy to select whole segments at once, or to give more granular control over editing.

Control Points:
:   Allows selection of individual control points.

Curve:
:   Limits selection to whole curve segments.
user: How do I use UV Overlays in Blender? Include parameters, examples, warnings and best practices.

assistant: # UV Overlays

[image reference removed]

The Overlays pop-over.

In the header, there is a button to turn off all overlays for the UV Editor.
This option also toggles the visibility of [UDIM](../../modeling/meshes/uv/workflows/udims.html)
tile information.

The drop-down button opens a pop-over with more detailed settings.
The following categories are available:
user: Show practical ways to work with GeometryNodePointsToVolume(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodePointsToVolume(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.GeometryNodePointsToVolume(*GeometryNode*)
:   Generate a fog volume sphere around every point

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

assistant: Color
:   RGB color interpolated from the attribute.

Vector
:   XYZ vector interpolated from the attribute.

Factor
:   Scalar value interpolated from the attribute.

Alpha
:   Alpha channel of the attribute, when available. If the attribute has no alpha channel, generally defaults to 1.
user: Show practical ways to work with Visibility in a Blender add-on or script – include code.

assistant: # Visibility

The Visibility panel controls how objects are interacted with in the viewport and in the final render.
These visibility options can also be set in the [Outliner](../../../editors/outliner/editing.html).

Selectable
:   The object is able to be selected in the 3D Viewport.

Show In
:   Viewports
    :   The object will be displayed in the 3D Viewport.

    Renders
    :   The object is able to be in the final render, note that it will still be visible in rendered shading view.

Mask
:   Holdout
    :   Render objects as a holdout or matte, creating a hole in the image with zero [Alpha](../../../glossary/index.html#term-Alpha-Channel),
        to fill out in [compositing](../../../compositing/index.html) with real footage or another render.
user: Provide the full official documentation entry for Enabling Add-on, preserving all code examples.

assistant: 1. Open Blender and go to [Add-ons](../../../editors/preferences/addons.xhtml) section of the [Preferences](../../../editors/preferences/index.xhtml).
2. Search “Rigify” and check the *Enable Add-on* checkbox.
user: Give a detailed overview of Crease Angle: syntax, arguments, return values, common patterns.

assistant: # Crease Angle

A modifier based on the Crease Angle (angle between two adjacent faces).
If a stroke segment does not lie on a crease (i.e. the edge does not have the *Crease Angle nature*),
its properties are not touched by the modifier.

Angle Min, Max
:   The range of input values to the mapping.
    Out-of-range crease angle values will be clamped by
    the Min and Max angles and their corresponding property values.

[[image reference removed]](../../../../../../_images/render_freestyle_parameter-editor_line-style_modifiers_color_crease-angle_example.png)

Crease Angle modifier example by T.K.
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Render_freestyle_modifier_crease_angle.blend)).
user: Describe Tool Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: Number of Cuts
:   Increases and decreases the number of cuts to create.
    These cuts are uniformly distributed in the original face loop,
    and you will *not* be able to control their positions.

Correct UVs
:   Corrects the corresponding UV coordinates, if these exist, to avoid image distortions.
user: Provide the full official documentation entry for Bpy.Types.Bakesettings, preserving all code examples.

assistant: as_pointer bpy_struct.driver_add bpy_struct.driver_remove bpy_struct.get bpy_struct.id_properties_clear bpy_struct.id_properties_ensure bpy_struct.id_properties_ui bpy_struct.is_property_hidden bpy_struct.is_property_overridable_library bpy_struct.is_property_readonly bpy_struct.is_property_set bpy_struct.items bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values References ¶ RenderSettings.bake Next BevelModifier(Modifier) Previous AttributeGroupPointCloud(bpy_struct) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page BakeSettings(bpy_struct) BakeSettings BakeSettings.cage_extrusion BakeSettings.cage_object BakeSettings.displacement_space BakeSettings.filepath BakeSettings.height BakeSettings.image_settings BakeSettings.margin BakeSettings.margin_type BakeSettings.max_ray_distance BakeSettings.normal_b BakeSettings.normal_g BakeSettings.normal_r BakeSettings.normal_space BakeSettings.pass_filter BakeSettings.save_mode BakeSettings.target BakeSettings.type BakeSettings.use_automatic_name BakeSettings.use_cage BakeSettings.use_clear BakeSettings.use_lores_mesh BakeSettings.use_multires BakeSettings.use_pass_color BakeSettings.use_pass_diffuse BakeSettings.use_pass_direct BakeSettings.use_pass_emit BakeSettings.use_pass_glossy BakeSettings.use_pass_indirect BakeSettings.use_pass_transmission BakeSettings.use_selected_to_active BakeSettings.use_split_materials BakeSettings.view_from BakeSettings.width BakeSettings.bl_rna_get_subclass() BakeSettings.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Provide the full official documentation entry for Edge Loops, preserving all code examples.

assistant: *Edge Loop* allows you to delete a selected edge loop if it is between two other edge loops.
This will create one face loop where two previously existed.

### Example

The selected edge loop on the UV Sphere has been deleted and
the faces have been merged with the surrounding edges.
If the edges had been deleted by choosing *Edges* from the *Delete* menu
there would be an empty band of deleted faces all the way around the sphere instead.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_mesh_delete_edge-loop-before.png>   Selected edge loop. | <../../../../_images/modeling_meshes_editing_mesh_delete_edge-loop-after.png>   Edge loop deleted. |
user: Explain Usage in complete detail according to the official Blender documentation.

assistant: Use the tool by:

1. Orient the 3D Viewport to define the direction in depth.
2. `LMB` and hold while moving the cursor to define direction of the line projection.
3. Adjust the operation with extra *Controls* shortcuts.
4. Release `LMB` to confirm.
user: Provide the full official documentation entry for ForeachGeometryElementZoneViewerPathElem(ViewerPathElem), preserving all code examples.

assistant: # ForeachGeometryElementZoneViewerPathElem(ViewerPathElem)

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

*class* bpy.types.ForeachGeometryElementZoneViewerPathElem(*ViewerPathElem*)
:   zone_output_node_id
    :   Type:
        :   int in [-inf, inf], default 0

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # FloatVectorValueReadOnly(bpy_struct)

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

*class* bpy.types.FloatVectorValueReadOnly(*bpy_struct*)
:   vector
    :   3D vector

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], default (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: Explain GeometryNodeSimulationOutput(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeSimulationOutput(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.GeometryNodeSimulationOutput(*GeometryNode*)
:   Output data from the simulation zone

    active_index
    :   Index of the active item

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

    active_item
    :   Index of the active item

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

    state_items
    :   Type:
        :   [`NodeGeometrySimulationOutputItems`](bpy.types.NodeGeometrySimulationOutputItems.html#bpy.types.NodeGeometrySimulationOutputItems "bpy.types.NodeGeometrySimulationOutputItems") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`SimulationStateItem`](bpy.types.SimulationStateItem.html#bpy.types.SimulationStateItem "bpy.types.SimulationStateItem"), (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")

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

assistant: # Geometry Attribute Constraint

The *Geometry Attribute* constraint transforms an object or bone according to a target object’s
sampled geometry attribute data. This allows motion and deformation to be driven directly by
procedural geometry outputs, such as positions or orientations from Geometry Nodes.
user: What is Motion Tracking & Masking and how is it used in Blender Python scripting?

assistant: # Motion Tracking & Masking

You perform masking and tracking with the Movie Clip Editor.

[image reference removed]

The Movie Clip Editor.

See [Movie Clip Editor](../editors/clip/index.xhtml) for more information on the Movie Clip Editor.
user: What is Recover and how is it used in Blender Python scripting?

assistant: ### Last Session

This will load the `quit.blend` file Blender automatically saved just before exiting.
This option enables you to recover your last work [session](../../glossary/index.xhtml#term-Session) if, for example, you closed
Blender by accident.

### Auto Save

The *Auto Save* option allows you to recover the most recent automatically saved version of your file.
This is useful in the event of a crash or if you closed Blender without saving.

Selecting this option opens a file browser pointed to your system’s [Temporary Directory](../../advanced/blender_directory_layout.xhtml#temp-dir).
Auto-saved files typically have a name such as `<filename>_autosave.blend` or a random identifier,
and use the `.blend` extension.

You can configure the autosave interval and behavior in the
[Auto Save Preferences](../../editors/preferences/save_load.xhtml#bpy-types-preferencesfilepaths-use-auto-save-temporary-files).
user: Show practical ways to work with Limit Total Vertex Groups in a Blender add-on or script – include code.

assistant: Reduce the number of weight groups per vertex to the specified Limit.
The tool removes lowest weights first until the limit is reached.

Subset
:   Restrict the tool to a subset.
    See above [The Subset Option](../../../sculpt_paint/weight_paint/editing.xhtml#sculpt-paint-weight-paint-editing-subset) for how subsets are defined.

Limit
:   Maximum number of weights allowed on each vertex.
user: Show practical ways to work with Displays in a Blender add-on or script – include code.

assistant: A full HD display (1920x1080) or higher is recommended. Multi-monitor setups are supported, and workspaces can be
configured to span multiple monitors.

[image reference removed]

Example of Blender’s multi-monitor support.
user: What is Group Output and how is it used in Blender Python scripting?

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

The output slots can be edited in the *Group* tab of the *Sidebar*.
user: How do I use Geometry in Blender? Include parameters, examples, warnings and best practices.

assistant: # Geometry

[image reference removed]

Geometry panel.

The Geometry panel lets you turn a curve from a 1D line into a 2D ribbon or a 3D tube.

[image reference removed]

Three copies of the same base curve: one without geometry (bright orange line);
one with Offset and Extrude applied (blue ribbon); and one with Offset, Extrude,
and Bevel applied (gray tube).

Offset
:   Moves the control points along their normals.

Extrude
:   Turns the curve from a line into a ribbon by extruding it to the “sides”:
    at each point, the curve normal is calculated as the “up” direction,
    and the curve is extruded to the “left” and “right.”

Taper Object
:   A separate Curve object, consisting of a single, non-[cyclic](../editing/curve.xhtml#bpy-ops-curve-cyclic-toggle),
    2D spline, that controls the scale factor of the geometry along the length of each of the curve’s splines.

    Specifically, the *Taper Object* defines a graph where the X axis represents the position on the
    curve and the Y axis represents the scale:

    - The first control point of the *Taper Object* spline corresponds to the first control point of
      each geometry spline. Same thing for the last points.
    - The first *Taper* point should have the highest X coordinate, and the last point the lowest
      (try [Switch Direction](../editing/segments.xhtml#bpy-ops-curve-switch-direction) if the scaling doesn’t seem to be working).
      The specific range of X coordinates doesn’t matter: it could be [-10, 10], [-1, 1], or anything else.
    - A Y coordinate of 1.0 leaves the geometry unchanged. A coordinate of 0.5 makes it half as large,
      while 2.0 makes it twice as large.

    The Z coordinates of the *Taper Object* control points are ignored, but if you want,
    you can set the object’s [Shape](shape.xhtml#bpy-types-curve-dimensions) to “2D” to force them to 0.

Taper Radius
:   How to combine the scale graph of the *Taper Object* with the radii of the control points.

    Override:
    :   The *Taper Object* (scale curve) overrides the radii (scales) of the curve’s control points.

    Multiply:
    :   The scale given by the *Taper Object* is multiplied by that of the control points.

    Add:
    :   The scale given by the *Taper Object* is added to that of the control points.

    Examples of a curve with a Radius of 0 on the left and 1 on the right.

    |  |  |  |
    | --- | --- | --- |
    | ../../../_images/modeling_curves_properties_geometry_taper-mode-override.png   Override mode. | ../../../_images/modeling_curves_properties_geometry_taper-mode-multiply.png   Multiply mode. | ../../../_images/modeling_curves_properties_geometry_taper-mode-add.png   Add mode. |

Map Taper
:   If geometry is only generated for part of the curve (which can be achieved by changing
    [Factor Start/End](#bpy-types-curve-bevel-factor-start)), enabling *Map Taper* will
    make the endpoints of the *Taper Object* correspond to those of the geometry instead of
    those of the curve.
user: How do I use Snapping in Blender? Include parameters, examples, warnings and best practices.

assistant: # Snapping

Snapping lets you easily align UV elements to others.
It can be toggled by clicking the magnet icon in the UV Editor’s header,
or more temporarily by holding `Ctrl`.

This page is about the Snap header button; for the Snap menu,
see [UV Editing](../../../modeling/meshes/uv/editing.html#bpy-ops-uv-snap-selected).
user: Describe Custom Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Custom properties are always imported, and will be exported from most objects
if the Include ‣ Custom Properties option is selected before export.
These are stored in the `extras` field on the corresponding object in the glTF file.

Unlike glTF extensions, custom properties (extras) have no defined namespace,
and may be used for any user-specific or application-specific purposes.
user: What is Inherited Properties and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Constraint.name`](bpy.types.Constraint.html#bpy.types.Constraint.name "bpy.types.Constraint.name") - [`Constraint.type`](bpy.types.Constraint.html#bpy.types.Constraint.type "bpy.types.Constraint.type") - [`Constraint.is_override_data`](bpy.types.Constraint.html#bpy.types.Constraint.is_override_data "bpy.types.Constraint.is_override_data") - [`Constraint.owner_space`](bpy.types.Constraint.html#bpy.types.Constraint.owner_space "bpy.types.Constraint.owner_space") - [`Constraint.target_space`](bpy.types.Constraint.html#bpy.types.Constraint.target_space "bpy.types.Constraint.target_space") - [`Constraint.space_object`](bpy.types.Constraint.html#bpy.types.Constraint.space_object "bpy.types.Constraint.space_object") - [`Constraint.space_subtarget`](bpy.types.Constraint.html#bpy.types.Constraint.space_subtarget "bpy.types.Constraint.space_subtarget") | - [`Constraint.mute`](bpy.types.Constraint.html#bpy.types.Constraint.mute "bpy.types.Constraint.mute") - [`Constraint.enabled`](bpy.types.Constraint.html#bpy.types.Constraint.enabled "bpy.types.Constraint.enabled") - [`Constraint.show_expanded`](bpy.types.Constraint.html#bpy.types.Constraint.show_expanded "bpy.types.Constraint.show_expanded") - [`Constraint.is_valid`](bpy.types.Constraint.html#bpy.types.Constraint.is_valid "bpy.types.Constraint.is_valid") - [`Constraint.active`](bpy.types.Constraint.html#bpy.types.Constraint.active "bpy.types.Constraint.active") - [`Constraint.influence`](bpy.types.Constraint.html#bpy.types.Constraint.influence "bpy.types.Constraint.influence") - [`Constraint.error_location`](bpy.types.Constraint.html#bpy.types.Constraint.error_location "bpy.types.Constraint.error_location") - [`Constraint.error_rotation`](bpy.types.Constraint.html#bpy.types.Constraint.error_rotation "bpy.types.Constraint.error_rotation") |
user: Describe Development from the Blender manual or Python API, including usage steps and snippets.

assistant: Only visible when [Developer Extras](interface.html#bpy-types-preferencesview-show-developer-ui) are enabled.

I18n Branches
:   The path to the `/branches` directory of your local SVN translation copy, to allow translating from the UI.
user: What is Light Portals and how is it used in Blender Python scripting?

assistant: When rendering a daylight indoor scene where most of the light is coming in through a window
or door opening, it is difficult for the integrator to find its way to them.
To fix this, use [Light Portals](../light_settings.xhtml#render-cycles-lights-area-portals).
You then will need to modify its shape to match that of the opening that you are trying to fill.

[image reference removed]

[image reference removed]
user: Provide the full official documentation entry for Color Fields, preserving all code examples.

assistant: [image reference removed]

Color fields. With and without alpha.

The color field stores a color value.
Clicking on it with `LMB` opens the [Color Picker](../templates/color_picker.html).

Color fields with an alpha channel are divided in half: on the left, the color is shown without an alpha channel,
and on the right, it’s shown with an alpha channel over a checker pattern.

Colors can be copied to other color fields by dragging and dropping.

Hovering over a color property will display a large swatch preview of the color
and the color’s hexadecimal, RGBA, and HSVA values.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Component
:   The material component to base the toon effect.

    Diffuse:
    :   Use shading based on the Diffuse BSDF.

    Glossy:
    :   Use shading based on the Glossy BSDF for specular reflection.
user: Give a detailed overview of Add IK to Bone: syntax, arguments, return values, common patterns.

assistant: # Add IK to Bone

Adds an [Inverse Kinematics Constraint](../../../constraints/tracking/ik_solver.xhtml) to the active bone.
The operator shows a menu for selecting the target of the constraint:

Without Target
:   Creates the constraint without a *Target*. Only available when no other bone
    or object is selected.

Target New Empty Object
:   Creates an [Empty](../../../../modeling/empties.xhtml) at the bone’s tail and uses it
    as the constraint target. Only available when no other bone or object is
    selected.

Target Selected Bone
:   Sets the target to the selected bone that’s *not* active.

Target Selected Object
:   Sets the target to the selected object that’s *not* active. Either select
    the object before selecting the Armature and entering Pose Mode,
    or select it in the [Outliner](../../../../editors/outliner/introduction.xhtml) when
    already in Pose Mode.

# Remove IK

Removes the [Inverse Kinematics Constraint](../../../constraints/tracking/ik_solver.xhtml) from the selected bones.
user: Show practical ways to work with SDF Fillet Node in a Blender add-on or script – include code.

assistant: # SDF Fillet Node

[image reference removed]

The *SDF Fillet* node smooths or rounds off concave internal corners in a Signed Distance Field (SDF) grid.
It modifies the field to produce softer transitions between surfaces that meet
at sharp inward angles, similar to adding a *fillet* or *bevel* in mesh modeling.

This operation only affects regions with **negative principal curvature**
(concave corners) and preserves overall volume. The result is a more organic
and continuous surface, useful for soft blending of intersecting shapes or
removing hard transitions after boolean operations.
user: Describe Images and Video from the Blender manual or Python API, including usage steps and snippets.

assistant: When working with image and video files, Blender will automatically try to guess the right color space.
If this is not correct, the color space of the image file can be configured in the image settings.

A common situation where manual changes are needed is when working with or baking normal maps and
displacement maps. Such maps do not actually store colors, just data encoded as colors.
Those images should be marked as *Non-Color Data*.

For intermediate image files in production, it is recommended to use *OpenEXR* files.
These are always stored in scene linear color spaces, with high precision to avoid data loss.
That makes them suitable to store renders that can later be composited, color graded and
converted to different output formats.
user: Describe Create Plane Track from the Blender manual or Python API, including usage steps and snippets.

assistant: The *Create Plane Track* operator creates a new plane track.
Planar tracking takes advantage of the fact that there are often planar surfaces in footage,
by attaching markers to points on these flat planes.
It can be used to replace things like billboards and screens on the footage with another image or video.
It also might be used for masking.

This button will create a plane object
which is deforming in the same way as plane defined by all selected point tracks.
At least four feature points tracked across the footage which belongs to
the plane you want to replace are needed. More tracks will give better estimation of plane motion.

Feature points used to estimate plane motion could be used from any place on the plane,
meaning it’s not necessarily need to be corners. Corners are not always easy to be tracked,
they might be occluded. In this case you can position tracked features that lay on the same plane
far away from the actual plane which should be replaced.

This provides more information about the possible deformation of the marker in following frames,
and such markers can be tracked even if partially occluded (appear and disappear during the time).
It is only required that two neighbor frames have at least four common tracks.

An image can be projected onto the plane with
the [Plane Track Deform Node](../../../../compositing/types/tracking/plane_track_deform.xhtml) compositing node.
user: Describe Some history from the Blender manual or Python API, including usage steps and snippets.

assistant: Bone Collections were introduced in Blender 4.0, as a replacement for armature
layers and bone groups. Bone Collections are owned by the Armature, so they are
available in all modes. To contrast, bone groups were stored on the object’s
pose, and thus were not available in armature edit mode.
user: How do I use Cube in Blender? Include parameters, examples, warnings and best practices.

assistant: Adds a standard cube mesh composed of six quad faces, eight vertices, and twelve edges.
This is one of the most basic and frequently used primitives in modeling,
serving as a starting point for creating boxes, crates, buildings, or sculpting bases.

Size
:   Sets the total width, height, and depth of the cube (i.e., the full diameter along each axis).
    A size of 2 creates a cube that spans from -1 to +1 on all axes.
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

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.html)
- [Rotate](rotate.html)
- [Scale](scale.html)

These three transforms are the three big ones. However, more advanced transformations can be found
in the [Advanced Transformations](index.html) 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: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`Object.local_view_get`](bpy.types.Object.html#bpy.types.Object.local_view_get "bpy.types.Object.local_view_get") - [`Object.local_view_set`](bpy.types.Object.html#bpy.types.Object.local_view_set "bpy.types.Object.local_view_set") - [`Object.visible_get`](bpy.types.Object.html#bpy.types.Object.visible_get "bpy.types.Object.visible_get") | - [`Object.visible_in_viewport_get`](bpy.types.Object.html#bpy.types.Object.visible_in_viewport_get "bpy.types.Object.visible_in_viewport_get") - [`SpaceView3D.local_view`](#bpy.types.SpaceView3D.local_view "bpy.types.SpaceView3D.local_view") |
user: Explain CollectionChild(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # CollectionChild(bpy_struct)

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

*class* bpy.types.CollectionChild(*bpy_struct*)
:   Child collection with its collection related settings

    light_linking
    :   Light linking settings of the collection object

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Point Info in a Blender add-on or script – include code.

assistant: # Point Info

Cycles Only

[image reference removed]

The *Point Info* node can be used in the material node tree for point cloud objects
and gives access to the data of individual points.
It can be useful to give some variation to a single material assigned a point cloud object.
user: How do I use TransformCacheConstraint(Constraint) in Blender? Include parameters, examples, warnings and best practices.

assistant: # TransformCacheConstraint(Constraint)

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

*class* bpy.types.TransformCacheConstraint(*Constraint*)
:   Look up transformation from an external file

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

    object_path
    :   Path to the object in the Alembic archive used to lookup the transform matrix

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Movie Clip
:   The selectable clip data-block used as input for the gradient colors.

Tracking Object
:   Tracking Object to generate the gradient.
    You will probably want to create new a tracking object
    in the [Object](../../../movie_clip/tracking/clip/sidebar/track/objects.html#movie-clip-tracking-properties-object) panel,
    because tracks used for gradients can not actually be used for camera/object tracking.
    After this tracks might be placed in places where gradient colors should be sampled.
    These tracks could be tracked or moved manually,
    so gradients would be updating automatically along the movie.
    Tracks might have an offset for easier tracking of feature-less screens.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Properties are available in the *Node* tab of the Sidebar.

Sync Sockets
:   Updates the current node to match the socket signature of the connected nodes.
    Use this after renaming, adding, or removing sockets.

Define Signature
:   Locks the current item list and types to stabilize interfaces when publishing node groups.
    When enabled, adding/removing items is disabled until the option is turned off.

### Bundle Items

List of bundle items
:   Displays one entry per element in the bundle.
    Double-click to rename.

    Add Item
    :   Add a new socket to the bundle.

    Remove Item
    :   Delete the selected socket.

Type
:   The data type for the selected item (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value control is shown and used when the socket is unlinked.
user: Show practical ways to work with Baking in a Blender add-on or script – include code.

assistant: The simulation is automatically cached during playback.
The valid cache can be seen as a strong yellow line in the timeline editor.
This allows for animators to quickly inspect all the previous frames of a simulation.

[image reference removed]

Cached frames in the Timeline.

For the cases where the current frame is the only one relevant, users can opt-out of “Cache” to save memory.

When the result is ready to be sent to a render-farm, it can be baked to disk.
This allows for the simulation to be rendered in a non-sequential order.

[image reference removed]

Simulation and Physics, Simulation Nodes user interface.
user: Describe Faces & Edges by Vertices from the Blender manual or Python API, including usage steps and snippets.

assistant: *Faces & Edges by Vertices* is similar to *Faces by Edges* except that
it also splits the vertices of the adjacent connecting edges.
This has the same functionality as manually ripping all faces and edges away from a vertex.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_mesh_split_faces-before.png   Before. | ../../../../_images/modeling_meshes_editing_mesh_split_faces-after.png   After (also moving edges away). |