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

assistant: # GeometryNodeImageInfo(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.GeometryNodeImageInfo(*GeometryNode*)
:   Retrieve information about an image

    *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 Options, preserving all code examples.

assistant: # Options

Display
:   Fast Navigate
    :   For multiresolution models, shows low resolution while navigating in the viewport.

    Delay Viewport Updated
    :   Update the geometry when it enters view. This provides for faster navigation.

    Use Deform Only
    :   Limits the activated modifiers on the active object to Deform Modifiers, and Multiresolution.
        Constructive modifiers (like Subdivision Surface, Mirror and other) get deactivated,
        because they could give inaccurate results.
user: Give a detailed overview of SEQUENCER_FH_movie_strip(FileHandler): syntax, arguments, return values, common patterns.

assistant: # SEQUENCER_FH_movie_strip(FileHandler)

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

*class* bpy.types.SEQUENCER_FH_movie_strip(*FileHandler*)
:   *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 Fly/Walk Navigation from the Blender manual or Python API, including usage steps and snippets.

assistant: # Fly/Walk Navigation

The standard navigation controls are sometimes limiting,
especially for large environments such as architectural models.
In these cases, it may be preferable to use first person controls instead,
where you can look around while “standing” in one place
rather than orbiting around a central viewpoint.

Blender offers two such alternative navigation methods: Flying and Walking.
You can initiate either method from the View ‣ Navigation
menu. You can also initiate your preferred one (configured
in the [Preferences](../../preferences/navigation.xhtml))
by pressing `Shift`-`AccentGrave`.

[image reference removed]

View Navigation.

Common use cases for Fly/Walk include:

Navigating
:   This can be a quick way to navigate a large scene.

Positioning a camera
:   When activated from a camera view `Numpad0`,
    the camera will move along with you.

