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

assistant: # Active Spline

The *Active Spline* panel contains the properties of the active surface.

[image reference removed]

Active Spline panel.

Cyclic U/V
:   When enabled, the last row/column of the surface will be connected back to the first,
    creating a closed loop.

Bézier U/V
:   When enabled, the surface will be generated as a series of Bézier splines instead of a
    NURBS curve in the row/column direction.

Endpoint U/V
:   Controls whether the surface touches the borders of its control point grid.

    [image reference removed]

    Surface with *Endpoint U* enabled.

Order U/V
:   A higher *Order* gives each control point a broader influence along its
    row/column. This makes the surface smoother, but also makes it follow
    the shape of the control grid less closely.
    See [NURBS Curves Order](../../curves/properties/active_spline.html#modeling-curve-order).

    [image reference removed]

    Surfaces with *Order U* set to 2 (top) and 4 (bottom).

    If *Bézier* is enabled, *Order* determines the number of control points per spline.

    The *Order* for a certain direction cannot be higher than the number of control
    points along that direction.

Resolution U/V
:   Determines the preview density of the generated surface mesh. The higher this number,
    the more vertices there will be and the smoother the surface will look.

    This setting only affects the active surface. To change the resolution of all surfaces
    in the object, you can use the [Resolution Preview U/V](shape.html#bpy-types-curve-resolution-v) setting in the
    *Shape* panel instead.

    If the *Render U/V* values in the *Shape* panel are nonzero, they will override these
    *Resolution U/V* values during rendering.

Smooth
:   Whether to apply [smooth shading](../../meshes/editing/mesh/shading.html#modeling-meshes-editing-normals-shading)
    to the generated surface mesh.
user: Provide the full official documentation entry for UV Sphere, preserving all code examples.

assistant: A UV sphere is composed of quad faces arranged in horizontal rings and vertical segments,
with triangle fans at the poles. This structure mirrors how textures are typically mapped
in 2D (hence the name “UV” sphere), making it well-suited for texturing.

It resembles lines of latitude and longitude on a globe, which also makes it useful for
planetary models or spherical shapes with pole-to-pole UV seams.

Segments
:   Number of vertical segments (longitudinal divisions).
    These are like meridians on a globe, running from the north to south pole.

Rings
:   Number of horizontal segments (latitudinal divisions).
    These are like parallels on a globe, stacked from top to bottom.

Radius
:   Distance from the center to the outer surface of the sphere.
user: Describe Version Number Guidelines from the Blender manual or Python API, including usage steps and snippets.

assistant: # Version Number Guidelines

The Blender Extensions platform doesn’t mandate any particular version numbering
scheme, so if you already have a versioning scheme that you use for your
extension, feel free to continue using that.

However, if you don’t have an existing version numbering scheme, we recommend
following the guidelines below.
user: Explain Angular Velocity in complete detail according to the official Blender documentation.

assistant: Lets you configure if and how particles should spin over time.
*Dynamic* needs to be enabled for this to work.

Axis
:   The axis to spin around. If this is set to *Velocity*, *Horizontal*, or *Vertical*,
    particles will additionally spin to keep the same orientation relative to their
    direction of movement, even if *Amount* is zero.

    None
    :   Spinning is disabled.

    Velocity
    :   Spin around the particle’s velocity vector.

    Horizontal
    :   Spin around the axis that’s horizontal (lying in the global XY plane)
        and perpendicular to the particle’s velocity. Particles moving along the
        global Z axis won’t spin because no unique rotation axis exists in this case.

    Vertical
    :   Spin around the axis that’s perpendicular to both the particle’s velocity
        and the above *Horizontal* axis. Particles moving along the global Z axis
        won’t spin.

    Global X, Y, Z
    :   Spin around the chosen global axis.

    Random
    :   Spin around a random axis.

Amount
:   How fast to spin around the *Axis*.
user: Provide the full official documentation entry for GeometryNodeInputMaterial(GeometryNode), preserving all code examples.

assistant: # GeometryNodeInputMaterial(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.GeometryNodeInputMaterial(*GeometryNode*)
:   Output a single material

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

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

assistant: # Toolbar

[Select](../../../../interface/selecting.html#tool-select-tweak)
:   Select or moved.

    [Select Box](../../../../interface/selecting.html#tool-select-box)
    :   Select UVs by dragging a box.

    [Select Circle](../../../../interface/selecting.html#tool-select-circle)
    :   Select UVs by painting on it.

    [Select Lasso](../../../../interface/selecting.html#tool-select-lasso)
    :   Select UVs by drawing a lasso.

Cursor
:   Change the location of the 2D Cursor.

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

Transform
:   Tool to adjust the UVs translation, rotation and scale.

[Annotate](../../../../interface/annotate_tool.html#tool-annotate-freehand)
:   Draw free-hand annotation.

    [Annotate Line](../../../../interface/annotate_tool.html#tool-annotate-line)
    :   Draw straight line annotation.

    [Annotate Polygon](../../../../interface/annotate_tool.html#tool-annotate-polygon)
    :   Draw a polygon annotation.

    [Annotate Eraser](../../../../interface/annotate_tool.html#tool-annotate-eraser)
    :   Erase previous drawn annotations.

[Rip](rip.html)
:   The Rip tool separates UV faces from each other.

[Grab](grab.html)
:   The Grab tool moves UVs around using a brush.

[Relax](relax.html)
:   The Relax tool makes UVs more evenly distributed using a brush.

[Pinch](pinch.html)
:   The Pinch tool moves UVs toward the brush’s center.
user: Provide the full official documentation entry for Animation, preserving all code examples.

assistant: Masks can be animated with the shape keying system.
This can be useful when there are not enough good feature points to track in the footage,
or the mask is not based on footage.
Mask animation timing can be edited from the *Dope Sheet’s* [Mask Mode](../../editors/dope_sheet/modes/mask.xhtml#dope-sheet-mask).

Insert Shape Key `I`
:   Will insert a shape key for the active mask layer at the current frame.
    This works on the level of mask layers,
    so inserting a shape key will keyframe all the splines and points contained in it.

Clear Shape Key `Alt`-`I`
:   Will clear the shape key for the active mask layer at the current frame.

Feather Reset Animation
:   Resets the feather offset across all animated frames.

Re-Key Points of Selected Shapes
:   Re-interpolate selected points on across the range of keys selected in the *Dope Sheet*.
user: Describe Operator Buttons from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Operator button.

Operator buttons execute an [Operator](../../operators.xhtml)
which in summary execute an action when clicked with `LMB`.
Operator buttons may be an icon, text, or text with an icon.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Vector
:   Texture coordinate to sample texture at;
    defaults to Generated texture coordinates if the socket is left unconnected.

Scale
:   Overall texture scale.

Distortion
:   Amount of distortion of the wave.

Detail
:   Amount of distortion noise detail.

Detail Scale
:   Scale of distortion noise.

Roughness
:   Blend between a smoother noise pattern, and rougher with sharper peaks.

Phase Offset
:   Position of the wave along the *Bands Direction*.
    This can be used as an input for more control over the distortion.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.light`](bpy.context.html#bpy.context.light "bpy.context.light") - [`BlendData.lights`](bpy.types.BlendData.html#bpy.types.BlendData.lights "bpy.types.BlendData.lights") | - [`BlendDataLights.new`](bpy.types.BlendDataLights.html#bpy.types.BlendDataLights.new "bpy.types.BlendDataLights.new") - [`BlendDataLights.remove`](bpy.types.BlendDataLights.html#bpy.types.BlendDataLights.remove "bpy.types.BlendDataLights.remove") |
user: Show practical ways to work with Notes in a Blender add-on or script – include code.

assistant: While the noise is random in nature, it follows a certain pattern that might not evaluate to
random values in some configurations. For instance, consider the following configuration
where a grid of objects have a material that evaluates a noise texture at their locations.
One might expect the objects to have random values since they have different locations,
but this is not the case.

[image reference removed]

An example configuration where the noise evaluates to a constant value.

It seems all objects have a value of 0.5. To understand why this happens, let us
look at the following plot of a 1D noise texture.

[image reference removed]

A plot of a 1D noise with zero details and zero distortion.

The horizontal line denotes a value of 0.5 and the vertical lines denotes whole numbers assuming
a noise scale of 1. As can be seen, the noise always intersects the 0.5 line at whole numbers.
Since the aforementioned objects were distributed on a grid and have whole number locations,
they all evaluate to 0.5. Which explains the issue at hand.

Generally, any discrete evaluation of noise at integer multiples of the reciprocal of
the noise scale will always evaluate to 0.5. It also follows that evaluations closer to
that will have values close to 0.5. In such cases, it is almost always preferred to use
the White Noise Texture.

Regardless, one can mitigate this issue in a number of ways:

- Adjust the scale of the noise to avoid aligning the noise with the evaluation domain.
- Add an arbitrary offset to the texture coordinates to break the alignment with the evaluation domain.
- Evaluate the noise at a higher dimension and adjust the extra dimension
  until a satisfactory result is achieved.

|  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_textures_noise_issue-constant-value.png   Constant value issue. | ../../../_images/render_shader-nodes_textures_noise_solution1-constant-value.png   Mitigating the issue by adjusting the scale. |
| ../../../_images/render_shader-nodes_textures_noise_solution2-constant-value.png   Mitigating the issue by adding an arbitrary offset. | ../../../_images/render_shader-nodes_textures_noise_solution3-constant-value.png   Mitigating the issue by evaluating at a higher dimension. |

Similarly, in other configurations, one might experience some banding patterns in the noise,
where there are bands of high contrast areas followed by banding of low contrast areas.
For instance, planar surfaces that are slightly tilted along one of the axis
will have such a banding pattern.

[image reference removed]

An example configuration where the noise have a banding pattern.

This happens because the slight tilt along one of the axis causes values along
the perpendicular axis to change very slowly making the grid structure of
the noise more apparent. The easiest way to mitigate this issue to rotate
the coordinates by an arbitrary amount.

[image reference removed]

Mitigating the issue by rotating the coordinates by an arbitrary amount.
user: Explain Delete in complete detail according to the official Blender documentation.

assistant: Deletes selected vertices, edges, or faces. This operation can also be limited to:

Vertices
:   Delete all vertices in current selection, removing any faces or edges they are connected to.

Edges
:   Deletes any edges in the current selection. Removes any faces that the edge shares with it.

Faces
:   Removes any faces in current selection.

Only Edges & Faces
:   Limits the operation to only selected edges and adjacent faces.

Only Faces
:   Removes faces, but edges within the face selection are retained.
user: Show practical ways to work with Zoom In/Out in a Blender add-on or script – include code.

assistant: Moves the view closer to, or further away from, the point of interest.
You can zoom in and out by rolling the `Wheel` or dragging with `Ctrl`-`MMB`.
To zoom with discrete steps, use the hotkeys `NumpadPlus` and `NumpadMinus`.

`RMB` cancels the zoom operation.
user: How do I use Menus in Blender? Include parameters, examples, warnings and best practices.

assistant: Close Menu on Leave
:   Close menus when the mouse is moved out of the region.

### Open on Mouse Over

Select this to have the menu open by placing the mouse pointer over the entry instead of clicking on it.

Top Level
:   Time delay in 1/10 second before a menu opens (*Open on Mouse Over* needs to be enabled).

Sub Level
:   Same as above for sub menus (for example: File ‣ Open Recent).

### Pie Menus

Animation Timeout
:   Length of animation when opening Pie Menus.

Tap Key Timeout
:   Keystrokes held longer than this will dismiss the menu on release (in 1/100ths of a second).

Recenter Timeout
:   The window system tries to keep the pie menu within the window borders.
    Pie menus will use the initial mouse position as center for this amount of time, measured in 1/100ths of a second.
    This allows for fast dragged selections.

Radius
:   The size of the Pie Menu set with the distance (in pixels) of the menu items from the center of the pie menu.

Threshold
:   Distance from center before a selection can be made.

Confirm Threshold
:   Distance threshold after which selection is made (zero disables).
user: Describe Distorted Noise from the Blender manual or Python API, including usage steps and snippets.

assistant: # Distorted Noise

*Distortion Noise* takes the option that you pick from *Noise Basis* and filters it, to create hybrid pattern.
It is often used for grunge but is also very complex and versatile.

[image reference removed]

Distorted Noise Texture panels.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`BoidSettings.active_boid_state`](bpy.types.BoidSettings.html#bpy.types.BoidSettings.active_boid_state "bpy.types.BoidSettings.active_boid_state") - [`BoidState.active_boid_rule`](bpy.types.BoidState.html#bpy.types.BoidState.active_boid_rule "bpy.types.BoidState.active_boid_rule") | - [`BoidState.rules`](bpy.types.BoidState.html#bpy.types.BoidState.rules "bpy.types.BoidState.rules") |
user: Give a detailed overview of Cache: syntax, arguments, return values, common patterns.

assistant: # Cache

The *Cache* panel is used to [Bake](../../../../glossary/index.xhtml#term-Baking) the fluid simulation and stores the outcome of
a simulation so it does not need to be recalculated.

Baking takes a **lot** of compute power (hence time). Depending on the scene, it is recommended
to allocate enough time for the baking process.

If the mesh has modifiers, the rendering settings are used for exporting the mesh to the fluid solver.
Depending on the setting, calculation times and memory use might exponentially increase. For example,
when using a moving mesh with *Subdivision Surface* as an obstacle, it might help to decrease simulation
time by switching it off, or to a low subdivision level. When the setup/rig is correct, you can always
increase settings to yield a more realistic result.

Cache Directory
:   Directory to store baked simulation files in. Inside this directory each simulation type
    (i.e. mesh, particles, noise) will have its own directory containing the simulation data.

Frame Start
:   The simulation starts on this frame, and this is the first one that is baked.

End
:   The simulation ends on this frame, and this is the last one to be baked.

Offset
:   Frame offset that is used when loading the simulation from the cache.
    It is not considered when baking the simulation, only when loading it.

Type
:   The type of the cache determines how the cache can be baked.

    Replay:
    :   The cache will be baked as the simulation is being played in the viewport.

    Modular:
    :   The cache will be baked step by step: The bake operators for this type are spread across various panels within
        the domain settings (e.g. the bake tool for the mesh can be found in the Mesh panel).

    All:
    :   The cache will be baked with a single tool. All selected settings will be considered during this bake.
        The bake tool for this type can be found in the Cache panel.

Resumable
:   Extra data will be saved so that you can resumed baking after pausing. Since more data will be written
    to drive it is recommended to avoid enabling this option when baking at high resolutions.

Bake All, Free All
:   This option is only available when using the [Final](#bpy-types-fluiddomainsettings-cache-type) cache type.
    *Bake All* will run the simulation considering all parameters from
    the settings (i.e. it will bake all steps that can be baked individually with
    the [Modular](#bpy-types-fluiddomainsettings-cache-type) cache type at once).

    The progress will be displayed in the status bar. Pressing `Esc` will abort the simulation.

    Once the simulation has been baked, the cache can be deleted by pressing *Free All*.
    It is not possible to pause or resume a *Bake All* process as
    only the most essential cache files are stored on drive.
user: What is Cryptomatte Node and how is it used in Blender Python scripting?

assistant: # Cryptomatte Node

[image reference removed]

The Cryptomatte node uses a [Cryptomatte image](https://en.wikipedia.org/wiki/Cryptomatte)
to create a mask for one or more objects or materials. The input matte is typically generated by
Blender itself (see the [Cryptomatte render pass](../../../render/layers/passes.html#render-layers-passes-cryptomatte)),
but can also come from other software that supports the standard.
user: Describe Known Limitations from the Blender manual or Python API, including usage steps and snippets.

assistant: For the most part, linking data will work as expected.
However, there are some limitations to be aware of.

### Circular Dependencies

In general, dependencies should not go in both directions.
Attempting to link or append data which links back to the current file will likely result in missing links.

### Scene-Level Settings

Scene-level settings such as the [Rigid Body World](../../physics/rigid_body/world.html) will not
be copied when linking objects. As an alternative, you can link the
entire scene and use it as a [Background Scene](../../scene_layout/scene/properties.html#bpy-types-scene-background-set).

### Compression & Memory Use

Referencing [compressed](../blend/open_save.html#files-blend-compress) blend-files may need a lot of
memory because they have to be loaded in their entirety, even if you only link/append
a small part of them. Once the data-blocks are loaded, however, memory usage is the same.
user: Describe Modes and Mesh Access from the Blender manual or Python API, including usage steps and snippets.

assistant: # Modes and Mesh Access

When working with mesh data you may run into the problem where a script fails to run as expected in Edit-Mode.
This is caused by Edit-Mode having its own data which is only written back to the mesh when exiting Edit-Mode.

A common example is that exporters may access a mesh through `obj.data` (a [`bpy.types.Mesh`](bpy.types.Mesh.html#bpy.types.Mesh "bpy.types.Mesh"))
when the user is in Edit-Mode, where the mesh data is available but out of sync with the edit mesh.

In this situation you can…

- Exit Edit-Mode before running the tool.
- Explicitly update the mesh by calling `bmesh.types.BMesh.to_mesh`.
- Modify the script to support working on the edit-mode data directly, see: [`bmesh.from_edit_mesh`](bmesh.html#bmesh.from_edit_mesh "bmesh.from_edit_mesh").
- Report the context as incorrect and only allow the script to run outside Edit-Mode.
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

Shape keys are used to deform objects into new shapes for animation.
In other terminology, shape keys may be called *morph targets* or *blend shapes*.

The most common use cases for shape keys are in character facial animation
(e.g. mouth positions, expressions, phonemes) and in refining a skeletal rig.
They are particularly useful for modeling organic, soft body parts and muscles,
where additional control over the resulting shape is needed beyond what can be achieved
with transformations such as rotation or scale.

Shape keys can be applied to object types with vertices, such as meshes, curves, surfaces, and lattices.

[image reference removed]

Example of a mesh with different shape keys applied.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`Object.field`](bpy.types.Object.html#bpy.types.Object.field "bpy.types.Object.field") - [`ParticleSettings.force_field_1`](bpy.types.ParticleSettings.html#bpy.types.ParticleSettings.force_field_1 "bpy.types.ParticleSettings.force_field_1") | - [`ParticleSettings.force_field_2`](bpy.types.ParticleSettings.html#bpy.types.ParticleSettings.force_field_2 "bpy.types.ParticleSettings.force_field_2") |
user: How do I use Import Curve Operators in Blender? Include parameters, examples, warnings and best practices.

assistant: # Import Curve Operators

bpy.ops.import_curve.svg(*\**, *filepath=''*, *filter_glob='\*.svg'*, *directory=''*, *files=None*)
:   Load a SVG file

    Parameters:
    :   - **filepath** (*string**,* *(**optional**,* *never None**)*) – File Path, Filepath used for importing the file
        - **filter_glob** (*string**,* *(**optional**,* *never None**)*) – filter_glob
        - **directory** (*string**,* *(**optional**,* *never None**)*) – directory
        - **files** (`bpy_prop_collection` of `OperatorFileListElement`, (optional)) – File Path

    File:
    :   [addons_core/io_curve_svg/__init__.py:61](https://projects.blender.org/blender/blender/src/branch/main/scripts/addons_core/io_curve_svg/__init__.py#L61)
user: Give a detailed overview of Getting Started: syntax, arguments, return values, common patterns.

assistant: Manual links

The following links take you from the basics to the more advanced
concepts of Python scripting for Blender.

- [Text Editor](../../editors/text_editor.xhtml)
- [Python Console](../../editors/python_console.xhtml)
- [Info Editor](../../editors/info_editor.xhtml)

External links

Here are external links containing a lot of good information
to start learning how to write scripts for Blender:

- [Python API: Quickstart](https://docs.blender.org/api/current/info_quickstart.html)
- [CG Cookie: Blender 2.8 Python Scripting Superpowers for Non-Programmers](https://cgcookie.com/posts/blender-2-8-python-scripting-superpowers-for-non-programmers)
- [Olav3D Tutorials: 3D Programming for Beginners Using Python](https://www.youtube.com/watch?v=rHzf3Dku_cE)
- [Blender Artists: Python Support Forum](https://blenderartists.org/c/coding/python-support)
user: Show practical ways to work with Set Sharpness by Angle in a Blender add-on or script – include code.

assistant: Sets the [sharp edge attribute](../../../geometry_nodes/attributes_reference.xhtml#geometry-nodes-builtin-attributes)
based on the angle between neighboring faces.

Angle
:   Maximum angle between face normals that will be considered as smooth.

Extend
:   Add new sharp edges without clearing existing sharp edges.
user: How do I use ConstraintTarget(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ConstraintTarget(bpy_struct)

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

*class* bpy.types.ConstraintTarget(*bpy_struct*)
:   Target object for multi-target constraints

    subtarget
    :   Armature bone, mesh or lattice vertex group, …

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

    target
    :   Target object

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

    *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 CurveProfilePoint(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CurveProfilePoint(bpy_struct)

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

*class* bpy.types.CurveProfilePoint(*bpy_struct*)
:   Point of a path used to define a profile

    handle_type_1
    :   Path interpolation at this point

        Type:
        :   enum in [`'AUTO'`, `'VECTOR'`, `'FREE'`, `'ALIGN'`], default `'FREE'`

    handle_type_2
    :   Path interpolation at this point

        Type:
        :   enum in [`'AUTO'`, `'VECTOR'`, `'FREE'`, `'ALIGN'`], default `'FREE'`

    location
    :   X/Y coordinates of the path point

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

    select
    :   Selection state of the path point

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

The Dot Dash modifier.

Offset
:   Determines the starting offset of the pattern.

Segment
:   Makes up individual stroke of a dot dash pattern.

    Use the plus/minus button on the side of the list to add/remove segments.

Dash
:   The number of consecutive points from the original stroke to include in this segment.

Gap
:   The number of points skipped after the segment ends.

Radius
:   The factor to apply to the original point’s radius for the new points.

Opacity
:   The factor to apply to the original point’s opacity for the new points.

Material Index
:   Use this index on generated segment, use -1 for existing material.

Use Cyclic
:   Close the segment.

### Influence Filters

See [Influence Filters](../introduction.html#grease-pencil-modifier-influence-filters).
user: Show practical ways to work with Blender Landmarks in a Blender add-on or script – include code.

assistant: Each Open Project places new demands on Blender as a 3D creation suite, which in turn leads to further upgrades. While
a complete list of updates is beyond the scope of this article, some milestones are worth noting.

Early 2008 saw the start of the Blender 2.5 project. This combined a major User Interface overhaul, with new tool
definitions, a data access system, event handling, and a new animation system. For 2.5, the primary goal was to bring
the interface standards and input methods up to date.

Cycles is Blender’s production-capable path-tracing render engine, first incorporated into release 2.61, back in 2011.
Over the years, Cycles has introduced support for a wide range of rendering possibilities, including AMD and NVIDIA.
Similarly, it’s grown to include support for many features including hair, motion blur, smoke and fire, major shaders
and materials, adaptive subdivisions, and much more.

With its watershed 2.8 release in July, 2019, Blender broke into the 3D mainstream. Starting with a drastically
revamped User Interface, the 2.8 series included a multitude of innovations, from EEVEE (a real-time render engine),
to new remeshing options for sculptors, to the integration of Mantaflow, to a fully functioning 2D animation workspace
that also offered the possibility of a 2D/3D hybrid workflow.

Although industry recognition for Blender had grown over the decades, 2.8 marked the moment when it was widely
accepted as a legitimate alternative to paid competitors. As well as using Blender in their own projects, some of the
world’s largest and most recognized companies became regular contributors to the Blender Development Fund, ensuring
that Blender can continue to innovate.

As well as Blender and Open Projects made with Blender, there’s Blender Cloud. This subscription-based Open Production
platform provides rolling updates on current Open Movie projects, as well as an archive of film assets in .blend file
form, animation and shot breakdowns, shaders and textures, and comprehensive training videos from professional artists
and developers, often those employed at Blender HQ in Amsterdam.
user: What is Toggle Cyclic and how is it used in Blender Python scripting?

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

assistant: # Introduction

[image reference removed]

The Vertex Groups panel.

Vertex groups are primarily used to tag vertices that belong to specific parts of a mesh or [Lattice](../../../../glossary/index.xhtml#term-Lattice) object.
For example, they can represent the legs of a chair, the hinges of a door, or the arms, hands, and head of a
character.

Each vertex group can store a weight value for each vertex it includes. These weights are in the range of 0 to 1 and
are used by many operators, tools, and modifiers, which is why vertex groups are sometimes also referred to as “weight
groups”.
user: Describe Tabs from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Top: Horizontal Tab header in the Topbar.
Bottom: Vertical Tab header shows tab icons in the Properties.

Tabs are used to control overlapping sections in the user interface.
The content of only one Tab is visible at a time.
Tabs are listed in a *Tab header*, which can be horizontal or vertical.

### Switching/Cycling

Vertical tabs can be switched with `Ctrl`-`Wheel` from anywhere in the tab.
You can also cycle through tabs with `Ctrl`-`Tab` and
`Shift`-`Ctrl`-`Tab`, or press down `LMB` and move the mouse over the tab header icons.
Pressing `NumpadPeriod` scrolls to the active tab in case it is out of view.

Note, these shortcuts does not apply to Workspace tabs; see [Workspace controls](workspaces.xhtml#workspaces-controls).
user: How do I use Bevel Vertices in Blender? Include parameters, examples, warnings and best practices.

assistant: # Bevel Vertices

The *Bevel* tool rounds off edges or corners of a mesh at the point of the selected vertices.
In “vertex only” mode, the *Bevel Vertices* tool works on selected vertices
but the option to switch to *Bevel Edges* is available.
By doing so, more vertices are added in order to smooth out profiles with a specified number of *segments*
(see the options below for details about the bevel algorithm).

[image reference removed]

Cubes with and without bevel.
user: Show practical ways to work with FunctionNodeEulerToRotation(FunctionNode) in a Blender add-on or script – include code.

assistant: # FunctionNodeEulerToRotation(FunctionNode)

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

*class* bpy.types.FunctionNodeEulerToRotation(*FunctionNode*)
:   Build a rotation from separate angles around each axis

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

assistant: Steps
:   Specifies how many copies will be extruded along the “sweep”.

Angle
:   Specifies the angle “swept” by this tool, in degrees (e.g. set it to 180 for half a turn).

Auto Merge
:   Automatically merges the first a last duplicates,
    if they make a full revolution which results in overlapping geometry.

Flip Normals
:   Reverses the [Normal’s](../../../glossary/index.html#term-Normal) direction for any resulting geometry.

Center X, Y, Z
:   Specifies the center of the spin. By default it uses the cursor position.

Axis X, Y, Z
:   Specify the spin axis as a vector. By default it uses the view axis (viewport).
user: Explain IMAGE_UL_udim_tiles(UIList) in complete detail according to the official Blender documentation.

assistant: # IMAGE_UL_udim_tiles(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.IMAGE_UL_udim_tiles(*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: Give a detailed overview of GeometryNodeMeshBoolean(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeMeshBoolean(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.GeometryNodeMeshBoolean(*GeometryNode*)
:   Cut, subtract, or join multiple mesh inputs

    operation
    :   - `INTERSECT`
          Intersect – Keep the part of the mesh that is common between all operands.
        - `UNION`
          Union – Combine meshes in an additive way.
        - `DIFFERENCE`
          Difference – Combine meshes in a subtractive way.

        Type:
        :   enum in [`'INTERSECT'`, `'UNION'`, `'DIFFERENCE'`], default `'INTERSECT'`

    solver
    :   - `EXACT`
          Exact – Slower solver with the best results for coplanar faces.
        - `FLOAT`
          Float – Simple solver with good performance, without support for overlapping geometry.
        - `MANIFOLD`
          Manifold – Fastest solver that works only on manifold meshes but gives better results.

        Type:
        :   enum in [`'EXACT'`, `'FLOAT'`, `'MANIFOLD'`], default `'FLOAT'`

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

assistant: Sets the [easing mode](properties.xhtml#editors-graph-fcurves-settings-easing) of the selected keyframes.
This determines whether easing is applied to the left side, right side, or both sides of the
curve segments between each keyframe and the next.
user: How do I use NodeSocketVectorDirection(NodeSocketStandard) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeSocketVectorDirection(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.NodeSocketVectorDirection(*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 3 items in [-inf, inf], default (0.0, 0.0, 0.0)

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: An empty can only be edited in Object Mode, which includes its transformation and parenting properties.
For other tools see the [Object section](../scene_layout/object/index.xhtml).

Apply Scale `Ctrl`-`A`
:   While empties don’t exactly have any object data attached to them which can be used for supporting
    “true” apply scale (i.e. with non-uniform scaling), they do have *Display Size* which controls how
    large the empties are displayed (before scaling). This works by taking the scale factor on the most-scaled axis,
    and combines this with the existing empty *Display Size* to maintain the correct dimensions on that axis.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.asset`](bpy.context.html#bpy.context.asset "bpy.context.asset") - [`bpy.context.selected_assets`](bpy.context.html#bpy.context.selected_assets "bpy.context.selected_assets") - [`AssetShelf.asset_poll`](bpy.types.AssetShelf.html#bpy.types.AssetShelf.asset_poll "bpy.types.AssetShelf.asset_poll") | - [`AssetShelf.draw_context_menu`](bpy.types.AssetShelf.html#bpy.types.AssetShelf.draw_context_menu "bpy.types.AssetShelf.draw_context_menu") - [`Context.asset`](bpy.types.Context.html#bpy.types.Context.asset "bpy.types.Context.asset") |
user: How do I use BlendDataLights(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

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

assistant: # Beautify Faces

*Beautify Faces* works only on selected existing faces.
It rearrange selected triangles to obtain more “balanced” ones (i.e. less long thin triangles).

Max Angle
:   An angle delimiter option to limit edge rotation to flat surfaces.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_face_beautify-faces_before.png   Text converted to a mesh. | ../../../../_images/modeling_meshes_editing_face_beautify-faces_after.png   Result of Beautify Faces. |
user: Describe Bpy.Types.Particleinstancemodifier from the Blender manual or Python API, including usage steps and snippets.

assistant: Modifier.bl_rna_get_subclass() ParticleInstanceModifier.bl_rna_get_subclass_py() Inherited Properties Inherited Functions