PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of Guides: syntax, arguments, return values, common patterns.

assistant: # Guides

Fluid guides are used to apply forces onto the simulation. They are like simple external forces
but also seek to preserve the physically accurate flow of the fluid.
The *Guides* panel allows you to adjust guiding forces globally, i.e. for the entire domain.
Enabling the guides hints the fluid solver to use the more accurate,
but also computationally more expensive pressure solving step.

Even when there are no guiding objects baked or there is no guiding domain attached,
the fluid solver will still perform the more expensive pressure guiding algorithm
if guiding is enabled. It is
therefore recommended to only enable *Guides* when there is a clear intention to
use guiding in the simulation.

Weight
:   Controls the lag of the guiding. A larger value (also known as the ‘alpha’ guiding value)
    results in a greater lag.

Size
:   This setting determines the size of the vortices that the guiding produces.
    A greater guiding size (also known as the blur radius or ‘beta’ guiding value)
    results in larger vortices.

Velocity Factor
:   All guiding velocities are multiplied by this factor. That is, every cell of the guiding grid,
    which has the same size as the domain object, is multiplied by this factor.

Velocity Source
:   Guiding velocities can either come from objects that move inside the domain or from other fluid
    domains.

    Effector:
    :   All effector objects inside the domain will be considered for the global guiding velocity grid.
        Once effector objects have been baked it is not possible to change the fluid domain resolution
        anymore.

    Domain:
    :   When using another fluid domain as the guiding velocity source this domain may have a different
        resolution and may also be of a different type (e.g. the guiding domain is of type *Gas*
        while the actual domain with the guiding effect in it is of type *Liquid*).

        In order to use a domain as the velocity source, this domain needs to be baked already.

Guide Parent
:   When using *Domain* as the velocity source, this field serves to select the guiding domain object.

