PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with Laptops in a Blender add-on or script – include code.

assistant: Laptops often have two GPUs for power saving purposes. One slower onboard GPU integrated into the main CPU (typically
Intel or AMD) that uses lower power, and one faster dedicated GPU for better performance (AMD or NVIDIA) that uses
more power.

For the best performance, the dedicated GPU should be used for Blender. Which GPU to use for which application can be
configured in your graphics driver or operating system settings.

If there is a graphics glitch or crash specific to the onboard GPU, then using the dedicated GPU can help avoid that.
Or vice versa, if the dedicated GPU causes issues, then using the onboard graphics can help.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Points
:   Standard geometry input. The position of the points of this geometry affect the transforms of
    each instance output.

Selection
:   Whether to instance on each point. True values mean an instance will be generated on the point,
    false values mean the point will be skipped.

Instance
:   The geometry to instance on each selected point. This can contain real geometry, or multiple instances,
    which can be useful when combined with the *Pick Instance* option.

Pick Instances
:   If enabled, instead of adding the entire geometry from the *Instance* input on every point,
    choose an instance from the instance list of the geometry based on the *Instance Index* input.
    This option is intended to be used with the [Collection Info Node](../input/scene/collection_info.html).

Instance Index
:   The selection of index for every selected point, only used when *Pick Instances* is true.
    By default the point [ID](../geometry/read/id.html) is used,
    or the [index](../geometry/read/input_index.html) if that doesn’t exist.
    Negative values or values that are too large are wrapped around to the other end of
    the instance list.

