PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Creating a Sequencer Scene

To start using the Sequencer, you first need to create or use an existing Scene.

1. Open a workspace that contains a [Video Sequence Editor](../editors/video_sequencer/index.html).
2. Press the “New” button in the [Sequencer header region](../editors/video_sequencer/sequencer/navigating.html) to
   create a new Sequencer Scene, or select an existing Scene.

### Working with Multiple Scenes

Since the sequencer scene is separate from the active scene in the window
it is possible to work with scene strips in the sequencer while also viewing
and editing the referenced scenes within the same workspace.

A common setup includes:

- Workspace with a Video Sequence Editor and a 3D Viewport.
- In the VSE, a Sequencer Scene (e.g. called “Edit”).
- Multiple other scenes in the same file e.g. for different locations or shots.

Now add a few scene strips in the sequencer using the existing scenes (or new scenes).
Then enable the Sync Scene Time option in the Sequencer Playback Controls region.
This will update the active scene (and therefor what is visible in the 3D Viewport)
with whatever scene the current scene strip in the Sequencer references.

This setup allows to quicky switch between different scenes just by scrubbing/playing
the Sequencer timeline.
user: Show practical ways to work with Mball Operators in a Blender add-on or script – include code.

assistant: # Mball Operators

bpy.ops.mball.delete_metaelems(*\**, *confirm=True*)
:   Delete selected metaball element(s)

    Parameters:
    :   **confirm** (*boolean**,* *(**optional**)*) – Confirm, Prompt for confirmation

bpy.ops.mball.duplicate_metaelems()
:   Duplicate selected metaball element(s)