Bake Guides, Free Guides
:   This option is only available when using the [Modular](cache.xhtml#bpy-types-fluiddomainsettings-cache-type) cache type
    and when using *Effector* as the [Velocity Source](#bpy-types-fluiddomainsettings-guide-source).
    *Bake Guides* writes vertex velocities of effector objects to drive.
    It is meant to be used before baking the fluid simulation.

    The progress will be displayed in the status bar. Pressing `Esc` will pause the simulation.

    Once the simulation has been baked, the cache can be deleted by pressing *Free Guides*.
    It is possible to pause or resume a *Bake Guides* process.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Output
:   Outputs the value from the input corresponding to the selected menu item, unchanged.

For each menu entry, an additional Boolean output is created.
The output corresponding to the selected item is *true*, and all others are *false*.
These Boolean outputs can be used to trigger different node branches, control visibility,
or drive conditional operations elsewhere in the node tree.
user: Explain Usage in complete detail according to the official Blender documentation.

assistant: First, select the tool in the Toolbar or press `K`. The cursor
will change into a scalpel to indicate it’s active.

Click `LMB` at the place where you want to start cutting.
This can be anywhere: on an existing vertex, edge or face,
or even outside of the mesh.

Move your mouse to the next location. You’ll see a purple line indicating
the new edges that will be created, and green squares indicating the new
vertices. Click `LMB` to confirm: the green squares will turn red,
and you can define the next line in the cutting path.

Once you’re done, press `Spacebar` or `Return` to apply the cuts.
Alternatively, press `Esc` to cancel.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/modeling_meshes_tools_knife_line-before.png   Mesh before knife cut. | ../../../../_images/modeling_meshes_tools_knife_line-active.png   Knife cut active. | ../../../../_images/modeling_meshes_tools_knife_line-after.png   After applying knife cut. |
user: Describe Set Active Keying Set from the Blender manual or Python API, including usage steps and snippets.

assistant: There are several ways to designate the active keying set:

- Press `Shift`-`K` in the 3D Viewport.
- Select a keying set in the [Keying Set](#bpy-types-keyingsets) panel.
- Select a keying set in the [Keying popover](../animation_editors.html#animation-editors-keying) in the Timeline header,
user: Give a detailed overview of Side of Active: syntax, arguments, return values, common patterns.

assistant: # Side of Active

With an active vertex, this tool will select all vertices in a specified direction.
It is similarly to the *Loop Inner-Region* tool in that it will fill select faces within its perimeters,
however, it is determined by direction and not by a closed loop.

Axis Mode
:   Determines the behavior of the selection.
    More information on this can be found in [Transform Orientations](../../../editors/3dview/controls/orientation.xhtml).

Axis Sign
:   Positive/Negative Axis
    :   Depending on which *Axis* is chosen, the selection will encompass the positive or negative axis
        starting from the active vertex outward.

    Aligned Axis
    :   Where *Positive and Negative Axis* select all vertices in a given direction,
        *Aligned Axis* will only select the vertices that are in-line with the active vertex.

[image reference removed]

While following along the X axis: (from left to right) active vertex, Aligned, Positive, and Negative.

Axis
:   Chooses the direction of the selection.

Threshold
:   The amount of influence the selection has outside the original perimeters.
    The higher the *Threshold* the more vertices will be selected.
user: Provide the full official documentation entry for Bump Only, preserving all code examples.

assistant: The least accurate but most memory efficient method is bump mapping.
This method does not actually alter the mesh surface, but merely changes the shading to make it seem so.

Bump maps are often used to add smaller details on a model, for example pores or wrinkles on skin.

For baked bump maps, 8-bit images are commonly used. However, 16 or 32-bit float maps can provide
better looking results. When using image textures use Cubic interpolation to avoid stepping artifacts,
these are more visible for bump maps than other types of textures.
user: Describe Weight Paint Tools from the Blender manual or Python API, including usage steps and snippets.

assistant: # Weight Paint Tools

For Grease Pencil Weight Paint modes each brush type is exposed as a tool,
the brush can be changed in the Tool Settings.
See [Brush](tool_settings/brush.xhtml) for more information.

[image reference removed]

Brush
:   Tool to use for any of the weight paint [brushes](brushes.xhtml).

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

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

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

    [Annotate Eraser](../../../interface/annotate_tool.xhtml#tool-annotate-eraser)
    :   Erase previous drawn annotations.
user: Describe [Local Editing](local_editing/index.xhtml) from the Blender manual or Python API, including usage steps and snippets.

assistant: Edit manual files on your computer using a plain text editor.
Files are synchronized with the online version through a repository, ensuring your local edits remain up-to-date.

Local editing also lets you build and preview your changes before submitting.
user: Show practical ways to work with Inherited Properties in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`FileHandler.bl_idname`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_idname "bpy.types.FileHandler.bl_idname") - [`FileHandler.bl_import_operator`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_import_operator "bpy.types.FileHandler.bl_import_operator") | - [`FileHandler.bl_export_operator`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_export_operator "bpy.types.FileHandler.bl_export_operator") - [`FileHandler.bl_label`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_label "bpy.types.FileHandler.bl_label") - [`FileHandler.bl_file_extensions`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_file_extensions "bpy.types.FileHandler.bl_file_extensions") |
user: Explain Controls in complete detail according to the official Blender documentation.

assistant: Disable `O`
:   Proportional Editing is off, only selected vertices will be affected.

Enable `O`
:   Vertices other than the selected vertex are affected, within a defined radius.

### Proportional Size

You can increase or decrease the radius of the tool’s influence during a transform operation
from the Proportional Editing popover or with `WheelUp`/`WheelDown`, or `PageUp`/`PageDown`
respectively. As you change the radius, the points surrounding your selection will adjust their positions
accordingly.

[image reference removed]

Influence circle.

### Falloff

While editing, you can change the curve profile by either clicking the *Falloff* icon in the header
or pressing `Shift`-`O` to get a pie menu.

|  |  |  |
| --- | --- | --- |
| ../../../_images/editors_3dview_controls_proportional-editing_falloff-constant.png   Constant, No Falloff. | ../../../_images/editors_3dview_controls_proportional-editing_falloff-random.png   Random Falloff. | ../../../_images/editors_3dview_controls_proportional-editing_falloff-linear.png   Linear Falloff. |
| ../../../_images/editors_3dview_controls_proportional-editing_falloff-sharp.png   Sharp Falloff. | ../../../_images/editors_3dview_controls_proportional-editing_falloff-root.png   Root Falloff. | ../../../_images/editors_3dview_controls_proportional-editing_falloff-sphere.png   Sphere Falloff. |
| ../../../_images/editors_3dview_controls_proportional-editing_falloff-smooth.png   Smooth Falloff. | ../../../_images/editors_3dview_controls_proportional-editing_falloff-inverse-square.png   Inverse Square Falloff. |  |
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Dimensions
:   The dimensions of the image in pixels with transformations applied.

Resolution
:   The width and height of the image in pixels.

Location
:   The position of the image in compositing space.

Rotation
:   The rotation of the image in radians, around its center.

Scale
:   The scale of the image relative to its original size in compositing space.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Value
:   The value of the input *Value* at the sample point.

Position
:   The position at the sample along the spline.

Tangent
:   The normalized [curve tangent](../read/curve_tangent.html) at the sample.

Normal
:   The normalized [curve normal](../../geometry/read/normal.html) at the sample.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: There are no options for this noise.

Often used for
:   White noise in an animation. This is not well suited if you do not want an animation.
    For material displacement or bump, use clouds instead.

Result(s)
:   Intensity.
user: How do I use Histogram in Blender? Include parameters, examples, warnings and best practices.

assistant: Shows three overlapping graphs, one for each color channel. Within each graph:

- The X axis corresponds to color intensity, going from 0 on the left (black)
  to 1 on the right (fully red/green/blue).
- The Y axis corresponds to number of pixels.

Use this mode to balance out the tonal range in an image.
A well-balanced image should have nice and smooth distribution of color values.

[image reference removed]

Example image.

[image reference removed]

Corresponding Histogram.
user: Provide the full official documentation entry for Making an Instanced Collection Real, preserving all code examples.

assistant: If you want to make further edits on an instanced collection select the *Instance Collection*.
Then call [Make Instances Real](../../editing/apply.html#bpy-ops-object-duplicates-make-real) to convert
the collection into regular objects that can be transformed and animated normally.
user: Give a detailed overview of Editing: syntax, arguments, return values, common patterns.

assistant: Flip (Distortion Free)
:   Mirrors the vertices displacement from their base position.

    U, V, W

Make Regular
:   Resets the whole lattice to a regular grid, where the cells are scaled to one cubic unit.
user: Provide the full official documentation entry for NodeTreeInterfaceSocketString(NodeTreeInterfaceSocket), preserving all code examples.

assistant: # NodeTreeInterfaceSocketString(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketString(*NodeTreeInterfaceSocket*)
:   String socket of a node

    default_value
    :   Input value used for unconnected socket

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

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Sticky Selection Mode in complete detail according to the official Blender documentation.

assistant: Options for automatically selecting additional UV vertices.
Only available for *Face* select mode or if *Sync Selection* is disabled.

Disabled
:   Each UV vertex can be selected independently of the others.

Shared Location
:   Automatically select UV vertices that correspond to the same mesh vertex and have the same UV coordinates.
    This is the default and gives the illusion that multiple faces in a UV map can share the same vertex;
    in reality, they have separate vertices that overlap.

Shared Vertex
:   Automatically select UV vertices that correspond to the same mesh vertex,
    even if they have different UV coordinates.
    This is also the behavior when *Sync Selection* is enabled.
user: Give a detailed overview of Cache Settings: syntax, arguments, return values, common patterns.

assistant: This panel allows configuration of how and when image data is cached during editing.
These settings apply globally to all strips in the Video Sequence Editor.

Prefetch Frames
:   When enabled, Blender will automatically prefetch and cache frames after the current frame
    in the background. This can result in smoother playback performance.

    Note: prefetching is not currently supported for Scene strips.

Cache
:   Raw
    :   Caches raw image data immediately after it is read from disk.
        This speeds up adjustments to strip parameters such as color correction,
        but increases memory usage.

    Final
    :   Caches the final composited image for each frame,
        allowing faster playback of fully processed strips.

### Display

Visual indicators in the Timeline showing which frames are cached.

Cache
:   Raw
    :   Displays a red bar in the Timeline below frames cached in their raw state.

    Final
    :   Displays a blue bar at the top of Timeline for frames cached in their final composited state.

A readout at the bottom of the panel shows real-time statistics about cache usage:

- **Current Cache Size**: Total amount of memory currently used by the cache system.
- **Raw**: Memory usage by raw image cache.
- **Final**: Memory usage by final rendered frame cache.
user: Describe Hints from the Blender manual or Python API, including usage steps and snippets.

assistant: - Ensure that the normals on the cage mesh point to the outside
  (they are used to determine the inside and outside of the cage).
- Besides the outer cage, more faces within the cage, either loose or forming another smaller cage,
  can be used for extra control. Such smaller cages may also overlap with the main cage.
  For example, to get extra control over eyes, two small sphere cages could be added around them.
user: Show practical ways to work with Interpolate Curves Node in a Blender add-on or script – include code.

assistant: # Interpolate Curves Node

[image reference removed]

Generate new curves on points by interpolating between existing curves.
This is useful to have a smaller set of original curves to make editing easier and faster
while still generating high-density curves for the viewport or a final render.
user: What is Properties and how is it used in Blender Python scripting?

assistant: In the Node Editor the inputs can be renamed, shuffled and removed.
This is also the place where sub-steps can be defined for a simulation.

### Inputs

Geometry
:   Standard geometry input, which is available by default to input geometry into the simulation zone.
    More bake items can be added by dragging sockets into the blank socket or in the *Simulation State* panel.
    Items can be renamed by `Ctrl`-`LMB` on the socket name or in the nodes *Properties* panel.

Delta Time
:   The time in seconds between frames.
    Essentially this the inverse of the render [Frame Rate](../../../render/output/properties/format.xhtml#bpy-types-rendersettings-fps).

    This delta is used to drive the simulation by connecting it node setups that depend on a rate.
    This will keep the simulation playback consistent when the frame rate changes.

Skip
:   Forward the output of the simulation input node directly
    to the output node and ignore the nodes in the simulation zone.
user: Show practical ways to work with Inherited Properties in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`StripModifier.name`](bpy.types.StripModifier.html#bpy.types.StripModifier.name "bpy.types.StripModifier.name") - [`StripModifier.type`](bpy.types.StripModifier.html#bpy.types.StripModifier.type "bpy.types.StripModifier.type") - [`StripModifier.mute`](bpy.types.StripModifier.html#bpy.types.StripModifier.mute "bpy.types.StripModifier.mute") - [`StripModifier.enable`](bpy.types.StripModifier.html#bpy.types.StripModifier.enable "bpy.types.StripModifier.enable") - [`StripModifier.show_expanded`](bpy.types.StripModifier.html#bpy.types.StripModifier.show_expanded "bpy.types.StripModifier.show_expanded") | - [`StripModifier.input_mask_type`](bpy.types.StripModifier.html#bpy.types.StripModifier.input_mask_type "bpy.types.StripModifier.input_mask_type") - [`StripModifier.mask_time`](bpy.types.StripModifier.html#bpy.types.StripModifier.mask_time "bpy.types.StripModifier.mask_time") - [`StripModifier.input_mask_strip`](bpy.types.StripModifier.html#bpy.types.StripModifier.input_mask_strip "bpy.types.StripModifier.input_mask_strip") - [`StripModifier.input_mask_id`](bpy.types.StripModifier.html#bpy.types.StripModifier.input_mask_id "bpy.types.StripModifier.input_mask_id") - [`StripModifier.is_active`](bpy.types.StripModifier.html#bpy.types.StripModifier.is_active "bpy.types.StripModifier.is_active") |
user: Show practical ways to work with Keying Nodes in a Blender add-on or script – include code.

assistant: # Keying Nodes

These nodes give you the essential tools for creating a [Matte](../../../glossary/index.html#term-Matte) for images
that do not already have their own [Alpha Channel](../../../glossary/index.html#term-Alpha-Channel).
One usage scenario is blue-screen or green-screen footage,
where live action is shot in front of a blue or green backdrop for replacement by
a matte painting or virtual background.

In general, hook up these nodes to a viewer, set your Image Editor to show the Viewer node,
and play with the sliders in real-time using a sample image from the footage,
to get the settings right. In some cases,
small adjustments can eliminate artifacts or foreground image degradation.
Taking out too much green can result in foreground actors looking flat or bluish/purplish.

You can and should chain these nodes together,
improving your masking and color correction in successive refinements,
using each node’s strengths to operate on the previous node’s output.
[Keying Node](keying.html) is the closest to a “does-it-all” node
for green screens, but the best results stem from a combination of techniques.
user: Provide the full official documentation entry for Selection, preserving all code examples.

assistant: Splits (disconnects) the selection from the rest of the mesh.
The border edge to any non-selected elements are duplicated.

Note that the “copy” is left exactly at the same position as the original, so you must move it
`G` to see it clearly…
user: Give a detailed overview of MovieTrackingMarker(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # MovieTrackingMarker(bpy_struct)

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

*class* bpy.types.MovieTrackingMarker(*bpy_struct*)
:   Match-moving marker data for tracking

    co
    :   Marker position at frame in normalized coordinates

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], default (0.0, 0.0)

    frame
    :   Frame number marker is keyframed on

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

    is_keyed
    :   Whether the position of the marker is keyframed or tracked

        Type:
        :   boolean, default True

    mute
    :   Is marker muted for current frame

        Type:
        :   boolean, default False

    pattern_bound_box
    :   Pattern area bounding box in normalized coordinates

        Type:
        :   float multi-dimensional array of 2 \* 2 items in [-inf, inf], default ((0.0, 0.0), (0.0, 0.0)), (readonly)

    pattern_corners
    :   Array of coordinates which represents pattern’s corners in normalized coordinates relative to marker position

        Type:
        :   float multi-dimensional array of 4 \* 2 items in [-inf, inf], default ((0.0, 0.0), (0.0, 0.0), (0.0, 0.0), (0.0, 0.0))

    search_max
    :   Right-bottom corner of search area in normalized coordinates relative to marker position

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], default (0.0, 0.0)

    search_min
    :   Left-bottom corner of search area in normalized coordinates relative to marker position

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], default (0.0, 0.0)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Displacement
:   Method used to perform [Displacement](../materials/components/displacement.xhtml) on materials.

    Displacement Only:
    :   Mesh vertices will be displaced before rendering, modifying the actual mesh.
        This gives the best quality results, if the mesh is finely subdivided.
        As a result, this method is also the most memory intensive.

    Bump Only:
    :   When executing the surface shader, a modified surface normal is used instead of the true normal.
        This is a less memory intensive alternative to actual displacement, but only an approximation.
        Surface silhouettes will not be accurate and there will be no self-shadowing of the displacement.

    Displacement and Bump:
    :   Both methods can be combined, to do displacement on a coarser mesh,
        and use bump mapping for the final detail.

Emission Sampling
:   The method used for sampling the emissive component of the material.
    This option will only have an influence if the material contains an emissive material node,
    otherwise it will be ignored.

    None:
    :   Do not use this surface as a light for sampling.

    Auto:
    :   Automatically determine if the surface should be treated as a light for sampling based on
        emission intensity.

    Front:
    :   Treat only the front side of the surface as a light, useful for closed meshes whose interior
        is not visible.

    Back:
    :   Treat only the back side of the surface as a light for sampling.

    Front and Back:
    :   Treat surface as a light for sampling, emitting from both the front and back side.

Transparent Shadows
:   Use transparent shadows if it contains a [Transparent BSDF](../shader_nodes/shader/transparent.xhtml),
    disabling will render faster but will not give accurate shadows.

Bump Map Correction
:   Applies corrections to solve shadow terminator artifacts caused by bump mapping.
user: Explain Roll in complete detail according to the official Blender documentation.

assistant: Activating the [Axes](../properties/display.html#bpy-types-armature-show-axes)
checkbox will show local axes for each bone’s tip. The Y axis is always aligned along the bone,
oriented from root to tip, this is the “roll” axis of the bones.
user: Describe Other Useful Links from the Blender manual or Python API, including usage steps and snippets.

assistant: - [Blender FAQ](https://www.blender.org/support/faq/) (Can I use Blender commercially? What is GPL/GNU? …)
- [Demo and benchmark files](https://www.blender.org/download/demo-files/)
- Developer’s [Ask Us Anything!](https://developer.blender.org/docs/handbook/new_developers/faq/)
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: The first two sockets are the minimum output.

Image
:   Outputs the entire image in the specified color space.

Alpha
:   The alpha value taken from the movie or image.

Offset X
:   The X offset value from the footage camera or tracking.

Offset Y
:   The Y offset value from the footage camera or tracking.

Scale
:   The scale of the image taken from the footage camera or tracking.

Angle
:   The lens angle taken from the footage camera or tracking.
user: Give a detailed overview of Fill Tool: syntax, arguments, return values, common patterns.

assistant: # Fill Tool

The Fill tool is used to automatically fill closed strokes areas.

The Fill tool uses any of the Grease Pencil *Fill* draw mode brushes.
Activating a brush from an asset shelf or brush selector will also activate this tool for convenience.
user: Give a detailed overview of Writing: syntax, arguments, return values, common patterns.

assistant: You can now edit the documentation files, which are the `.rst` files inside the `manual` folder using a text
editor of your choice.

Be sure to check the [Writing Style Guide](../../guides/writing_guide.xhtml) for conventions and
[Markup Style Guide](../../guides/markup_guide.xhtml) to learn how to write in the reStructuredText markup language.

Happy writing!

### Bigger Changes

If you are going to add or overhaul a section, be sure to check carefully that it does not already exist. In some
places, the docs are so disorganized that sections may be duplicated or in a strange location. In the case that you
find a duplicate or out of place section, [create an issue](https://projects.blender.org/blender/documentation/issues/new) explaining the issue, and optionally include a
revision (actual changes).

Before you make any edits that are not simple and plainly justified (for example, moving folders around), you should
verify with a manual maintainer that your contribution is along the community’s vision for the manual. This ensures
the best use of your time and good will as it is otherwise possible that, for some reason, your changes will conflict
and be rejected or need time-consuming review. For example, another person may be already working on the section you
wish to change, the section may be scheduled for deletion or to be updated according to a planned change to Blender.

[Communicating](../../index.xhtml#contribute-contact) early and frequently is the key to have a productive environment, to not
waste people’s effort and to attain a better Blender manual as a result.

### Getting Help/Answers

If you are in doubt about functionality that you wish to document, you should pose your questions to the Blender
developers responsible for that area or ask at the unofficial user support channel in the `#docs` or
`#blender-coders` channel in [Chat](../../../../getting_started/about/community.xhtml#blender-chat).

Blender itself has a system of module owners with developer and artist members who are responsible for the design and
maintenance of the assigned Blender areas. See the [module pages](https://projects.blender.org/blender/blender/wiki) for more information.
user: Provide the full official documentation entry for Snap, preserving all code examples.

assistant: Selection to Current Frame
:   Move the start of the selected strips to the current frame.

Selection to Nearest Frame
:   Move the start of the selected strips to the nearest full frame.

Selection to Nearest Second
:   Move the start of the selected strips to the nearest second.

Selection to Nearest Marker
:   Move the start of the selected strips to the nearest marker.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Grid
:   The input signed distance field to smooth.
    Typically, the grid represents a surface or volume generated from a mesh or procedural operation.

Iterations
:   The number of mean curvature flow iterations to apply.
    Each iteration progressively smooths the surface, with higher values
    resulting in a more pronounced smoothing effect.
    A small number of iterations will gently polish the surface, while
    larger values can significantly alter its shape.
user: Describe Usage from the Blender manual or Python API, including usage steps and snippets.

assistant: First define the base of the object by dragging with `LMB`.
Next, release `LMB` and move the mouse to define the height of the object.
Finally, click `LMB` to confirm the shape of the object.

You can use the following hotkeys to temporarily change a setting
(for as long as the key is held):

|  |  |
| --- | --- |
| `Ctrl` | Toggles snapping. |
| `Alt` | Toggles the *Origin* setting. |
| `Shift` | Toggles the *Aspect* setting. |
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Edge Index
:   The geometry-wide index of the selected edge. You can pass this to the
    [Evaluate at Index Node](../../utilities/field/evaluate_at_index.xhtml) or the
    [Sample Index Node](../../geometry/sample/sample_index.xhtml) (with the domain set to Edge)
    to retrieve details about the edge.

    If the vertex has no connected edges, *Edge Index* will be zero.

Total
:   The number of edges connected to the selected vertex.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Domain
:   The domain on which the selection and group ID fields are evaluated.

    Point:
    :   The fields are evaluated on points, control points, and vertices.

    Edge:
    :   The fields are evaluated on the edges of the mesh component.

    Faces:
    :   The fields are evaluated on the faces of the mesh component.

    Spline:
    :   The fields are evaluated on the splines in the curve component.

    Instance:
    :   The fields are evaluated on the top-level instances. Realized instances are ignored.
user: Describe Documentation Links from the Blender manual or Python API, including usage steps and snippets.

assistant: While going through the tutorial, you may want to look into our reference documentation.

- [Blender API Overview](https://docs.blender.org/api/current/info_overview.html):
  This document is rather detailed but helpful if you want to know more on a topic.
- [`bpy.context`](https://docs.blender.org/api/5.0/bpy.context.html#module-bpy.context "(in Blender 5.0.1 Python API v5.0)") API reference –
  Handy to have a list of available items your script may operate on.
- [`bpy.types.Operator`](https://docs.blender.org/api/5.0/bpy.types.Operator.html#bpy.types.Operator "(in Blender 5.0.1 Python API v5.0)") –
  The following add-ons define operators, these docs give details and more examples of operators.
user: Give a detailed overview of Noise: syntax, arguments, return values, common patterns.

assistant: # Noise

The *Noise* modifier uses a pseudo-random number generator to variably distribute the property along the stroke.

Amplitude
:   The maximum value of the noise. A higher amplitude means a less transparent (more solid) stroke.

Period
:   The period of the noise. This means how quickly the property value can change.
    A higher value means a more smoothly changing color along the stroke.

Seed
:   Seed used by the pseudo-random number generator.

Asymmetric Thickness only
:   Allows the thickness to be distributed unevenly at every point.
    Internally, the stroke is represented as a backbone with a thickness to the right and left side.
    All other thickness shaders make sure that the left and right thickness values are equal.
    For the Noise shader however, a meaningful (and good-looking) result
    can be created by assigning different values to either side of the backbone.

[[image reference removed]](../../../../../../_images/render_freestyle_parameter-editor_line-style_modifiers_color_noise_thickness-noise-example.png)

Effect generated with a noise thickness modifier using asymmetric thickness.
user: Explain GeometryNodeInputRadius(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeInputRadius(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.GeometryNodeInputRadius(*GeometryNode*)
:   Retrieve the radius at each point on curve or point cloud geometry

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

assistant: # Bridge Edge Loops

*Bridge Edge Loops* connects multiple edge loops with faces.

Connect Loops
:   Open Loop:
    :   Loops connected with open ends.

    Closed Loop:
    :   Tries to connect to a circular loop (where the start and end are merged).

    Loop Pairs:
    :   Connects each even count of loops individually.

Merge
:   Merges edge loops rather than creating a new face.

Merge Factor
:   Which edge loop the edges are merged to, a value of 0.5 will merge at a half-way point.

Twist
:   Determines which vertices in both loops are connected to each other.

Number of Cuts
:   The number of intermediate edge loops used to bridge the distance between two loops.

Interpolation
:   Linear, Blend Path, Blend Surface

Smoothness
:   Smoothness of the *Blend Path* and *Blend Surface*.

Profile Factor
:   How much intermediary new edges are shrunk/expanded.

Profile Shape
:   The shape of the new edges.
    See the [Proportional Editing](../../../../editors/3dview/controls/proportional_editing.html#bpy-types-toolsettings-proportional-edit-falloff) page
    for a description of each option.
user: What is Texture and how is it used in Blender Python scripting?

assistant: # Texture

Assigns a texture to the Freestyle stroke.

[image reference removed]

Line Style: Texture.

Use Nodes
:   In Cycles textures are defined by means of shader [Nodes](#nodes).

Spacing Along Stroke
:   Allows to set the “pace” of textures mapped along the length of strokes.

Go to Linestyle Textures
:   A shortcut to the line style texture properties in the other *Textures* tab of the Properties.
    Make sure to first enable *Use Nodes*.
user: Describe Event Type Mask Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Event Type Mask Items

KEYBOARD_MODIFIER:
:   Keyboard Modifier.

KEYBOARD:
:   Keyboard.

MOUSE_WHEEL:
:   Mouse Wheel.

MOUSE_GESTURE:
:   Mouse Gesture.

MOUSE_BUTTON:
:   Mouse Button.

MOUSE:
:   Mouse.

NDOF:
:   NDOF.

ACTIONZONE:
:   Action Zone.
user: Describe Edge Loops from the Blender manual or Python API, including usage steps and snippets.

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

assistant: |  |  |
| --- | --- |
| - [`bpy.context.active_bone`](bpy.context.html#bpy.context.active_bone "bpy.context.active_bone") - [`bpy.context.bone`](bpy.context.html#bpy.context.bone "bpy.context.bone") - [`Armature.bones`](bpy.types.Armature.html#bpy.types.Armature.bones "bpy.types.Armature.bones") - [`ArmatureBones.active`](bpy.types.ArmatureBones.html#bpy.types.ArmatureBones.active "bpy.types.ArmatureBones.active") - [`Bone.bbone_custom_handle_end`](#bpy.types.Bone.bbone_custom_handle_end "bpy.types.Bone.bbone_custom_handle_end") | - [`Bone.bbone_custom_handle_start`](#bpy.types.Bone.bbone_custom_handle_start "bpy.types.Bone.bbone_custom_handle_start") - [`Bone.children`](#bpy.types.Bone.children "bpy.types.Bone.children") - [`Bone.parent`](#bpy.types.Bone.parent "bpy.types.Bone.parent") - [`BoneCollection.bones`](bpy.types.BoneCollection.html#bpy.types.BoneCollection.bones "bpy.types.BoneCollection.bones") - [`PoseBone.bone`](bpy.types.PoseBone.html#bpy.types.PoseBone.bone "bpy.types.PoseBone.bone") |
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Vector
:   Texture coordinate to sample texture at;
    defaults to Generated texture coordinates if the socket is left unconnected.

Scale
:   Scale of the texture.

Distortion
:   Amount of distortion.
user: Describe Your First Armature from the Blender manual or Python API, including usage steps and snippets.

assistant: In order to see what we are talking about, let us try to add the default armature in Blender.

(Note that armature editing details are explained in
the [armatures editing section](bones/editing/index.xhtml).)

Open a default scene, then:

1. Delete all objects in the scene.
2. Make sure the cursor is in the world origin with `Shift`-`C`.
3. Press `Numpad1` to see the world in Front view.
4. Add a *Single Bone* (Add ‣ Armature).
5. Press `NumpadPeriod` to see the armature at maximum zoom.

[image reference removed]

The default armature.
user: Give a detailed overview of Gesture Tools: syntax, arguments, return values, common patterns.

assistant: # Gesture Tools

Separate from brushes and filters, Sculpt mode also has a set of tools that perform actions to a drawn
selection area. These tools are similar to the selection tools (e.g. [box selection](../../../interface/selecting.html#tool-select-box)
and [lasso selection](../../../interface/selecting.html#tool-select-lasso) in other areas of Blender).

These tools do not provide a selection of elements that are then modified, they directly modify the underlying
mesh.
user: Show practical ways to work with Finding the Page to Edit in a Blender add-on or script – include code.

assistant: Navigate to the Blender Manual ([docs.blender.org/manual](https://docs.blender.org/manual/en/dev/))
and browse to the page you want to improve (make sure you are browsing under the development version (`/dev`)).

At the top-right of every page, you’ll find an “Edit Page” link.
Clicking it will take you to the online editor at projects.blender.org.
user: Show practical ways to work with Roll in a Blender add-on or script – include code.

assistant: Activating the [Axes](../properties/display.xhtml#bpy-types-armature-show-axes)
checkbox will show local axes for each bone’s tip. The Y axis is always aligned along the bone,
oriented from root to tip, this is the “roll” axis of the bones.
user: Provide the full official documentation entry for StringAttributeValue(bpy_struct), preserving all code examples.

assistant: # StringAttributeValue(bpy_struct)

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

*class* bpy.types.StringAttributeValue(*bpy_struct*)
:   String value in geometry attribute

    value
    :   Type:
        :   byte 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: Explain Mesh to Density Grid Node in complete detail according to the official Blender documentation.

assistant: # Mesh to Density Grid Node

[image reference removed]

The *Mesh to Density Grid* node converts a mesh into a **density grid**, where
each voxel stores a scalar value representing how far it lies inside or near
the surface of the mesh. This can be used to generate fog volumes, soft-body
representations, or as input to volumetric and field-based effects.

The resulting grid contains smooth gradients that transition from high values
inside the mesh to low values outside, allowing for continuous blending and
sampling operations.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Generated
:   Automatically-generated texture coordinates from the vertex positions of the mesh without deformation,
    keeping them sticking to the surface under animation.
    Range from 0.0 to 1.0 over the bounding box of the non-deformed mesh.
    See [Texture Spaces](../../../modeling/meshes/uv/uv_texture_spaces.xhtml#properties-texture-space) for more information.

Normal
:   Object space normal, for texturing objects with the texture staying fixed on the object as it transformed.
    The Normal output can be used on Point and Spot lights. The coordinates will take
    the rotation of the light into account.

UV
:   UV texture coordinates from the [Active Render](../../../modeling/meshes/uv/uv_texture_spaces.xhtml#bpy-types-meshuvlooplayer-active-render) UV map.
    See [UV Mapping](../../../editors/uv/index.xhtml#editors-uv-index) for more information.

Object
:   Uses an object as a source for coordinates. Often used with an empty,
    this is an easy way to place a small image at a given point on the object.
    This object can also be animated, to move a texture around or through a surface.

Camera
:   Position coordinate in camera space.

Window
:   Location of shading point on the screen, ranging from 0.0 to 1.0
    from the left to right side and bottom to top of the render.
    This is well suited for blending two objects.

Reflection
:   Uses the direction of the reflection vector as coordinates.
    This is useful for adding reflection maps. You will need this input when using environment maps.
user: What is Radial Tiling Node and how is it used in Blender Python scripting?

assistant: # Radial Tiling Node

[image reference removed]

The *Radial Tiling Node* provides the ability to divide a 2D cartesian input coordinate system
into as many radial segments as specified by the *Sides* input.
Each segment has its own affinely transformed segment coordinate system,
which can be used to tile textures in a radially symmetric manner.