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

assistant: # Introduction

We have seen in [previous pages](../index.xhtml) how to design an armature,
create chains of bones, etc.
Now, having a good rig is not the final goal, unless you want to produce a “Dance Macabre” animation,
you will likely want to put some flesh on your skeletons!
Surprisingly, “linking” an armature to the object(s)
it should transform and/or deform is called the “skinning” process…

[image reference removed]

The human mesh skinned on its armature.

In Blender, you have two main skinning types:

1. You can [Parent/Constrain Objects to Bones](../../../scene_layout/object/editing/parent.xhtml) –
   then, when you transform the bones in *Pose Mode*, their “children” objects are also transformed,
   exactly as with a standard parent/children relationship…
   The “children” are **never** deformed when using this method.
2. You can [Use the Armature Modifier on entire Mesh](parenting.xhtml),
   and then, some parts of this object to some bones inside this armature.
   This is the more complex and powerful method,
   and the only way to really deform the geometry of the object,
   i.e. to modify its vertices/control points relative positions.
user: Show practical ways to work with Node Combsep Color Items in a Blender add-on or script – include code.

assistant: # Node Combsep Color Items

RGB:
:   RGB.

    Use RGB (Red, Green, Blue) color processing.

HSV:
:   HSV.

    Use HSV (Hue, Saturation, Value) color processing.

HSL:
:   HSL.

    Use HSL (Hue, Saturation, Lightness) color processing.
user: What is Options and how is it used in Blender Python scripting?

assistant: [image reference removed]

The Multiple Strokes modifier.

Duplicates
:   The number of additional strokes.

Distance
:   Distance between the original and the duplicate strokes.

Offset
:   Control the offset position (inner or outer) for duplicate strokes.

### Fade

When activated, the duplicate strokes fades out using their opacity or thickness.

Center
:   Control the initial position for the fading.

Thickness
:   Fade influence on strokes thickness.

Opacity
:   Fade influence on strokes opacity.

### Influence

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

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 Properties: syntax, arguments, return values, common patterns.

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: Describe Integration from the Blender manual or Python API, including usage steps and snippets.

assistant: Integrators are a set of mathematical methods available to calculate the movement of particles.
The following guidelines will help to choose a proper integrator,
according to the behavior aimed at by the animator.

Integration
:   Euler
    :   Also known as “Forward Euler”. Simplest integrator.
        Very fast but also with less exact results.
        If no dampening is used, particles get more and more energy over time.
        For example, bouncing particles will bounce higher and higher each time.
        Should not be confused with “Backward Euler” (not implemented) which has the opposite feature,
        the energy decrease over time, even with no dampening.
        Use this integrator for short simulations or simulations with a lot of
        dampening where speedy calculations are more important than accuracy.

    Verlet
    :   Very fast and stable integrator, energy is conserved over time with very little numerical dissipation.

    Midpoint
    :   Also known as “2nd order Runge-Kutta”. Slower than Euler but much more stable.
        If the acceleration is constant (no drag for example), it is energy conservative.
        It should be noted that in example of the bouncing particles,
        the particles might bounce higher than they started once in a while, but this is not a trend.
        This integrator is a generally good integrator for use in most cases.

    RK4
    :   Short for “4th order Runge-Kutta”. Similar to Midpoint but slower and in most cases more accurate.
        It is energy conservative even if the acceleration is not constant.
        Only needed in complex simulations where Midpoint is found not to be accurate enough.

Timestep
:   The amount of simulation time (in seconds) that passes during each frame.

Subframes
:   The number of simulation steps per frame.
    Subframes to simulate for improved stability and finer granularity in simulations.
    Use higher values for faster-moving particles.

The following options are only available for Fluid type physics:

Adaptive
:   Automatically set the number of subframes.

    Threshold
    :   A tolerance value that allows the number of subframes to vary.
        It sets the relative distance a particle can move before requiring more subframes.

        The number of steps per frame will be at least Subframes + 1.
        More subframes may be simulated if the fluid becomes turbulent, according to the Threshold.
