PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain Compositing in complete detail according to the official Blender documentation.

assistant: Blend
:   The method for blending the current strip with strips in lower channels.
    See [Blend Modes](../../../../glossary/index.xhtml#term-Blend-Modes) for more information.

Opacity
:   The opacity ([alpha](../../../../glossary/index.xhtml#term-Alpha-Channel)) of the strip.

    When this property is animated, the opacity is drawn as an overlay on the strip.
    The overlay will look like a dark section that follows the animation curve.
    This can be hidden by disabling the [F-Curves](../display.xhtml#bpy-types-sequencertimelineoverlay-show-fcurves).
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: The lattice should be scaled and moved to fit around your object in Object Mode.
Any scaling applied to the object in Edit Mode will result in the object deforming.
This includes applying its scale with `Ctrl`-`A` as this will achieve the same result as
scaling the lattice in Edit Mode, and therefore the object.

[image reference removed]

Lattice around the cube object in Object Mode.
user: Describe BoidRuleAverageSpeed(BoidRule) from the Blender manual or Python API, including usage steps and snippets.

assistant: # BoidRuleAverageSpeed(BoidRule)

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

*class* bpy.types.BoidRuleAverageSpeed(*BoidRule*)
:   level
    :   How much velocity’s z-component is kept constant

        Type:
        :   float in [0, 1], default 0.0

    speed
    :   Percentage of maximum speed

        Type:
        :   float in [0, 1], default 0.0

    wander
    :   How fast velocity’s direction is randomized

        Type:
        :   float in [0, 1], 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 Burn into Image: syntax, arguments, return values, common patterns.

assistant: Add metadata as text to the render.

Font Size
:   Set the size of the text.

Text Color
:   Set the color and alpha of the stamp text.

Background
:   Set the color and alpha of the color behind the text.

Include Labels
:   Displays the labels before the metadata text. For example,
    “Camera” in front of the camera name, etc.
user: Show practical ways to work with Triangulate Modifier in a Blender add-on or script – include code.

assistant: # Triangulate Modifier

The *Triangulate* modifier converts all faces in a mesh (quads and n-gons) to triangular faces.
It fulfills the exact same function as the [Triangulate](../../meshes/editing/face/triangulate_faces.xhtml#bpy-ops-mesh-quads-convert-to-tris) tool in Edit Mode.

|  |  |
| --- | --- |
| ../../../_images/modeling_modifiers_generate_triangulate_before.png   Mesh before Triangulate modifier. | ../../../_images/modeling_modifiers_generate_triangulate_after.png   Mesh after Triangulate modifier. |
user: Explain GeometryNodeSeparateGeometry(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeSeparateGeometry(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.GeometryNodeSeparateGeometry(*GeometryNode*)
:   Split a geometry into two geometry outputs based on a selection

    domain
    :   Which domain to separate on

        Type:
        :   enum in [Attribute Domain Without Corner Items](bpy_types_enum_items/attribute_domain_without_corner_items.html#rna-enum-attribute-domain-without-corner-items), default `'POINT'`

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

assistant: Uniform
:   Normalized coordinates centered at zero, scaled based on the image’s largest dimension.
    This is useful for procedural effects that need aspect-ratio-independent coordinates,
    similar to *Object* coordinates in shader nodes.

Normalized
:   Normalized coordinates ranging from 0 to 1 across the image dimensions,
    with half-pixel offsets to align with pixel centers.

Pixel
:   Pixel-space coordinates representing the center position of each pixel.
    These are integer-based coordinates with a half-pixel offset applied.
user: Describe MovieTrackingMarker(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # MovieTrackingMarker(bpy_struct)

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

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

    co
    :   Marker position at frame in normalized coordinates

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

    frame
    :   Frame number marker is keyframed on

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

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

        Type:
        :   boolean, default True

    mute
    :   Is marker muted for current frame

        Type:
        :   boolean, default False

    pattern_bound_box
    :   Pattern area bounding box in normalized coordinates

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

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Bone Collections can be shown & hidden via the list in the Armature properties,
as well as via the list in the Bone properties. Bone visibility is determined by
the visibility of its collections, its own ‘solo’ and ‘hidden’ properties:

- If the bone itself is marked as ‘hidden’, it is invisible regardless of the
  bone collections.
- If a parent collection is hidden, child collections will also be hidden; same is true for soloed collections.
- A bone is visible when it is contained in any visible collection.
- If a collection is soloed, it will be visible regardless of the collection’s ‘hidden’ property.
- A bone that is not assigned to any bone collection is visible; otherwise it
  would be impossible to select it & assign it to a collection.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Time Offset Modifier.

Mode
:   Regular:
    :   Offsets keyframes in the default animation playback direction (playhead moving from left to right).

    Reverse:
    :   Offsets keyframes in reversed animation playback direction (playhead moving from right to left).

    Fixed Frame:
    :   The Frame parameter determines which frame is displayed. This value needs to be animated in order to
        have the displayed frame change during playback.

        Frame
        :   The number of the frame to display.

    Ping Pong:
    :   Loop back and forth animation.

    Chain:
    :   It allows to combine the different Modes consecutively.

        Repeat
        :   Number of cycle repeats

Frame Offset
:   The number of frames to offset the original keyframes by.

Scale
:   Controls the speed of the frames playback. 1 is equal to the actual frame rate, could be positive (faster)
    or negative (slower).

Keep Loop
:   Moves end frame to the animation start to keep animation in a loop.

### Custom Range

When enabled, the animation playback is restricted only to a frame range.

Frame Start/End
:   Sets the range start and end frames.

### Influence

See [Influence Filters](../introduction.html#grease-pencil-modifier-influence-filters).
user: Provide the full official documentation entry for Transparency, preserving all code examples.

assistant: The [Transparent BSDF](../../shader_nodes/shader/transparent.xhtml) shader is given
special treatment. Rays pass straight through it, changing neither direction nor type
as if there were no geometry at all.

Alpha pass output is also different for the transparent
BSDF.
Other transmission BSDFs are considered opaque,
because they change the light direction. As such they cannot be used for
alpha-over compositing, while this is possible with the transparent BSDF.

Note that, while semantically the ray passes through as if no geometry was hit,
rendering performance is affected as each transparency step requires executing the shader and tracing a ray.
user: Show practical ways to work with AnyType(bpy_struct) in a Blender add-on or script – include code.

assistant: # AnyType(bpy_struct)

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

*class* bpy.types.AnyType(*bpy_struct*)
:   RNA type used for pointers to any possible data

    *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 Bpy.Types.Imagepaint: syntax, arguments, return values, common patterns.

assistant:  ImagePaint.invert_stencil ImagePaint.missing_materials ImagePaint.missing_stencil ImagePaint.missing_texture ImagePaint.missing_uvs ImagePaint.mode ImagePaint.normal_angle ImagePaint.screen_grab_size ImagePaint.seam_bleed ImagePaint.stencil_color ImagePaint.stencil_image ImagePaint.use_backface_culling ImagePaint.use_clone_layer ImagePaint.use_normal_falloff ImagePaint.use_occlude ImagePaint.use_stencil_layer ImagePaint.detect_data() ImagePaint.bl_rna_get_subclass() ImagePaint.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: What is Point and how is it used in Blender Python scripting?

assistant: [image reference removed]

Marker schematic.

The whole marker can be moved with `RMB` or by dragging the anchor point (black dot) with `LMB`.
Pressing `G` also moves the whole marker. When pressing `G` twice the marker will be moved
while keeping the anchor in place. Note that the anchor point outside the pattern area is shown as a cross connected
with marker position with a dashed line.

`S` scales the whole marker.
The whole pattern area only will be scaled by pressing `S` twice;
The Pattern can also be rotated using the `R` key which, depending on the used pivot point,
will either rotate patterns around their own centers or rotate the whole markers around e.g. the median point.

To match the perspective transformation of a marker on a plane, the individual corners must be edited manually.
Each marker corner can deform individually to define the shapes.
Corner positions can be edited by dragging them with a mouse.
Dragging with `LMB` will change the position of an individual corner.

The Search area can not be rotated; this is intentional. It doesn’t make sense to deform the search area.
user: What is Brush Settings and how is it used in Blender Python scripting?

assistant: ### General

Size
:   Pressure Sensitivity is not supported for this brush type. More info at [Size](../../brush/brush_settings.xhtml#bpy-types-brush-size).

Strength
:   Pressure Sensitivity is not supported for this brush type. More info at [Strength](../../brush/brush_settings.xhtml#bpy-types-brush-strength).

Normal Radius
:   For this brush, this setting is a purely visual change.
    It does not alter the brush behavior. More info at [Normal Radius](../../brush/brush_settings.xhtml#bpy-types-brush-normal-radius-factor).

Auto-Smooth
:   This setting is not supported. More info at [Auto-Smooth](../../brush/brush_settings.xhtml#bpy-types-brush-auto-smooth-factor).

### Unique

Grab Active Vertex
:   Applies the maximum strength of the brush to the highlighted active vertex,
    making it easier to manipulate low-poly models or meshes with modifiers.

    Enabling this option also enables a white wireframe overlay within the brush radius.
    This helps to visualize the real base geometry that is being manipulated
    while sculpting with [Modifiers](../../../modeling/modifiers/index.xhtml).

[image reference removed]

Grab Silhouette
:   Preserves the object’s silhouette shape by only grabbing vertices on one side of the mesh curvature.
    The shape of the silhouette is determined by the orientation of the 3D Viewport and the start of the stroke.

[image reference removed]

Note how in the image only the bottom side of the leg is pulled down, despite the size of the brush.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Mesh
:   Standard geometry input.

Selection
:   A boolean field indicating which elements should be extruded.

Offset
:   The translation vector for each extruded element. By default, this is the element’s
    [normal](../../geometry/read/normal.xhtml).

Offset Scale
:   Scaling factor for the above translation vector.

Individual Face Mode Only
:   Whether to extrude each face individually rather than extruding connected groups of faces together.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: As the modifier is only a container its actual options can be configured in the *Physics Properties* tab.
See the [Collision Physics Properties](../../../physics/cloth/settings/index.html) for more information.
user: Describe NodeTreeInterfaceSocketColor(NodeTreeInterfaceSocket) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeTreeInterfaceSocketColor(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketColor(*NodeTreeInterfaceSocket*)
:   RGBA color socket of a node

    default_value
    :   Input value used for unconnected socket

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

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Gamma Node: syntax, arguments, return values, common patterns.

assistant: # Gamma Node

[image reference removed]

Use this node to apply a gamma correction. The node is typically used to convert from gamma encoded to linear
color space, or in the reverse direction with 1/gamma.
user: How do I use Emission in Blender? Include parameters, examples, warnings and best practices.

assistant: # Emission

[image reference removed]

The *Emission* node is used to add Lambertian emission shader.
This can for example, be used for material and light surface outputs.

Light strength for point, spot and area lights is specified in Watts.

Sun lights are specified in Watts/m2, which require much smaller values like 1 W/m2.
This can be confusing, but specifying strength in Watts would not have been convenient;
the real sun for example has strength 384.6×1024W.
Emission shaders on meshes are also in Watts/m2.
user: Provide the full official documentation entry for GreasePencilLayerMasks(bpy_struct), preserving all code examples.

assistant: # GreasePencilLayerMasks(bpy_struct)

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

*class* bpy.types.GreasePencilLayerMasks(*bpy_struct*)
:   Collection of Grease Pencil masking layers

    active_mask_index
    :   Active index in layer mask array

        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: Explain Force Fields in complete detail according to the official Blender documentation.

assistant: Soft body vertices interact with all the [Force Fields](../../forces/force_fields/index.html)
applied (usually to particles) in the layer, such as wind, force fields,
and what ever physics field effect is on a common layer.

### Soft Body Field Weights

The *Soft Body Field Weights* panel allows you to control how much influence
each type of external force field has on the soft body system.

Effector Collection
:   Limit effectors to a specified group. Only effectors in this group will have an effect on the current system.

Gravity
:   Control how much the Global Gravity has an effect on the system.

All
:   Scale all of the effector weights.
user: Show practical ways to work with Usage in a Blender add-on or script – include code.

assistant: - Use the *Shape Key Editor* to keyframe shape key influences over time.
- Adjust timing by moving or scaling keyframes directly in the timeline.
- Combine with other Dope Sheet modes (such as the *Action Editor*) for complex character animation workflows.

See also: [Shape Key Basics](../../../animation/shape_keys/introduction.html) for details on creating
and managing shape keys.
user: Give a detailed overview of Renderer Settings: syntax, arguments, return values, common patterns.

assistant: While shading nodes control the appearance, these settings control the quality and algorithms
that each renderer uses to render the material.

- [EEVEE specific settings](../eevee/material_settings.xhtml)
- [Cycles specific settings](../cycles/material_settings.xhtml)
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: The tool is interactive and has two steps:

1. Choose the face loop to cut

   After activating the tool, move the cursor over an edge through which the cut should pass
   (that is, an edge that’s perpendicular to the cutting direction). Blender shows a yellow line
   previewing the cut that will be made. Click `LMB` to confirm and move to the next step,
   or `RMB` to abort.
2. Slide the new edge loop(s)

   You can now move the mouse to change the position of the new edge loop.
   Click `LMB` to create the cut at the chosen location,
   or `RMB` to create it at the center.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/modeling_meshes_tools_loop_before.png   Mesh before inserting edge loop. | ../../../../_images/modeling_meshes_tools_loop_preview.png   Choosing the face loop. | ../../../../_images/modeling_meshes_tools_loop_placement.png   Sliding the new edge loop. |
user: Give a detailed overview of Light Portals: syntax, arguments, return values, common patterns.

assistant: When rendering a daylight indoor scene where most of the light is coming in through a window
or door opening, it is difficult for the integrator to find its way to them.
To fix this, use [Light Portals](../light_settings.xhtml#render-cycles-lights-area-portals).
You then will need to modify its shape to match that of the opening that you are trying to fill.

[image reference removed]

[image reference removed]
user: Show practical ways to work with Troubleshooting macOS – Intel in a Blender add-on or script – include code.

assistant: # Troubleshooting macOS – Intel

Blender uses OpenGL for the 3D Viewport and user interface. The graphics processing unit (GPU) and driver have a big
impact on Blender’s behavior and performance.

This section lists possible solutions for graphics glitches, problems with EEVEE and Cycles, and crashes related to
your GPU.
user: What is Offset Edge Slide and how is it used in Blender Python scripting?

assistant: # Offset Edge Slide

Add two edge loops on either side of selected loops.

Cap Endpoint
:   Extends the loop by creating triangles at endpoints.

Factor
:   Location of the loop relative to the center loop and the outside edge loops.

Even
:   Only available for single edge loops.
    This matches the shape of the edge loop to one of the adjacent edge loops.
    (See [Edge Slide tool](edge_slide.xhtml#modeling-meshes-editing-edge-slide) for details.)

Flipped
:   When Even is enabled, this flips the target edge loop to match.
    (See [Edge Slide tool](edge_slide.xhtml#modeling-meshes-editing-edge-slide) for details.)

Clamp
:   Clamp within the edge extents.

Correct UVs
:   Correct UV coordinates when transforming.
user: Describe MovieClipScopes(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # MovieClipScopes(bpy_struct)

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

*class* bpy.types.MovieClipScopes(*bpy_struct*)
:   Scopes for statistical view of a movie clip

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

assistant: # Drivers Panel

[image reference removed]

Edit Driver popover.

This panel is visible in Sidebar of the [Drivers Editor](../../editors/drivers_editor.html)
or as a popover when adding a driver to a property.

It shows the property that is being driven, followed by a series of settings
that determine how the driver works.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Curves
:   Standard geometry input with a curve component.

Value
:   A field input to evaluate custom attributes.
    The evaluation is outputted through the *Value* output.

Factor Factor mode
:   The portion of the total length used to determine the sample position.

Length Length mode
:   A length in distance units used to determine how far along the curve to travel before sampling.

Curve Index
:   An index to only evaluate specific splines, these indices can be specified manually
    or from the [Index Node](../../geometry/read/input_index.html).
    This input is ignored when the *All Curves* property is enabled.
user: Show practical ways to work with Video in a Blender add-on or script – include code.

assistant: Strobe
:   Display every nth frame.
    For example, if you set this to 10, the strip will only display frames 1, 11, 21, 31, 41… of the source.

    It is important to realize that this property is a float value.
    This allows you to strobe effect synced exactly to a beat.

Reverse Frames
:   Plays the strip backwards starting from the last frame in the sequence.
user: How do I use Join Geometry Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Join Geometry Node

The *Join Geometry* node merges separately generated geometries into a single one.
If the geometry inputs contain different types of data, the output will also contain different data types.

[image reference removed]
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Pivot constraint.

[Target](../interface/common.html#rigging-constraints-interface-common-target)
:   The object or bone to use as the pivot point. Can be left empty,
    in which case the pivot point is either relative to the constraint owner itself
    or not relative to anything (fixed in space).

Use Relative Offset No Target set
:   Whether the *Pivot Point* coordinates are relative to the constraint owner
    or absolute in the world. If a *Target* is set, the coordinates are always relative.

Pivot Point X, Y, Z
:   The coordinates of the pivot point.

Rotation Range
:   Euler axis and direction for which the constraint should be active.

    Always:
    :   Apply pivoting for every possible owner rotation.

    -X/-Y/-Z Rotation:
    :   Only apply pivoting if the owner’s X/Y/Z rotation is negative or zero.

    X/Y/Z Rotation:
    :   Only apply pivoting if the owner’s X/Y/Z rotation is positive or zero.

[Influence](../interface/common.html#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Give a detailed overview of Type: syntax, arguments, return values, common patterns.

assistant: Blender has five types of metas, each determined by its underlying (or directing) structure.

In Edit Mode, you can change this structure,
either using the relevant buttons in the *Active Element* panel,
or the selector in the *Transform* panel in the Sidebar region.
Depending on the structure, you might have additional parameters,
located in both *Transform* panel and *Active Element* panel.

Ball (point, zero-dimensional structure)
:   This is the simplest meta, without any additional setting. As it is just a point,
    it generates an isotropic field, yielding a spherical surface
    (this is why it is called *Meta Ball* or *Ball* in Blender).

Capsule (straight line, one-dimensional structure)
:   This is a meta which surface is generated by the field produced by a straight line of a given length.
    This gives a cylindrical surface, with rounded closed ends.

    Size X
    :   The length of the line (and hence, of the capsule).

Plane (rectangular plane, two-dimensional structure)
:   This is a meta which surface is generated by the field produced by a rectangular plane.
    This gives a parallelepipedal surface, with a fixed thickness, and rounded borders.

    Size X/Y
    :   The length and width of the rectangle.

Ellipsoid (ellipsoidal volume, three-dimensional structure)
:   This is a meta which surface is generated by the field produced by an ellipsoidal volume.
    This gives an ellipsoidal surface.

    Size X/Y/Z
    :   The length, width and height of the ellipsoid.

Cube (parallelepipedal volume, three-dimensional structure)
:   This is a meta which surface is generated by the field produced by a parallelepipedal volume.
    This gives a parallelepipedal surface, with rounded edges.

    Size X/Y/Z
    :   The length, width and height of the parallelepiped.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Geometry
:   Standard geometry input.

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

ID
:   The value for each element. By default, this input uses
    the [index](../read/input_index.xhtml), which is useful
    when stable IDs are desired when deleting a dynamic number of instances.
user: Show practical ways to work with Weights in a Blender add-on or script – include code.

assistant: The shape can be further tweaked by changing the weight of individual control
points in the [Transform Panel](properties/transform_panel.xhtml) found in the Sidebar.

The property is called *W*; while there is also one called *Weight*,
this is the [Goal Weight](properties/transform_panel.xhtml#surface-goal-weight) for soft body simulations.

[image reference removed]

A control point with a higher weight pulls the surface towards it.

Weights are necessary to achieve certain “pure” shapes like cylinders or spheres.
The [primitives](primitives.xhtml) in the *Add* menu
have these preconfigured.

[image reference removed]

Control point weights on a spherical Surface.
user: Show practical ways to work with Restore Curve Segment Length in a Blender add-on or script – include code.

assistant: # Restore Curve Segment Length

The *Restore Curve Segment Length* node restores the original length of each curve segment
based on a reference position, typically from a pre-deformation state.
It is useful for correcting unwanted stretching or compression that occurs after
curve deformations, simulations, or procedural modifications.
user: What is Bpy.Types.Geometrynodeforeachgeometryelementoutput and how is it used in Blender Python scripting?

assistant: deForeachGeometryElementOutput.inspection_index GeometryNodeForeachGeometryElementOutput.main_items GeometryNodeForeachGeometryElementOutput.is_registered_node_type() GeometryNodeForeachGeometryElementOutput.input_template() GeometryNodeForeachGeometryElementOutput.output_template() GeometryNodeForeachGeometryElementOutput.bl_rna_get_subclass() GeometryNodeForeachGeometryElementOutput.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Explain Hold Split in complete detail according to the official Blender documentation.

assistant: Like *Split*, it splits a strip in two distinct strips;
however you will not be able to drag the endpoints to show the frames past the split of each resulting strip.

Although you can adjust the [Hold Offset](../../../editors/video_sequencer/sequencer/sidebar/strip.xhtml#sequencer-duration-hard)
number fields in the *Strip Info* panel.
user: How do I use LineStyleGeometryModifier_BezierCurve(LineStyleGeometryModifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # LineStyleGeometryModifier_BezierCurve(LineStyleGeometryModifier)

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

*class* bpy.types.LineStyleGeometryModifier_BezierCurve(*LineStyleGeometryModifier*)
:   Replace stroke backbone geometry by a Bézier curve approximation of the original backbone geometry

    error
    :   Maximum distance allowed between the new Bézier curve and the original backbone geometry

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Geometry Modifier Type Items](bpy_types_enum_items/linestyle_geometry_modifier_type_items.html#rna-enum-linestyle-geometry-modifier-type-items), default `'2D_OFFSET'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        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](#bpy.types.LineStyleGeometryModifier_BezierCurve.type "bpy.types.LineStyleGeometryModifier_BezierCurve.type")
user: Provide the full official documentation entry for Editing, preserving all code examples.

assistant: ### Duplicate Marker

You can duplicate the selected markers by pressing `Shift`-`D`. Once duplicated,
the new ones are automatically placed in select mode, so you can move them to the desired location.

### Duplicate Marker to Scene

Duplicates the selected markers into another scene.

### Delete Marker

To delete the selected markers simply press `X`,
and confirm the pop-up message with `LMB`.

### Rename Marker

Having dozens of markers scattered throughout your scene’s time will not help you much unless you
know what they stand for. You can name a marker by selecting it, pressing `F2`,
typing the name, and press `Return`

### Move Marker

Once you have one or more markers selected, press `G`,
while hovering with the mouse over the marker bar,
to move them, and confirm the move with `LMB` or `Return`
(as usual, cancel the move with `RMB`, or `Esc`).
Or drag them with the `LMB`.

By default, you move the markers in one-frame steps, but if you hold `Ctrl`,
the markers will move in steps corresponding to 1 second (according to the scene’s *FPS*).

### Select

Convenient operators for selecting Marks; see [Selecting](#bpy-ops-marker-select) for more information on selecting Markers.

All `A`
:   Selects all Markers.

None `Ctrl`-`A`
:   Deselects any already selected Markers.

Invert `Ctrl`-`I`
:   Select all unselected Markers and deselects all selected Markers.

Before Current Frame
:   Selects all Markers to the left of the current frame and the Marker on the current frame if it exists.

After Current Frame
:   Selects all Markers to the Right of the current frame and the Marker on the current frame if it exists.

### Show Pose Markers

Shows markers belonging to the active action instead of scene markers.

### Make Markers Local

It is possible to convert standard markers into pose markers with Marker ‣ Make Markers Local.
Note that the original marker will be gone. If you want to keep it, make a duplicate before you convert.

### Jump to Next/Previous Marker

Moves the Playhead to the next/previous marker relative to the current frame.
user: Explain Texture Coordinate Node in complete detail according to the official Blender documentation.

assistant: # Texture Coordinate Node

[image reference removed]

The *Texture Coordinate* node outputs various coordinate systems
that can be used for procedural textures, image textures, and other vector-based texture inputs.

It is most commonly connected to the *Vector* input of texture nodes,
allowing textures to be placed or manipulated in different coordinate spaces.
user: Provide the full official documentation entry for ShaderFxBlur(ShaderFx), preserving all code examples.

assistant: # ShaderFxBlur(ShaderFx)

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

*class* bpy.types.ShaderFxBlur(*ShaderFx*)
:   Gaussian Blur effect

    rotation
    :   Rotation of the effect

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

    samples
    :   Number of Blur Samples (zero, disable blur)

        Type:
        :   int in [0, 32], default 4

    size
    :   Factor of Blur

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

    use_dof_mode
    :   Blur using camera depth of field

        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: Give a detailed overview of Transform Modal Map: syntax, arguments, return values, common patterns.

assistant: # Transform Modal Map

During a transformation, some hotkeys can change the behavior of the operation.

You can check editing the keys of these modal modifiers in
Blender Preferences ‣ Keymap ‣ Transform Modal Map
(at the bottom of the keymap).
user: Explain BlendDataScenes(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # BlendDataScenes(bpy_struct)

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

*class* bpy.types.BlendDataScenes(*bpy_struct*)
:   Collection of scenes

    new(*name*)
    :   Add a new scene to the main database

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the data-block

        Returns:
        :   New scene data-block

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

    remove(*scene*, *\**, *do_unlink=True*)
    :   Remove a scene from the current blendfile

        Parameters:
        :   - **scene** ([`Scene`](bpy.types.Scene.html#bpy.types.Scene "bpy.types.Scene"), (never None)) – Scene to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this scene before deleting it

    tag(*value*)
    :   tag

        Parameters:
        :   **value** (*boolean*) – Value

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

assistant: Gas or smoke simulations are a subset of the fluids system, and can be used for simulating collections
of airborne solids, liquid particulates and gases, such as those that make up smoke.
It simulates the fluid movement of air and generates animated [Voxel](../../glossary/index.xhtml#term-Voxel)
textures representing the density, heat, and velocity of other fluids or suspended particles
(e.g. smoke) which can be used for rendering.

[image reference removed]

Example of a fire simulation.

Gases or smoke are emitted inside of a [Domain](type/domain/index.xhtml) from
a mesh object or particle system. The smoke movement is controlled by airflow inside the domain,
which can be influenced by [Effector](type/effector.xhtml) objects.
Smoke will also be affected by the scene’s gravity and [force fields](../forces/force_fields/index.xhtml).
Airflow inside the domain can affect other physics simulations
via the [Fluid Flow](../forces/force_fields/types/fluid_flow.xhtml) force field.
user: Provide the full official documentation entry for ShaderNodeFloatCurve(ShaderNode), preserving all code examples.

assistant: # ShaderNodeFloatCurve(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.ShaderNodeFloatCurve(*ShaderNode*)
:   Map an input float to a curve and outputs a float value

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

assistant: Procedural textures can either produce colored textures, intensity only textures,
textures with alpha values and normal textures.
If intensity only ones are used the result is a black-and-white texture,
which can be greatly enhanced by the use of ramps.
If on the other hand you use ramps and need an intensity value,
you have to switch on *No RGB* in the *Mapping* panel.
user: What is Bpy.Types.Spaceuveditor and how is it used in Blender Python scripting?

assistant: l_rna_get_subclass_py() Inherited Properties Inherited Functions References