bpy.ops.mball.duplicate_move(*\**, *MBALL_OT_duplicate_metaelems=None*, *TRANSFORM_OT_translate=None*)
:   Make copies of the selected metaball elements and move them

    Parameters:
    :   - **MBALL_OT_duplicate_metaelems** (`MBALL_OT_duplicate_metaelems`, (optional)) – Duplicate Metaball Elements, Duplicate selected metaball element(s)
        - **TRANSFORM_OT_translate** (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items

bpy.ops.mball.hide_metaelems(*\**, *unselected=False*)
:   Hide (un)selected metaball element(s)

    Parameters:
    :   **unselected** (*boolean**,* *(**optional**)*) – Unselected, Hide unselected rather than selected

bpy.ops.mball.reveal_metaelems(*\**, *select=True*)
:   Reveal all hidden metaball elements

    Parameters:
    :   **select** (*boolean**,* *(**optional**)*) – Select

bpy.ops.mball.select_all(*\**, *action='TOGGLE'*)
:   Change selection of all metaball elements

    Parameters:
    :   **action** (enum in [`'TOGGLE'`, `'SELECT'`, `'DESELECT'`, `'INVERT'`], (optional)) –

        Action, Selection action to execute

        - `TOGGLE`
          Toggle – Toggle selection for all elements.
        - `SELECT`
          Select – Select all elements.
        - `DESELECT`
          Deselect – Deselect all elements.
        - `INVERT`
          Invert – Invert selection of all elements.

bpy.ops.mball.select_random_metaelems(*\**, *ratio=0.5*, *seed=0*, *action='SELECT'*)
:   Randomly select metaball elements

    Parameters:
    :   - **ratio** (*float in* *[**0**,* *1**]**,* *(**optional**)*) – Ratio, Portion of items to select randomly
        - **seed** (*int in* *[**0**,* *inf**]**,* *(**optional**)*) – Random Seed, Seed for the random number generator
        - **action** (enum in [`'SELECT'`, `'DESELECT'`], (optional)) –

          Action, Selection action to execute

          - `SELECT`
            Select – Select all elements.
          - `DESELECT`
            Deselect – Deselect all elements.

bpy.ops.mball.select_similar(*\**, *type='TYPE'*, *threshold=0.1*)
:   Select similar metaballs by property types

    Parameters:
    :   - **type** (enum in [`'TYPE'`, `'RADIUS'`, `'STIFFNESS'`, `'ROTATION'`], (optional)) – Type
        - **threshold** (*float in* *[**0**,* *inf**]**,* *(**optional**)*) – Threshold
user: Explain Drawing Plane in complete detail according to the official Blender documentation.

assistant: # Drawing Plane

[image reference removed]

Drawing Planes pop-over.

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

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

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

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

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

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

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

Stroke using different Drawing Planes with Canvas overlay activated.

|  |  |  |  |  |
| --- | --- | --- | --- | --- |
| ../../../_images/grease-pencil_modes_draw_drawing-planes_front.png   Front. | ../../../_images/grease-pencil_modes_draw_drawing-planes_side.png   Side. | ../../../_images/grease-pencil_modes_draw_drawing-planes_top.png   Top. | ../../../_images/grease-pencil_modes_draw_drawing-planes_view.png   View. | ../../../_images/grease-pencil_modes_draw_drawing-planes_cursor.png   Cursor. |
user: What is Marble and how is it used in Blender Python scripting?

assistant: # Marble

The marble texture is used to generate marble, fire, or noise with a structure.
Bands are generated based on the sine, saw, or triangular formula and noise turbulence.

[image reference removed]

Marble Texture panels.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Transform Cache Constraint.

Cache File
:   Data-block menu to select the Alembic or USD file.

File Path
:   Path to the Alembic or USD file.

Sequence
:   Whether or not the cache is separated in a series of files.

Override Frame
:   Whether to use a custom frame for looking up data in the cache file,
    instead of using the current scene frame.

    The *Frame* value is the time to use for looking up the data in the cache file,
    or to determine which to use in a file sequence.

Frame Offset
:   Subtracted from the current frame to use for looking up the data in the cache file,
    or to determine which file to use in a file sequence.

Manual Scale
:   Value by which to enlarge or shrink the object with respect to the world’s origin.

Velocity Attribute
:   The name of the Alembic attribute used for generating motion blur data;
    by default, this is `.velocities` which is standard for most Alembic files.

Velocity Unit
:   Defines how the velocity vectors are interpreted with regard to time.

    Frame:
    :   The velocity unit was encoded in frames and does not need to be scaled by scene FPS.

    Second:
    :   The velocity unit was encoded in seconds and needs to be scaled by the scene FPS (1 / FPS).

Object Path
:   The path to the Alembic or USD object inside the archive or stage.

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

assistant: # NodeSocketVectorTranslation2D(NodeSocketStandard)

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

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

    default_value
    :   Input value used for unconnected socket

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

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Tool Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: Filter Type
:   Fill:
    :   Fills in a single color.

    Hue:
    :   Shifts the Hue of each color.

    Saturation:
    :   Increases or decreases the saturation.

    Value:
    :   Increases or decreases the values.

    Brightness:
    :   Increases or decreases the brightness.

    Contrast:
    :   Increases or decreases the contrast.

    Smooth:
    :   Blurs or sharpens the colors.

    Red:
    :   Increases or decreases the red channel.

    Green:
    :   Increases or decreases the green channel.

    Blue:
    :   Increases or decreases the blue channel.

Fill Color
:   Set a color that will be used for the fill filter type.

Strength
:   The amount of effect the filter has on the color attribute.
user: Describe The Simple Case from the Blender manual or Python API, including usage steps and snippets.

assistant: Whenever the camera is basically fixed, or at least “almost” stationary, and the footage is crisp and
without motion blur, perfect stabilization is easy to achieve. This might be the case when a tripod was used,
but wind or vibrations on the floor (e.g. on a stage) caused some minor shakes.
Shoulder camera shots done by an experienced operator also frequently fall into this category.

- Use as few points as possible. Start with a single point right on the main subject.
- Track this single point as accurate as possible. Beware of movements and shape changes of the tracked feature.
  Proceed in small increments (e.g. 50 frames), zoom in and readjust the target point manually when it drifts away.
  Another option is to use a larger target area for tracking; since we’re tracking only a single point,
  the slower tracking speed might be acceptable.
- After enabling the basic (location) stabilization, consider if you really need rotation stabilization.
  Often, some minor, slow swinging movements are not really noticeable and do not warrant the additional working time
  and quality loss caused by rotation and scale stabilization.
- For rotation, start with one extra point, well spaced but preferably still attached to the main subject.
- Consider to fix some slow residual motion by manually animating the “*Expected* \*” parameters,
  before you even think of adding more tracking markers. Because doing so is often not worth the effort.
- If you need to add more points, the most important goal is to achieve *symmetry.*
  Place location tracking points symmetrically above and below the horizon.
  Place rotation tracking points into diagonally opposed direction, always centered around the main focal area.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Type
:   Shape of the influence volume. Can be set to Sphere or Box.

Radius / Size
:   A probe object only influences the lighting of nearby surfaces.
    This influence zone is defined by the size parameter and object scaling.

Falloff
:   Percentage of the influence distance in which the influence of a probe fades linearly.

### Capture

Clipping Start, End
:   Define the near and far clip distances when capturing the scene.

### Custom Parallax

By default, the influence volume is also the parallax volume.
The parallax volume is a volume on which the recorded light is projected.
It should roughly fit it surrounding area. In some cases it may be better to
adjust the parallax volume without touching the influence parameters.
In this case, enable the *Custom Parallax* and
change the shape and radius of the parallax volume independently.

### Viewport Display

Data
:   Show the captured light using a reflective sphere of the given size.

Clipping
:   Show the clipping distance in the 3D Viewport.

Influence
:   Show the influence bounds in the 3D Viewport. The inner sphere is where the falloff starts.

Parallax
:   Show the *Custom Parallax* shape in the 3D Viewport.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Geometry
:   The input geometry containing the hair curves to be grouped and,
    optionally, existing guide curves.

Guides
:   The curves or points that can act as guides.
    These are the candidates that other curves will be assigned to.

Guide Distance
:   The minimum spacing between chosen guides.
    This prevents guides from being selected too close together and helps control
    how large each guide’s influence region will be.

Guide Mask
:   A mask that restricts which curves are allowed to become guides.
    Curves with a mask value of 0 cannot be selected as guides.

Group ID
:   An ID used to divide the curves into independent groups for guide assignment.
    A curve will only select a guide that has the same *Group ID* value.
    This is useful for ensuring that different regions (for example, left vs. right side of a groom)
    do not mix.
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: Linear Motor/Angular Motor
:   Enable
    :   Enable linear or angular motor respectively.

        Target Velocity
        :   Target linear or angular motor velocity respectively.

        Max Impulse
        :   Maximum linear or angular motor impulse respectively.
user: Show practical ways to work with Modifier Triangulate Quad Method Items in a Blender add-on or script – include code.

assistant: # Modifier Triangulate Quad Method Items

BEAUTY:
:   Beauty.

    Split the quads in nice triangles, slower method.

FIXED:
:   Fixed.

    Split the quads on the first and third vertices.

FIXED_ALTERNATE:
:   Fixed Alternate.

    Split the quads on the 2nd and 4th vertices.

SHORTEST_DIAGONAL:
:   Shortest Diagonal.

    Split the quads along their shortest diagonal.

LONGEST_DIAGONAL:
:   Longest Diagonal.

    Split the quads along their longest diagonal.
user: What is J and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [jitter (bpy.types.Brush attribute)](bpy.types.Brush.html#bpy.types.Brush.jitter) - [jitter_absolute (bpy.types.Brush attribute)](bpy.types.Brush.html#bpy.types.Brush.jitter_absolute) - [jitter_factor (bpy.types.ParticleSettings attribute)](bpy.types.ParticleSettings.html#bpy.types.ParticleSettings.jitter_factor) - [jitter_unit (bpy.types.Brush attribute)](bpy.types.Brush.html#bpy.types.Brush.jitter_unit) - [join() (aud.aud.Sound method)](aud.html#aud.aud.Sound.join)   - [(in module bpy.ops.node)](bpy.ops.node.html#bpy.ops.node.join)   - [(in module bpy.ops.object)](bpy.ops.object.html#bpy.ops.object.join)   - [(in module bpy.ops.palette)](bpy.ops.palette.html#bpy.ops.palette.join) - [join_named() (in module bpy.ops.node)](bpy.ops.node.html#bpy.ops.node.join_named) - [join_nodes() (in module bpy.ops.node)](bpy.ops.node.html#bpy.ops.node.join_nodes) | - [join_selection() (in module bpy.ops.grease_pencil)](bpy.ops.grease_pencil.html#bpy.ops.grease_pencil.join_selection) - [join_shapes() (in module bpy.ops.object)](bpy.ops.object.html#bpy.ops.object.join_shapes) - [join_tracks() (in module bpy.ops.clip)](bpy.ops.clip.html#bpy.ops.clip.join_tracks) - [join_triangles() (in module bmesh.ops)](bmesh.ops.html#bmesh.ops.join_triangles) - [join_uvs() (in module bpy.ops.object)](bpy.ops.object.html#bpy.ops.object.join_uvs) - [joint_bindings (bpy.types.SplineIKConstraint attribute)](bpy.types.SplineIKConstraint.html#bpy.types.SplineIKConstraint.joint_bindings) - [jpeg2k_codec (bpy.types.ImageFormatSettings attribute)](bpy.types.ImageFormatSettings.html#bpy.types.ImageFormatSettings.jpeg2k_codec) - [jump() (in module bpy.ops.text)](bpy.ops.text.html#bpy.ops.text.jump) - [jump_height (bpy.types.WalkNavigation attribute)](bpy.types.WalkNavigation.html#bpy.types.WalkNavigation.jump_height) - [jump_to_file_at_point() (in module bpy.ops.text)](bpy.ops.text.html#bpy.ops.text.jump_to_file_at_point) - [jump_to_target_button() (in module bpy.ops.ui)](bpy.ops.ui.html#bpy.ops.ui.jump_to_target_button) |
user: What is LineStyleColorModifier_DistanceFromObject(LineStyleColorModifier) and how is it used in Blender Python scripting?

assistant: # LineStyleColorModifier_DistanceFromObject(LineStyleColorModifier)

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

*class* bpy.types.LineStyleColorModifier_DistanceFromObject(*LineStyleColorModifier*)
:   Change line color based on the distance from an object

    blend
    :   Specify how the modifier value is blended into the base value

        Type:
        :   enum in [Ramp Blend Items](bpy_types_enum_items/ramp_blend_items.html#rna-enum-ramp-blend-items), default `'MIX'`

    color_ramp
    :   Color ramp used to change line color

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

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

    range_max
    :   Upper bound of the input range the mapping is applied

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

    range_min
    :   Lower bound of the input range the mapping is applied

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

    target
    :   Target object from which the distance is measured

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

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Color Modifier Type Items](bpy_types_enum_items/linestyle_color_modifier_type_items.html#rna-enum-linestyle-color-modifier-type-items), default `'ALONG_STROKE'`, (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.LineStyleColorModifier_DistanceFromObject.type "bpy.types.LineStyleColorModifier_DistanceFromObject.type")
user: How do I use Gpu in Blender? Include parameters, examples, warnings and best practices.

assistant: o . fragment_source ( "void main()" "{" " FragColor = texture(img_input, uvInterp);" "}" ) shader = gpu . shader . create_from_info ( shader_info ) batch = batch_for_shader ( shader , &#39;TRI_FAN&#39; , { "position" : (( - 1 , - 1 ), ( 1 , - 1 ), ( 1 , 1 ), ( - 1 , 1 )), "uv" : (( 0 , 0 ), ( 1 , 0 ), ( 1 , 1 ), ( 0 , 1 )), }, ) def draw (): shader . uniform_float ( "modelMatrix" , Matrix . Translation (( 0 , 0 , 0 )) @ Matrix . Scale ( 1 , 4 )) shader . uniform_float ( "viewProjectionMatrix" , bpy . context . region_data . perspective_matrix ) shader . uniform_sampler ( "img_input" , texture ) batch . draw ( shader ) compute_shader . image ( &#39;img_output&#39; , texture ) compute_shader . uniform_float ( "time" , time . time () - start_time ) gpu . compute . dispatch ( compute_shader , 128 , 128 , 1 ) def drawTimer (): for area in bpy . context . screen . areas : if area . type == &#39;VIEW_3D&#39; : area . tag_redraw () return 1.0 / 60.0 bpy . app . timers . register ( drawTimer ) bpy . types . SpaceView3D . draw_handler_add ( draw , (), &#39;WINDOW&#39; , &#39;POST_VIEW&#39; ) Next GPU Types (gpu.types) Previous freestyle.utils submodule (freestyle.utils.ContextFunctions) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page GPU Module (gpu) Geometry Batches Vertex Buffers Index Buffers Shaders Batch Creation Offscreen Rendering Examples Triangle with Custom Shader Wireframe Cube using Index Buffer Mesh with Random Vertex Colors 2D Rectangle 2D Image Generate a texture using Offscreen Rendering Copy Off-screen Rendering result back to RAM Rendering the 3D View into a Texture Custom Shader for dotted 3D Line Custom compute shader (using image store) and vertex/fragment shader
user: Describe Visualization from the Blender manual or Python API, including usage steps and snippets.

assistant: In the supported editors, if at least one is created, markers are visualized
in a separate row at their bottom.
This area can be disabled per editor via the View ‣ Show Markers menu option.

### Standard

[image reference removed]

Regular markers are shown as small white triangles, empty if unselected or filled if selected,
and with a dashed line that covers the editor height at the corresponding frame.
If they have a name, this is shown to their right in white.

### 3D Viewport

[image reference removed]

The 3D Viewport does not allow you to create, edit or remove markers,
but it shows their name in the Object Info in the upper left corner,
when on their frame.

### Pose Markers

[image reference removed]

Pose markers show a diamond-shaped icon in the Dope Sheet.
In the NLA editor pose markers are shown as a red dashed line inside the relative action strip.
user: Describe Tool Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: You can configure the brush main settings exposed on the Tool Settings for convenience.
For the draw brushes configuration and settings see:
[Draw Brush](../brushes/draw.xhtml).

Subdivisions
:   The number of stroke points between each stroke edge.

Thickness Profile
:   Use a [curve widget](../../../../interface/controls/templates/curve.xhtml) to define the stroke thickness
    from the start (left) to end (right) of the stroke.

    Use Curve
    :   When enabled, the stroke use a curve profile to control the thickness along the line.
user: Describe Scene Options from the Blender manual or Python API, including usage steps and snippets.

assistant: Object
:   Determine which objects will be included in the export.

    Active:
    :   Export only the active Grease Pencil object.

    Selected:
    :   Export all selected Grease Pencil objects.

    Visible:
    :   Export all visible Grease Pencil object in the scene.
user: How do I use Navigating in Paint Modes in Blender? Include parameters, examples, warnings and best practices.

assistant: # Navigating in Paint Modes

There are different preferences for navigating the 3D Viewport in Blender.
For painting and sculpting specific workflows it is recommended to use any of the following methods.

Center View to Mouse `Alt` `MMB`
:   Center the View on the surface directly under the mouse position.
    This way the rotation point of the viewport can be manually changed to any point you wish to orbit around.

Center on Last Stroke `NumpadPeriod`
:   Center the View on the average position of the last stroke.

Various preferences can also make navigation more convenient.
These can be found in the “Navigation” tab of the preferences.

Orbit Method = Trackball
:   Tumble the view based on the mouse position in your 3D Viewport while rotating.
    This makes it very easy to tilt the viewport freely,
    instead of having the Z axis of the viewport locked.

[Zoom to Mouse Position](../editors/preferences/navigation.xhtml#bpy-types-preferencesinput-use-zoom-to-mouse)
:   Use the mouse position to zoom towards and rotate around the surface that is pointed at.
    This can be an alternative to the repeated manual use of the Center View to Mouse operator.

    The disadvantage is that this navigation preference can lead to accidental navigation
    around backfacing geometry or very distant geometry.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Texture Mapping.

Mode
:   The texture transformation will be applied to the stroke/fill or stroke UVs.

    Stroke:
    :   Stroke Fit Method
        :   Selects the texture fitting method.

            Constant Length:
            :   The texture keep a consistent length along the strokes.

            Stroke Length:
            :   The texture is normalized to fit the stroke length.

        UV Offset
        :   Moves the texture along the strokes.

        Rotation
        :   Rotates the points of the strokes.

        Scale
        :   Factor for the texture scale.

    Fill:
    :   Fill Rotation
        :   Sets the texture angle.

        Offset
        :   Moves the texture origin.

            X, Y

        Scale
        :   Factor for the texture scale.

### Influence

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

assistant: |  |  |
| --- | --- |
| - [**Edge**](glossary/index.html#term-Edge) - [**Edge Loop**](glossary/index.html#term-Edge-Loop) - [**Edge Ring**](glossary/index.html#term-Edge-Ring) - [Editors](editors/index.html#index-0)   - [3D Viewport](editors/3dview/introduction.html#index-0)   - [Asset Browser](editors/asset_browser.html#index-0)   - [Compositor](editors/compositor.html#index-0)   - [Dope Sheet](editors/dope_sheet/introduction.html#index-0)   - [Drivers Editor](editors/drivers_editor.html#index-0)   - [File Browser](editors/file_browser.html#index-0)   - [Geometry Node Editor](editors/geometry_node.html#index-0)   - [Graph Editor](editors/graph_editor/introduction.html#index-0)   - [Image Editor](editors/image/introduction.html#index-0)   - [Info Editor](editors/info_editor.html#index-0)   - [Movie Clip Editor](editors/clip/introduction.html#index-0)   - [NLA Editor](editors/nla/introduction.html#index-0)   - [Outliner](editors/outliner/introduction.html#index-0)   - [Preferences](editors/preferences/introduction.html#index-0)   - [Properties](editors/properties_editor.html#index-0)   - [Python Console](editors/python_console.html#index-0)   - [Shader Editor](editors/shader_editor.html#index-0)   - [Spreadsheet](editors/spreadsheet.html#index-0)   - [Text Editor](editors/text_editor.html#index-0)   - [Texture Node Editor](editors/texture_node/introduction.html#index-0)   - [Timeline](editors/timeline.html#index-0)   - [UV Editor](editors/uv/introduction.html#index-0)   - [Video Sequencer](editors/video_sequencer/introduction.html#index-0) | - [**Elastic**](glossary/index.html#term-Elastic) - [**Elasticity**](glossary/index.html#term-Elasticity) - [**Empty**](glossary/index.html#term-Empty) - [**Euler**](glossary/index.html#term-Euler) - [**Euler Rotation**](glossary/index.html#term-Euler-Rotation) - [Extensions](advanced/extensions/getting_started.html#index-0), [[1]](advanced/extensions/index.html#index-0) |
user: How do I use 3D Viewport in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Rotate UVs

The orientation of the UV texture is defined by each face.
If the image is, for example, upside down or laying on its side,
use the Face ‣ Rotate UVs (in the 3D Viewport in Face Select mode)
menu to rotate the UVs per face in 90-degree turns.

### Reverse UVs

The Face ‣ Reverse UVs tool mirrors the UVs per face,
which flips the image over, showing you the image reversed.
user: Describe Transparent from the Blender manual or Python API, including usage steps and snippets.

assistant: Render the background transparent, for compositing the image over another background after rendering.

Transparent Glass
:   Render transmissive surfaces as transparent, for compositing glass over another background.

Roughness Threshold
:   For transparent glass, keep surfaces with roughness above the threshold opaque.
user: What is Toolbar and how is it used in Blender Python scripting?

assistant: Sample
:   Used to sample the color of one or more pixels in the image.
    As long as you hold `LMB`, the footer will show the following:

    - X and Y coordinates of the mouse cursor.
    - Color in RGBA.
    - Color in RGB after [Color Management](../../render/color_management/index.xhtml).
    - Color in HSV.
    - Luminance.

    Sample Size
    :   The dimensions of the square used to sample underlying pixels.
        If larger than 1, the resulting sample is an average of all underlying pixels.

Annotate
:   See [Annotations](../../interface/annotate_tool.xhtml) for more information.
user: Provide the full official documentation entry for MATERIAL_UL_matslots(UIList), preserving all code examples.

assistant: # MATERIAL_UL_matslots(UIList)

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Rounding Mode
:   Round:
    :   Outputs the closest integer to Float, rounding either up or down based on the value.

    Floor:
    :   Outputs the closest integer less than Float, always rounding down.

    Ceiling:
    :   Outputs the closest integer greater than Float, always rounding up.

    Truncate:
    :   Outputs the closest integer between Float and zero. For positive numbers, acts like Floor.
        For negative numbers, acts as Ceiling.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Image
:   Standard color input.

Key Color
:   The target color to be keyed out (made transparent).
    This is typically the background color, such as pure green or blue.

Hue
:   The tolerance for hue difference from the key color.
    A wider range will key out more colors with similar hues.

Saturation
:   The tolerance for saturation difference from the key color.
    Helps avoid removing unintended desaturated areas like skin tones or clothing.

Value
:   The tolerance for brightness difference from the key color.
    Useful when lighting is uneven or background luminance varies.
user: How do I use Overview in Blender? Include parameters, examples, warnings and best practices.

assistant: This template streamlines the workflow for editing video, image, and audio sources together in a single timeline.
Each piece of media is represented as its own strip in the Sequencer, where clips can be arranged, trimmed,
and combined with effects to produce a polished final video.
user: Show practical ways to work with Dirty Vertex Colors in a Blender add-on or script – include code.

assistant: Generate a dirt map gradient based on cavity.

Blur Strength
:   Blur strength per iteration.

Blur Iterations
:   Number of times to blur the colors (higher blurs more).

Highlight Angle
:   Clamps the angle for convex areas of the mesh.
    Lower values increase the contrast but can result in clamping.
    90 means flat, 180 means infinitely pointed.

Dirt Angle
:   Clamps the angle for concave areas of the mesh.
    Higher values increase the contrast but can result in clamping.
    90 means flat, 0 means infinitely deep.

Dirt Only
:   When active it won’t calculate cleans for convex areas.

Normalize
:   Choose optimal contrast by effectively lowering
    *Highlight Angle* and increasing *Dirt Angle* automatically.
    Disabling *Normalize* allows getting consistent results across multiple objects.
user: What is Strokes Location & Orientation Controls and how is it used in Blender Python scripting?

assistant: Drawing in a 3D space is not the same as drawing on a flat canvas.
When drawing with Grease Pencil you have to define
the location and orientation of the new strokes in the 3D space.

[image reference removed]

3D Viewport header Controls for strokes.

### Stroke Placement

The Stroke Placement selector defines the new strokes location in 3D space.

See [Stroke Placement](stroke_placement.html) for more information.

### Drawing Planes

The Drawing Planes selector defines the plane (orientation) to which the new strokes will be restricted.

See [Drawing Planes](drawing_planes.html) for more information.
user: Explain Settings in complete detail according to the official Blender documentation.

assistant: # Settings

[image reference removed]

Default rigid body panel.

Mass
:   Specifies how heavy the object is and “weights” irrespective of gravity.

Dynamic
:   Enables/disables rigid body simulation for the object.

Animated
:   Allows the rigid body to additionally be controlled by the animation system.
user: Describe bpy_prop_collection_idprop from the Blender manual or Python API, including usage steps and snippets.

assistant: # bpy_prop_collection_idprop

base classes — [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection")

*class* bpy.types.bpy_prop_collection_idprop
:   built-in class used for user defined collections.

    add()
    :   This is a function to add a new item to a collection.

        Returns:
        :   A newly created item.

        Return type:
        :   Any

    clear()
    :   This is a function to remove all items from a collection.

    move(*src_index*, *dst_index*)
    :   This is a function to move an item in a collection.

        Parameters:
        :   - **src_index** (*int*) – Source item index.
            - **dst_index** (*int*) – Destination item index.

    remove(*index*)
    :   This is a function to remove an item from a collection.

        Parameters:
        :   **index** (*int*) – Index of the item to be removed.
user: Explain Visual Transform in complete detail according to the official Blender documentation.

assistant: Constraints give their owning object or bone a new location, rotation, and/or scale which together
are called the *visual transform*. This transform is separate from the “base” transform found
in the *Transform* panel of the Properties Editor,
and as its name implies, it determines where the owner *really* appears in the world.

For example, even when an object’s *Transform* panel still shows the original *Location* of (0, 0, 0),
a constraint could have placed it somewhere else entirely. What’s more, attempting to move or even
animate that object won’t work: its *Location* numbers will change, but visually,
it will remain stuck in place. The only way to “free” the object is to disable or delete the constraint,
or to set its [Influence](interface/common.xhtml#bpy-types-constraint-influence) to zero.

Of course, transform properties that are not constrained can still be changed as usual.

While the visual transform is not shown in the UI, it can be copied to the base transform:

- By running [Apply Visual Transform](../../scene_layout/object/editing/apply.xhtml#bpy-ops-object-visual-transform-apply).
- By [applying](interface/header.xhtml#bpy-ops-constraint-apply) the constraint. This also deletes the constraint.
user: Show practical ways to work with Brush Control in a Blender add-on or script – include code.

assistant: These are the most common hotkeys for controlling the brush.

- Set brush size `F`
- Set brush strength `Shift`-`F`
- Rotate brush texture / Set brush weight `Ctrl`-`F`

After pressing these hotkeys, you can then either adjust the value interactively or by typing in numbers.
Move the mouse right or left to increase/reduce the value
(additionally with precision (`Shift`) and/or snapping (`Ctrl`) activated).
Finally confirm (`LMB`, `Return`) or cancel (`RMB`, `Esc`).

You can also invert the brush direction/effect by holding `Ctrl`.
user: How do I use NodeSocketGeometry(NodeSocketStandard) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeSocketGeometry(NodeSocketStandard)

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

*class* bpy.types.NodeSocketGeometry(*NodeSocketStandard*)
:   Geometry socket of a node

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Trace Image to Grease Pencil in Blender? Include parameters, examples, warnings and best practices.

assistant: # Trace Image to Grease Pencil

The *Trace Image to Grease Pencil* tool traces a black and white image and generates Grease Pencil strokes.
If the image is not black and white, it will be internally converted.
For better results, convert the images manually to black and white.
Also try to keep the resolution of the image small; high resolutions can produce very dense strokes.
user: Provide the full official documentation entry for Grid Display, preserving all code examples.

assistant: Use a specific color map for the visualization of the simulation field.
This comes in handy during debugging or when making more advanced
adjustments to the simulation. For instance, if the actual color of
a fire simulation is barely visible in the viewport then changing
the color profile can help to see the real size of the flame.

Field
:   The simulation field used in the display options (e.g. density, fuel, heat).

    Comparison of a fire simulation with and without color mapping.

    |  |  |
    | --- | --- |
    | ../../../../../_images/physics_fluid_type_domain_gas_viewport-display_colormapping-1.png   Slice view of “fire” grid without color mapping. | ../../../../../_images/physics_fluid_type_domain_gas_viewport-display_colormapping-2.png   Slice view of “fire” grid with color mapping. |

Scale
:   Scale the selected simulation field by this value.
user: How do I use Add Sound Strip in Blender? Include parameters, examples, warnings and best practices.

assistant: Move Strips
:   Use mouse to position strip in timeline immediately after adding. If this option is enabled, Start Frame and
    Channel properties are not displayed.

Start Frame
:   The [Start Frame](../../../../editors/video_sequencer/sequencer/sidebar/strip.xhtml#bpy-types-strip-frame-start) to place the left handle of the strip.

Channel
:   The [Channel](../../../../editors/video_sequencer/sequencer/channels.xhtml) to place the strip.

Relative Path
:   Store the location of the image file relative to the blend-file.

Replace Selection
:   Replaces the currently selected strips with the new strip.

Cache
:   Cache the sound in memory, enables [Caching](../../../../editors/video_sequencer/sequencer/sidebar/strip.xhtml#bpy-types-sound-use-memory-cache) in the Source properties.

Mono
:   Merge all sound channels into one channel,
    enables [Mono](../../../../editors/video_sequencer/sequencer/sidebar/strip.xhtml#bpy-types-sound-use-mono) in the Sound properties.
user: How do I use Vertex Groups for Particles in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Weight painted particle emission.

By selecting vertex groups in the [Vertex Groups](../../physics/particles/emitter/vertex_groups.xhtml)
panel of a [particle system](../../physics/particles/introduction.xhtml)’s properties,
you can have different particle densities, hair lengths etc. across different areas of the mesh.
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

Curves and [Surfaces](../surfaces/introduction.xhtml) are particular types of Blender objects.
They are expressed by mathematical functions (interpolation)
rather than linear interpolation between a series of points.

Blender offers both [Bézier](structure.xhtml#curve-bezier) and [NURBS](structure.xhtml#curve-nurbs).
Both Bézier curves and NURBS curves and surfaces are defined in terms of a set of “control points”
(or “control vertices”) which define a “control polygon”.

[image reference removed]

Blender logo made from Bézier curves.

Both Bézier and NURBS curves are named after their mathematical definitions, and
choosing between them is often more a matter of how they are computed behind the scenes
than how they appear from a modeler’s perspective.
Bézier curves are generally more intuitive because they start and end at the control points that you set,
but NURBS curves are more efficient for the computer to calculate when there are many twists and turns in a curve.

The main advantage to using curves instead of polygonal meshes is that curves are defined by
less data and so can produce results using less memory and storage space at modeling time.
However, this procedural approach to surfaces can increase demands at render time.

Certain modeling techniques, such as
[extruding a profile along a path](properties/geometry.xhtml),
are possible only using curves. On the other hand, when using curves,
vertex-level control is more difficult and if fine control is necessary,
[mesh editing](../meshes/editing/introduction.xhtml) may be a better modeling option.

Bézier curves are the most commonly used curves for designing letters or logos.

They are also widely used in animation, both as for objects to move along (see constraints below)
and as [F-Curves](../../editors/graph_editor/fcurves/introduction.xhtml)
to change the properties of objects as a function of time.
user: Show practical ways to work with GeometryNodeCurveStar(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeCurveStar(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.GeometryNodeCurveStar(*GeometryNode*)
:   Generate a poly spline in a star pattern by connecting alternating points of two circles

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

Driver curve in the Drivers editor.

The main area of the [Drivers editor](../../editors/drivers_editor.xhtml)
shows an [F-Curve](../../editors/graph_editor/fcurves/introduction.xhtml) that
represents the driver function.

The **X axis** maps to the output value of the driver configuration. The units depend on the setup.

The **Y axis** shows the value applied to the target property. The units depend on the property.

In the example image, if the driver value is 2.0 the property value will be 0.5.

The default F-Curve is an identity map, i.e. the value produced by the driver configuration
is applied to the driven property unchanged. If the driver output value is 2.0,
the property will be 2.0.

The driver function can be defined artistically with Bézier curve handles or
mathematically with trigonometric functions or polynomial expressions such as \(y = a + bx\).
Furthermore, the function can also be procedurally modulated with noise or cyclic repetitions.
See [Modifiers](../../editors/graph_editor/fcurves/modifiers.xhtml) for more details.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Camera Solver constraint.

Active Clip
:   Whether to follow the physical camera of the scene’s [Active Clip](../../../scene_layout/scene/properties.html#bpy-types-scene-active-clip).
    If unchecked, a selector appears for choosing another clip.

Constraint to F-Curve
:   Replaces the constraint by a set of equivalent [keyframes](../../keyframes/introduction.html).

[Influence](../interface/common.html#bpy-types-constraint-influence)
:   How strongly the constraint affects the Blender camera.