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

assistant: # StringAttribute(Attribute)

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

*class* bpy.types.StringAttribute(*Attribute*)
:   Geometry attribute that stores strings

    data
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`StringAttributeValue`](bpy.types.StringAttributeValue.html#bpy.types.StringAttributeValue "bpy.types.StringAttributeValue"), (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 Toggle Local View from the Blender manual or Python API, including usage steps and snippets.

assistant: Global view shows all 3D objects in the scene. Local view isolates the selected object(s)
so that they are the only ones visible in the viewport. This is useful for working on
objects that are obscured by others, or to speed up the viewport performance in heavy scenes.
Local view is contextual, meaning that it can be set per 3D Viewport.

You can toggle between *Global* and *Local View* by selecting the option
from the View menu or using the shortcut `NumpadSlash`.

|  |  |
| --- | --- |
| <../../../_images/editors_3dview_navigate_local-view_local1.png>   Global View. | <../../../_images/editors_3dview_navigate_local-view_local2.png>   Local View. |

### Remove from Local View

Objects can be removed from Local View by selecting them and using the *Remove from Local View* operator.
If the last remaining object is removed, Blender will automatically return to the Global View.
user: Show practical ways to work with Sample UV Surface Node in a Blender add-on or script – include code.

assistant: # Sample UV Surface Node

[image reference removed]

The *Sample UV Surface* node finds values on a mesh’s surface at specific UV locations.
Internally the process is a “reverse UV lookup” from a location in 2D space. The node then
finds the face that corresponds to each UV coordinate, and the location within that face.
user: Provide the full official documentation entry for Normalize All, preserving all code examples.

assistant: For each vertex, this tool makes sure that the sum of the weights across
all vertex groups is equal to 1. This tool normalizes all of the vertex groups,
except for locked groups, which keep their weight values untouched.

Lock Active
:   Keep the values of the active group while normalizing all the others.
user: Describe Adaptive Sampling from the Blender manual or Python API, including usage steps and snippets.

assistant: If the *Noise Threshold* checkbox is enabled, Cycles will use adaptive sampling,
cutting short the sampling process in areas that have become less noisy than the
specified threshold value – in other words, not wasting time further refining
areas that already look good enough. For example, hair on a character may need many samples,
but the background may only need few.

Noise Threshold
:   The threshold to decide whether to continue sampling a pixel.
    Typical values are in the range from 0.1 to 0.001, with lower values meaning better
    quality but longer render times.
    Setting this to 0 makes Cycles guess an automatic value based on the total sample count.

Min Samples
:   The minimum number of samples a pixel receives before adaptive sampling is applied.
    When set to 0 (default), Cycles automatically picks a value determined by the *Noise Threshold*.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

Each blend-file contains a database.
This database contains all scenes, objects, meshes, textures, etc. that are in the file.

A file can contain multiple [Scenes](../scene_layout/scene/introduction.html)
and each scene can contain multiple [Objects](../scene_layout/object/introduction.html).
Objects can contain multiple materials which can contain many textures.
It is also possible to create links between different objects, or share data between objects.
A file can link data from other Blender files.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Texture Mapping.

Mode
:   The texture transformation will be applied to the stroke/fill or stroke UVs.

    Stroke:
    :   Stroke Fit Method
        :   Selects the texture fitting method.

            Constant Length:
            :   The texture keep a consistent length along the strokes.

            Stroke Length:
            :   The texture is normalized to fit the stroke length.

        UV Offset
        :   Moves the texture along the strokes.

        Rotation
        :   Rotates the points of the strokes.

        Scale
        :   Factor for the texture scale.

    Fill:
    :   Fill Rotation
        :   Sets the texture angle.

        Offset
        :   Moves the texture origin.

            X, Y

        Scale
        :   Factor for the texture scale.

### Influence

See [Influence Filters](../introduction.html#grease-pencil-modifier-influence-filters).
user: Describe Cache from the Blender manual or Python API, including usage steps and snippets.

assistant: # Cache

After you have set up the deflection mesh for the frame range you intend to run the simulation
(including animating that mesh *via* armatures),
you can now tell the cloth simulation to compute (and avoid) collisions.
Select the cloth object and in the *Object* tab,
*Physics* tab, set the *Start* and *End* settings for
the simulation frames you wish to compute, and click the *Bake* button.

Cache settings for cloth are the same as with other dynamic systems.
See [Particle Cache](../../particles/emitter/cache.html) for details.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: Angle
:   The amount of rotation.

Axis
:   Used to constraint the transformation to one or more axes.

Orientation
:   Aligns the transformation axes to a specified orientation constraint.
    See [Transform Orientations](../../../../editors/3dview/controls/orientation.html) for more information.

Proportional Editing
:   The extruded face will affect nearby geometry.
    See [Proportional Editing](../../../../editors/3dview/controls/proportional_editing.html) for a full reference.
user: Provide the full official documentation entry for Gabor Texture Node, preserving all code examples.

assistant: # Gabor Texture Node

[image reference removed]

The *Gabor Texture* node evaluates a Gabor noise at the input texture coordinates. Gabor noise is
visually characterized by random interleaved bands whose direction and width can be controlled.
Additionally, it can be used to create omnidirectional noise like the standard Noise Texture node,
but since it is more expensive to compute, using the Noise Texture node is probably the better
option in those cases. See the examples for more information.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Geometry
:   Standard Geometry input.

Selection
:   Boolean field used to calculate which output each part of the geometry will go to.
    Parts in the selection will move to the *Selection* output.
    Parts not in the selection will move to the *Inverted* output.
user: Provide the full official documentation entry for Usage, preserving all code examples.

assistant: ### Selecting a Brush and Material

In the Tool Settings select the brush, material and color type to use with the tool.
The Line tool uses *Draw Brush* types.
See [Brush Settings](../brushes/draw.html#grease-pencil-draw-common-options) for more information.

### Creating Polylines

1. Click (`LMB` or the `Pen` tip) and drag the start point.
2. Release on the desired end point.
3. Click multiple times on different locations to create multiple connected lines.
4. Then confirm (`Return`/`MMB`) or cancel (`Esc`/`RMB`).

While dragging you can use `Shift` to snapping the line to horizontal, vertical or 45° angle.

`NumpadPlus` and `NumpadMinus` or using the mouse `Wheel`
will increase or decrease the amount of points in the final line.

`F` will adjust the line thickness and `Shift`-`F` will adjust the opacity of the strokes.

|  |  |  |
| --- | --- | --- |
| <../../../../_images/grease-pencil_modes_draw_tools_polyline_example-01.png>   click and dragging the start point. | <../../../../_images/grease-pencil_modes_draw_tools_polyline_example-02.png>   Click multiple times to create multiple connected lines. | <../../../../_images/grease-pencil_modes_draw_tools_polyline_example-03.png>   The polyline after confirming. |
user: Explain Ray Visibility in complete detail according to the official Blender documentation.

assistant: As with other objects,
*Ray Visibility* allows you to control which other shaders can “see” the environment.

### Tricks

Sometimes it may be useful to have a different background that is directly visible versus one
that is indirectly lighting the objects. A simple solution to this is to add a Mix node,
with the *Blend Factor* set to *Is Camera Ray*. The first input color is then the indirect color,
and the second the directly visible color. This is useful when using a high-res image for
the background and a low-res image for the actual lighting.

Similarly, adding the *Is Camera* and *Is Glossy* rays will mean that the high-res image
will also be visible in reflections.

[image reference removed]

Nodes for the trick above.
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: The *Bend* tool can be used in any case where you might want to bend a shape in two
with a gradual transition between both sides.

This may take a little getting used to, the basics are listed below controls are noted here:

- The initial position of the cursors define the axis to bend on.
- The distance of the mouse cursor to the 3D cursor controls how sharp the bend will be.
- The relative angle of the mouse cursor to the initial axis defines the bend angle.

If this seems overly complicated, it’s probably best to try the tool
where it becomes quickly apparent how the tool reacts to your input.

Bend Angle
:   The amount of rotation.

Radius
:   The sharpness of the bend.

Clamp
:   Normally the arc turns through a clamped rotation angle with the selected elements extended along
    a tangent line beyond that (see above left).
    When the clamp is deactivated, the arc continues around aligning the selected elements into a circle (right).

    When off `Alt` all selected elements follow a circle,
    even when outside the segment between the 3D cursor and the mouse.

[image reference removed]

Bend Transform example.
user: Explain MeshDeformModifier(Modifier) in complete detail according to the official Blender documentation.

assistant: # MeshDeformModifier(Modifier)

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

*class* bpy.types.MeshDeformModifier(*Modifier*)
:   Mesh deformation modifier to deform with other meshes

    invert_vertex_group
    :   Invert vertex group influence

        Type:
        :   boolean, default False

    is_bound
    :   Whether geometry has been bound to control cage

        Type:
        :   boolean, default False, (readonly)

    object
    :   Mesh object to deform with

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

    precision
    :   The grid size for binding

        Type:
        :   int in [2, 10], default 5

    use_dynamic_bind
    :   Recompute binding dynamically on top of other deformers (slower and more memory consuming)

        Type:
        :   boolean, default False

    vertex_group
    :   Vertex group name

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Image
:   The default image input for the node group, available when the group is created.
    It can be used to feed images or render layers into the group.

Any additional inputs defined in the node group’s interface will appear here as output sockets.
user: Provide the full official documentation entry for Emission, preserving all code examples.

assistant: # Emission

[image reference removed]

Hair particle system settings.

Number
:   Sets the amount of hair strands. Use as few particles as possible
    (especially if you plan to use soft body animation later),
    but still enough to cover the surface and have good control.
    A few thousand particles is generally enough for a regular haircut.
    The hair will be made denser later on using
    [Children](../emitter/children.xhtml).

Hair Length
:   Controls the length of the hair.
user: Give a detailed overview of Trim Gesture Tools: syntax, arguments, return values, common patterns.

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

|  |  |  |
| --- | --- | --- |
| ../../../_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.html#sculpting-editing-facesets).
When removing geometry, the new interior geometry along the selection will be assigned
a new face set instead.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Curve
:   Standard geometry input.

Selection
:   Whether or not to change the resolution value on each spline. True values mean the value will be changed,
    false values mean the resolution will remain the same.

Resolution
:   The number of evaluated points generated for each control point in NURBS and Bézier splines.
    It controls the accuracy of operations like trimming or sampling a curve.
    Higher resolutions are more accurate, but slower.
user: Explain Field Variance Node in complete detail according to the official Blender documentation.

assistant: # Field Variance Node

[image reference removed]

The *Field Variance* node computes the variance and standard deviation of a field over a given domain.
This is useful for measuring how much a value varies across geometry or within specific groups.

For example, it can be used to analyze the spread of values like weights, positions, or custom attributes
within each group defined by the *Group ID*.
user: Show practical ways to work with Adaptive Sampling in a Blender add-on or script – include code.

assistant: If the *Noise Threshold* checkbox is enabled, Cycles will use adaptive sampling,
cutting short the sampling process in areas that have become less noisy than the
specified threshold value – in other words, not wasting time further refining
areas that already look good enough. For example, hair on a character may need many samples,
but the background may only need few.

Noise Threshold
:   The threshold to decide whether to continue sampling a pixel.
    Typical values are in the range from 0.1 to 0.001, with lower values meaning better
    quality but longer render times.
    Setting this to 0 makes Cycles guess an automatic value based on the total sample count.

Min Samples
:   The minimum number of samples a pixel receives before adaptive sampling is applied.
    When set to 0 (default), Cycles automatically picks a value determined by the *Noise Threshold*.
user: Show practical ways to work with Example in a Blender add-on or script – include code.

assistant: Lattice modifier example.

|  |  |
| --- | --- |
| ../../../_images/grease-pencil_modifiers_deform_lattice_original.png   Original model. | ../../../_images/grease-pencil_modifiers_deform_lattice_edit.png   After lattice editing. |
user: What is Bpy.Types.Renderlayer and how is it used in Blender Python scripting?

assistant: y_struct.is_property_set bpy_struct.items bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values References ¶ RenderResult.layers Next RenderPass(bpy_struct) Previous RenderEngine(bpy_struct) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page RenderLayer(bpy_struct) RenderLayer RenderLayer.name RenderLayer.passes RenderLayer.use_ao RenderLayer.use_grease_pencil RenderLayer.use_motion_blur RenderLayer.use_pass_ambient_occlusion RenderLayer.use_pass_combined RenderLayer.use_pass_diffuse_color RenderLayer.use_pass_diffuse_direct RenderLayer.use_pass_diffuse_indirect RenderLayer.use_pass_emit RenderLayer.use_pass_environment RenderLayer.use_pass_glossy_color RenderLayer.use_pass_glossy_direct RenderLayer.use_pass_glossy_indirect RenderLayer.use_pass_material_index RenderLayer.use_pass_mist RenderLayer.use_pass_normal RenderLayer.use_pass_object_index RenderLayer.use_pass_position RenderLayer.use_pass_shadow RenderLayer.use_pass_subsurface_color RenderLayer.use_pass_subsurface_direct RenderLayer.use_pass_subsurface_indirect RenderLayer.use_pass_transmission_color RenderLayer.use_pass_transmission_direct RenderLayer.use_pass_transmission_indirect RenderLayer.use_pass_uv RenderLayer.use_pass_vector RenderLayer.use_pass_z RenderLayer.use_sky RenderLayer.use_solid RenderLayer.use_strand RenderLayer.use_volumes RenderLayer.load_from_file() RenderLayer.bl_rna_get_subclass() RenderLayer.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Provide the full official documentation entry for ObjectLightLinking(bpy_struct), preserving all code examples.

assistant: # ObjectLightLinking(bpy_struct)

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

*class* bpy.types.ObjectLightLinking(*bpy_struct*)
:   blocker_collection
    :   Collection which defines objects which block light from this emitter

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

    receiver_collection
    :   Collection which defines light linking relation of this emitter

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

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

assistant: # Velocity

The initial velocity of particles can be set through different parameters,
based on the type of the particle system.
If the particle system type is Emitter or Hair,
then the following parameters give the particle an initial velocity.

Normal
:   The emitter’s surface normals (i.e. let the surface normal give the particle a starting speed).

Tangent
:   Let the tangent speed give the particle a starting speed.

Tangent Phase
:   Rotates the surface tangent.

Object Align
:   Give an initial velocity in the X, Y, and Z axes.

    X, Y, Z

Object Velocity
:   The emitter objects movement (i.e. let the object give the particle a starting speed).

Randomize
:   Gives the starting speed a random variation.
    You can use a texture to only change the value, see Controlling Emission, Interaction and Time.
user: How do I use Point(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # Point(bpy_struct)

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

*class* bpy.types.Point(*bpy_struct*)
:   Point in a point cloud

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

    index
    :   Index of this point

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Geometry
:   The resulting geometry with updated curve attachments.

Surface UV Coordinate
:   The UV coordinate on the surface mesh corresponding to each curve’s attachment point.

Surface Normal
:   The normal vector of the surface mesh evaluated at each curve’s attachment point.
user: Provide the full official documentation entry for Contrast Brushes, preserving all code examples.

assistant: [image reference removed]

Recognizable by their red thumbnail and cursor.
These brushes generally flatten or heighten the contrast of the surface.

Smooth
:   Brush Type: [Smooth](smooth.xhtml)

    Shortcut: `S`

    Smooths out irregularities in the surface and shrinks volumes by averaging the vertices positions.
    An essential brush that is frequently used.

Flatten/Contrast
:   Brush Type: [Plane](plane.xhtml)

    Pushes vertices to an average height to create a flat surfaces. Alternatively pushes them away from the center for
    more contrast.

Plateau
:   Brush Type: [Plane](plane.xhtml)

    Similar to Flatten but with a locked orientation and depth to create a consistently flat surface.

Fill/Deepen
:   Brush Type: [Plane](plane.xhtml)

    Pushes surfaces upwards towards a flat plane. Useful for filling in holes and crevices. Alternatively deepens
    existing holes when holding ‘Ctrl’.

Scrape/Fill
:   Brush Type: [Plane](plane.xhtml)

    Shortcut: `Shift` `T`

    Pushes surfaces inwards. Alternatively fills surfaces while holding ‘Ctrl’. This is the most common brush for
    flattening meshes.

Trim
:   Brush Type: [Plane](plane.xhtml)

    Pushes surfaces inwards toward a locked direction. The depth can be defined by going deeper towards surfaces along
    the stroke.

Scrape Multiplane
:   Brush Type: [Scrape Multiplane](multiplane_scrape.xhtml)

    Scrapes the mesh with two angled planes at the same time, producing a sharp edge between them.
user: Describe NodeClosureInput(NodeInternal) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeClosureInput(NodeInternal)

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")

*class* bpy.types.NodeClosureInput(*NodeInternal*)
:   paired_output
    :   Zone output node that this input node is paired with

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    pair_with_output(*output_node*)
    :   Pair a zone input node with an output node.

        Parameters:
        :   **output_node** ([`NodeInternal`](bpy.types.NodeInternal.html#bpy.types.NodeInternal "bpy.types.NodeInternal")) – Output Node, Zone output node to pair with

        Returns:
        :   Result, True if pairing the node was successful

        Return type:
        :   boolean

    *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 Extrude Faces Along Normals in complete detail according to the official Blender documentation.

assistant: Available when a [Face](../../../../glossary/index.xhtml#term-Face) is selected.

See [Extrude Faces Along Normals](../face/extrude_faces_normal.xhtml#bpy-ops-view3d-edit-mesh-extrude-move-shrink-fatten).
user: What is Images and Video and how is it used in Blender Python scripting?

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

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

For intermediate image files in production, it is recommended to use *OpenEXR* files.
These are always stored in scene linear color spaces, with high precision to avoid data loss.
That makes them suitable to store renders that can later be composited, color graded and
converted to different output formats.
user: Explain Draw in complete detail according to the official Blender documentation.

assistant: # Draw

Moves vertices inward or outward, based the average vertex normals within the brush radius.
This is a very default behavior for sculpting and can be used in most cases.

It is common to use this particular brush with heavy customization for creating many custom brushes.
user: Explain NodeTreeInterfaceSocketFloatPercentage(NodeTreeInterfaceSocket) in complete detail according to the official Blender documentation.

assistant: # NodeTreeInterfaceSocketFloatPercentage(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.NodeTreeInterfaceSocketFloatPercentage(*NodeTreeInterfaceSocket*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

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

assistant: Geometry
:   The geometry on which to create instances.

Instance On
:   The geometry element type to instance on.

    Points:
    :   Instances are created at the location of each point.

    Edges:
    :   Instances are placed along edges.

    Faces:
    :   Instances are placed on the surface of each face.

    Corners:
    :   Instances are created at each face corner (vertex per face).

Mask
:   A selection controlling which elements are used for instancing.
    Floating-point values between 0 and 1 are treated as probabilistic selections,
    resulting in a random subset of elements being used.

Input Type
:   Defines how the instance geometry input is provided.

    Data-Block:
    :   Instances are created from an object or collection data-block.

    Geometry:
    :   Instances are created from input geometry provided to the node.

Instance Type Data-Block
:   When using *Data-Block* input, determines whether to instance an *Object* or a *Collection*.

Object / Collection Data-Block
:   The specific object or collection to instance when using *Data-Block* input mode.

Instance Geometry
:   The geometry to instance when using *Geometry* input mode.

Realize Instances
:   Converts all instances into real geometry, producing a single combined geometry output.
    This can be required for some subsequent geometry operations or modifiers.

Keep Surface
:   Keeps the underlying surface used for instancing, rather than outputting only the instances.

Seed
:   Random seed value used to vary random selections or random instance indexing.

### Pick Instance Data-Block Collection

When instancing from a collection, this option enables random or controlled selection
of which child object to instance per element.

Instance Index
:   Determines how a child instance is chosen from the collection.

    Random:
    :   Picks a random object from the collection for each element.

    Sequence:
    :   Cycles through objects in collection order.

    Input:
    :   Uses the value from the *Instance Index* input socket.

Instance Index Input
:   Specifies the index of the object in the collection to be instanced,
    used when the *Instance Index* method is set to *Input*.

### Transform

Surface Offset
:   Moves instances along the element normal, offsetting them from the surface.

Align Rotation
:   Aligns instance rotation to the orientation of the geometry element (e.g., normal direction).

Scale
:   Controls the uniform or per-axis scaling of instances.
user: Describe Usage from the Blender manual or Python API, including usage steps and snippets.

assistant: To use Open Shading Language (OSL) in Blender, follow these steps:

1. **Enable OSL Rendering**

   In the Render Properties enable
   [Open Shading Language](../render_settings/index.html#bpy-types-cyclesrendersettings-shading-system).
2. **Add a Script Node**

   In the Shader Editor add [Script Node](../../shader_nodes/utilities/script.html) then in the node’s properties:

   - Set the *Mode* to *Internal* to use a Blender text data-block, or
   - Set it to *External* to load a shader file from disk (either .osl or compiled .oso).

   For the internal mode, create a new text data-block in the Text Editor,
   then write or paste your OSL code there.

   Blender will compile the OSL source file automatically.
   If the source is .osl, it will be compiled into .oso bytecode.
   Compilation errors will be shown in the system console.
3. **Use Shader Outputs**

   Once compiled, the node’s outputs will reflect the `output` parameters defined in the OSL code.
   These outputs can be connected to any part of the material node tree.
user: How do I use D in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [**Data User**](glossary/index.xhtml#term-Data-User) - [**Data-Block**](glossary/index.xhtml#term-Data-Block) - [**Depth of Field**](glossary/index.xhtml#term-Depth-of-Field) - [**Dielectric Material**](glossary/index.xhtml#term-Dielectric-Material) - [**Diffuse Light**](glossary/index.xhtml#term-Diffuse-Light) - [**Directional Light**](glossary/index.xhtml#term-Directional-Light) | - [**Displacement Mapping**](glossary/index.xhtml#term-Displacement-Mapping) - [**Display Referenced**](glossary/index.xhtml#term-Display-Referenced) - [**DOF**](glossary/index.xhtml#term-DOF) - [**Dots Per Inch**](glossary/index.xhtml#term-Dots-Per-Inch) - [**Double Buffer**](glossary/index.xhtml#term-Double-Buffer) - [**DPI**](glossary/index.xhtml#term-DPI) |
user: Give a detailed overview of Tools: syntax, arguments, return values, common patterns.

assistant: ### Comb

Moves the keypoints (similar to the Proportional Editing tool).

Deflect Emitter
:   Hair particles only – Do not move keypoints through the emitting mesh.

    Distance
    :   The distance to keep from the Emitter.

### Smooth

Parallels visually adjacent segments.

### Add

Adds new particles.

Count
:   The number of new particles per step.

Interpolate
:   Interpolate the shape of new hairs from existing ones.

Steps
:   Amount of brush steps.

Keys
:   How many keys to make new particles with.

### Length

Scales the segments, so it makes the hair longer with *Grow* or shorter with *Shrink*.

Grow/Shrink
:   Sets the brush to add the effect or reverse it.

### Puff

Rotates the hair around its first keypoint (root).
So it makes the hair stand up with *Add* or lay down with *Sub*.

Puff Volume
:   Apply puff to unselected end points, (Helps to maintain the hair volume when puffing the root.)

### Cut

Scales the segments until the last keypoint reaches the brush.

### Weight

This is especially useful for soft body animations, because the weight defines the soft body *Goal*.
A keypoint with a weight of 1 will not move at all,
a keypoint with a weight of 0 subjects fully to soft body animation.
This value is scaled by the Strength *Min* to *Max* range of soft body goals…

### Common Options

Below the brush types, their settings appear:

Radius `F`
:   Set the radius of the brush.

Strength `Shift`-`F`
:   Set the strength of the brush effect (not for Add brush).
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Vertices
:   Number of vertices on the circle at the top and bottom.
    No geometry is generated if the number is below three.

Side Segments
:   Number of edges running vertically along the side of the cone.
    No geometry is generated if the number is below one.

Fill Segments
:   Number of concentric rings used to fill the round faces at the top and bottom.
    No geometry is generated if the number is below one.

Radius
:   Distance of the vertices from the Z axis.
    If this is zero, the output will be a single line.

Depth
:   Height of the cylinder.
user: Give a detailed overview of Controls: syntax, arguments, return values, common patterns.

assistant: These keyboard shortcuts are shown in the
[status bar](../../../../interface/window_system/status_bar.html) while cutting.
They’re available both when using the tool from the Toolbar and when pressing `K`.

Cut `LMB`
:   You can either click to add a new cutting line, or drag to create cutting lines
    as you move the mouse over edges.

Close Loop - Double-click `LMB`
:   Adds a cutting point at the cursor (just like when single-clicking) and then connects
    it to the first point in the current path, closing the loop.

Stop `RMB`
:   Completes the current cutting path and begins a new one. The cursor will snap to previously
    defined cuts.

    |  |  |
    | --- | --- |
    | ../../../../_images/modeling_meshes_tools_knife_multiple-before.png   After defining the horizontal cut, press `RMB` and define the vertical one. | ../../../../_images/modeling_meshes_tools_knife_multiple-after.png   Result after applying. |

Confirm `Spacebar` or `Return`
:   Confirms the cut, turning the cutting paths into edges.

Cancel `Esc`
:   Cancels the cut.

Undo `Ctrl`-`Z`
:   Undoes the previous cutting line (or, if you dragged the mouse before, all the cutting
    lines created during that drag).

Midpoint Snap `Shift`
:   Hold to snap the cursor to the center of edges.

Ignore Snap `Ctrl`
:   Hold to temporarily stop the cursor from snapping to existing vertices, edges,
    and cutting lines.

Cut Through `C`
:   Also cut through occluded faces, instead of only the visible ones.
    This is linked to (and the opposite of) the *Occlude Geometry* setting above.

Axis `X`, `Y`, or `Z`
:   Constrains the current cutting line to a global axis. Press a second time to use the
    object’s local axis, and a third time to disable the constraint again.

Measure `S`
:   Cycles between measurements to show: distances, angles, or both.

X-Ray `V`
:   Toggles whether to display cuts occluded by geometry.

Angle Constraint `A`
:   Constrains cutting lines to multiples of the *Snap Increment* angle. This angle
    can be specified in the Tool Settings before cutting (see above) or typed
    while cutting with *Angle Constraint* active.

    By default, the snapping is done in the *Screen* plane. Press `A`
    a second time to snap in planes on the geometry, *Relative* to an automatically
    chosen edge or cutting line. You can press `R` to select a different reference line.

    Press `A` a third time to disable the snapping again.
user: Explain Brush Tool in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The *Brush* tool.

Painting or sculpting with brushes requires the brush tool to be active. Activating a brush from an
asset shelf or brush selector also activates the brush tool for convenience.
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

Particles are lots of items emitted from mesh objects, typically in the thousands.
Each particle can be a point of light or a mesh, and be joined or dynamic.
They may react to many different influences and forces, and have the notion of a lifespan.
Dynamic particles can represent fire, smoke, mist,
and other things such as dust or magic spells.

[Hair](hair/index.xhtml) type particles are a subset of regular particles.
Hair systems form curves that can represent hair, fur, grass and bristles.

You see particles as a Particle Modifier,
but all settings are done in the *Particle tab*.

[image reference removed]

Some fur made from particles.

Particles generally flow out from their mesh into space.
Their movement can be affected by many things, including:

- Initial velocity out from the mesh.
- Movement of the emitter (vertex, face or object) itself.
- Movement according to “gravity” or “air resistance”.
- Influence of force fields like wind, vortexes or guided along a curve.
- Interaction with other objects like collisions.
- Partially intelligent members of a flock (herd, school, …),
  that react to other members of their flock, while trying to reach a target or avoid predators.
- Smooth motion with soft body physics (only *Hair* particle systems).
- Or even manual transformation with [Lattices](../../modeling/modifiers/deform/lattice.xhtml).

Particles may be rendered as:

- [Halos](emitter/render.xhtml#particle-halo) (for Flames, Smoke, Clouds).
- Meshes which in turn may be animated (e.g. fish, bees, …).
  In these cases, each particle “carries” another object.
- [Hair curves](hair/shape.xhtml), following the path of the particle.
  These hair curves can be manipulated in the 3D Viewport (combing, adding, cutting, moving, etc.).

Every object may carry many particle systems. Each particle system may contain up to
10,000,000 particles. Certain particle types (*Hair* and *Keyed*)
may have up to 10,000 children for each particle
(children move and emit more or less like their respective parents).
The size of your memory and your patience are your practical boundaries.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Samples
:   Number of samples to take for each shader evaluation.
    More samples give more accurate results, but are also slower to render.
    The default value of 4 works well for most cases, with any noise resolved by using more AA samples.
user: Provide the full official documentation entry for GeometryNodeStoreNamedGrid(GeometryNode), preserving all code examples.

assistant: # GeometryNodeStoreNamedGrid(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.GeometryNodeStoreNamedGrid(*GeometryNode*)
:   Store grid data in a volume geometry with the specified name

    data_type
    :   Type of grid data

        Type:
        :   enum in [Volume Grid Data Type Items](bpy_types_enum_items/volume_grid_data_type_items.html#rna-enum-volume-grid-data-type-items), default `'FLOAT'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`BlendData.workspaces`](bpy.types.BlendData.html#bpy.types.BlendData.workspaces "bpy.types.BlendData.workspaces") - [`Context.workspace`](bpy.types.Context.html#bpy.types.Context.workspace "bpy.types.Context.workspace") | - [`Window.workspace`](bpy.types.Window.html#bpy.types.Window.workspace "bpy.types.Window.workspace") |
user: Show practical ways to work with Empty Hair in a Blender add-on or script – include code.

assistant: Adds an empty high-performance curves object and automatically:

- Assigns the active object as the [Surface](../../sculpt_paint/curves_sculpting/introduction.html).
- Set the surface object as the parent of the new object.
- Adds a Geometry Nodes modifier to deform the curves on the surface.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Image
:   The image socket can be used to connect to the Group Input node.
    If this is not connected the image can be opened or selected from the node.

Vector
:   Texture coordinate for texture look-up. If this socket is left unconnected,
    the Position attribute is used.

Frame
:   If the Image supports animation, the frame can be set here.
    This can be keyframed so that the image changes between frames.