Rotation
:   The [Euler](../../../glossary/index.html#term-Euler) rotation for every instance. This can use the rotation output of nodes like
    [Distribute Points on Faces](../point/distribute_points_on_faces.html)
    and [Curve to Points](../curve/operations/curve_to_points.html). An Euler rotation
    can also be created from a direction vector like the [normal](../geometry/read/normal.html)
    with the [Align Rotation to Vector Node](../utilities/rotation/align_rotation_to_vector.html).

Scale
:   The size of each generated instance.
user: How do I use Inspection in Blender? Include parameters, examples, warnings and best practices.

assistant: # Inspection

Inspecting intermediate values in a geometry node tree is useful while
building/understanding one or when trying to figure out why something is not working.
Blender provides multiple tools to understand how a node tree is working
or why it is not working.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`SpaceSequenceEditor.preview_overlay`](bpy.types.SpaceSequenceEditor.html#bpy.types.SpaceSequenceEditor.preview_overlay "bpy.types.SpaceSequenceEditor.preview_overlay") |  |
user: Describe Setup Tracking Scene from the Blender manual or Python API, including usage steps and snippets.

assistant: Automatically performs the common steps needed to prepare a scene for match moving and compositing.

This operator sets up a basic VFX workflow by:

- Creating reference objects for the floor and a test object (a cube) to verify the track.
- Creating and configuring a camera object that matches the tracked motion.
- Setting up a compositor node tree that combines the rendered 3D scene with the background footage.

The resulting setup provides a starting point for integrating 3D objects into real footage.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: A, B
:   Standard value inputs of the selected type.

C
:   Compared against the dot product of two input vectors in when the *Mode* property is set to *Dot Product*.

Epsilon
:   This value is used as a threshold for still considering the two inputs as equal
    for the Equal and Not Equal operations.
user: Give a detailed overview of ShaderNodeBsdfMetallic(ShaderNode): syntax, arguments, return values, common patterns.

assistant: # ShaderNodeBsdfMetallic(ShaderNode)

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"), [`ShaderNode`](bpy.types.ShaderNode.html#bpy.types.ShaderNode "bpy.types.ShaderNode")

*class* bpy.types.ShaderNodeBsdfMetallic(*ShaderNode*)
:   Metallic reflection with microfacet distribution, and metallic fresnel

    distribution
    :   Light scattering distribution on rough surface

        - `BECKMANN`
          Beckmann.
        - `GGX`
          GGX.
        - `MULTI_GGX`
          Multiscatter GGX – GGX with additional correction to account for multiple scattering, preserve energy and prevent unexpected darkening at high roughness.

        Type:
        :   enum in [`'BECKMANN'`, `'GGX'`, `'MULTI_GGX'`], default `'BECKMANN'`

    fresnel_type
    :   Fresnel method used to tint the metal

        - `PHYSICAL_CONDUCTOR`
          Physical Conductor – Fresnel conductor based on the complex refractive index per color channel.
        - `F82`
          F82 Tint – An approximation of the Fresnel conductor curve based on the colors at perpendicular and near-grazing (roughly 82°) angles.

        Type:
        :   enum in [`'PHYSICAL_CONDUCTOR'`, `'F82'`], default `'PHYSICAL_CONDUCTOR'`

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

assistant: Key Targets
:   The [list view](../../../../interface/controls/templates/list_view.xhtml#ui-list-view) of keys (target particle systems).

Object
:   The name of a target object for the selected key. If empty it uses the current particle system.

System
:   Index of particle system on the target object.

Time
:   The time (frame number) at which the particles will be at the position of the selected system.
    Note also that the *Start* frame of the Keyed system adds an offset to this time.

Duration
:   How long (in frames) the particles stay on this system before they start moving to the next one.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Method
:   The algorithm used to compute the tangents:

    Exact:
    :   Uses the *MikkTSpace* algorithm for tangent computation.
        Produces consistent and accurate results that match the tangents used in
        Blender’s shading system and exported geometry.
        This method ensures that tangents align with the normal map space used in rendering.

    Fast:
    :   A faster approximate method that interpolates tangents across face corners with matching UVs.
        It provides similar results at a much lower computational cost but may
        produce less consistent results on complex or uneven surfaces.
        For an exact tangent aligned to the surface, the cross product of the
        result with the surface normal can be used.

UV
:   The UV map used to calculate the tangent direction.
    The UV coordinates define how the tangent vectors are oriented across the surface.
user: Explain Cloth in complete detail according to the official Blender documentation.

assistant: # Cloth

This brush simulates cloth physics on the mesh under the brush cursor.
There are various deformation types and settings to customize the brush.

It’s also easy to sculpt the mesh with other brushes and tools
in between using the cloth brushes.
user: How do I use TextureNodeInvert(TextureNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # TextureNodeInvert(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.TextureNodeInvert(*TextureNode*)
:   *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Ambient Occlusion Node

[image reference removed]

The *Ambient Occlusion* node computes how much the hemisphere above the shading point is occluded.
This can be used for procedural texturing, for example to add weathering effects to corners only.

For Cycles, this is an expensive shader and can slow down render significantly.
If render time is a concern, using Pointiness from the Geometry node or baking Ambient Occlusion will result
in faster renders.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Geometry
:   The resulting geometry with curled hair curves.

### Guide Map

Guide Index
:   The guide index map used for the operation.
    If this node created a new guide map, it is stored and output here
    for use in subsequent nodes.
user: How do I use Split Non-Planar Faces in Blender? Include parameters, examples, warnings and best practices.

assistant: Splits any selected faces that are bent beyond a given limit.

Max Angle
:   Faces that are bent by more than this angle will be split.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_mesh_cleanup_split-non-planar-before.png   Original mesh. | ../../../../_images/modeling_meshes_editing_mesh_cleanup_split-non-planar-after.png   Result of Split Non-Planar Faces. |
user: How do I use CompositorNodeKeyingScreen(CompositorNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CompositorNodeKeyingScreen(CompositorNode)

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

*class* bpy.types.CompositorNodeKeyingScreen(*CompositorNode*)
:   Create plates for use as a color reference for keying nodes

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

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Mode
:   Whether to update left or right or both handles.
    When both are selected, both the left and the right handles will be updated.

    Left:
    :   Update the left handles.

    Right:
    :   Update the right handles.

Handle Type
:   The handle type to switch to. See the [Bézier curves](../../../curves/structure.xhtml#curve-bezier-handle-type)
    page for more details on the different handle types.
user: Explain Clean in complete detail according to the official Blender documentation.

assistant: Clean Vertex Group Weights unassigns vertices from
[Vertex Groups](../../modeling/meshes/properties/vertex_groups/index.xhtml)
whose weights are below the *Limit*. Removes weights below a given threshold.
This tool is useful for clearing your weight groups of very low (or zero) weights.

In the example shown, a cutoff value of 0.2 is used (see operator options below)
so all blue parts are cleaned out.

Note, the images use the *Show Zero weights* Active option
so that unreferenced Weights are shown in Black.

[image reference removed]

Clean example.

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

Limit
:   This is the minimum weight value that will be kept in the group.
    Weights below this value will be removed from the group.

Keep Single
:   Ensure that the *Clean* tool will not create completely unreferenced vertices
    (vertices which are not assigned to any vertex group), so each vertex will
    keep at least one weight, even if it is below the limit value!
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: The different modes of the node: faces, edges and points.
In this example the Geometry Nodes modifier is added on the target plane.
Note that the larger plane is subdivided and the smaller plane is not.

[image reference removed]

The three target element modes: faces, edges, and points.

[image reference removed]

Points distributed on a sphere used as a target for a distance used in a shader.
user: Provide the full official documentation entry for Clean Up, preserving all code examples.

assistant: These tools help to cleanup degenerate geometry on the strokes.

### Clean Loose Points

Removes strokes with only a few points.

Limit
:   The number of points to consider a stroke as loose.

### Delete Duplicate Frames

Removes any duplicate keyframes.

### Merge by Distance

Simplifies a stroke by merging the selected points that are closer than a specified distance to each other.
Note, unless using *Unselected*, selected points must be contiguous, else they will not be merged.

Merge Distance
:   Sets the distance threshold for merging points.

Unselected
:   Allows points in selection to be merged with unselected points.
    When disabled, selected points will only be merged with other selected ones.

### Reproject Strokes

Sometimes you may have drawn strokes unintentionally in different locations in the 3D space
but they look right from a certain plane or from the camera view.
You can use Reproject to flatten all the selected strokes from a certain viewpoint.

Reprojected Type
:   Front:
    :   Reproject selected strokes onto the front plane (XZ).

    Side:
    :   Reproject selected strokes onto the side plane (YZ).

    Top:
    :   Reproject selected strokes onto the top plane (XY).

    View:
    :   Reproject selected strokes onto the current view.

    Surface:
    :   Reproject selected strokes onto the mesh surfaces.

        Surface Offset
        :   When Surface Mode is activated controls the stroke offset from the object.

    Cursor:
    :   Reproject selected strokes onto 3D cursor rotation.

Keep Original
:   Maintains the original strokes after applying the tool.

|  |  |  |  |
| --- | --- | --- | --- |
| ../../../_images/grease-pencil_modes_edit_grease-pencil-menu_reproject-strokes-1.png   Original drawing from the front view. | ../../../_images/grease-pencil_modes_edit_grease-pencil-menu_reproject-strokes-2.png   Original drawing in the 3D Viewport. | ../../../_images/grease-pencil_modes_edit_grease-pencil-menu_reproject-strokes-3.png   Strokes reprojected onto the front plane to fix strokes misalignment. | ../../../_images/grease-pencil_modes_edit_grease-pencil-menu_reproject-strokes-1.png   Drawing after reprojection operation from the front view. |
user: Describe CameraStereoData(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CameraStereoData(bpy_struct)

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

*class* bpy.types.CameraStereoData(*bpy_struct*)
:   Stereoscopy settings for a Camera data-block

    convergence_distance
    :   The converge point for the stereo cameras (often the distance between a projector and the projection screen)

        Type:
        :   float in [1e-05, inf], default 1.95

    convergence_mode
    :   - `OFFAXIS`
          Off-Axis – Off-axis frustums converging in a plane.
        - `PARALLEL`
          Parallel – Parallel cameras with no convergence.
        - `TOE`
          Toe-in – Rotated cameras, looking at the same point at the convergence distance.

        Type:
        :   enum in [`'OFFAXIS'`, `'PARALLEL'`, `'TOE'`], default `'OFFAXIS'`

    interocular_distance
    :   Set the distance between the eyes - the stereo plane distance / 30 should be fine

        Type:
        :   float in [0, inf], default 0.065

    pivot
    :   Type:
        :   enum in [`'LEFT'`, `'RIGHT'`, `'CENTER'`], default `'LEFT'`

    pole_merge_angle_from
    :   Angle at which interocular distance starts to fade to 0

        Type:
        :   float in [0, 1.5708], default 1.0472

    pole_merge_angle_to
    :   Angle at which interocular distance is 0

        Type:
        :   float in [0, 1.5708], default 1.309

    use_pole_merge
    :   Fade interocular distance to 0 after the given cutoff angle

        Type:
        :   boolean, default False

    use_spherical_stereo
    :   Render every pixel rotating the camera around the middle of the interocular distance

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Set Grid Background Node in complete detail according to the official Blender documentation.

assistant: # Set Grid Background Node

[image reference removed]

The *Set Grid Background* node defines the background value for a voxel grid.
This value is used when sampling regions of the grid that do not contain any
explicitly stored voxels, such as inactive areas or tiles that have not been
initialized.

By default, empty voxels in a grid evaluate to zero or another implicit value.
This node allows customizing that behavior, which can be useful when
constructing grids procedurally or when combining multiple grids.
user: What is PointCaches(bpy_struct) and how is it used in Blender Python scripting?

assistant: # PointCaches(bpy_struct)

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

*class* bpy.types.PointCaches(*bpy_struct*)
:   Collection of point caches

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Due to limited resolution of images and computer screens, pixel filters are needed to avoid [Aliasing](../../../glossary/index.html#term-Aliasing).
This is achieved by slightly blurring the image to soften edges.

Type
:   Pixel Filtering algorithm to use.

    Box:
    :   No filter.

    Gaussian:
    :   Smooth filter.

    Blackman-Harris:
    :   Default filter with a better balance between smoothness and detail preservation.

Width
:   Lower values give more crisp renders, higher values are softer and reduce aliasing.
user: Give a detailed overview of Mist Pass: syntax, arguments, return values, common patterns.

assistant: Mist can greatly enhance the illusion of depth in your rendering. To create mist,
Blender generates a render layer with a depth map ranging between 0.0 and 1.0
that can be used in the Compositor to generate a mist effect.

Start
:   The distance from the camera at which the mist starts to fade in.

Depth
:   The distance from *Start* of the mist, that it fades in over.
    Objects further from the camera than *Start + Depth* are completely hidden by the mist.

Falloff
:   The curve function that controls the rate of change of the mist’s strength further and further into the distance.

    Quadratic:
    :   Uses the same calculation as light falloff (\(1\over{x^2}\)) and provides the smoothest
        transition from transparent (0.0) to opaque (1.0).

    Linear:
    :   Has a steeper start than quadratic (\(1\over{x}\)).

    Inverse Quadratic:
    :   Has the steepest start (\(1\over{\sqrt{x}}\)) and approaches 1.0 faster than the other two functions.

[image reference removed]

Mist example
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:25-Manual-World-Mist-Example1.blend)).
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

Thickness Modifier.

Uniform Thickness
:   When enabled, makes the thickness equal for the entire strokes.

    Thickness
    :   Absolute Thickness for the stroke points.

Thickness Factor
:   Value to add or subtract to the actual points thickness.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Give a detailed overview of A Bouncing Cube: syntax, arguments, return values, common patterns.

assistant: ### The Process

First, change your start and end frames to 1 and 150.

Then, add a plane, and scale it five times. Next, go to the physics tab, and add a collision.
The default settings are fine for this example.

Now add a cube, or use the default cube, then enter *Edit Mode* to subdivide it three times.
Add a Bevel Modifier to it to smoothen the edges and then to add a little more,
press `R` twice, and move your cursor a bit.

When finished, your scene should look like this:

[image reference removed]

The scene, ready for soft body physics.

Everything is ready to add the soft body physics.
Go to Properties ‣ Physics and choose *Soft Body*.
Uncheck the *Soft Body Goal*, and check *Soft Body Self Collision*.
Also, under *Soft Body Edges*, increase the Bending to 10.

Playing the animation will now give a slow animation of a bouncing cube.
To speed things up, we need to bake the soft body physics.

Under *Soft Body Cache* change the values of your start and end frames. In this case 1 and 150.
Now, to test if everything is working, you can take a cache step of 5 or 10,
but for the final animation it is better to reduce it to 1, to cache everything.

When finished, your physics panel should look like this:

[image reference removed]

The physics cache settings.

[image reference removed]

The physics edges and self collision settings.

You can now bake the simulation, give the cube materials and textures and render the animation.

### The Result

[The rendered bouncing cube](https://www.youtube.com/watch?v=3PzgB9jw9iA)
user: Describe Operators from the Blender manual or Python API, including usage steps and snippets.

assistant: Most hotkeys and buttons in Blender call an operator which is also exposed to Python via [`bpy.ops`](bpy.ops.html#module-bpy.ops "bpy.ops").

To see the Python equivalent hover your mouse over the button and see the tooltip,
e.g `Python: bpy.ops.render.render()`,
If there is no tooltip or the `Python:` line is missing then this button is not using an operator
and can’t be accessed from Python.

If you want to use this in a script you can press `Ctrl`-`C` while your mouse is over the button
to copy it to the clipboard.
You can also use button’s context menu and view the *Online Python Reference*, this mainly shows arguments and
their defaults, however, operators written in Python show their file and line number which may be useful if you
are interested to check on the source code.

### Info Editor

Blender records operators you run and displays them in the Info editor.
Select the Scripting workspace that comes default with Blender to see its output.
You can perform some actions and see them show up – delete a vertex for example.

Each entry can be selected, then copied `Ctrl`-`C`, usually to paste in the text editor or Python console.
user: Give a detailed overview of Known Limitations: syntax, arguments, return values, common patterns.

assistant: ### Non-Contiguous Normals

Abrupt normal changes will prevent portions of the mesh from producing a smooth subdivision.
Instead, these portions with non-contiguous normals will be subdivided using the “Simple” subdivision method.

|  |  |
| --- | --- |
| <../../../_images/modeling_modifiers_generate_subdivision-surface_normal-orientation-1.png>   Comparison of good normals and bad normals. | <../../../_images/modeling_modifiers_generate_subdivision-surface_normal-orientation-2.png>   Side view of image on the left. |

A quick way to fix this is to [Recalculate Normals](../../meshes/editing/mesh/normals.html).
If this does not work you may have to [manually flip the normals](../../meshes/editing/mesh/normals.html).
user: How do I use Mesh Structure in Blender? Include parameters, examples, warnings and best practices.

assistant: # Mesh Structure

With meshes, everything is built from three basic elements:
*vertices*, *edges* and *faces*.

[[image reference removed]](../../_images/modeling_meshes_structure_example.svg)

Example of mesh structure.
user: Provide the full official documentation entry for Boid Brain, preserving all code examples.

assistant: The Boid Brain panel controls how the boids particles will react with each other.
The boids’ behavior is controlled by a list of rules.
Only a certain amount of information in the list can be evaluated.
If the memory capacity is exceeded, the remaining rules are ignored.

The rules are by default parsed from top-list to bottom-list
(thus giving explicit priorities),
and the order can be modified using the little arrows buttons on the right side.

Rule Evaluation
:   There are three ways to control how rules are evaluated:

    Average
    :   All rules are averaged.

    Random
    :   A random rule is selected for each boid.

    Fuzzy
    :   Uses fuzzy logic to evaluate rules. Rules are gone through top to bottom.
        Only the first rule that affect above the *Rule Fuzziness* threshold is evaluated.
        The value should be considered how hard the boid will try to respect a given rule
        (a value of 1 means the Boid will always stick to it, a value of 0 means it will never).
        If the boid meets more than one conflicting condition at the same time,
        it will try to fulfill all the rules according to the respective weight of each.

In Air
:   The current rule affects boids while they are flying.

On Land
:   The current rule affects boids while they are not flying.

### Goal Rule

Seek goal.

Object
:   Specifies the goal object. If not specified, Boid force fields with negative Strength are used as goals.

Predict
:   Predict target’s movements.

### Avoid Rule

Avoid “predators”.

Object
:   Specifies the object to avoid.
    If not specified, Boid force fields with positive Strength are used as predators.

Predict
:   Predict target’s movements.

Fear Factor
:   Avoid object if danger from it is above this threshold.

### Avoid Collision Rule

Avoid objects with activated Deflection.

Boids
:   Avoid collision with other boids.

Deflectors
:   Avoid collision with deflector objects.

Look Ahead
:   Time to look ahead in seconds.

### Separate Rule

Boids move away from each other.

### Flock Rule

Copy movements of neighboring boids, but avoid each other.

### Follow Leader Rule

Follows a leader object instead of a boid.

Distance
:   Distance behind leader to follow.

Line
:   Follow the leader in a line.

    Queue Size
    :   How many boids that are allowed to follow in a line.

### Average Speed Rule

Maintain average velocity.

Speed
:   Percentage of maximum speed.

Wander
:   How fast velocity’s direction is randomized.

Level
:   How much velocity’s Z component is kept constant.

### Fight Rule

Move toward nearby boids.

Fight Distance
:   Attack boids at a maximum of this distance.

Flee Distance
:   Flee to this distance.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`Object.motion_path`](bpy.types.Object.html#bpy.types.Object.motion_path "bpy.types.Object.motion_path") | - [`PoseBone.motion_path`](bpy.types.PoseBone.html#bpy.types.PoseBone.motion_path "bpy.types.PoseBone.motion_path") |
user: Describe Track To Constraint from the Blender manual or Python API, including usage steps and snippets.

assistant: # Track To Constraint

The *Track To* constraint makes an object or bone point towards a certain target,
then roll to make a certain local axis point upwards.
It’s typically called “Look At” or “Aim” in other 3D software.

If the constraint owner is almost directly above the target, the roll around
the tracking axis will become unstable. For this scenario, it’s recommended to
use the [Damped Track Constraint](damped_track.xhtml) instead.
user: Show practical ways to work with Scale Radius in a Blender add-on or script – include code.

assistant: You can alter the radius that a bone has by selecting the head, body or tail of a bone,
and then press `Alt`-`S` and move the mouse left or right.
If the body is selected the mean radius will be scaled.
And as usual, with connected bones, you scale at the same time the radius
of the parent’s tip and of the children’s roots.

You can also alter the bone radius by selecting the tail or head of the bone you wish to alter,
then navigate to Properties ‣ Bone ‣ Deform ‣ Radius Section
and entering new values for the *Tail* and *Head* number fields.

Bone Scale and Scale Radius comparison.

|  |  |
| --- | --- |
| ../../../../_images/animation_armatures_bones_selecting_single-bone.png   A single selected bone in Octahedron visualization. | ../../../../_images/animation_armatures_bones_editing_transform_scaling-bone-radius-2.png   After normal scale. |
| ../../../../_images/animation_armatures_bones_editing_transform_scaling-bone-radius-3.png   A single selected bone in Envelope visualization. | ../../../../_images/animation_armatures_bones_editing_transform_scaling-bone-radius-4.png   After Scaled Radius. Its length remains the same, but its joints’ radius are bigger. |

Note that, when you resize a bone (either by directly scaling it, or by moving one of its joints),
Blender automatically adjusts the end-radii of its envelope proportionally to the size of the modification.
Therefore, it is advisable to place all the bones first, and only then edit their properties.
user: Describe Mask Display from the Blender manual or Python API, including usage steps and snippets.

assistant: # Mask Display

This popover controls how masks are displayed in Mask mode.

Spline
:   Toggles the display of the mask splines. Note that if they’re hidden,
    you won’t be able to edit them.

    Edge Display Type
    :   Line style of the splines.

Overlay
:   Visualizes masks by shading the whole clip.

    Overlay Mode
    :   Alpha Channel:
        :   Displays just the masks as a grayscale image. Excluded areas are black,
            while included areas are white.

        Combined:
        :   Displays the clip with excluded areas darkened.

Blending Factor
:   How much excluded areas are darkened when using the “Combined” *Overlay Mode*.
user: How do I use Alpha Over & Alpha Under Strips in Blender? Include parameters, examples, warnings and best practices.

assistant: # Alpha Over & Alpha Under Strips

Using the alpha (transparency channel),
this effect composites a result based on transparent areas of the dominant image.
If you use a Scene strip, the areas of the image where there is not anything solid are transparent;
they have an alpha value of 0. If you use a Movie strip, that movie has an alpha value of 1 (completely opaque).

So, you can use the *Alpha Over* / *Alpha Under* effect to composite the CGI Scene on top of your movie.
The result is your model doing whatever as if it was part of the movie.
The Adjust ‣ Compositing ‣ Opacity controls how much
the foreground is mixed over the background, fading in the foreground on top of the background.
The colors of transparent foreground image areas are ignored and do not change the color of the background.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Mode
:   Position:
    :   The handle inputs are the absolute positions of the handles in 3D space.

    Offset:
    :   The handle positions are relative to the control point on the curve.
        The handle inputs give the offset from the control points.
user: Explain General Information in complete detail according to the official Blender documentation.

assistant: Links that are useful while writing scripts:

- [Python.org](https://www.python.org/)
  – General information about Python.
- [Blender Python API](https://docs.blender.org/api/current/)
  – Official API documentation. Use this for referencing while writing scripts.
- [API Introduction](https://docs.blender.org/api/current/info_quickstart.html)
  – A short introduction to get you started with the API. Contains examples.

Links that deal with distributing your scripts:

- [Creating Add-ons](https://developer.blender.org/docs/handbook/addons/guidelines/)
  – Add-ons are used to encapsulate and distribute scripts.
- [Creating Extensions](../extensions/getting_started.xhtml#extensions-getting-started)
  – Share add-ons on the [Blender Extensions](https://extensions.blender.org/) platform.
user: How do I use Bend in Blender? Include parameters, examples, warnings and best practices.

assistant: # Bend

Bend Transform with Clamp on and off.

|  |  |  |
| --- | --- | --- |
| ../../../../../_images/modeling_meshes_editing_mesh_transform_bend_example-clamp-1.png   Before. | ../../../../../_images/modeling_meshes_editing_mesh_transform_bend_example-clamp-2.png   Clamp on. | ../../../../../_images/modeling_meshes_editing_mesh_transform_bend_example-clamp-3.png   Clamp off. |

This tool rotates a line of selected elements forming an arc between the mouse cursor and the 3D cursor.
user: What is CompositorNodeDespeckle(CompositorNode) and how is it used in Blender Python scripting?

assistant: # CompositorNodeDespeckle(CompositorNode)

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

*class* bpy.types.CompositorNodeDespeckle(*CompositorNode*)
:   Smooth areas of an image in which noise is noticeable, while leaving complex areas untouched

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Bpy.Types.Nodetreeinterfacesocketvectorpercentage4D and how is it used in Blender Python scripting?

assistant: 4D.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Explain Bundling Scripts in complete detail according to the official Blender documentation.

assistant: Besides extensions, it’s possible to bundle scripts for presets,
application templates, legacy add-ons, as well as scripts run on startup.

Script directories can be manually added in the File Paths preferences.
`$BLENDER_SYSTEM_SCRIPTS` can also be used to add script directories
without modifying the preferences.

Script directories are expected to contain specific subdirectories
like `presets`, `addons` and `startup` for different types of
scripts. See [Path Layout](blender_directory_layout.xhtml#blender-directory-path-layout) for a complete list.

### Startup Scripts

The Blender Python API can be used to customize Blender. This includes
changing preferences, changing the startup file and adding UI elements.

For example, a script can enable add-ons for every user.

```
$BLENDER_SYSTEM_SCRIPTS/startup/enable_addons.py
```

```
def register():
    import addon_utils
    addon_utils.enable("my-addon")

def unregister():
    pass

if __name__ == "__main__":
    register()
```

### Application Templates

[Application Templates](app_templates.xhtml#app-templates) can be used to set up Blender for particular
tasks or projects, separate from the default configuration. When
creating a new file the user can choose the template.

The files are expected to be placed in the system script directories like this:

```
$BLENDER_SYSTEM_SCRIPTS/startup/bl_app_templates_system/MyTemplate/__init__.py
$BLENDER_SYSTEM_SCRIPTS/startup/bl_app_templates_system/MyTemplate/startup.blend
```

### Legacy Add-ons

Add-ons that have not been converted to become an extension yet need
to be placed in the `addons` script directory.

For example, an add-on could be located at:

```
$BLENDER_SYSTEM_SCRIPTS/addons/simple_addon.py
$BLENDER_SYSTEM_SCRIPTS/addons/complex_addon/__init__.py
```
user: Provide the full official documentation entry for Drawing Plane, preserving all code examples.

assistant: # Drawing Plane

[image reference removed]

Drawing Planes pop-over.

The Drawing Planes selector helps to select the plane in which strokes are drawn.

To see which plane you are using when drawing strokes,
you can enable *Canvas* in [Viewport Overlays](../../../editors/3dview/display/overlays.xhtml#dview-overlay-grease-pencil).
See [Viewport Display](../../../interface/controls/templates/curve.xhtml) to know more about Canvas settings.

View:
:   Strokes are drawn with the current 3D Viewport orientation.

Front (X-Z):
:   Strokes are drawn on the plane determined by the XZ axes (front view).

Side (Y-Z):
:   Strokes are drawn on the plane determined by the YZ axes (side view).

Top (X-Y):
:   Strokes are drawn on the plane determined by the XY axes (top view).

Cursor:
:   Strokes are drawn with the current 3D cursor orientation.

Stroke using different Drawing Planes with Canvas overlay activated.

|  |  |  |  |  |
| --- | --- | --- | --- | --- |
| ../../../_images/grease-pencil_modes_draw_drawing-planes_front.png   Front. | ../../../_images/grease-pencil_modes_draw_drawing-planes_side.png   Side. | ../../../_images/grease-pencil_modes_draw_drawing-planes_top.png   Top. | ../../../_images/grease-pencil_modes_draw_drawing-planes_view.png   View. | ../../../_images/grease-pencil_modes_draw_drawing-planes_cursor.png   Cursor. |
user: Provide the full official documentation entry for Smooth Modifier, preserving all code examples.

assistant: # Smooth Modifier

The *Smooth* modifier smooths a mesh by flattening the angles between adjacent faces in it,
just like the [Smooth tool](../../meshes/editing/vertex/smooth_vertices.html#bpy-ops-mesh-vertices-smooth) in Edit Mode.
It smooths without subdividing the mesh, the number of vertices remains the same.

This modifier is not limited to smoothing, though.
Its control factor can be configured outside the (0.0 to 1.0) range
(including negative values), which can result in interesting deformations.
user: How do I use Culling in Blender? Include parameters, examples, warnings and best practices.

assistant: Camera Cull
:   Automatically culls objects based on the camera frustum defined by the *Margin*.

Distance Cull
:   Automatically culls objects based on their distance from the active camera.
    This is set via the *Distance* property.
user: How do I use Basic Menu Example in Blender? Include parameters, examples, warnings and best practices.

assistant: Here is an example of a simple menu. Menus differ from panels in that they must
reference from a header, panel or another menu.

Notice the ‘CATEGORY_MT_name’ in [`Menu.bl_idname`](#bpy.types.Menu.bl_idname "bpy.types.Menu.bl_idname"), this is a naming
convention for menus.

```
import bpy

class BasicMenu(bpy.types.Menu):
    bl_idname = "OBJECT_MT_select_test"
    bl_label = "Select"

    def draw(self, context):
        layout = self.layout

        layout.operator("object.select_all", text="Select/Deselect All").action = 'TOGGLE'
        layout.operator("object.select_all", text="Inverse").action = 'INVERT'
        layout.operator("object.select_random", text="Random")

bpy.utils.register_class(BasicMenu)

# Test call to display immediately.
bpy.ops.wm.call_menu(name="OBJECT_MT_select_test")
```
user: How do I use Outliner in Blender? Include parameters, examples, warnings and best practices.

assistant: You can easily inspect the contents of your file by using the *Outliner* editor,
which displays all of the data in your blend-file.

The *Outliner* allows you to do simple operations on objects,
such as selecting, renaming, deleting, linking and parenting.

[Read more about the Outliner](../editors/outliner/index.html).
user: How do I use Bpy.Types.Movieclip in Blender? Include parameters, examples, warnings and best practices.

assistant: ieClip.annotation MovieClip.colorspace_settings MovieClip.display_aspect MovieClip.filepath MovieClip.fps MovieClip.frame_duration MovieClip.frame_offset MovieClip.frame_start MovieClip.proxy MovieClip.size MovieClip.source MovieClip.tracking MovieClip.use_proxy MovieClip.use_proxy_custom_directory MovieClip.metadata() MovieClip.bl_rna_get_subclass() MovieClip.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References