Recording camera movement
:   You can record the path you take by entering a camera view, enabling
    [Auto Keying](../../../animation/animation_editors.xhtml#bpy-types-toolsettings-use-keyframe-insert-auto),
    starting animation playback, and finally activating Fly/Walk navigation.
    The path will be recorded as camera keyframes which can then be
    used for rendering.

    Animation playback can’t be controlled while Fly/Walk navigation is active,
    so when you’re done recording, you first need to exit the navigation
    with `LMB` before you can stop playback.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Data Type
:   The data type that is used for mixing.
    The node supports float, vector, color, and rotation data types.

Factor Mode (Vector only)
:   The factor mode can be set to *Uniform* and *Non-Uniform*.
    In uniform mode, a single float controls the factor.
    In non-uniform mode, a vector controls the factor for
    each XYZ channel separately.

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

    Add, Subtract, Multiply, Screen, Divide, Difference,
    Darken, Lighten, Overlay, Color Dodge, Color Burn,
    Hue, Saturation, Value, Color, Soft Light, Linear Light

Clamp Factor
:   Limit the factor value between 0.0 and 1.0. If this option is
    unchecked then the node operates using *Extrapolation*.

Clamp Result (Color only)
:   Limit the Result to the range between 0.0 and 1.0.
user: Give a detailed overview of Rendering Animations: syntax, arguments, return values, common patterns.

assistant: # Rendering Animations

While rendering stills will allow you to view and save the image from the render buffer when
it is complete, animations are a series of images, or frames,
and are automatically saved directly out to a drive after being rendered.

After rendering the frames, you may need to edit the clips,
or first use the Compositor to do green-screen masking, matting, color correction, DOF,
and so on to the images. That result is then fed to the Sequencer where the strips are cut and
mixed and a final overlay is done.

Finally you can render out from the Sequencer and compress the frames into a playable movie clip.
user: Describe Viewpoint from the Blender manual or Python API, including usage steps and snippets.

assistant: # Viewpoint

The menu View ‣ Viewpoint lets you align the viewing direction to
a specific axis. This can also be done using the [Navigation Gizmo](introduction.html#navigation-gizmo)
or the following hotkeys:

Top:
:   `Numpad7`

Front:
:   `Numpad1`

Right:
:   `Numpad3`

Bottom:
:   `Ctrl`-`Numpad7`

Back:
:   `Ctrl`-`Numpad1`

Left:
:   `Ctrl`-`Numpad3`

The above hotkeys align the view to a global (world) axis. You can also align to a local axis
of the selected item by additionally holding `Shift`. This way, you can for example
view any mesh face head-on, no matter how it’s oriented.
(To get out of this local viewpoint, simply align to a global axis again.)

The view can also be aligned by holding `Alt`-`MMB` and dragging the mouse in a certain direction.
user: Explain Usage in complete detail according to the official Blender documentation.

assistant: The tool is interactive and has two steps:

1. Pre-Visualizing the Cut

   After the tool is activated, move the cursor over a desired edge.
   The cut to be made is marked with a magenta colored line as you move the mouse over the various edges.
   The to be created edge loop stops at the poles (triangles and n-gons) where the existing face loop terminates.
2. Perform the Cut

   Once the desired location of the new edge loop is found, the edge loop can be created via `LMB`.

|  |  |  |
| --- | --- | --- |
| ../../../_images/modeling_meshes_tools_loop_before.png   Mesh before inserting edge loop. | ../../../_images/modeling_meshes_tools_loop_preview.png   Preview of edge loop location. | ../../../_images/modeling_meshes_tools_loop_placement.png   Interactive placement of edge loop between adjacent loops. |
user: What is LatticePoint(bpy_struct) and how is it used in Blender Python scripting?

assistant: # LatticePoint(bpy_struct)

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

*class* bpy.types.LatticePoint(*bpy_struct*)
:   Point in the lattice grid

    co
    :   Original undeformed location used to calculate the strength of the deform effect (edit/animate the Deformed Location instead)

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

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

    groups
    :   Weights for the vertex groups this point is member of

        Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`VertexGroupElement`](bpy.types.VertexGroupElement.html#bpy.types.VertexGroupElement "bpy.types.VertexGroupElement"), (readonly)

    select
    :   Selection status

        Type:
        :   boolean, default False

    weight_softbody
    :   Softbody goal weight

        Type:
        :   float in [0.01, 100], default 0.0

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of GeometryNodeInputShadeSmooth(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeInputShadeSmooth(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.GeometryNodeInputShadeSmooth(*GeometryNode*)
:   Retrieve whether each face is marked for smooth or sharp normals

    *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 References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`PathCompareCollection.new`](bpy.types.PathCompareCollection.html#bpy.types.PathCompareCollection.new "bpy.types.PathCompareCollection.new") - [`PathCompareCollection.remove`](bpy.types.PathCompareCollection.html#bpy.types.PathCompareCollection.remove "bpy.types.PathCompareCollection.remove") | - [`Preferences.autoexec_paths`](bpy.types.Preferences.html#bpy.types.Preferences.autoexec_paths "bpy.types.Preferences.autoexec_paths") |
user: Show practical ways to work with Drivers Editor in a Blender add-on or script – include code.

assistant: # Drivers Editor

This editor lets you set up [Drivers](../animation/drivers/index.html), which calculate the value for a property
based on other properties. In other words, they make a set of source properties “drive” the target property,
and can thus serve as an alternative to animating the property by hand.

[image reference removed]

The Drivers Editor, showing how you might drive a cube’s rotation based on its position.

The user interface is largely the same as that of the [Graph Editor](graph_editor/introduction.html),
with two important differences:

- The Sidebar has an additional [Drivers tab](../animation/drivers/drivers_panel.html). This is where
  the source properties are brought together to calculate an intermediate value for the target property.
- The curve doesn’t represent the property’s value over time, but a mapping from the above intermediate
  value (X axis) to the final value (Y axis).
user: How do I use With Empty Groups in Blender? Include parameters, examples, warnings and best practices.

assistant: When parenting it will create empty [vertex groups](../../../modeling/meshes/properties/vertex_groups/index.html)
on the child objects (if they do not already exist) for and named after each deforming bone in the armature.
The newly created vertex groups will be empty. This means they will not have any weights assigned.
Vertex groups will only be created for bones which are setup as deforming
(Properties ‣ Bone ‣ Deform Panel).

You can then manually select the vertices and assign them to a particular vertex group of your
choosing to have bones in the armature influence them.

Choose this option if you have already created (and weighted) all the vertex groups the mesh requires.

### Example

For example, if you have an armature which consists of three bones named “BoneA”,
“BoneB” and “BoneC” and cube mesh called “Cube”. If you parent the cube to
the armature, the cube will get three new vertex groups created on it called “BoneA”,
“BoneB” and “BoneC”. Notice that each vertex group is empty.

[image reference removed]

Cube in Edit Mode using Armature Deform with empty groups.
user: Show practical ways to work with FModifierCycles(FModifier) in a Blender add-on or script – include code.

assistant: # FModifierCycles(FModifier)

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

*class* bpy.types.FModifierCycles(*FModifier*)
:   Repeat the values of the modified F-Curve

    cycles_after
    :   Maximum number of cycles to allow after last keyframe (0 = infinite)

        Type:
        :   int in [-32768, 32767], default 0

    cycles_before
    :   Maximum number of cycles to allow before first keyframe (0 = infinite)

        Type:
        :   int in [-32768, 32767], default 0

    mode_after
    :   Cycling mode to use after last keyframe

        - `NONE`
          No Cycles – Don’t do anything.
        - `REPEAT`
          Repeat Motion – Repeat keyframe range as-is.
        - `REPEAT_OFFSET`
          Repeat with Offset – Repeat keyframe range, but with offset based on gradient between start and end values.
        - `MIRROR`
          Repeat Mirrored – Alternate between forward and reverse playback of keyframe range.

        Type:
        :   enum in [`'NONE'`, `'REPEAT'`, `'REPEAT_OFFSET'`, `'MIRROR'`], default `'NONE'`

    mode_before
    :   Cycling mode to use before first keyframe

        - `NONE`
          No Cycles – Don’t do anything.
        - `REPEAT`
          Repeat Motion – Repeat keyframe range as-is.
        - `REPEAT_OFFSET`
          Repeat with Offset – Repeat keyframe range, but with offset based on gradient between start and end values.
        - `MIRROR`
          Repeat Mirrored – Alternate between forward and reverse playback of keyframe range.

        Type:
        :   enum in [`'NONE'`, `'REPEAT'`, `'REPEAT_OFFSET'`, `'MIRROR'`], default `'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: What is Brush Settings and how is it used in Blender Python scripting?

assistant: # Brush Settings

[image reference removed]

Brush settings panel.

Information on brush settings for every mode can be found in these pages:

[Brush](../../brush/brush_settings.xhtml)
:   General and advanced settings.

[Texture](../../brush/texture.xhtml)
:   Color and mask texture settings.

[Stroke](../../brush/stroke.xhtml)
:   Stroke methods and settings.

[Falloff](../../brush/falloff.xhtml)
:   Falloff curves and settings.

[Cursor](../../brush/cursor.xhtml)
:   Cursor and appearance settings.
user: How do I use Writing Configurations for Blender in Blender? Include parameters, examples, warnings and best practices.

assistant: OpenColorIO configurations do not strictly specify all information needed for Blender to work optimally.
These guidelines help ensure a configuration works well:

- Use OpenColorIO v2 `display_colorspaces` and `view_transforms` with `cie_xyz_d65_interchange`
  intermediate display linear space. This is used to emulate the chosen display on the actual display.
  In older configs without this, display emulation will be disabled and wide gamut and HDR display will
  not work well. Saving colorspace metadata for images and video also depends on this.
- For every display, include a view transform without tone mapping. Blender will look for a view
  transform named `Standard` or `Un-tone-mapped` or the config wide `default_view_transform`.
  If not found, the first view transform of the display will be used. This is more important
  for OpenColorIO v1 configs without `display_colorspaces`, to determine the color space of an image
  after applying a view transform.
- Include the interop ID from the [Color Interop Forum](https://github.com/AcademySoftwareFoundation/ColorInterop)
  for every color space and display color space that you can. This helps save image and video
  with correct colorspace information. Add the interop ID as an alias of the colorspace. For
  OpenColor 2.5 configs, additionally set the native `interop_id` attribute but keep the alias
  for compatibility with older software.
- Mark HDR displays by setting `encoding: hdr-video` on the corresponding colorspace.
- For HDR view transforms, use `HDR 500 nits`, `HDR 1000 nits`, `HDR 2000 nits` or `HDR 4000 nits`
  as part of the name to automatically determine maximum luminance for mastering display metadata.
user: How do I use Align to Transform Orientation in Blender? Include parameters, examples, warnings and best practices.

assistant: # Align to Transform Orientation

Aligns (rotates) the selected objects so that their local orientation matches the active transform orientation
in the Transform orientation panel or the *Orientation* selection
in the Transform [Adjust Last Operation](../../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panels.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Geometry
:   Standard Geometry input.

Selection
:   Boolean field used to calculate which output each part of the geometry will go to.
    Parts in the selection will move to the *Selection* output.
    Parts not in the selection will move to the *Inverted* output.
user: How do I use NodeGeometrySimulationOutputItems(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeGeometrySimulationOutputItems(bpy_struct)

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

*class* bpy.types.NodeGeometrySimulationOutputItems(*bpy_struct*)
:   Collection of simulation items

    new(*socket_type*, *name*)
    :   Add an item at the end

        Parameters:
        :   - **socket_type** (enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items)) – Socket Type, Socket type of the item
            - **name** (*string**,* *(**never None**)*) – Name

        Returns:
        :   Item, New item

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

    remove(*item*)
    :   Remove an item

        Parameters:
        :   **item** ([`SimulationStateItem`](bpy.types.SimulationStateItem.html#bpy.types.SimulationStateItem "bpy.types.SimulationStateItem"), (never None)) – Item, The item to remove

    clear()
    :   Remove all items

    move(*from_index*, *to_index*)
    :   Move an item to another position

        Parameters:
        :   - **from_index** (*int in* *[**0**,* *inf**]*) – From Index, Index of the item to move
            - **to_index** (*int in* *[**0**,* *inf**]*) – To Index, Target index for the item

    *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 Vignette Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Vignette Node

[image reference removed]

The *Vignette* node darkens or fades out the edges of an image to draw attention toward the center.
This effect is often used for artistic or cinematic purposes to create focus, mood, or a sense of depth.
user: Give a detailed overview of Using Gizmos: syntax, arguments, return values, common patterns.

assistant: Node inputs that can be controlled with a gizmo have an additional icon.
The gizmos of that node are shown if it is selected.
Clicking on the icon pins the gizmo, so that it is shown even if the node is not selected.
Modifying the gizmo in the 3D viewport, modifies the value in the socket.

[image reference removed]

Example of a node group that has gizmos.

Gizmos are often automatically propagated when an input socket with a gizmo is linked.
The gizmo then controls the value that it is propagated to, instead of the input of the node group directly.
Not all nodes support propagating gizmos, but many math operations do.
A double link indicates that the propagation was successful.

[image reference removed]

The gizmo is propagated from the Size X input socket to the Value node.

Gizmos can also be propagated to Group Inputs, in which case they are also available on the parent group node.
If the current group is used by a modifier directly, the gizmo will also be available on the modifier.
Gizmos that are propagated to the modifier always show when the modifier is active, independent of whether any node
is visible or selected.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Glow Visual Effect.

Mode
:   Determines the mode for the glow effect.

    Luminance:
    :   The glow light illuminates the entire object.

    Color:
    :   The glow light only affect a single color.

        Select Color
        :   Allows to select a single color to apply the glow light.

Threshold
:   Limits the colors affected by the glow light. (A value of 1 means no colors affected.)

Glow Color
:   Defines the glow color.

Blend Mode
:   The mask blending operation to perform. See [Color Blend Modes](../../glossary/index.xhtml#term-Color-Blend-Modes).

Opacity
:   Control the Opacity of the glow over the object.

Size X, Y
:   Control the glow scale in pixels on the X and Y axis.

Rotation
:   Control the Rotation of the glow.

Samples
:   Number of Blur samples (0 disabled the blur effect).

Glow Under
:   When enabled, glow only affects alpha areas.
user: Give a detailed overview of Self-Collisions: syntax, arguments, return values, common patterns.

assistant: Real cloth cannot penetrate itself, so you normally want the cloth to self-collide.
Enable this to tell the cloth object that it should not penetrate itself.
This adds to the simulation’s compute time, but provides more realistic results.

Friction
:   A coefficient for how slippery the cloth is when it collides with itself.
    For example, silk has a lower coefficient of friction than cotton.

Distance
:   As cloth at this distance begins to repel away from itself.
    Smaller values might give errors but gives some speed-up while
    larger will give unrealistic results if too large and can be slow.
    It is best to find a good in between value.

Impulse Clamping
:   Prevents explosions in tight and complicated collision situations
    by restricting the amount of movement after a collision.

Vertex Group
:   Faces that have all vertices assigned to this
    [Vertex Group](../../../modeling/meshes/properties/vertex_groups/index.html) are excluded from self-collision.

### Troubleshooting

If you encounter some problems with collision detection, there are a few ways to fix them:

- The fastest solution is to increase the *Distance* for Object/Self Collisions.
  This will be the fastest way to fix the clipping; however, it will be less accurate and will not look as good.
  Using this method tends to make it look like the cloth is resting on air, and gives it a very rounded look.
- A second method is to increase the *Quality* (in the *Cloth* panel).
  This results in smaller steps for the simulator and
  therefore to a higher probability that fast-moving collisions get caught.
  You can also increase the Collisions *Quality* to perform more iterations to get collisions solved.
- If none of the methods help, you can easily edit the cached/baked result in *Edit Mode* afterwards.
- If the Cloth is torn by the deforming mesh; increase the stiffness settings.
user: Give a detailed overview of Naming: syntax, arguments, return values, common patterns.

assistant: # Naming

You can rename your bones, either using the *Name* field in the *Bones Properties*.
It is also possible to rename by double-clicking bones in the Outliner.

Blender also provides you some tools that take advantage of bones named in a left/right
symmetry fashion, and others that automatically name the bones of an armature.
user: Explain Ray Types in complete detail according to the official Blender documentation.

assistant: Ray types can be divided into four categories:

1. Camera: the ray comes straight from the camera.
2. Reflection: the ray is generated by a reflection off a surface.
3. Transmission: the ray is generated by a transmission through a surface.
4. Shadow: the ray is used for (transparent) shadows.

Reflection and transmission rays can further have these properties:

- Diffuse: the ray is generated by a diffuse reflection or transmission (translucency).
- Glossy: the ray is generated by a glossy specular reflection or transmission.
- Singular: the ray is generated by a perfectly sharp reflection or transmission.

The Light Path node can be used to find out the type of ray the shading is being computed for.

[image reference removed]
user: How do I use GPENCIL_UL_matslots(UIList) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GPENCIL_UL_matslots(UIList)

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

*class* bpy.types.GPENCIL_UL_matslots(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *icon*, *_active_data*, *_active_propname*, *_index*)

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

assistant: # LayerCollection(bpy_struct)

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

*class* bpy.types.LayerCollection(*bpy_struct*)
:   Layer collection

    children
    :   Layer collection children

        Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`LayerCollection`](#bpy.types.LayerCollection "bpy.types.LayerCollection"), (readonly)

    collection
    :   Collection this layer collection is wrapping

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

    exclude
    :   Exclude from view layer

        Type:
        :   boolean, default False

    hide_viewport
    :   Temporarily hide in viewport

        Type:
        :   boolean, default False

    holdout
    :   Mask out objects in collection from view layer

        Type:
        :   boolean, default False

    indirect_only
    :   Objects in collection only contribute indirectly (through shadows and reflections) in the view layer

        Type:
        :   boolean, default False

    is_visible
    :   Whether this collection is visible for the view layer, take into account the collection parent

        Type:
        :   boolean, default False, (readonly)

    name
    :   Name of this layer collection (same as its collection one)

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

    visible_get()
    :   Whether this collection is visible, take into account the collection parent and the viewport

        Return type:
        :   boolean

    has_objects()
    :   Return type:
        :   boolean

    has_selected_objects(*view_layer*)
    :   Parameters:
        :   **view_layer** ([`ViewLayer`](bpy.types.ViewLayer.html#bpy.types.ViewLayer "bpy.types.ViewLayer")) – View layer the layer collection belongs to

        Return type:
        :   boolean

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Meta Strips, preserving all code examples.

assistant: # Meta Strips

A Meta Strip is a strip which contain multiple strips treated as if it was one strip.
It allows you to reduce the vertical space used in the Sequencer.
You can edit it the same way as any other strips.

It is organization tool. For example, if you are using a lot of strips with
complicated arrangement, you can group them together using Meta strips.

Make Meta Strip `Ctrl`-`G`
:   To create a Meta strip, select all the strips you want to group, and `Ctrl`-`G` to group them.
    The Meta strips will span from the beginning of the first strip to the end of the last one,
    and condenses all channels into a single strip.

UnMeta Strip `Ctrl`-`Alt`-`G`
:   Separating (ungrouping) the Meta strip restores the strips to their relative positions and channels.
    This can be used if you choose to delete a Meta strip and want to keep the strips inside.

[image reference removed]

Example of Meta strips.

You can edit the content inside a Meta strip by pressing `Tab`.
It will expand the strip to the whole view and hide any other strips.
To exit the Meta strip press `Tab` again.
Meta strips can also be nested, which make editing them a little confusing.
To exit out one level of Meta Strip make sure you do not have a Meta strips selected when you press `Tab`.

One convenient use for Meta strips is when you want to apply the same effect to multiple strips.
For example: if you have a video that was recorded in different files and want to add an effect strip.
It is much more convenient to apply a single set of effects
to one Meta strip than applying it to each individual strip.
user: Give a detailed overview of NodeSocketVectorFactor(NodeSocketStandard): syntax, arguments, return values, common patterns.

assistant: # NodeSocketVectorFactor(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVectorFactor(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

    links
    :   List of node links from or to this socket.

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Set Selection Node

[image reference removed]

The *Set Selection* node controls which geometry is [selected](../../../../interface/selecting.xhtml).

The input node for this data is the [Selection Node](../read/selection.xhtml).
user: What is BlendImportContextLibraries(bpy_struct) and how is it used in Blender Python scripting?

assistant: # BlendImportContextLibraries(bpy_struct)

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

*class* bpy.types.BlendImportContextLibraries(*bpy_struct*)
:   Collection of source libraries, i.e. blendfile paths

    *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 Transfer Mesh Data Layout: syntax, arguments, return values, common patterns.

assistant: # Transfer Mesh Data Layout

Transfers layout of data layer(s) from active to selected meshes.

Data Type
:   Which data to transfer.

    [image reference removed]

    Data types.

Exact Match
:   Also Delete some data layers from destination if necessary, so that it matches the source exactly.

Source Layers Selection
:   Which layers to transfer, in case of multi-layer types.

    Active Layer
    :   Only transfer the active data layer.

    All Layers
    :   Transfer all data layers.

Destination Layers Matching
:   How to match source and destination layers.

    By Name
    :   Match target data layers to affect by name.

    By Order
    :   Match target data layers to affect by order (indices).
user: Describe Toolbar from the Blender manual or Python API, including usage steps and snippets.

assistant: # Toolbar

The following tools are available in Edit Mode:

[Select](../../../interface/selecting.xhtml)
:   Select control points.

Cursor
:   Change the location of the [3D Cursor](../../../editors/3dview/3d_cursor.xhtml).

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

    [Scale Cage](../../../scene_layout/object/tools/scale_cage.xhtml)
    :   Editable bounding box for scaling control points.

Transform
:   Combined tool for translating, rotating, and scaling.

[Annotate](../../../interface/annotate_tool.xhtml)
:   Draw free-hand annotations.

[Measure](../../../editors/3dview/toolbar/measure.xhtml)
:   Measure distances in the scene.

[Shear](../../meshes/editing/mesh/transform/shear.xhtml)
:   Shear control points along a certain axis.
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.xhtml) 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: Provide the full official documentation entry for Bpy.Types.Idoverridelibrary, preserving all code examples.

assistant: deLibrary.resync() IDOverrideLibrary.bl_rna_get_subclass() IDOverrideLibrary.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Describe Workspace Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: Pin Scene
:   When enabled, the current workspace will remember the currently selected scene.
    Then, whenever you activate the workspace, it’ll automatically switch back to that scene.

Mode
:   Switch to this [Mode](../../editors/3dview/modes.xhtml) when activating the workspace.

Sequencer Scene
:   The scene containing the edit that is used by the video sequence editor.
    See [Sequencer Scene](../../video_editing/sequencer_scene.xhtml).

Sync Scene Time
:   Sync the active scene and time based on the current [scene strip](../../video_editing/edit/montage/strips/scene.xhtml#bpy-types-scenestrip) in the video sequence editor.
    See [Sequencer Scene](../../video_editing/sequencer_scene.xhtml).

Filter Add-ons
:   Determines which [add-ons](../../addons/index.xhtml) are enabled in the active workspace.
    When unchecked, the global add-ons will be used.
    When checked, you can enable individual add-ons in the list below.
user: What is Levels Node and how is it used in Blender Python scripting?

assistant: # Levels Node

[image reference removed]

The Levels Node read the input color channels and outputs analytical values.
The output is one-dimensional meaning the visualization will be a uniform gray color.
user: Show practical ways to work with Tool Settings in a Blender add-on or script – include code.

assistant: Depth
:   The initial depth (from the screen into the scene) used when placing the object.

    Surface:
    :   Start placing on the surface under the mouse cursor.
        If there is no surface, this does the same as *Cursor Plane*.

    Cursor Plane:
    :   Start placing on a plane that goes through the [3D Cursor](../3d_cursor.xhtml)
        and is aligned according to the *Orientation* and *Plane Axis*.

    Cursor View:
    :   Start placing on a plane that goes through the 3D Cursor and is aligned to the view.

Orientation
:   The new object’s orientation – a set of three axes, out of which *Plane Axis* chooses one.

    Surface:
    :   The object uses the normal orientation of the surface under the mouse cursor.
        If there is no surface, this does the same as *Default*.

    Default:
    :   The object uses the default [Transform Orientation](../controls/orientation.xhtml).

Snap To
:   The target to use while [Snapping](../controls/snapping.xhtml).

    Geometry:
    :   Snap to all types of geometry (vertices, edges, and faces).

    Default:
    :   Snap to the target defined in the global snapping options.

Plane Axis
:   Which of the three *Orientation* axes (X, Y or Z) is “up” for the object.
    The object’s base will be perpendicular to this axis.

Auto Axis
:   Rather than using the *Orientation* axis indicated by *Plane Axis*,
    use the one that’s closest to the viewport’s viewing direction
    (when not hovering over a surface).

Base

Origin
:   How the base is defined.

    Edge:
    :   The base is defined from one corner to the opposing corner.

    Center:
    :   The base is defined from the centerpoint to a corner.

Aspect
:   Whether the base has a free or fixed aspect ratio.

    Free:
    :   The width and depth of the base can be chosen independently.

    Fixed:
    :   The width and depth of the base are forced to be equal.

Height

Origin
:   How the height is defined.

    Edge:
    :   The base becomes the bottom, after which you define the top.

    Center:
    :   The base becomes the center, after which you define the top.

Aspect
:   Whether the side of the bounding box has a free or fixed aspect ratio.

    Free:
    :   The height can be chosen independently of the base.

    Fixed:
    :   The height is forced to be equal to the largest side of the base.

Subdivisions
:   Influences how many vertices are used to define the sphere.
    At level 1 the icosphere is an icosahedron, a solid with 20 equilateral triangular faces.
    Each increase in the number of subdivisions splits each triangular face into four.
user: What is Reducing Noise and how is it used in Blender Python scripting?

assistant: # Reducing Noise

When performing a final render, it is important to reduce noise as much as possible.
Here we will discuss a number of tricks that, while breaking the laws of physics,
are particularly important when rendering animations within a reasonable time.
Click to enlarge the example images to see the noise differences well.
user: How do I use MovieTrackingObjectPlaneTracks(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # MovieTrackingObjectPlaneTracks(bpy_struct)

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

*class* bpy.types.MovieTrackingObjectPlaneTracks(*bpy_struct*)
:   Collection of tracking plane tracks

    active
    :   Active track in this tracking data object

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

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

assistant: With *Alpha Under*, this is the contrary:
The first strip selected is the foreground, and the second one, the background.
Moreover, the *Opacity* controls the transparency of the *background*, i.e. an *Opacity* of 0.0;
will only show the foreground (the background is completely transparent),
and an *Opacity* of 1.0 will give the same results as with *Alpha Over*.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.lattice`](bpy.context.html#bpy.context.lattice "bpy.context.lattice") - [`BlendData.lattices`](bpy.types.BlendData.html#bpy.types.BlendData.lattices "bpy.types.BlendData.lattices") - [`BlendDataLattices.new`](bpy.types.BlendDataLattices.html#bpy.types.BlendDataLattices.new "bpy.types.BlendDataLattices.new") | - [`BlendDataLattices.remove`](bpy.types.BlendDataLattices.html#bpy.types.BlendDataLattices.remove "bpy.types.BlendDataLattices.remove") - [`Lattice.unit_test_compare`](#bpy.types.Lattice.unit_test_compare "bpy.types.Lattice.unit_test_compare") |
user: How do I use Preview in Blender? Include parameters, examples, warnings and best practices.

assistant: To view your changes, build the manual [as instructed](build.html).
Keep in mind that you can also build only the chapter you just edited to view it quickly.
Open the generated `.html` files inside the `build/html` folder using your web browser,
or refresh the page if you have it open already.