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

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

The Skin modifier.

Branch Smoothing
:   A branch point is a vertex with three or more connected edges.
    These areas tend to produce more complicated topology, some of which may overlap.
    This setting relaxes the surface around these points,
    with the side effect of shrinking it.

Symmetry
:   These checkboxes are used to keep the output topology symmetrical in their respective axes.
    In other words, using it avoids merging triangles across an axis unless the triangles form a symmetric quad.

Smooth Shading
:   Output faces with smooth shading rather than flat shading.
    The smooth/flat shading of the input geometry is not preserved.

Create Armature
:   Create an armature on top of the object. Each edge becomes a bone.

    This tool does the following:

    1. A new armature object is added with bones matching the input mesh.
       The active selection is switched to the new armature.
    2. Weight groups are added to the input mesh. The Skin modifier propagates these weights to the output as well.
    3. An [Armature](../deform/armature.html) modifier is added directly below the Skin one.
       Note that the Armature modifier is being applied after
       the Skin one because it should only deform the output,
       whereas if it were above, it might change the resulting topology.

Add Skin Data
:   This modifier uses a [custom set of data](#modeling-modifiers-generate-skin-data) in the mesh,
    that is generated automatically when you add the modifier the first time.

    However, you may remove that data, or loose it some way or the other. That operator will generate it again.

Mark/Clear Loose
:   By default, a branch vertex (vertex with three or more connected edges)
    will generate extra edge loops along adjacent edges in order to keep the output tight.
    Branches can be made loose by clicking *Mark Loose*, which will allow the output to stretch between
    all adjacent vertices. This can be disabled again by clicking *Clear Loose*.

Mark Root
:   Marking a vertex as root causes that vertex to be used for calculating rotations for connected limbs.
    Root vertices also affect the armature output, they will be used as the origin for the root bones.

    Each set of connected vertices should have one root node
    (one is selected by default if you do not assign any manually).
    *Mark Root* enforces the one-root per set rule, so it is not necessary to manually unmark roots.

Equalize Radii
:   Makes the skin radii of selected vertices equal on each axis.
user: Describe ThemeFileBrowser(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ThemeFileBrowser(bpy_struct)

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

*class* bpy.types.ThemeFileBrowser(*bpy_struct*)
:   Theme settings for the File Browser

    row_alternate
    :   Overlay color on every other row

        Type:
        :   float array of 4 items in [0, 1], default (0.0, 0.0, 0.0, 0.0)

    selected_file
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    space
    :   Settings for space

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Internally, cloth physics is simulated with virtual springs that connect the vertices of a mesh.
There are four types of springs that control how the cloth bends.
These four types are defined below and illustrated in the following image:

[image reference removed]

Illustration of cloth springs; tension springs (blue),
compression springs (red), shear springs (cyan),
and angular bending springs (green).

Tension Springs
:   Control the stiffness of the cloth.

Compression Springs
:   Control the amount of force required to collapse or compress the cloth.

Shear Springs
:   Like compression springs but it controls the angular deformation.

Angular Bending Springs
:   Control how resilient the cloth is to folding or crumpling.

All four of these spring types can be controlled independently in
the [Physical Properties](settings/physical_properties.xhtml) panel. While these settings
control surface springs, optionally, internal springs can be used for 3D meshes
and behave similarly to [Soft Bodies](../soft_body/index.xhtml).
user: Give a detailed overview of Nodes: syntax, arguments, return values, common patterns.

assistant: ### UV Along Stroke Node

[image reference removed]

UV Along Stroke Node.

The *UV Along Stroke* input node is maps textures along the stroke length,
making it possible to mimic pencil, paintbrush, and other art medium marks.

#### Inputs

This node has no inputs.

#### Properties

Use Tips
:   Allows to use lower quarters of a texture image for the head and tail tips of a stroke,
    while the upper half for the stroke body.

#### Outputs

UV
:   UV maps defined along strokes.

### Line Style Output Node

[image reference removed]

Line Style Output Node.

The *Line Style Output* node specifies how to mix the texture information
into the base color of line styles.

#### Inputs

Color
:   Color input for the texture.

Color Factor
:   Standard mix factor of the *Color* value.

Alpha
:   Alpha input for the texture.

Alpha Factor
:   Standard mix factor of the *Alpha* value.

#### Properties

Mix
:   The Blend mode can be selected in the select menu.
    See [Color Blend Modes](../../../../glossary/index.xhtml#term-Color-Blend-Modes) for details on each blending mode.

Clamp
:   Limit the highest color value to not exceed 1.0.

#### Outputs

This node has no outputs.
user: Give a detailed overview of Collection: syntax, arguments, return values, common patterns.

assistant: # Collection

*Instance Collections* allows you to create an instance of a collection for each instance of another object.
Collections may contain animations, objects with physics simulations and even other nested collections.
user: Show practical ways to work with Accessibility in a Blender add-on or script – include code.

assistant: Reduce Motion
:   Avoids interface animations and motion effects.
    This option helps reduce visual distractions and can improve comfort for
    users sensitive to motion or those who prefer a more static interface.
user: Show practical ways to work with Tool Settings in a Blender add-on or script – include code.

assistant: Filter Type
:   Operation that is going to be applied to the mesh.

    Gravity:
    :   Applies gravity to the simulation.

    Inflate:
    :   Inflates the cloth.

    Expand:
    :   Expands the cloth’s dimensions.

    Pinch:
    :   Pinches the cloth to the point where the cursor was when the filter started.

    Scale:
    :   Scales the mesh as a [Soft Body](../../../physics/soft_body/index.xhtml)
        using the distance to the origin of the object as scale.
        This creates filter produces folds in the surface.
        The orientation of the folds can be controlled using the *Force Axis* and *Orientation*.

Strength
:   The amount of effect the filter has on the mesh.

Force Axis
:   Apply the force along the selected axis.

Orientation
:   [Orientation](../../../editors/3dview/controls/orientation.xhtml) of the axis to limit the filter force.

    Local:
    :   Use the local axis to limit the force and set the gravity direction.

    World:
    :   Use the world axis to limit the force and set the gravity direction.

    View:
    :   Use the view axis to limit the force and set the gravity direction.

Cloth Mass
:   Mass of each simulation particle.

Cloth Damping
:   How much the applied forces are propagated through the cloth.

Use Face Sets
:   Only applies the cloth forces to the vertices assigned to the [Face Set](../editing/face_sets.xhtml#sculpting-editing-facesets)
    that are under the mouse.

Use Collisions
:   Enables the detection of collisions with other objects during the simulation.
    In order for the sculpt object to collide with object,
    the collision object must have [Collision Physics](../../../physics/collision.xhtml) activated.
user: Describe S-Curves from the Blender manual or Python API, including usage steps and snippets.

assistant: # S-Curves

The curve type used for creating mask splines is almost a Bézier curve, but with some differences.
Smooth edges of the mask are defined by feathering.
The curve needed to support feathering in a way that stuck to the curve as you edited it,
for ease of editing an animation. These are called S-curves.

Besides the handles, every control point also has points that define the feather between
the current point and the next point on the spline.
Each feather point is stored in UW space,
where U means position across spline segment, and W (weight) means distance between main spline and feather points.

[image reference removed]

S-Curve explained.

This allows for deforming the main spline in almost any way,
and the feather will be updated automatically to reflect that change.

For example if there is just rotation of the spline,
feather would stay completely unchanged. If one point’s feather is moved,
the other feathers will be automatically stretched uniformly along that segment
and the overall shape will be almost the same as artists would want it to be.
user: Give a detailed overview of Save and Override: syntax, arguments, return values, common patterns.

assistant: The workspaces are saved in the blend-file.
When you open a file, enabling [Load UI](../../files/blend/open_save.xhtml#file-load-ui) in the File Browser indicates that Blender should
use the file’s screen layout rather than the current one.

A custom set of workspaces can be saved as a part of the [Defaults](../../getting_started/configuration/defaults.xhtml).
user: Show practical ways to work with Basic Usage in a Blender add-on or script – include code.

assistant: Create a Collection:
:   - Create a new collection (this can be done via the Outliner).
    - Link the objects that need to be instanced as part of the newly created collection.

Create a new Collection Instance:
:   - Add ‣ Collection Instance

At this point, an instance of the collection and an [empty object](../../../../modeling/empties.html) will appear.
You can duplicate the empty, and the *Instance Collections* settings will be preserved for each empty.
This way, you can get multiple copies of linked data very easily.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Target Element
:   Faces:
    :   Calculate the closest point anywhere on the faces of the target’s mesh geometry.

    Edges:
    :   Calculate the closest point anywhere on the edges of the target’s mesh geometry.

    Points:
    :   Calculate the closest point or vertex on the target geometry. This mode is usually the fastest.
        This mode works for both point cloud and mesh geometry, the other modes only work for meshes.
user: Describe EEVEE Limitations from the Blender manual or Python API, including usage steps and snippets.

assistant: - [Depth of Field](../cameras.xhtml#bpy-types-cameradofsettings) and [Motion Blur](../eevee/render_settings/motion_blur.xhtml)
  are not rendered in passes other than *Combined*.
  They can be emulated in the Compositor using the [Defocus Node](../../compositing/types/filter/blur/defocus.xhtml)
  and the [Vector Blur Node](../../compositing/types/filter/blur/vector_blur.xhtml).
- Transparent materials that have their [Render Method](../eevee/material_settings.xhtml#bpy-types-material-surface-render-method)
  set to *Blended* are not rendered in passes other than *Combined* and *Transparent*.
  Use the *Dithered* method instead.
- The [Shader To RGB Node](../shader_nodes/color/shader_to_rgb.xhtml) only works correctly
  in the *Combined* pass as EEVEE excludes parts of the BSDF equation.
- There is a maximum of 16 *Color* and 16 *Value* AOVs (custom render passes).
user: Describe Node Compositor Extension Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Node Compositor Extension Items

CLIP:
:   Clip.

    Areas outside of the image are filled with zero.

EXTEND:
:   Extend.

    Areas outside of the image are filled with the closest boundary pixel in the image.

REPEAT:
:   Repeat.

    Areas outside of the image are filled with repetitions of the image.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: Limits
:   Angular
    :   X Angle, Y Angle, Z Angle
        :   Enables/disables limit rotation around X, Y or Z axis respectively.

            Lower
            :   Lower limit of rotation for X, Y or Z axis respectively.

            Upper
            :   Upper limit of rotation for X, Y or Z axis respectively.

    Linear
    :   X Axis, Y Axis, Z Axis
        :   Enables/disables limit translation on X, Y or Z axis respectively.

            Lower
            :   Lower limit of translation for X, Y or Z axis respectively.

            Upper
            :   Upper limit of translation for X, Y or Z axis respectively.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`CollectionChild.light_linking`](bpy.types.CollectionChild.html#bpy.types.CollectionChild.light_linking "bpy.types.CollectionChild.light_linking") | - [`CollectionObject.light_linking`](bpy.types.CollectionObject.html#bpy.types.CollectionObject.light_linking "bpy.types.CollectionObject.light_linking") |
user: What is Post Processing and how is it used in Blender Python scripting?

assistant: # Post Processing

The Post Processing panel is used to control different options used to process your image after rendering.

[image reference removed]

Post Processing panel.

Pipeline – Compositing
:   Renders the output from the compositing node setup,
    and then applies the Composite node tree on all images,
    displaying the image inputted in the Group Output node.

Pipeline – Sequencer
:   Renders the output of the Video Sequence editor, instead of the view from the 3D scene’s active camera.
    If the sequence contains Scene strips, these will also be rendered as part of the pipeline.
    If *Compositing* is also enabled, the Scene strip will be the output of the Compositor.

Dither
:   Dithering is a technique for blurring pixels to prevent banding that is seen in areas of
    gradients, where stair-stepping appears between colors.
    Banding artifacts are more noticeable when gradients are longer, or less steep.
    Dithering was developed for graphics with low bit depths,
    meaning they had a limited range of possible colors.

    Dithering works by taking pixel values and comparing them with a threshold and
    neighboring pixels then does calculations to generate the appropriate color.
    Dithering creates the perceived effect of a larger color palette by creating a sort of visual color mixing.
    For example, if you take a grid and distribute red and yellow pixels evenly across it,
    the image would appear to be orange.
user: How do I use Image Tab in Blender? Include parameters, examples, warnings and best practices.

assistant: ### UV Vertex

The averaged-out position of the selected UV vertices.

### Image

See [Image Settings](../image/image_settings.xhtml).

### UDIM Tiles

See [UDIM Tiles](../../modeling/meshes/uv/workflows/udims.xhtml).
user: Explain Transform Panel in complete detail according to the official Blender documentation.

assistant: When nothing is selected, the panel is empty.
When more than one vertex is selected, the median values is edited
and “Median” is added in front of the labels.

Vertex
:   The first controls (X, Y, Z) show the coordinates of the selected vertex or the median point.

Space
:   The Space radio buttons let you choose if those coordinates are relative to the object origin (local) or
    the global origin (global).

    Global, Local

### Vertex Data

Bevel Weight
:   This vertex property, a value between (0.0 to 1.0),
    is used by the [Bevel Modifier](../../../../modifiers/generate/bevel.html)
    to control the bevel intensity of the vertices, when the *Only Vertices* option is active.

Crease
:   This vertex property, a value between (0.0 to 1.0), is used by
    the [Subdivision Surface Modifier](../../../../modifiers/generate/subdivision_surface.html)
    to control the sharpness of the vertices in the subdivided mesh.

### Edge Data

When an edge is selected, the following options are available. More buttons appear:

Bevel Weight
:   This edge property, a value between (0.0 to 1.0),
    is used by the [Bevel Modifier](../../../../modifiers/generate/bevel.html)
    to control the bevel intensity of the edges.

    This property can also be set using the [Edge Bevel Weight](../../edge/edge_data.html#bpy-ops-transform-edge-bevelweight) operator.

Crease
:   This edge property, a value between (0.0 to 1.0), is used by
    the [Subdivision Surface Modifier](../../../../modifiers/generate/subdivision_surface.html)
    to control the sharpness of the edges in the subdivided mesh.
user: Explain Controls in complete detail according to the official Blender documentation.

assistant: These keyboard shortcuts are shown in the
[status bar](../../../../interface/window_system/status_bar.xhtml) 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: Provide the full official documentation entry for Shadow Visual Effect, preserving all code examples.

assistant: # Shadow Visual Effect

The *Shadow* Visual Effect shows a simulated shadow casting by the object.

For simulating the shadow a color silhouette of the object is displaced in
horizontal and/or vertical direction on the back of the object.
user: Provide the full official documentation entry for Notes, preserving all code examples.

assistant: While the noise is random in nature, it follows a certain pattern that might not evaluate to
random values in some configurations. For instance, consider the following configuration
where a grid of objects have a material that evaluates a noise texture at their locations.
One might expect the objects to have random values since they have different locations,
but this is not the case.

[image reference removed]

An example configuration where the noise evaluates to a constant value.

It seems all objects have a value of 0.5. To understand why this happens, let us
look at the following plot of a 1D noise texture.

[image reference removed]

A plot of a 1D noise with zero details and zero distortion.

The horizontal line denotes a value of 0.5 and the vertical lines denotes whole numbers assuming
a noise scale of 1. As can be seen, the noise always intersects the 0.5 line at whole numbers.
Since the aforementioned objects were distributed on a grid and have whole number locations,
they all evaluate to 0.5. Which explains the issue at hand.

Generally, any discrete evaluation of noise at integer multiples of the reciprocal of
the noise scale will always evaluate to 0.5. It also follows that evaluations closer to
that will have values close to 0.5. In such cases, it is almost always preferred to use
the White Noise Texture.

Regardless, one can mitigate this issue in a number of ways:

- Adjust the scale of the noise to avoid aligning the noise with the evaluation domain.
- Add an arbitrary offset to the texture coordinates to break the alignment with the evaluation domain.
- Evaluate the noise at a higher dimension and adjust the extra dimension
  until a satisfactory result is achieved.

|  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_textures_noise_issue-constant-value.png   Constant value issue. | ../../../_images/render_shader-nodes_textures_noise_solution1-constant-value.png   Mitigating the issue by adjusting the scale. |
| ../../../_images/render_shader-nodes_textures_noise_solution2-constant-value.png   Mitigating the issue by adding an arbitrary offset. | ../../../_images/render_shader-nodes_textures_noise_solution3-constant-value.png   Mitigating the issue by evaluating at a higher dimension. |

Similarly, in other configurations, one might experience some banding patterns in the noise,
where there are bands of high contrast areas followed by banding of low contrast areas.
For instance, planar surfaces that are slightly tilted along one of the axis
will have such a banding pattern.

[image reference removed]

An example configuration where the noise have a banding pattern.

This happens because the slight tilt along one of the axis causes values along
the perpendicular axis to change very slowly making the grid structure of
the noise more apparent. The easiest way to mitigate this issue to rotate
the coordinates by an arbitrary amount.

[image reference removed]

Mitigating the issue by rotating the coordinates by an arbitrary amount.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Phase
:   Volume scattering phase function.

    Henyey-Greenstein:
    :   Simple and widely used phase function, useful for approximating scattering in biological tissues.

    Fournier-Forand:
    :   Cycles Only
        Suitable for modeling the scattering of light in underwater environments.

    Draine:
    :   Cycles Only
        Suitable for modeling the scattering of interstellar dust.

    Rayleigh:
    :   Cycles Only
        Describes the scattering by particles with a size smaller than the wavelength of light,
        such as the scattering of sunlight in earth’s atmosphere.

    Mie:
    :   Cycles Only
        Describes the scattering by particles with a size larger than the wavelength of light, such as cloud and fog.

[image reference removed]

Volume scattering phase as a function of angles between the incoming and the outgoing direction,
in logarithmic scale. Light comes from the left side.
user: Describe Geometry from the Blender manual or Python API, including usage steps and snippets.

assistant: 3D Markers to Mesh
:   See [3D Markers to Mesh](../editing/reconstruction.xhtml#bpy-ops-clip-bundles-to-mesh).

Link Empty to Track
:   See [Link Empty to Track](../editing/reconstruction.xhtml#bpy-ops-clip-track-to-empty).
user: Explain Scale Cage in complete detail according to the official Blender documentation.

assistant: # Scale Cage

The *Scale Cage* tool is a bounding box around the object(s) which scales objects from a particular point or axis.
The tool works by selecting a scale point and dragging inwards or outwards to adjust the scale accordingly.
The origin for the scale will be from the point on the cube directly opposite from the point selected.
Selecting points on the faces of the cube scales along one axis,
selecting points on the edges of the cube scales along two axes,
and selecting points on the vertices of the cube scales along all three axes.

[image reference removed]

Scale Cage tool.
user: How do I use Feature Sets in Blender? Include parameters, examples, warnings and best practices.

assistant: # Feature Sets

Rigify allows third party developers to implement sub-addons, called *Feature Sets*,
which can provide new [Meta-Rigs](metarigs.html) and
[Rig Types](rig_types/index.html). Similar to regular add-ons,
they can be installed from zip-files through Rigify settings.

These are some examples of *Feature Sets* currently provided by past and current Rigify developers:

[Cessen’s Rigify Extensions](https://github.com/cessen/cessen_rigify_ext)
:   This feature set provides the original Rigify rigs by Nathan Vegdahl, minimally ported
    and repackaged to work without switching Rigify to legacy mode. Note that their names
    were changed, so meta-rigs designed for legacy mode aren’t directly compatible.

[Experimental Rigs by Alexander Gavrilov](https://github.com/angavrilov/angavrilov-rigs)
:   Rig experiments, some of which might be included in Rigify in the future. Examples include
    limbs with an extra IK system based at knee/elbow, a spline based tentacle, and more.

You can install these packages by clicking Code ‣ Download ZIP,
and then install the downloaded file through Rigify settings.

Developer documentation is available on the [Blender Developer Documentation](https://developer.blender.org/docs/features/animation/rigify/).
user: Describe Usage from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Setup for Hair Particles

1. Create a *Hair* particle system.
2. Give it an initial velocity in the *Normal* direction.
3. Create a simulation.
4. Check the *Hair Dynamics* box.

[image reference removed]

Editing hair strands in Particle Edit Mode.

### Setup for Particle, Cloth, and Soft Body Simulations

1. Use *Emitter* particles, or a cloth/soft body simulation.
2. Create a simulation by setting up objects and/or emitters,
   set your time range (use a small range if you are just starting out and experimenting),
   set up the simulation how you want it, play the animation to preview it.

### Bake the Simulation

Once you are happy with the general simulation, [bake](emitter/cache.html)
the simulation from Object Mode. The simulation must be baked to enable editing.

### Edit the Simulation

Switch to *Particle Edit* from the *Mode* select menu in the header of the 3D Viewport
to edit the particle’s paths/Keyframes. You may need to press `T` from within the 3D Viewport
to see the *Particle Edit* toolbox. Move to the frame you want to edit and use the various
tools to edit your simulation.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Rotation
:   The [Euler](../../../../glossary/index.xhtml#term-Euler) rotation to rotate.

Rotate By
:   Specifies how much an Euler rotation is rotated. This input is only available
    when the rotation type is set to *Euler*.

Axis
:   The axis to rotate around. This input is only available when the rotation type is set to *Axis Angle*.

Angle
:   The angle to rotate by around the specified axis. This input is only available
    when the rotation type is set to *Axis Angle*.
user: Give a detailed overview of Attach Hair Curves to Surface: syntax, arguments, return values, common patterns.

assistant: # Attach Hair Curves to Surface

The *Attach Hair Curves to Surface* node binds hair curves to a surface mesh,
establishing their attachment positions and optionally aligning them to the
surface orientation.
This node is a fundamental part of hair generation and grooming workflows,
ensuring that curves remain anchored correctly to the underlying surface,
even after deformation or topology changes.
user: Explain Shadow in complete detail according to the official Blender documentation.

assistant: EEVEE uses a technique called *Virtual Shadow Mapping* along with *Shadow Map Raytracing*.
*Virtual Shadow Mapping* produces more accurate results than traditional shadow mapping by putting resolution
only where it is needed. It also includes a very efficient caching mechanism.
This technique offers better performance than ray tracing and is compatible
with any [Render Method](material_settings.xhtml#bpy-types-material-surface-render-method).

Jitter
:   Enable jittered soft shadows to increase shadow precision.
    Has a high performance impact as the shadow map cannot be cached and needs to be updated for each render sample.

Overblur
:   Apply shadow tracing to each jittered sample to reduce under-sampling artifacts.

Filter
:   Blur shadow aliasing using PCF with a circular kernel.
    The effective world scale of the filter depends on the shadow map resolution at the shadowed pixel position.

Resolution Limit
:   Minimum size of a shadow map pixel. Higher values use less memory at the cost of shadow quality.
    Higher values also speed-up rendering of heavy scenes.
    Each shadow is scaled depending on the shadowed pixel on screen. This can create very sharp shadows
    but also requires a lot of memory if the shadowed pixel is close to the camera.
    This property limits the maximum amount of detail that the shadow map can capture.

Absolute Resolution Limit
:   Limit the resolution at 1 unit from the light origin instead of relative to the shadowed pixel.
    This makes [Resolution Limit](#bpy-types-light-shadow-maximum-resolution)
    act as a regular shadow map pixel size.
user: Describe TextureNodeMath(TextureNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # TextureNodeMath(TextureNode)

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

*class* bpy.types.TextureNodeMath(*TextureNode*)
:   operation
    :   Type:
        :   enum in [Node Math Items](bpy_types_enum_items/node_math_items.html#rna-enum-node-math-items), default `'ADD'`

    use_clamp
    :   Clamp result of the node to 0.0 to 1.0 range

        Type:
        :   boolean, default False

    *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 View3DCursor(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # View3DCursor(bpy_struct)

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

*class* bpy.types.View3DCursor(*bpy_struct*)
:   location
    :   Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], default (0.0, 0.0, 0.0)

    matrix
    :   Matrix combining location and rotation of the cursor

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

    rotation_axis_angle
    :   Angle of Rotation for Axis-Angle rotation representation

        Type:
        :   float array of 4 items in [-inf, inf], default (0.0, 0.0, 1.0, 0.0)

    rotation_euler
    :   3D rotation

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

    rotation_mode
    :   The kind of rotation to apply, values from other rotation modes are not used

        Type:
        :   enum in [Object Rotation Mode Items](bpy_types_enum_items/object_rotation_mode_items.html#rna-enum-object-rotation-mode-items), default `'XYZ'`

    rotation_quaternion
    :   Rotation in quaternions (keep normalized)

        Type:
        :   [`mathutils.Quaternion`](mathutils.html#mathutils.Quaternion "mathutils.Quaternion") rotation of 4 items in [-inf, inf], default (1.0, 0.0, 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: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Factor
:   The opacity of the foreground image.

A
:   The background image. Determines the dimensions of the output.

B
:   The foreground image.

Keep in mind that, unlike image editing programs where the foreground layer is on top,
the foreground slot in Blender is on the bottom.
user: Show practical ways to work with skin.anchor in a Blender add-on or script – include code.

assistant: This rig effectively acts as a zero-length chain with highest priority,
ensuring that it becomes the owner when merging controls with other chains.
And also allowing one to input custom automation influence into the skin system.

All constraints on the meta-rig bone are moved to the created control.

Generate Deform Bone
:   Creates a deformation bone parented to the control.

Suppress Control
:   Makes the control a hidden mechanism bone to hide it from the user.

Widget Type
:   Selects which widget to generate for the control.

Relink Constraints
:   Operates the same as in [basic.raw_copy](basic.xhtml#rigify-rigs-basic-raw-copy),
    except all constraints are moved from ORG to the control bone.

Orientation
:   Specifies the bone used to orient the control, like for other chains.
user: Provide the full official documentation entry for GeometryNodeMergeLayers(GeometryNode), preserving all code examples.

assistant: # GeometryNodeMergeLayers(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.GeometryNodeMergeLayers(*GeometryNode*)
:   Join groups of Grease Pencil layers into one

    mode
    :   Determines how to choose which layers are merged

        - `MERGE_BY_NAME`
          By Name – Combine all layers which have the same name.
        - `MERGE_BY_ID`
          By Group ID – Provide a custom group ID for each layer and all layers with the same ID will be merged into one.

        Type:
        :   enum in [`'MERGE_BY_NAME'`, `'MERGE_BY_ID'`], default `'MERGE_BY_NAME'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Show/Hide

You do not have to use bone layers to show/hide some bones. As with objects,
vertices or control points, you can use `H`:

- `H` will hide the selected bone(s).
- `Shift`-`H` will hide all bones *but the selected one(s)*.
- `Alt`-`H` will show all hidden bones.

You can also use the *Hide* checkbox of the Bone tab ‣ Viewport Display panel.

Note that hidden bones are specific to a mode,
i.e. you can hide some bones in *Edit Mode*,
they will still be visible in *Pose Mode*, and vice versa.
Hidden bones in *Pose Mode* are also invisible in *Object Mode*.
And in *Edit Mode*, the bone to hide must be fully selected,
not just its root or tip.
user: Describe Notes from the Blender manual or Python API, including usage steps and snippets.

assistant: The slightest difference in seed values would result in completely different outputs.
Consequently, bad precision may have significant impact on the output.
Usually, we can mitigate this issue by:

- Eliminating the problematic seed value. If the problematic seed value is constant,
  it should be eliminated by choosing a lower dimension or multiplying it by zero.
- Adding an arbitrary value to the seed. The issue might only happen at certain boundaries,
  like unit boundaries, so simply adding an arbitrary value might solve the issue.
- Taking the absolute value of the seed. In computing, zero may be positive or negative,
  so taking the absolute values unifies the zero into a single value.

|  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_textures_white-noise_issue.png   Precision issue due to signed zeros on the Z axis. | ../../../_images/render_shader-nodes_textures_white-noise_solution1.png   Mitigating the issue by eliminating the Z axis. |
| ../../../_images/render_shader-nodes_textures_white-noise_solution2.png   Mitigating the issue by adding an arbitrary value. | ../../../_images/render_shader-nodes_textures_white-noise_solution3.png   Mitigating the issue by taking the absolute value. |
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

Materials control the appearance of meshes, curves, volumes and other objects.
They define the substance that the object is made of, its color and texture,
and how light interacts with it.

Physically based materials can be created using
the [Principled BSDF](../shader_nodes/shader/principled.html),
[Principled Hair](../shader_nodes/shader/hair_principled.html),
and [Principled Volume](../shader_nodes/shader/volume_principled.html) shaders.
With these uber shaders, a wide variety of materials including
plastic, glass, metal, cloth, skin, hair, smoke and fire can be created.

A flexible [shading nodes](../shader_nodes/introduction.html) system is used
to set up textures and create entirely different types of materials like toon shading.
user: Describe Start Editing Stashed Action from the Blender manual or Python API, including usage steps and snippets.

assistant: Enters Tweak Mode for the selected strip’s action, making its keyframes available for editing in
e.g. the [Graph Editor](../../graph_editor/introduction.xhtml). In addition, marks the strip’s
track as *Solo*, muting all the other tracks – this way, they no longer influence the animation
and you can focus exclusively on the action you’re editing.

While the menu item refers to stashed (muted) actions, this only reflects the typical use case.
It works on unmuted actions as well.

When you’re done editing, click Strip ‣ Stop Editing Stashed Action
or press `Shift`-`Tab` again.

|  |  |
| --- | --- |
| ../../../_images/editors_nla_editing_nla-mode.png   Strip in NLA mode. | ../../../_images/editors_nla_editing_edit-mode.png   Strip in Tweak mode. |
user: Describe Resyncing Overrides from the Blender manual or Python API, including usage steps and snippets.

assistant: The relationships between linked data-blocks can change, resulting in outdated overrides.
When this happens, overrides need to be resynced to match the new structure of their hierarchy.
Overrides are automatically resynced if needed on blend-files opening. However,
it may be needed to resynced them manually sometimes, see [Troubleshoot an Override Hierarchy](#troubleshoot-an-override-hierarchy).
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Geometry
:   Standard geometry input.

Radius
:   Float value indicating the radius of the point geometry at each point.

Selection
:   Boolean input for selecting which points will have the radius value applied.
user: Describe Transform Panel from the Blender manual or Python API, including usage steps and snippets.

assistant: When nothing is selected, the panel is empty.
When more than one vertex is selected, the median values is edited
and “Median” is added in front of the labels.

Vertex
:   The first controls (X, Y, Z) show the coordinates of the selected vertex or the median point.

Space
:   The Space radio buttons let you choose if those coordinates are relative to the object origin (local) or
    the global origin (global).

    Global, Local

### Vertex Data

Bevel Weight
:   This vertex property, a value between (0.0 to 1.0),
    is used by the [Bevel Modifier](../../../../modifiers/generate/bevel.xhtml)
    to control the bevel intensity of the vertices, when the *Only Vertices* option is active.

Crease
:   This vertex property, a value between (0.0 to 1.0), is used by
    the [Subdivision Surface Modifier](../../../../modifiers/generate/subdivision_surface.xhtml)
    to control the sharpness of the vertices in the subdivided mesh.

### Edge Data

When an edge is selected, the following options are available. More buttons appear:

Bevel Weight
:   This edge property, a value between (0.0 to 1.0),
    is used by the [Bevel Modifier](../../../../modifiers/generate/bevel.xhtml)
    to control the bevel intensity of the edges.

    This property can also be set using the [Edge Bevel Weight](../../edge/edge_data.xhtml#bpy-ops-transform-edge-bevelweight) operator.

Crease
:   This edge property, a value between (0.0 to 1.0), is used by
    the [Subdivision Surface Modifier](../../../../modifiers/generate/subdivision_surface.xhtml)
    to control the sharpness of the edges in the subdivided mesh.
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Anywhere the geometry is a curve, this node can be used to generate a selection of
only the first and last points of each spline. Here, the *Points* input of
the [Instance on Points Node](../../instances/instance_on_points.xhtml) is a curve
consisting of the poly spline shown in Edit Mode.
user: Show practical ways to work with Modes in a Blender add-on or script – include code.

assistant: Depending on the type of object you are trying to model, there are different types
of modeling [modes](../editors/3dview/modes.xhtml).
Since modes are not specific to modeling they are covered in different parts of the manual.

Switching between modes while modeling is common.
Some tools may be available in more than one mode while others may be unique to a particular mode.

### Edit Mode

Edit Mode is the main mode where modeling takes place.
Edit Mode is used to edit the following types of objects:

- Meshes
- Curves
- Surfaces
- Metaballs
- Text objects
- Lattice

You can only modify the mesh of the objects you are editing.
To modify other objects you can leave Edit Mode, select another object and enter Edit Mode,
or use [Multi-Object Editing](../editors/3dview/modes.xhtml#dview-multi-object-mode).