PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain Fast GI Approximation in complete detail according to the official Blender documentation.

assistant: Fast GI Approximation is a fallback to the ray-tracing pipeline for
BSDF with high roughness.
It produces a less noisy output and captures bounce lighting more efficiently than individually traced rays.

This is currently implemented as a screen space effect and will inherit all associated
[limitations](../limitations/limitations.xhtml#eevee-limitations-screenspace).

Threshold
:   Maximum roughness a BSDF can have to use ray-tracing.
    BSDFs with higher roughness will progressively use the *Fast GI Approximation*.
    A value of 1 will raytrace every surfaces and disable the Fast GI.

Method
:   Determine the method used to compute the fast GI approximation.

    Ambient Occlusion:
    :   Use scene intersections to shadow the distant lighting from light-probes.
        This is the fastest option.

    Global Illumination:
    :   Compute global illumination taking into account light bouncing off surrounding objects.

Resolution
:   Resolution at which the fast GI is computed.
    Lower options will be faster and use less memory but will produce blurrier results.

Rays
:   Number of GI rays per pixel at the specified *Resolution*.
    Higher values will reduce noise.

Steps
:   Number of screen samples per GI ray.
    Higher values will reduce the noise amount and increase the quality.

Precision
:   Higher values increase the precision of the scene intersections with the GI rays.
    Increased precision also increases performance cost.

Distance
:   If non-zero, the maximum distance at which other surfaces will contribute to the fast GI approximation.

Thickness Near
:   Geometric thickness of the surfaces when computing fast GI and ambient occlusion.
    Reduces light leaking and missing contact occlusion.
    The effectiveness decreases proportionally to the distance from the shading point,
    following the inverse square law.

Far
:   Angular thickness of the surfaces when computing fast GI and ambient occlusion.
    Reduces energy loss and missing occlusion of far geometry.
    Higher values will make the very thin objects block or reflect too much light.

Bias
:   Bias the shading normal to reduce self intersection artifacts.
user: Show practical ways to work with Seams in a Blender add-on or script – include code.

assistant: # Seams

For many cases, using the Unwrap calculations of Cube, Cylinder, Sphere,
or the regular “Unwrap” operators will produce a good UV layout.
But for more complex meshes, especially those with lots of indentations,
you may want to define a *seam* to limit and guide the [Unwrap](../../editing/uv.xhtml#bpy-ops-uv-unwrap) operator.

Just like in sewing, a seam is where the ends of the image/cloth are sewn together.
In unwrapping, the UV map is discontinuous at the seams.
Think of this method as peeling an orange or skinning an animal.
You make a series of cuts in the skin, then peel it off. You could then flatten it out,
applying some amount of stretching. These cuts are the same as seams.

[image reference removed]

Simple seam on a cylinder.

When using this method, you need to be aware of how much stretching there is.
The more seams there are, the less stretching there is,
but this is often an issue for the texturing process.
It is a good idea to have as few seams as possible while having the least amount of stretching.
Try to hide seams where they will not be seen. In productions where 3D paint is used,
this becomes less of an issue, as projection painting can easily deal with seams,
as opposed to 2D texturing, where it is difficult to match the edges of different UV islands.

The workflow is the following:

1. Mark seams.
2. Unwrap.
3. Adjust seams and repeat.
4. Manually adjust UVs.
user: Describe CompositorNodeGamma(CompositorNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CompositorNodeGamma(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.CompositorNodeGamma(*CompositorNode*)
:   *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: What is GeometryNodeSubdivideCurve(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeSubdivideCurve(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.GeometryNodeSubdivideCurve(*GeometryNode*)
:   Dividing each curve segment into a specified number of pieces

    *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 Transform Driver in Blender? Include parameters, examples, warnings and best practices.

assistant: Control a property with an object’s transform.
In this example, the Y rotation of Object 2 will be driven by the X position of Object 1.
Starting from a simple setup with two objects:

1. Add a Driver to the *Rotation Y* property of the second object via the context menu or with `Ctrl`-`D`.

   [image reference removed]
2. Open the *Drivers Editor* and select the *Y Euler Rotation* property in the channels region.
3. Open the Sidebar region and select the *Drivers* tab.
4. Configure the driver to be the *Averaged Value* of a *Transform Channel* of the first object.

   [image reference removed]
5. Experiment with moving the first object and notice how it affects the Y rotation of the second object.
user: How do I use Addon(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # Addon(bpy_struct)

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

*class* bpy.types.Addon(*bpy_struct*)
:   Python add-ons to be loaded automatically

    module
    :   Module name

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

    preferences
    :   Type:
        :   [`AddonPreferences`](bpy.types.AddonPreferences.html#bpy.types.AddonPreferences "bpy.types.AddonPreferences"), (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: Describe Join Bundle Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Join Bundle Node

[image reference removed]

The *Join Bundle* node combines multiple bundles into a single output bundle.
Each connected input bundle is merged together, producing one bundle
that contains all items from the inputs.
user: Describe Sample Grid Index Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Sample Grid Index Node

[image reference removed]

The *Sample Grid Index* node retrieves values directly from a voxel grid at
specific voxel indices rather than at arbitrary spatial positions.
Unlike the [Sample Grid](sample_grid.xhtml)
node, which interpolates between voxels in object space, this node reads the
exact stored value of the voxel located at the specified integer coordinates.

This makes it useful for working in *index space*, for example when performing
voxel neighborhood lookups, procedural filtering, or sampling based on values
from the [Voxel Index](../read/voxel_index.xhtml) node.
user: Provide the full official documentation entry for Trim Gesture Tools, preserving all code examples.

assistant: # Trim Gesture Tools

Trim gesture tools add or remove geometry based on a selection area.
This tool is especially useful for sketching an early base mesh for further
sculpting with the [voxel remesher](../tool_settings/remesh.xhtml).

|  |  |  |
| --- | --- | --- |
| ../../../_images/sculpt-paint_sculpt_trim_lasso_visual_example_a.png   Using Lasso Trim set to *Join* | ../../../_images/sculpt-paint_sculpt_trim_lasso_visual_example_b.png   The symmetrized mesh. | ../../../_images/sculpt-paint_sculpt_trim_lasso_visual_example_c.png   Sculpting with voxel remeshing. |

New geometry is assigned to a new [Face Set](../editing/face_sets.xhtml#sculpting-editing-facesets).
When removing geometry, the new interior geometry along the selection will be assigned
a new face set instead.
user: Give a detailed overview of Instance Processing: syntax, arguments, return values, common patterns.

assistant: Almost all nodes that process geometry do so by processing each unique
geometry separately rather than realized geometry. For example,
if a [Subdivision Surface Node](mesh/operations/subdivision_surface.html) was placed at
the end of the example above, it would only have to subdivide three meshes,
rather than each instance of a mesh. Another important example is processing with
the output of the [String to Curves Node](utilities/text/string_to_curves.html),
where each unique character only has to be processed once.

This method can improve performance a lot, but it means that the result of an operation
will be the same for every instance of a certain geometry. In order to have unique results
for every instance, the [Realize Instances Node](instances/realize_instances.html)
node can be used.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`SpaceFileBrowser.bookmarks`](bpy.types.SpaceFileBrowser.html#bpy.types.SpaceFileBrowser.bookmarks "bpy.types.SpaceFileBrowser.bookmarks") - [`SpaceFileBrowser.recent_folders`](bpy.types.SpaceFileBrowser.html#bpy.types.SpaceFileBrowser.recent_folders "bpy.types.SpaceFileBrowser.recent_folders") | - [`SpaceFileBrowser.system_bookmarks`](bpy.types.SpaceFileBrowser.html#bpy.types.SpaceFileBrowser.system_bookmarks "bpy.types.SpaceFileBrowser.system_bookmarks") - [`SpaceFileBrowser.system_folders`](bpy.types.SpaceFileBrowser.html#bpy.types.SpaceFileBrowser.system_folders "bpy.types.SpaceFileBrowser.system_folders") |
user: Describe Inherited Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Modifier.name`](bpy.types.Modifier.html#bpy.types.Modifier.name "bpy.types.Modifier.name") - [`Modifier.type`](bpy.types.Modifier.html#bpy.types.Modifier.type "bpy.types.Modifier.type") - [`Modifier.show_viewport`](bpy.types.Modifier.html#bpy.types.Modifier.show_viewport "bpy.types.Modifier.show_viewport") - [`Modifier.show_render`](bpy.types.Modifier.html#bpy.types.Modifier.show_render "bpy.types.Modifier.show_render") - [`Modifier.show_in_editmode`](bpy.types.Modifier.html#bpy.types.Modifier.show_in_editmode "bpy.types.Modifier.show_in_editmode") - [`Modifier.show_on_cage`](bpy.types.Modifier.html#bpy.types.Modifier.show_on_cage "bpy.types.Modifier.show_on_cage") | - [`Modifier.show_expanded`](bpy.types.Modifier.html#bpy.types.Modifier.show_expanded "bpy.types.Modifier.show_expanded") - [`Modifier.is_active`](bpy.types.Modifier.html#bpy.types.Modifier.is_active "bpy.types.Modifier.is_active") - [`Modifier.use_pin_to_last`](bpy.types.Modifier.html#bpy.types.Modifier.use_pin_to_last "bpy.types.Modifier.use_pin_to_last") - [`Modifier.is_override_data`](bpy.types.Modifier.html#bpy.types.Modifier.is_override_data "bpy.types.Modifier.is_override_data") - [`Modifier.use_apply_on_spline`](bpy.types.Modifier.html#bpy.types.Modifier.use_apply_on_spline "bpy.types.Modifier.use_apply_on_spline") - [`Modifier.execution_time`](bpy.types.Modifier.html#bpy.types.Modifier.execution_time "bpy.types.Modifier.execution_time") - [`Modifier.persistent_uid`](bpy.types.Modifier.html#bpy.types.Modifier.persistent_uid "bpy.types.Modifier.persistent_uid") |
user: Explain Options in complete detail according to the official Blender documentation.

assistant: These options are available while the tool is in use, and later in
the [Adjust Last Operation](../../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.

Number of Cuts `Wheel`
:   During the first step, you can change the number of cuts to create by
    scrolling `Wheel`, typing a number, or pressing `PageUp`/`PageDown`.

    |  |  |
    | --- | --- |
    | ../../../../_images/modeling_meshes_editing_edge_loopcut-slide_multicut.png   Preview of multiple edge loops. | ../../../../_images/modeling_meshes_editing_edge_loopcut-slide_multicut-after.png   Result of using multiple cuts. |

Smoothness
:   How much to offset the newly created edges along their normals to maintain surface curvature.
    You can change this in the first step using `Alt`-`Wheel`, but because the smoothness
    isn’t previewed at that stage, it’s typically better to change it afterwards in the
    *Adjust Last Operation* panel.

    |  |  |
    | --- | --- |
    | ../../../../_images/modeling_meshes_editing_edge_loopcut-slide_unsmooth.png   Added edge loop without smoothing. | ../../../../_images/modeling_meshes_editing_edge_loopcut-slide_smooth.png   Same edge loop, but with smoothing value. |

Falloff
:   Falloff type for *Smoothness*. Changes the shape of the profile.

Factor
:   Position of the edge loop relative to the surrounding ones.

Even `E`
:   Makes the new edge loop have an even distance to an existing adjacent one
    (instead of a distance that’s proportional to the length of each
    perpendicular edge it crosses). You can press `E` during the second
    step to toggle it.

Flipped `F`
:   Keep an *Even* distance to the other adjacent edge. You can press `F`
    during the second step to toggle it.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_loopcut-slide_uneven.png   Cut with *Even* disabled. | ../../../../_images/modeling_meshes_editing_edge_loopcut-slide_even.png   Cut with *Even* enabled. The red dot shows the side to which an even distance is kept. | ../../../../_images/modeling_meshes_editing_edge_loopcut-slide_even_flipped.png   Cut with *Even* and *Flipped* enabled. |

Clamp `C`
:   When unchecked, the new edge loop can go outside the face loop’s boundary edges.
    You can press `C` or hold `Alt` during the second step to toggle it.

Mirror Editing
:   When checked, sliding the newly created edges will also slide any existing edges
    on the other side of the mesh. [Mesh Symmetry](../../tools/tool_settings.xhtml#modeling-meshes-tools-settings-mirror)
    needs to be enabled for this to work.

Correct UVs
:   When unchecked, the faces in the [UV map](../../../../editors/uv/introduction.xhtml) will be split
    uniformly even if the cut was placed off-center on the 3D mesh.
user: How do I use Bpy.Types.Textcurve in Blender? Include parameters, examples, warnings and best practices.

assistant: rve.render_resolution_v Curve.eval_time Curve.bevel_object Curve.taper_object Curve.dimensions Curve.fill_mode Curve.twist_mode Curve.taper_radius_mode Curve.bevel_factor_mapping_start Curve.bevel_factor_mapping_end Curve.twist_smooth Curve.use_fill_caps Curve.use_map_taper Curve.use_auto_texspace Curve.texspace_location Curve.texspace_size Curve.materials Curve.bevel_factor_start Curve.bevel_factor_end Curve.is_editmode Curve.animation_data Curve.cycles Inherited Functions ¶ bpy_struct.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 ID.bl_system_properties_get ID.rename ID.evaluated_get ID.copy ID.asset_mark ID.asset_clear ID.asset_generate_preview ID.override_create ID.override_hierarchy_create ID.user_clear ID.user_remap ID.make_local ID.user_of_id ID.animation_data_create ID.animation_data_clear ID.update_tag ID.preview_ensure ID.bl_rna_get_subclass ID.bl_rna_get_subclass_py Curve.transform Curve.validate_material_indices Curve.update_gpu_tag Curve.bl_rna_get_subclass Curve.bl_rna_get_subclass_py Next TextLine(bpy_struct) Previous TextCharacterFormat(bpy_struct) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page TextCurve(Curve) TextCurve TextCurve.active_textbox TextCurve.align_x TextCurve.align_y TextCurve.body TextCurve.body_format TextCurve.edit_format TextCurve.family TextCurve.follow_curve TextCurve.font TextCurve.font_bold TextCurve.font_bold_italic TextCurve.font_italic TextCurve.has_selection TextCurve.is_select_bold TextCurve.is_select_italic TextCurve.is_select_smallcaps TextCurve.is_select_underline TextCurve.offset_x TextCurve.offset_y TextCurve.overflow TextCurve.shear TextCurve.size TextCurve.small_caps_scale TextCurve.space_character TextCurve.space_line TextCurve.space_word TextCurve.text_boxes TextCurve.underline_height TextCurve.underline_position TextCurve.use_fast_edit TextCurve.bl_rna_get_subclass() TextCurve.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Provide the full official documentation entry for Group, preserving all code examples.

assistant: # Group

A [Group Node](../../interface/controls/nodes/groups.xhtml) combines a set of nodes into a single one,
and selectively exposes inputs and outputs of those nodes.

Group nodes can simplify a node tree by hiding away complexity and reusing functionality.
user: Show practical ways to work with BoneColor(bpy_struct) in a Blender add-on or script – include code.

assistant: # BoneColor(bpy_struct)

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

*class* bpy.types.BoneColor(*bpy_struct*)
:   Theme color or custom color of a bone

    custom
    :   The custom bone colors, used when palette is ‘CUSTOM’

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

    is_custom
    :   A color palette is user-defined, instead of using a theme-defined one

        Type:
        :   boolean, default False, (readonly)

    palette
    :   Color palette to use

        Type:
        :   enum in [`'DEFAULT'`, `'THEME01'`, `'THEME02'`, `'THEME03'`, `'THEME04'`, `'THEME05'`, `'THEME06'`, `'THEME07'`, `'THEME08'`, `'THEME09'`, `'THEME10'`, `'THEME11'`, `'THEME12'`, `'THEME13'`, `'THEME14'`, `'THEME15'`, `'THEME16'`, `'THEME17'`, `'THEME18'`, `'THEME19'`, `'THEME20'`, `'CUSTOM'`], default `'DEFAULT'`

    *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 StripCrop(bpy_struct), preserving all code examples.

assistant: # StripCrop(bpy_struct)

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

*class* bpy.types.StripCrop(*bpy_struct*)
:   Cropping parameters for a sequence strip

    max_x
    :   Number of pixels to crop from the right side

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

    max_y
    :   Number of pixels to crop from the top

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

    min_x
    :   Number of pixels to crop from the left side

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

    min_y
    :   Number of pixels to crop from the bottom

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

assistant: Clicking places a point in the viewport. Each time `LMB` is pressed, a new point of the polygon is created.
Pressing `LMB` on the starting point, pressing `LMB` twice,
or pressing `Return` closes the selection area.

### Controls

Move `Spacebar`
:   Hold to reposition the selection area.
user: Describe Inherited Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleGeometryModifier.name`](bpy.types.LineStyleGeometryModifier.html#bpy.types.LineStyleGeometryModifier.name "bpy.types.LineStyleGeometryModifier.name") |
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

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

The Wireframe modifier.

Thickness
:   The depth or size of the wireframes.

Offset
:   A value between (-1 to 1) to change whether the wireframes are
    generated inside or outside of the original mesh.
    Set to zero, *Offset* will center the wireframes around the original edges.

Boundary
:   Creates wireframes on mesh island boundaries.

Replace Original
:   If this option is enabled, the original mesh is replaced by the generated wireframe.
    If not, the wireframe is generated on top of it.

Thickness
:   Even
    :   Maintain thickness by adjusting for sharp corners.
        Sometimes improves quality but also increases computation time.

    Relative
    :   Determines the edge thickness by the length of the edge. Longer edges will be thicker.

Crease Edges
:   This option is intended for usage with
    the [Subdivision](subdivision_surface.html) modifier.
    Enable this option to crease edges on their junctions and prevent large curved intersections.

    Crease Weight
    :   Define how much crease (0 to 1, nothing to full) the junctions should receive.

Material Offset
:   Uses the chosen material index as the material for the wireframe;
    this is applied as an offset from the first material.

### Vertex Group

The weights of the selected vertex group are multiplied onto the *Thickness*,
so vertices with lower weights will be less thick. The vertices which are not part
of the vertex group will be used as if their weight was zero.

Invert
:   Reverses the vertex group weights, so that the used weight is one minus the actual weight.

Factor
:   How much the vertex weights are taken into account.

    - On 0.0 , vertices with zero weight will have no thickness at all.
    - On 0.5 , vertices with zero weight will be half as thick as those with full weight.
    - On 1.0 , the weights are ignored and the *Thickness* value is used for every vertex.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

UV Map
:   Which UV map to modify; if not set it defaults to the active rendering layer.

UV Center
:   The center point of the UV map to use when applying scale or rotation.
    With (0, 0) at the bottom left and (1, 1) at the top right.

Axis U, V
:   The axes to use when mapping the 3D coordinates into 2D.

Object From, To
:   The two objects used to define the transformation. See [Usage](#usage) below.

Vertex Group
:   The vertex group can be used to scale the influence of the transformation per vertex.

    Invert
    :   Inverts the influence of the selected vertex group, meaning that the group
        now represents vertices that will not be deformed by the modifier.

        The setting reverses the weight values of the group.

### Transform

Offset
:   Amount to move the UV map.

Scale
:   Amount to scale the UV map.

Rotation
:   Amount to rotate the UV map.
user: Show practical ways to work with Shape in a Blender add-on or script – include code.

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

Fast Editing
:   Does not fill the letters in Edit Mode, only show their outline.
user: Show practical ways to work with GeometryNodeSetSplineResolution(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeSetSplineResolution(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.GeometryNodeSetSplineResolution(*GeometryNode*)
:   Control how many evaluated points should be generated on every curve segment

    *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: Show practical ways to work with Export in a Blender add-on or script – include code.

assistant: ### Scene Options

Object
:   Determine which objects will be included in the export.

    Active:
    :   Export only the active Grease Pencil object.

    Selected:
    :   Export all selected Grease Pencil objects.

    Visible:
    :   Export all visible Grease Pencil object in the scene.

### Export Options

Frame
:   Determine which frames will be included in the export.

    Active:
    :   Export only the active keyframe.

    Selected:
    :   Export all selected keyframes as SVG animation.

    Scene:
    :   Export all frames as SVG animation.

Sampling
:   Precision for the stroke sampling. Low values mean a more accurate result.

Fill
:   When enabled, export the Grease Pencil strokes fill.

Uniform Width
:   When enabled, export strokes with constant thickness.

Clip Camera
:   When enabled and camera view is active, export only the strokes clipped from camera view.
user: Give a detailed overview of Timeline: syntax, arguments, return values, common patterns.

assistant: Allow Negative Frame
:   Playback and animations can occur during negative frame ranges.

Minimum Grid Spacing
:   The minimum number of pixels between grid lines.

Timecode Style
:   Format of timecodes displayed when not displaying timing in terms of frames.

    Minimal Info:
    :   Most compact representation, uses ‘+’ as separator for sub-second frame numbers,
        with left and right truncation of the timecode as necessary.

    SMPTE (Full):
    :   Full SMPTE timecode (format is HH:MM:SS:FF).

    SMPTE (Compact):
    :   SMPTE timecode showing minutes, seconds, and frames only
        – hours are also shown if necessary, but not by default.

    Compact with Decimals:
    :   Similar to SMPTE (Compact), except that the decimal part of the second is shown instead of frames.

    Only Seconds:
    :   Direct conversion of frame numbers to seconds.

Zoom to Frame Type
:   Defines what time range (around the cursor) will be displayed
    when the *View Frame* `Numpad0` is performed.

    Keep Range:
    :   The currently displayed time range is preserved.

    Seconds:
    :   The number of seconds specified in the *Zoom Seconds* field will be shown around the cursor.

    Keyframes:
    :   The number of animation keyframes defined in the *Zoom Keyframes* field will be shown around the cursor.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Result
:   If both depth values are equal, it will use the foreground image.
    Whichever depth value is less decides which image pixel is used.
    See [Z-buffer](../../../glossary/index.html#term-Z-buffer).

Depth
:   The combined depth, which allows to thread multiple Depth Combine nodes together.
user: What is Calculating Distortion and how is it used in Blender Python scripting?

assistant: Before using this node, one has to calculate the lens distortion of the clip. This can be done by adjusting
K1, K2 and K3 values in Movie Clip Editor ‣ Properties ‣ Lens.
For more information on how to edit those values,
[check this out](https://blender.stackexchange.com/questions/15620).
user: Provide the full official documentation entry for Performance, preserving all code examples.

assistant: Playback performance can be improved in several ways.

The method with the most impact is to allow the Video Sequencer to cache generated frames.
There are two levels of cache: a memory cache, which is enabled by default
(and can be enlarged if RAM allows), and a disk cache, which is slower but has more capacity.
Both of these can be configured in the [Preferences](../preferences/system.xhtml#prefs-system-video-sequencer).

Another way to improve performance is by using [Strip Proxies](sequencer/sidebar/proxy.xhtml#bpy-types-stripproxy).
These are copies of source images and videos with a lower resolution and/or quality,
making them faster to load than the originals.
user: Describe Add/Subtract Brushes from the Blender manual or Python API, including usage steps and snippets.

assistant: These brushes generally push vertices outwards and inwards and are the most customizable to achieve a wide variety of
effects. They typically don’t use a color in their thumbnail.

[image reference removed]

Draw
:   Brush Type: [Draw](draw.xhtml)

    Shortcut: `V`

    The standard brush for pushing vertices inwards and outwards from the surface direction.

Draw Sharp
:   Brush Type: [Draw Sharp](draw_sharp.xhtml)

    Shortcut: `Shift` `V`

    Same as *Draw* but with a much sharper [Falloff](../../brush/falloff.xhtml).
    Useful for creating creases and sharp angles.

Clay
:   Brush Type: [Clay](clay.xhtml)

    Similar to the *Draw* brush but with a flattening effect and subtle smoothing.
    Useful for polishing and building volumes.

Clay Strips
:   Brush Type: [Clay Strips](clay_strips.xhtml)

    Shortcut: `C`

    The same as the *Clay* brush, but more aggressive with a square falloff.
    A common standard for building rough volumes.

Clay Thumb
:   Brush Type: [Clay Thumb](clay_thumb.xhtml)

    The same as the *Clay* brush, but specifically for emulating the effect of running your thumb over surfaces.
    Pushes geometry in and sideways.

Layer
:   Brush Type: [Layer](layer.xhtml)

    Draw with a fixed height. Useful for adding flat layers to a surface.

Inflate/Deflate
:   Brush Type: [Inflate](inflate.xhtml)

    Shortcut: `I`

    Moves the mesh in multiple direction. Useful for inflating or shrinking surfaces and volumes.

Blob
:   Brush Type: [Blob](blob.xhtml)

    Magnifies the mesh as you draw. Useful for an additional inflation effect on the stroke.

Crease Polish
:   Brush Type: [Crease](crease.xhtml)

    Shortcut: `Shift` `C`

    A Draw brush with a pinching effect. Useful for polishing existing creases or carefully creating new ones.

Crease Sharp
:   Brush Type: [Crease](crease.xhtml)

    Much sharper and stronger Crease brush. Great for creating thin and deep pinches.
user: Describe Emission from the Blender manual or Python API, including usage steps and snippets.

assistant: # Emission

The *Emitter* system works just like its name says: it emits/produces particles for a certain amount of time.
In such a system, particles are emitted from the selected object from the *Start*
frame to the *End* frame and have a certain lifespan.
These particles are rendered default as [Halos](render.xhtml#particle-halo),
but you may also render this kind of particles as objects
(depending on the particle system’s render settings,
see [Visualization](render.xhtml)).

[image reference removed]

Particle Emission settings.

The buttons in the *Emission* panel control the way particles are emitted over time:

Number
:   The maximum amount of parent particles used in the simulation.

Seed
:   Blender uses this as starting point to produce random numbers during the simulation.

Frame Start
:   The start frame of particle emission. You may set negative values,
    which enables you to start the simulation before the actual rendering.

End
:   The end frame of particle emission.

Lifetime
:   The lifespan (in frames) of the particles.

Lifetime Randomness
:   A random variation of the lifetime of a given particle.
    The shortest possible lifetime is *Lifetime* × (1 - *Random*).
    Values above 1.0 are not allowed.
    For example with the default *Lifetime* value of 50 a *Random* setting of 0.5
    will give you particles with a live span ranging from 50 frames to \(50 × (1.0 - 0.5) = 25\)
    frames, and with a *Random* setting of 0.75 you will get particles with live spans ranging
    from 50 frames to \(50 × (1.0 - 0.75) = 12.5\) frames.
user: Describe Generic Spring Constraint from the Blender manual or Python API, including usage steps and snippets.

assistant: # Generic Spring Constraint

The generic spring constraint adds some spring parameters for the X/Y/Z axes
to all the options available on the Generic constraint.
Using the spring alone allows the objects to bounce around as if attached
with a spring anchored at the constraint object.
This is usually a little too much freedom,
so most applications will benefit from enabling translation or rotation constraints.

If the damping on the springs is set to 1, then the spring forces are prevented from realigning the anchor points,
leading to strange behavior. If your springs are acting weird, check the damping.
user: How do I use Sample Nearest Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Sample Nearest Node

[image reference removed]

The *Sample Nearest* node retrieves the [index](../read/input_index.html)
of the geometry element in its input geometry that is closest to the input position.

This node is similar to the [Geometry Proximity Node](geometry_proximity.html),
but it outputs the index of the closest element instead of its distance from the current location.
user: Provide the full official documentation entry for Histogram(bpy_struct), preserving all code examples.

assistant: # Histogram(bpy_struct)

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

*class* bpy.types.Histogram(*bpy_struct*)
:   Statistical view of the levels of color in an image

    mode
    :   Channels to display in the histogram

        - `LUMA`
          Luma – Luma.
        - `RGB`
          RGB – Red Green Blue.
        - `R`
          R – Red.
        - `G`
          G – Green.
        - `B`
          B – Blue.
        - `A`
          A – Alpha.

        Type:
        :   enum in [`'LUMA'`, `'RGB'`, `'R'`, `'G'`, `'B'`, `'A'`], default `'LUMA'`

    show_line
    :   Display lines rather than filled shapes

        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: Provide the full official documentation entry for Install from a DMG, preserving all code examples.

assistant: Blender for macOS is distributed as disk images (dmg-files). To mount the disk image, double-click on the dmg-file.
Then drag `Blender.app` into the Applications folder.

Depending on the Security and Privacy preferences of your Mac, macOS will request your approval before opening Blender
for the first time.

To make the installation and configuration fully self-contained, set up a
[Portable Installation](../../advanced/blender_directory_layout.html#portable-installation).
user: What is Random Mask and how is it used in Blender Python scripting?

assistant: Generates a mask with random values for the entire object based on different mesh data.

Per Vertex
:   Assigns a random mask value for each vertex.

Per Face Set
:   Assigns a random mask value for each [Face Set](face_sets.xhtml).

Per Loose Mask
:   Assigns a random mask value for each disjoint part of the mesh.
user: Explain Properties in complete detail according to the official Blender documentation.

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

assistant: [image reference removed]

Offset Modifier.

### General

Location X, Y, Z
:   Sets strokes location offset from its object origin.

Rotation X, Y, Z
:   Sets strokes rotation.

Scale X, Y, Z
:   Sets strokes scale.

### Advanced

Mode
:   Random:
    :   Add random values to the individual strokes offset.

    Layer:
    :   Offset by layers.

    Stroke:
    :   Offset by strokes (based on the stroke draw order).

    Material:
    :   Offset by Materials.

Offset X, Y, Z
:   Sets individual element location offset.

Rotation X, Y, Z
:   Sets individual element rotation.

Scale X, Y, Z
:   Sets individual element scale.

Uniform Scale (Random mode)
:   Use the same random *Seed* for each scale axis in the strokes for a uniform scale.

Seed (Random mode)
:   [Seed](../../../glossary/index.xhtml#term-Seed) used by the pseudo-random number generator.

Layer/Stroke/Material Step (For Layer, Stroke and Material mode)
:   The number of elements to be grouped and offset together.

Offset (For Layer, Stroke and Material mode)
:   Offset the element starting point.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Explain String Node in complete detail according to the official Blender documentation.

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: Give a detailed overview of Workflow: syntax, arguments, return values, common patterns.

assistant: A general process for working with cloth is to:

1. Model the cloth object as a general starting shape.
2. Designate the object as a “cloth” in the *Physics* tab of the Properties.
3. Model other deflection objects that will interact with the cloth.
   Ensure the Deflection modifier is last on the modifier stack, after any other mesh deforming modifiers.
4. Light the cloth and assign materials and textures, UV unwrapping if desired.
5. If desired, give the object particles, such as steam coming off the surface.
6. Run the simulation and adjust settings to obtain satisfactory results.
   The Timeline editors playback controls are great for this step.
7. Optionally age the mesh to some point in the simulation to obtain a new default starting shape.
8. Make minor edits to the mesh on a frame-by-frame basis to correct minor tears.
user: Give a detailed overview of Edit Mode Tools: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| `Ctrl`-`E` | [Extrude](../../modeling/meshes/editing/mesh/extrude.html) |
| `Ctrl`-`B` | [Bevel](../../modeling/meshes/editing/edge/bevel.html) |
| `I` | [Inset](../../modeling/meshes/editing/face/inset_faces.html) |
| `K` | [Knife](../../modeling/meshes/editing/mesh/knife_topology_tool.html) |
| `Alt`-`C` | [Loop Cut](../../modeling/meshes/editing/edge/loopcut_slide.html) |
user: How do I use Handling Time in Blender? Include parameters, examples, warnings and best practices.

assistant: Unlike Blender and many other applications and file formats, Alembic files don’t have any concept of frames.
Alembic works purely with time, and values that are sampled over time. For example,
there is no way to distinguish 30 FPS with 2 samples per frame, and 60 FPS with 1 sample per frame.
This has caused many developers to just
[hard-coded 24 FPS](https://projects.blender.org/blender/blender/issues/55288)
when reading Alembic files.

Blender uses the current scene frame rate to convert a frame number (in Blender) to a time
in seconds (in Alembic). As a result, you can import an Alembic file that was produced at 120 FPS into
a Blender scene that is 30 FPS and still not see any time stretching.
user: Provide the full official documentation entry for Curve Tangent Node, preserving all code examples.

assistant: # Curve Tangent Node

[image reference removed]

The *Curve Tangent* node outputs the direction that a curve points in at each control point,
depending on the direction of the curve (which can be controlled with
the [Reverse Curve Node](../operations/reverse_curve.xhtml)). The output values are normalized vectors.