user: Describe Bpy.Types.Imagestrip from the Blender manual or Python API, including usage steps and snippets.

assistant: oat ImageStrip.use_multiview ImageStrip.use_proxy ImageStrip.use_reverse_frames ImageStrip.views_format ImageStrip.bl_rna_get_subclass() ImageStrip.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Explain Limitations in complete detail according to the official Blender documentation.

assistant: Some OSL features are not available when using the OptiX backend. Examples include:

- Memory usage reductions offered by features like on-demand texture loading and
  :   mip-mapping are not available.
- Texture lookups require OSL to be able to determine a constant image file path for each
  :   texture call.
- Some noise functions are not available. Examples include *Cell*, *Simplex*, and *Gabor*.
- The [trace](#render-shader-nodes-osl-trace) function is not functional.
  As a result of this, the [Ambient Occlusion](../../shader_nodes/input/ao.xhtml#bpy-types-shadernodeambientocclusion)
  and [Bevel](../../shader_nodes/input/bevel.xhtml#bpy-types-shadernodebevel) nodes do not work.
user: Describe Scale Elements Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Scale Elements Node

[image reference removed]

Scales the selected faces or edges, letting you specify a scaling factor and pivot point for each one.
Connected faces/edges are scaled together using their average factor and pivot point.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Geometry
:   The input geometry containing the hair curves to be deformed.

Factor
:   Controls the overall strength of the rolling effect.
    A value of 0.0 disables the effect, while 1.0 applies the full roll.

Subdivision
:   Defines how finely each curve is subdivided before deformation.
    Higher values produce smoother and more detailed rolls but increase computational cost.

Variation Level
:   Introduces variation along the roll path by smoothing or distorting its shape.
    Higher values produce more natural and uneven rolls.

Roll Length
:   Specifies the portion of each curve (measured from the tip) that is rolled.
    Increasing this value extends the length of the coiled section.

Roll Radius
:   Determines the radius of the roll, controlling how tightly each curve is coiled.

Roll Depth
:   Adds an offset along the roll axis, producing a stretched or compressed spiral shape.

Roll Taper
:   Controls how the roll radius decreases toward the tip, tapering the spiral.

Retain Overall Shape
:   When enabled, offsets the roll along the curve’s original path to better preserve the initial flow and shape
    of the hair.

Roll Direction
:   Defines the axis around which the roll is performed (e.g., X, Y, or Z).
    This determines the orientation of the curls.

Random Orientation
:   Introduces randomization to the direction of the roll, helping to avoid uniform patterns
    and adding a more natural appearance.

Seed
:   Sets the random seed for the orientation randomization.
    Changing the value alters the distribution of curl directions while keeping the same parameters.

Preserve Length
:   When enabled, maintains the total length of each curve after deformation.
    When disabled, the curves may stretch or compress slightly as a result of rolling.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Volume
:   The input volume geometry that contains one or more named grids.

Name
:   The name of the grid to retrieve from the volume.
    The name must match an existing grid stored in the volume data block.

Remove
:   When enabled, removes the grid from the volume after it has been retrieved.
    This can be useful when restructuring volume data to avoid duplication or
    manage memory more efficiently.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`ImageStrip.retiming_keys`](bpy.types.ImageStrip.html#bpy.types.ImageStrip.retiming_keys "bpy.types.ImageStrip.retiming_keys") - [`MovieStrip.retiming_keys`](bpy.types.MovieStrip.html#bpy.types.MovieStrip.retiming_keys "bpy.types.MovieStrip.retiming_keys") | - [`SceneStrip.retiming_keys`](bpy.types.SceneStrip.html#bpy.types.SceneStrip.retiming_keys "bpy.types.SceneStrip.retiming_keys") - [`SoundStrip.retiming_keys`](bpy.types.SoundStrip.html#bpy.types.SoundStrip.retiming_keys "bpy.types.SoundStrip.retiming_keys") |
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: Distance Metric
:   This procedural texture has seven Distance Metric options.
    These determine the algorithm to find the distance between cells of the texture. These options are:

    - Minkowski
    - Minkowski 4
    - Minkowski 1/2
    - Chebychev
    - Manhattan
    - Distance Squared
    - Actual Distance

    The *Minkowski* setting has a user definable value (the *Exponent* button)
    which determines the Minkowski exponent *e* of the distance function:

    > (*x*e + *y*e + *z*e)1/e

    A value of one produces the *Manhattan* distance metric, a value less than one produces stars
    (at 0.5, it gives a *Minkowski 1/2*), and higher values produce square cells
    (at 4.0, it gives a *Minkowski 4*, at 10.0, a *Chebychev*).
    So nearly all Distance Settings are basically the same – a variation of *Minkowski*.

    You can get irregularly-shaped rounded cells with
    the *Actual Distance* / *Distance Squared* options.

|  |  |  |
| --- | --- | --- |
| <../../../../_images/render_materials_legacy-textures_types_voronoi_minkowski0-5.jpg>   Minkowski Exponent: 0.5 (Minkowski 1/2). | <../../../../_images/render_materials_legacy-textures_types_voronoi_minkowski1.jpg>   Minkowski Exponent: 1 (Manhattan). | <../../../../_images/render_materials_legacy-textures_types_voronoi_minkowski2.jpg>   Minkowski Exponent: 2 (Actual Distance). |
| <../../../../_images/render_materials_legacy-textures_types_voronoi_minkowski4.jpg>   Minkowski Exponent: 4 (Minkowski 4). | <../../../../_images/render_materials_legacy-textures_types_voronoi_minkowski10.jpg>   Minkowski Exponent: 10 (Chebychev). | <../../../../_images/render_materials_legacy-textures_types_voronoi_distancesquared.jpg>   Distance Squared (more contrast than Actual Distance). |

Feature Weights
:   These four sliders at the bottom of the Voronoi panel represent the values of the four Worley constants,
    which are used to calculate the distances between each cell in the texture based on the distance metric.
    Adjusting these values can have some interesting effects on the end result…

Coloring
:   Four settings (*Intensity*, *Position*, *Position and Outline*, and *Position, Outline, and Intensity*)
    that can use four different noise basis as methods to calculate color and intensity of the texture output.
    This gives the Voronoi texture you create with the “Worley Sliders”
    a completely different appearance and is the equivalent of the noise basis setting found on the other textures.
user: What is Clear Transform and how is it used in Blender Python scripting?

assistant: # Clear Transform

Once you have transformed some bones, if you want to return to their rest position,
just clear their transformations.

All
:   Resets location, rotation, and scaling of selected bones to their default values.

Location, Rotation, Scale `Alt`-`G`, `Alt`-`R`, `Alt`-`S`
:   Clears individual transforms.

    Note that in *Envelope* visualization, `Alt`-`S` does not clear the scale,
    but rather scales the *Distance* influence area of the selected bones.
    (This is also available through the Pose ‣ Scale Envelope Distance menu entry,
    which is only effective in *Envelope* visualization, even though it is always available…)

Reset Unkeyed
:   Clears the transforms to their keyframe state.

    Only Selected
    :   Operate on just the selected or all bones.
user: What is Poor Performance and how is it used in Blender Python scripting?

assistant: - Update your graphics drivers (see above).
- On laptops, make sure you are using a dedicated GPU (see above).
- Try lowering quality settings in Preferences ‣ System ‣ Memory & Limits.
- Try undoing settings in your graphics drivers, if you made any changes there.
user: What is Direction of Time and how is it used in Blender Python scripting?

assistant: F-Curves are similar to [Curve objects](../../../modeling/curves/introduction.xhtml) in that they interpolate
between a set of user-defined control points. However, because their purpose is to define a *single*
value on every frame, there’s an important difference: F-curves can’t be closed or otherwise made to
turn back on themselves. They always continue going further to the right.

If you try to make a curve go left by dragging one control point past another,
it switches the order of the points to prevent this.

Two control points switching: the curve cannot go back in time!

|  |  |
| --- | --- |
| ../../../_images/editors_graph-editor_fcurves_introduction_moving1.png   Before moving the second keyframe. | ../../../_images/editors_graph-editor_fcurves_introduction_moving2.png   After moving the second keyframe. |
user: Give a detailed overview of Transform Geometry Node: syntax, arguments, return values, common patterns.

assistant: # Transform Geometry Node

[[image reference removed]](../../../../_images/node-types_GeometryNodeTransform.webp)

The *Transform Geometry Node* allows you to move, rotate or scale the geometry.
The transformation is applied to the entire geometry, and not per element.
The [Set Position Node](../write/set_position.html) is used for moving
individual points of a geometry. For transforming instances individually, the instance
[translate](../../instances/translate_instances.html),
[rotate](../../instances/rotate_instances.html), or
[scale](../../instances/scale_instances.html) nodes can be used.
user: What is Playback Context and how is it used in Blender Python scripting?

assistant: Since the Sequencer Scene can be different from the active scene, playback is contextual,
meaning that depending on where playback is started, a different scene might be playing.

Playing back the scene from the Sequencer plays the Sequencer Scene.
All other editors play back the active scene in the window.
user: Give a detailed overview of Struct(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # Struct(bpy_struct)

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

*class* bpy.types.Struct(*bpy_struct*)
:   RNA structure definition

    base
    :   Struct definition this is derived from

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

    description
    :   Description of the Struct’s purpose

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

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

    identifier
    :   Unique name used in the code and scripting

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

    name
    :   Human readable name

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

    name_property
    :   Property that gives the name of the struct

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

    nested
    :   Struct in which this struct is always nested, and to which it logically belongs

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

    properties
    :   Properties in the struct

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

    property_tags
    :   Tags that properties can use to influence behavior

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

    translation_context
    :   Translation context of the struct’s name

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

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

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

        Return type:
        :   [`bpy.types.Struct`](#bpy.types.Struct "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 CompositorNodeLensdist(CompositorNode), preserving all code examples.

assistant: # CompositorNodeLensdist(CompositorNode)

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

*class* bpy.types.CompositorNodeLensdist(*CompositorNode*)
:   Simulate distortion and dispersion from camera lenses

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Data Type
:   Float:
    :   The node will average a *Float* field.

    Integer:
    :   The node will accumulate an *Integer* field.

    Vector:
    :   The node will average a *Vector* field.

Domain
:   The [attribute domain](../../attributes_reference.html#attribute-domains) used for evaluate the *Value* input.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Clamp Type
:   Method to clamp.

    Min Max:
    :   Constrain values between Min and Max.

    Range:
    :   Constrain values between Min and Max. When Min is greater than Max,
        constrain between Max and Min instead.
user: What is Motion Blur and how is it used in Blender Python scripting?

assistant: Each object has its own motion blur settings along with
the [Scene Level Motion Blur](../render_settings/motion_blur.html).
These settings can be found in the Object Properties tab of the Properties.

Steps
:   Controls accuracy of deformation motion blur, more steps uses more memory.
    The actual number of time steps is \(2^{steps -1}\).

Deformation
:   Enables motion blur for deformed meshes such as animated characters, including hair.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`WindowManager.piemenu_begin__internal`](bpy.types.WindowManager.html#bpy.types.WindowManager.piemenu_begin__internal "bpy.types.WindowManager.piemenu_begin__internal") | - [`WindowManager.piemenu_end__internal`](bpy.types.WindowManager.html#bpy.types.WindowManager.piemenu_end__internal "bpy.types.WindowManager.piemenu_end__internal") |
user: Give a detailed overview of Clamp To Constraint: syntax, arguments, return values, common patterns.

assistant: # Clamp To Constraint

The *Clamp To* constraint snaps an object or bone to a [Curve](../../../modeling/curves/introduction.xhtml).
Specifically, it works as follows:

- If no explicit *Main Axis* is chosen, the constraint picks one automatically based on the longest
  side of the Curve’s bounding box.
- Using this axis, it compares the original coordinate of the object or bone to the minimum and maximum
  coordinates of the Curve, and remaps it to the range 0-1 accordingly.
- This remapped coordinate is then used as a “curve time” to determine the position along the Curve,
  where a value of 0 corresponds to the first control point and 1 to the last.

Unless the Curve is a perfectly straight line, the object’s/bone’s coordinate along the *Main Axis*
will likely change.

If the object or bone moves along the Curve in the opposite direction than the expected one,
use [Switch Direction](../../../modeling/curves/editing/segments.xhtml#bpy-ops-curve-switch-direction) to flip the order of the Curve’s control points.
user: Describe Evaluate on Domain Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Evaluate on Domain Node

[image reference removed]

The *Evaluate on Domain* allows evaluating a field for a different [attribute domain](../../attributes_reference.html#attribute-domains)
than the domain from the [field context](../../fields.html#field-context). For example, the face index could be used instead
of the face corner index, when setting the values of a [UV Map](../../../../glossary/index.html#term-UV-Map)
user: Explain Toggle Cyclic in complete detail according to the official Blender documentation.

assistant: Toggles between an open stroke and closed stroke (cyclic).

Type
:   Close All:
    :   Close all open selected strokes.

    Open All:
    :   Open all closed selected strokes.

    Toggle:
    :   Close or Open selected strokes as required.

Match Point Density
:   Add point in the new segment to keep the same density.
user: What is Options and how is it used in Blender Python scripting?

assistant: [[image reference removed]](../../../_images/modeling_modifiers_modify_uv-project_panel.png)

The UV Project modifier.

UV Map
:   Which UV map to modify. Defaults to the active rendering layer.

Aspect X/Y
:   Changes the image’s aspect ratio. Only apply when a camera is used as projector object.

Scale X/Y
:   Scales the image. Only apply when a camera is used as projector object.

Projectors
:   Up to ten projector objects are supported.
    Each face will choose the closest and aligned projector with its surface normal.
    Projections emit from the negative Z axis (i.e. straight down a camera or light).
    If the projector is a camera, the projection will adhere to its perspective/orthographic setting.

Object
:   Specify the projector object(s).
user: Give a detailed overview of Common Operations: syntax, arguments, return values, common patterns.

assistant: This section lists useful generic operations which can be used.

### Key Bindings for Pop-Ups

Menus and panels can be assigned key shortcuts,
even if they’re only accessible from submenus elsewhere.

Open a Pop-up Menu (`wm.call_menu`)
:   Open any menu on key press.

Open a Pie Menu (`wm.call_menu_pie`)
:   Open any pie menu on key press.

Open a Panel (`wm.call_panel`)
:   Open a pop-up panel (also known as a pop-over).

#### Menu & Panel Identifiers

To find the `name` of a menu,
enable the preference Interface ‣ Display ‣ Python Tooltips.

Then hover the cursor over the popover button or menu item.
For submenus you will need to use the back arrow to prevent the submenu from opening and gaining focus.

### Key Bindings for Properties

There are many properties you might want to bind a key with.
To avoid having to define operators for each property,
there are generic operators for this purpose:

Operators for adjusting properties begin with `wm.context_`.

Some of these include:

- `wm.context_toggle` toggle a Boolean property.
- `wm.context_cycle_enum` cycle an enum property forwards or backwards.
- `wm.context_menu_enum` show a pop-up menu for an enum property.
- `wm.context_pie_enum` show a pie menu for an enum property.
- `wm.context_scale_float` scale a number (used for increasing / decreasing brush size for example).
- `wm.context_toggle_enum` toggle between two options of an enum.
- `wm.context_modal_mouse` moving the cursor to interactively change a value.

See [bpy.ops.wm](https://docs.blender.org/api/current/bpy.ops.wm.html) for a complete list.

Each of these operators has a `data_path` setting to reference the property to change.

To find the `data_path`, basic Python knowledge is needed.

For example, you can use the Python Console to access a Boolean property you wish to map to a key:

```
bpy.context.object.show_name
```

To bind this to a key, add a new keymap item using the operator `wm.context_toggle`
with `data_path` set to `object.show_name` (notice the `bpy.context` prefix is implicit).

See [bpy.context](https://docs.blender.org/api/current/bpy.context.html)
for other context attributes.

The Python API documentation can be used to find properties
or you may use the Python Console’s auto-complete to inspect available properties.
user: Give a detailed overview of Sound Strips: syntax, arguments, return values, common patterns.

assistant: These strips control when a [Speaker Objects](../../render/output/audio/speaker.xhtml) starts to playback the audio.
Playback continues the length of audio file and does not take into account the length of the sound strip.
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

The proverb “A good start is half the battle”, certainly applies to video editing.
Setting up your *work environment* and *project* to your needs is key to success.
In setting up your video project, you have to distinguish between:

- Work Environment related settings and activities:

  These settings apply to all of your projects and are set at “Blender level”; for example the installation
  of add-ons. In fact, they can also influence your non-video editing projects.
  Most of these settings remain more or less stable throughout your projects and should probably only set once.
- Project related settings and activities:

  These settings vary from project to project and are very specific for your project;
  for example the output media format. For each new project, you have to evaluate these settings and activities.

Of course, many settings and activities occur at both levels.
For example, automatic proxies can be enabled globally but changed on a per project or even strip basis.
The layout of the Video Editing Workspace is defined at Blender level but can be tweaked per project.
user: Give a detailed overview of Scale Instances Node: syntax, arguments, return values, common patterns.

assistant: # Scale Instances Node

[image reference removed]

The *Scale Instances* node scales geometry instances in local or global space.

The [Instances](../instances.html) page contains more information about geometry instances.
user: Show practical ways to work with Inherited Properties in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleGeometryModifier.name`](bpy.types.LineStyleGeometryModifier.html#bpy.types.LineStyleGeometryModifier.name "bpy.types.LineStyleGeometryModifier.name") |
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Axis
:   Local axis of the object that is to be rotated towards the vector input.

Pivot
:   The local axis to rotate around.

    Auto:
    :   The best rotation angle is computed automatically.
        This minimizes the angle of rotation.

    X, Y, Z:
    :   Rotate around a specific local axis.
user: Describe GeometryNodeViewportTransform(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeViewportTransform(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.GeometryNodeViewportTransform(*GeometryNode*)
:   Retrieve the view direction and location of the 3D viewport

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

assistant: # GeometryNodeCurveLength(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.GeometryNodeCurveLength(*GeometryNode*)
:   Retrieve the length of all splines added together

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

assistant: # BlendDataLights(bpy_struct)

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

*class* bpy.types.BlendDataLights(*bpy_struct*)
:   Collection of lights

    new(*name*, *type*)
    :   Add a new light to the main database

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – New name for the data-block
            - **type** (enum in [Light Type Items](bpy_types_enum_items/light_type_items.html#rna-enum-light-type-items)) – Type, The type of light to add

        Returns:
        :   New light data-block

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

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

        Parameters:
        :   - **light** ([`Light`](bpy.types.Light.html#bpy.types.Light "bpy.types.Light"), (never None)) – Light to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this light before deleting it (WARNING: will also delete objects instancing that light data)
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this light data
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this light data

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

assistant: [image reference removed]

Panel layout (Blur effect as an example).

The visual effects panels and interface are similar to modifiers.
Each effect shares the same basic interface components similar to modifiers for meshes.

See [Modifiers Interface](../../modeling/modifiers/introduction.html#bpy-types-modifier-show) for more information.
user: Give a detailed overview of Source: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Paint source panel.

*Paint* source setting lets you define how brush influence/intersection is defined.

Mesh Volume

The Brush affects all surface point inside the mesh volume.

[image reference removed]

Source: Mesh Volume.

Proximity

Only uses defined distance to the closest point on brush mesh surface.
Note that inside of the volume is not necessarily affected because it is not close to the surface.

[image reference removed]

Source: Proximity. Brush affects all canvas pixels around it.

Mesh Volume + Proximity

Same as volume type, but also has influence over defined distance.

Inner Proximity
:   Applies proximity inside the mesh volume.

Negate Volume
:   Negates brush alpha within mesh volume.

|  |  |
| --- | --- |
| ../../_images/physics_dynamic-paint_brush_source-mesh-volume-proximity-1.png   The Volume + Proximity brush with no additional settings. | ../../_images/physics_dynamic-paint_brush_source-mesh-volume-proximity-2.png   Inner Proximity. Proximity falloff is now visible inside the volume. |
| ../../_images/physics_dynamic-paint_brush_source-mesh-volume-proximity-3.png   Negate Volume. Inner side of the volume has become completely transparent. | ../../_images/physics_dynamic-paint_brush_source-mesh-volume-proximity-4.png   Inner Proximity and Negate Volume enabled together. |

Object Center

Instead of calculating proximity to the brush object mesh, which can be quite slow in some cases,
only distance to only center is calculated. This is much faster and often good enough.

[image reference removed]

Source: Object Center.

Particle System

Brush influence is defined by particles from a selected particle system.

[image reference removed]

Effect Solid Radius
:   Defines the distance, inside which paint is solid color.

Use Particle Radius
:   Uses the settings in the particle panel to determine solid radius size.
    Solid Radius size disabled while Particle Radius enabled.

Smooth Radius
:   An additional radius outside Solid Radius to add a smooth falloff.

    If you set “Smooth Radius” to zero, particle will be painted as a solid sphere.
    If you set “Solid Radius” to zero, it gets painted as a smooth halo.

    [image reference removed]

    [image reference removed]

    Source: Particle System.

### Common Options

Paint Distance
:   The maximum distance to mesh surface to affect paint.

Project
:   Projects brush to the canvas from a defined direction.
    Basically this can be considered as “direction aligned” proximity.

    [image reference removed]

    The Project option enabled. See how brush only affects canvas in normal direction.

Falloff
:   Sharp:
    :   Paints solid paint within the defined distance.

    Smooth:
    :   Makes paint to linearly fade out until becoming completely invisible
        when it reaches the maximum distance.

    Color Ramp:
    :   Allows you to manually make a custom falloff behavior.
user: Show practical ways to work with ColorManagedSequencerColorspaceSettings(bpy_struct) in a Blender add-on or script – include code.

assistant: # ColorManagedSequencerColorspaceSettings(bpy_struct)

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

*class* bpy.types.ColorManagedSequencerColorspaceSettings(*bpy_struct*)
:   Input color space settings

    name
    :   Color space that the sequencer operates in

        Type:
        :   enum in [Color Space Convert Default Items](bpy_types_enum_items/color_space_convert_default_items.html#rna-enum-color-space-convert-default-items), 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: Explain Make Instances Real in complete detail according to the official Blender documentation.

assistant: *Make Instances Real* creates a new object for each
[instance](../properties/instancing/index.xhtml) generated by the selected ones,
and removes any direct instancing from those.

In the end, each instance becomes a real object.

### Options

By default, new objects will be added to the same collection as the one containing their instancer,
without keeping any hierarchy relationships. This behavior can be altered with the following options.

Parent
:   If *Keep Hierarchy* is not set, parents all the generated objects to the former instancer.

    Otherwise, parents all the generated objects *which are not already parented* to their respective instancer,
    or its matching new copy (this is important in case of recursive instancing, see the note below).

Keep Hierarchy
:   Preserves internal hierarchies (i.e. parent relationships) in the newly generated objects.
user: How do I use Example in Blender? Include parameters, examples, warnings and best practices.

assistant: Closures are useful when part of a node group’s logic should be user-defined.
For example, a terrain generator can use a closure to define tree placement:

- The [Evaluate Closure](evaluate_closure.xhtml)
  node is placed where tree instances are distributed.
- A closure input is exposed on the group’s interface.
- A [Closure](closure.xhtml)
  node is connected defining any custom placement logic.

When the closure is evaluated, the contents of the connected node graph
are executed inside the context of the terrain generator.
This allows the generator to provide stable infrastructure
(e.g., scattering, masks, attributes) while users supply their own functional behavior.

[image reference removed]

A terrain generator node group using closures for custom tree placement.
user: What is Bpy.Types.Marbletexture and how is it used in Blender Python scripting?

assistant: rate_preview ID.override_create ID.override_hierarchy_create ID.user_clear ID.user_remap ID.make_local ID.user_of_id ID.animation_data_create ID.animation_data_clear ID.update_tag ID.preview_ensure ID.bl_rna_get_subclass ID.bl_rna_get_subclass_py Texture.evaluate Texture.bl_rna_get_subclass Texture.bl_rna_get_subclass_py Next Mask(ID) Previous MaintainVolumeConstraint(Constraint) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page MarbleTexture(Texture) MarbleTexture MarbleTexture.marble_type MarbleTexture.nabla MarbleTexture.noise_basis MarbleTexture.noise_basis_2 MarbleTexture.noise_depth MarbleTexture.noise_scale MarbleTexture.noise_type MarbleTexture.turbulence MarbleTexture.users_material MarbleTexture.users_object_modifier MarbleTexture.bl_rna_get_subclass() MarbleTexture.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Closures define outputs that return values to the node tree in which they are evaluated.
Outputs can be created by dragging a socket from within the zone into the blank socket on the closure’s output, or by
adding sockets manually in the node’s properties.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Domain
:   The domain on which the selection field is evaluated.

    Point:
    :   The selection is on the points, control points, and vertices of the geometry.

    Edge:
    :   The selection is on the edges of the mesh component. The other components
        are not modified.

    Face:
    :   The selection is on the faces of the mesh component. The other components
        are not modified.

    Spline:
    :   The selection is on the splines in the curve component. For each spline, it
        will either be deleted entirely or not at all. The other components are not
        modified.

    Instance:
    :   The selection is on the top-level instances, and the entire instance is
        removed if it is selected. If the input also contains realized geometry,
        that will be unaffected.

Mode
:   The type of elements to be affected.
    This only applies to the mesh component.

    All:
    :   Vertices, edges, and faces in the selection will be deleted.

    Only Edges & Faces:
    :   Vertices won’t be deleted, even if they are in the selection.

    Only Faces:
    :   Only faces in the selection will be deleted.
user: What is Translate Blender and how is it used in Blender Python scripting?

assistant: # Translate Blender

Bring Blender closer to everyone! 🌎 By translating Blender’s user interface, you help artists and creators worldwide
work in their native language. No coding skills are needed—just a passion for Blender and the ability to translate.
Join the translation community today and make Blender truly global!

For more information, see the [Blender UI Translation Guide](https://developer.blender.org/docs/handbook/translating/translator_guide/).
user: Explain Installing on Windows in complete detail according to the official Blender documentation.

assistant: # Installing on Windows

Check the [Downloading Blender](index.xhtml) page to find the minimum requirements and the
different versions that are available for Blender (if you have not done so yet).

Download the zip-file or Windows Installer File.