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

assistant: # TextBox(bpy_struct)

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

*class* bpy.types.TextBox(*bpy_struct*)
:   Text bounding box for layout

    height
    :   Type:
        :   float in [0, inf], default 0.0

    width
    :   Type:
        :   float in [0, inf], default 0.0

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Light Settings (EEVEE) and how is it used in Blender Python scripting?

assistant: # Light Settings (EEVEE)

Besides lighting from the background and materials with emission shaders,
lights are another way to add light into the scene.
The difference is that they are not directly visible in the rendered image,
and can be more easily managed as objects of their own type.

See [Light settings](../lights/light_object.xhtml) for settings common to all renderers.
user: Provide the full official documentation entry for Add Marker, preserving all code examples.

assistant: Places a new marker at the position of the mouse
(which is under the button in this case, not ideal but it is just how things work)
and then it can be moved to the needed location. When it is moved to the desired position,
`LMB` can be used to finish placing the new marker.
Also, `Return` and `Spacebar` can be used to finish placing the marker.
But it is faster to use `Ctrl`-`LMB` to place markers directly on the footage.
This shortcut will place the marker in the place you have clicked.

In addition to this until you have released the mouse button,
you can adjust the marker position by moving the mouse and
using the track preview widget to control how accurately the marker is placed.
user: Explain New Edge/Face from Vertices in complete detail according to the official Blender documentation.

assistant: # New Edge/Face from Vertices

This is a context-sensitive tool which creates geometry by filling in the selection.
When only two vertices are selected it will create an edge, otherwise it will create faces.

The typical use case is to select vertices and press `F`,
yet Blender also supports creating faces from different selections to help to
quickly build up geometry.
user: Provide the full official documentation entry for Interpolate Sequence, preserving all code examples.

assistant: Interpolate strokes between the previous and next keyframe by adding *multiple* keyframes.
When you are on a frame between two keyframes and click the sequence button
a breakdown keyframe will be added on every frame between the previous and next keyframe.

Step
:   The number of frames between generated interpolated frames.

Layer
:   Restrict the interpolation to Active or All layers.

Only Selected Edit Mode
:   When enabled, only selected strokes will be interpolated.

Exclude Breakdowns
:   Exclude existing [Breakdowns keyframes](../../animation/keyframes/introduction.xhtml#keyframe-type) as interpolation extremes.

Flip Mode
:   Invert strokes start and end. Automatic will try to found the right mode for every stroke.

Smooth
:   Amount of smoothing to apply to interpolated strokes for reducing jitter/noise.

Iterations
:   Number of time to smooth newly created strokes.

Type
:   Interpolation method to use for the sequence.
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Noise Texture with high detail.

Different Noise types with the same parameters.

|  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_textures_musgrave_example-type-fbm.jpg   fBM (fractal Brownian Motion). | ../../../_images/render_shader-nodes_textures_musgrave_example-type-multifractal.jpg   Multifractal. |
| ../../../_images/render_shader-nodes_textures_musgrave_example-type-hybrid.jpg   Hybrid Multifractal. | ../../../_images/render_shader-nodes_textures_musgrave_example-type-terrain.jpg   Heterogeneous Terrain. |
| ../../../_images/render_shader-nodes_textures_musgrave_example-type-ridged.jpg   Ridged Multifractal. |  |
user: Give a detailed overview of Mask Extract: syntax, arguments, return values, common patterns.

assistant: Creates a duplicate mesh object based on masked geometry.
The extracted geometry is also further processed by default for a cleaner result.

Threshold
:   Minimum mask value to consider the vertex valid to extract a face from the original mesh.

Add Boundary Loop
:   Creates and extra boundary loop on the edges of the geometry,
    making it easier smooth the boundaries and apply additional modifiers.

Smooth Iterations
:   Smooth iterations applied to the extracted mesh.

Project to Sculpt
:   Project the extracted mesh on to the original sculpt object.

Extract as Solid
:   Adds a [Solidify Modifier](../../../modeling/modifiers/generate/solidify.xhtml) to the newly created mesh object.
user: Show practical ways to work with Brush Settings in a Blender add-on or script – include code.

assistant: # Brush Settings

[image reference removed]

Brush settings panel.

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

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

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

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

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

[Cursor](../../brush/cursor.xhtml)
:   Cursor and appearance settings.
user: Give a detailed overview of Tone Map Node: syntax, arguments, return values, common patterns.

assistant: # Tone Map Node

[image reference removed]

Tone mapping is used to map high dynamic range colors into a more limited dynamic
range supported by the display, while preserving the appearance as much as possible.

This is a legacy node. It is recommended to use view transforms in the
color management settings instead, and output linear high dynamic range images
from the compositor instead of low dynamic range.
user: Explain Deflection in complete detail according to the official Blender documentation.

assistant: Size Deflect
:   Use the particle size in deflections.

Die on Hit
:   Kill particle when it hits a deflector object.

Collision Collection
:   If set, particles collide with objects from the collection.
user: Provide the full official documentation entry for Named Attribute Node, preserving all code examples.

assistant: # Named Attribute Node

[image reference removed]

The *Named Attribute* node outputs the data of an attribute based on the
context of where it is connected (the [Field Context](../../fields.xhtml#field-context)).
user: Show practical ways to work with Main Region in a Blender add-on or script – include code.

assistant: The editor displays a stack of [tracks](tracks.html) which work like layers in an image editing
program. Higher tracks take precedence over lower ones, although you can also choose to blend them.

Each track can contain any number of [strips](strips.html) – typically Action Strips,
which are instances of actions.

The top track highlighted in orange is special: this is the Action Track. Unlike the other tracks,
it doesn’t contain strips – instead, it contains the object’s *active action*,
which is where new keyframes are added to by default.

Editors like the [Dope Sheet Editor](../dope_sheet/introduction.html)
normally only show the keyframes of this active action. If you want to edit another action,
you can select it in the NLA editor and press `Tab` to enter Tweak Mode.

[image reference removed]

Tweaking an action. Notice that it’s shown in both its original track and the Action Track.
The active action is temporarily hidden.
user: Provide the full official documentation entry for Bake Object Transform to Grease Pencil, preserving all code examples.

assistant: Applies all transform animation at Object level within a selected frame range to Grease Pencil object keyframes.

Start Frame, End Frame
:   Start/End frame for the baking process.

Step
:   Frame steps for the baking process.

Only Selected Keyframes
:   Convert only the selected keyframes.

Target Frame
:   Target destination frame for the baked animation.

Projection Type
:   Sets the projection type to use for the converted strokes.
user: What is Levels and how is it used in Blender Python scripting?

assistant: Adds an offset and a scale to all weights of the selected weight groups.
with this tool you can raise or lower the overall “heat” of the weight group.

[image reference removed]

Levels example.

Subset
:   Restrict the tool to a subset.
    See above [The Subset Option](#sculpt-paint-weight-paint-editing-subset) for how subsets are defined.

Offset
:   A value from the range (-1.0 - 1.0) to be added to all weights in the vertex group.

Gain
:   All weights in the Subset are multiplied with the gain.
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: [image reference removed]

The difference between *F1* and *Smooth F1* can be used to create beveled Voronoi cells.

[image reference removed]

Creating a hammered metal shader using the *Voronoi Texture* node.
user: How do I use Armature Deform Parent in Blender? Include parameters, examples, warnings and best practices.

assistant: # Armature Deform Parent

Armature Deform Parenting is a way of creating and setting up
an [Armature Modifier](../../../modeling/modifiers/deform/armature.xhtml).

To use *Armature Deform Parenting* you must first select all the child objects that will be
influenced by the armature and then lastly, select the armature object itself.
Once all the child objects and the armature are selected, press `Ctrl`-`P` and
select *Armature Deform* in the *Set Parent To* pop-up menu.

The armature will be the parent object of all the other child objects and each child object
will have an Armature Modifier with the armature associated (*Object* field).

[image reference removed]

Bone associated with Mesh Object.
user: Describe Un-Subdivide from the Blender manual or Python API, including usage steps and snippets.

assistant: # Un-Subdivide

Un-subdivide functions as the reverse of subdivide by attempting to remove edges
that were the result of a subdivide operation.
If additional editing has been done after the subdivide operation,
unexpected results may occur.

Iterations
:   How many subdivisions to remove.
user: What is Inherited Properties and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleColorModifier.name`](bpy.types.LineStyleColorModifier.html#bpy.types.LineStyleColorModifier.name "bpy.types.LineStyleColorModifier.name") |
user: Show practical ways to work with ShaderNodeInvert(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeInvert(ShaderNode)

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

*class* bpy.types.ShaderNodeInvert(*ShaderNode*)
:   Invert a color, producing a negative

    *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 Arrange/Align Islands in complete detail according to the official Blender documentation.

assistant: Arranges the selected UV islands along a straight line on the UV grid.
This operator can align islands horizontally or vertically, with customizable
starting positions, alignment reference, sorting order, and spacing.

This is useful for organizing UV layouts, aligning modular texture pieces, or
arranging UDIM tiles consistently.

Initial Position
:   Determines the reference point used to calculate the initial alignment.

    Bounding Box:
    :   Uses the bounding boxes of the selected islands.

    UV Grid:
    :   Aligns islands relative to the UV grid origin (0-1 UV tile).

    Active UDIM:
    :   Aligns islands based on the active UDIM tile.

    2D Cursor:
    :   Uses the current position of the 2D cursor as the origin.

Axis
:   The axis along which to arrange UV islands.

    X:
    :   Align UV islands horizontally.

    Y:
    :   Align UV islands vertically.

Align
:   Determines how the islands are aligned relative to each other.

    Min:
    :   Aligns islands by their minimum boundary.

    Max:
    :   Aligns islands by their maximum boundary.

    Center:
    :   Aligns islands by the center of the largest island.

    None:
    :   Keeps each island’s original offset and alignment.

Order
:   Specifies how to order the islands along the chosen axis.

    Largest to Smallest:
    :   Sorts islands by area, from largest to smallest.

    Smallest to Largest:
    :   Sorts islands by area, from smallest to largest.

    Fixed:
    :   Keeps the current selection order.

Margin
:   Defines the space between arranged islands, measured in UV units.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Points
:   The input points that define the centers of the generated SDF regions.

Radius
:   The radius of influence for each point, defining how far the signed
    distance extends from the point center. Each point is treated as a sphere
    with this radius.

Voxel Size
:   The size of each voxel in object space units.
    Smaller voxel sizes yield higher-resolution fields that better capture
    fine detail, at the cost of increased memory and processing time.
user: Describe MaskSplinePoints(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # MaskSplinePoints(bpy_struct)

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

*class* bpy.types.MaskSplinePoints(*bpy_struct*)
:   Collection of masking spline points

    add(*count*)
    :   Add a number of point to this spline

        Parameters:
        :   **count** (*int in* *[**0**,* *inf**]*) – Number, Number of points to add to the spline

    remove(*point*)
    :   Remove a point from a spline

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

    *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 MaskSplinePoints(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # MaskSplinePoints(bpy_struct)

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

*class* bpy.types.MaskSplinePoints(*bpy_struct*)
:   Collection of masking spline points

    add(*count*)
    :   Add a number of point to this spline

        Parameters:
        :   **count** (*int in* *[**0**,* *inf**]*) – Number, Number of points to add to the spline

    remove(*point*)
    :   Remove a point from a spline

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Falloff and how is it used in Blender Python scripting?

assistant: # Falloff

The *Falloff* is a curve that determines how the strength of the brush decreases
with increasing distance from the center. You can set up a custom curve or choose
a predefined one.

[image reference removed]

Brush falloff example.

Curve Preset
:   Custom
    :   Shows a [Curve Widget](../../interface/controls/templates/curve.xhtml) for configuring a custom falloff.
        The left side of the curve corresponds to the center of the brush while the right side
        corresponds to the edge.

    Predefined
    :   The predefined falloff curves look as follows:

        Built-in falloff curves

        |  |  |  |
        | --- | --- | --- |
        | ../../_images/sculpt-paint_brush_falloff_smooth.png   Smooth | ../../_images/sculpt-paint_brush_falloff_smoother.png   Smoother | ../../_images/sculpt-paint_brush_falloff_sphere.png   Sphere |
        | ../../_images/sculpt-paint_brush_falloff_root.png   Root | ../../_images/sculpt-paint_brush_falloff_sharp.png   Sharp | ../../_images/sculpt-paint_brush_falloff_linear.png   Linear |
        | ../../_images/sculpt-paint_brush_falloff_sharper.png   Sharper | ../../_images/sculpt-paint_brush_falloff_invsquare.png   Inverse Square | ../../_images/sculpt-paint_brush_falloff_constant.png   Constant |

Falloff Shape
:   Determines how the falloff distance is calculated.

    Sphere:
    :   The falloff is calculated using a sphere in three-dimensional world space.
        If two points on the mesh appear near each other in the 3D Viewport but are
        far away in the world, painting one will not affect the other.

    Projected:
    :   The falloff is calculated using a circle in two-dimensional screen space.
        If two points on the mesh appear near each other in the 3D Viewport, painting
        one will also affect the other, no matter their distance in the world.

    Texture Paint Mode does not have this option – it always uses *Projected*.

Normal Falloff / Front-Face Falloff
:   Weakens the brush strength for faces whose normal points towards the screen edges
    instead of the camera.

    This feature is not available in Sculpt Mode.

    Angle
    :   The minimum angle between the face normal and the viewing direction for the
        falloff to start.
user: Give a detailed overview of Noise: syntax, arguments, return values, common patterns.

assistant: # Noise

Adding noise to the gas simulation creates a finer detailed looking simulation on top of the base.
This makes it possible to add more details to gases (i.e. fire or smoke or both) without changing
the overall fluid motion.

Besides enabling parts of the interface, checking *Noise* lets the cache know
which simulation data to read. If, for example, *Noise* is enabled but
there is no noise simulation data to read it will show an empty domain.
The checkbox does not reset the cache and can be used to switch
the view between base resolution and noise view.

Upres Factor
:   Factor by which to enhance the resolution of the noise. The scaling factor is coupled
    to the [Resolution Divisions](../settings.xhtml#bpy-types-fluiddomainsettings-resolution-max).

Strength
:   Strength of the noise. Higher values result in more turbulent vortices.

Scale
:   Scale of the noise. Greater values result in larger vortices.

Time
:   Animation time of the noise. This value has an influence on where the noise field is evaluated.
    It can be used as a seed to give wavelet noise a slightly different look in two domains that are
    otherwise the same.

    Smoke plume with varying animation time. While the fluid motion of all four smoke
    plumes are alike each example has a unique look.

    |  |  |
    | --- | --- |
    | ../../../../../_images/physics_fluid_type_domain_gas_noise_timeanim-0-1.png   Animation Time: 0.1 | ../../../../../_images/physics_fluid_type_domain_gas_noise_timeanim-1-0.png   Animation Time: 1.0 |
    | ../../../../../_images/physics_fluid_type_domain_gas_noise_timeanim-2-5.png   Animation Time: 2.5 | ../../../../../_images/physics_fluid_type_domain_gas_noise_timeanim-10-0.png   Animation Time: 10.0 |

    Comparison of fire simulations with and without noise at the same grid
    resolution.

    |  |  |
    | --- | --- |
    | ../../../../../_images/physics_fluid_type_domain_gas_noise_base-res-1.png   Resolution Divisions: 200, without noise | ../../../../../_images/physics_fluid_type_domain_gas_noise_base-res-2.png   Resolution Divisions: 100, Noise scale: 2. |

    Low division simulations with lots of *Upres Factor* divisions generally appear smaller in
    real-world scale and can be used to achieve pyroclastic plumes such as in the following image:

    [image reference removed]

Bake Noise, Free Noise
:   This option is only available when using the [Modular](../cache.xhtml#bpy-types-fluiddomainsettings-cache-type) cache type.

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

    Once the simulation has been baked, the cache can be deleted by pressing *Free Noise*.
    It is possible to pause or resume a *Bake Noise* process.
user: What is S-Curves and how is it used in Blender Python scripting?

assistant: # S-Curves

The curve type used for creating mask splines is almost a Bézier curve, but with some differences.
Smooth edges of the mask are defined by feathering.
The curve needed to support feathering in a way that stuck to the curve as you edited it,
for ease of editing an animation. These are called S-curves.

Besides the handles, every control point also has points that define the feather between
the current point and the next point on the spline.
Each feather point is stored in UW space,
where U means position across spline segment, and W (weight) means distance between main spline and feather points.

[image reference removed]

S-Curve explained.

This allows for deforming the main spline in almost any way,
and the feather will be updated automatically to reflect that change.

For example if there is just rotation of the spline,
feather would stay completely unchanged. If one point’s feather is moved,
the other feathers will be automatically stretched uniformly along that segment
and the overall shape will be almost the same as artists would want it to be.
user: Show practical ways to work with Space in a Blender add-on or script – include code.

assistant: While object positions, vertex locations are not clamped, larger values become increasingly imprecise.
To get an idea of the precision you can work with using different scales.
Here’s a table of scales and their associated accuracy:

10:
:   1/1,048,576th

100:
:   1/131,072th

1,000:
:   1/16,384th

10,000:
:   1/1,024th

100,000:
:   1/128th

1,000,000:
:   1/16th
user: Show practical ways to work with ShaderNodeEmission(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeEmission(ShaderNode)

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

*class* bpy.types.ShaderNodeEmission(*ShaderNode*)
:   Lambertian emission shader

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

assistant: # GeometryNodeFieldToGrid(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.GeometryNodeFieldToGrid(*GeometryNode*)
:   Create new grids by evaluating new values on an existing volume grid topology

    active_index
    :   Index of the active item

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

    active_item
    :   Index of the active item

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

    data_type
    :   Data type for topology grid

        Type:
        :   enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items), default `'FLOAT'`

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe ThemeProperties(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ThemeProperties(bpy_struct)

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

*class* bpy.types.ThemeProperties(*bpy_struct*)
:   Theme settings for the Properties

    match
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    space
    :   Settings for space

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

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

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

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.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 Setting the Active Camera in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Active camera (left) displayed with a solid triangle above it.

This sets the current active object as the active camera and switches to the camera view.

The active camera is the one that will be used for rendering,
and which you’ll look through when choosing camera view.

Another way of setting the active camera is through the *Scene* tab of the
[Properties](../../properties_editor.xhtml).

### Animated Camera Switching

While a scene contains only one camera by default, it’s possible to have multiple.
You can then bind the cameras to specific time points in your animation
to create jump cuts showing different viewpoints.
See [Animating Cameras](../../../animation/markers.xhtml#bpy-ops-marker-camera-bind).
user: Provide the full official documentation entry for Inputs, preserving all code examples.

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: Give a detailed overview of Rip Vertices and Fill: syntax, arguments, return values, common patterns.

assistant: # Rip Vertices and Fill

Rip fill works the same as the Rip tool above, but instead of leaving a hole,
it fills in the gap with geometry.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_vertex_rip-vertices_edges-before.png>   Edges selected. | <../../../../_images/modeling_meshes_editing_vertex_rip-vertices-fill_result.png>   Result of rip fill. |
user: Give a detailed overview of Mask Slice: syntax, arguments, return values, common patterns.

assistant: Removes the masked vertices from the mesh.

Threshold
:   Minimum mask value to consider the vertex valid to extract a face from the original mesh.

Fill Holes
:   Fills concave holes with geometry that might have resulted from the *Mask Slice* operation.

Slice to New Object
:   Create a new object from the masked geometry.
user: Provide the full official documentation entry for KeyingSet(bpy_struct), preserving all code examples.

assistant: # KeyingSet(bpy_struct)

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

*class* bpy.types.KeyingSet(*bpy_struct*)
:   Settings that should be keyframed together

    bl_description
    :   A short description of the keying set

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

    bl_idname
    :   If this is set, the Keying Set gets a custom ID, otherwise it takes the name of the class used to define the Keying Set (for example, if the class name is “BUILTIN_KSI_location”, and bl_idname is not set by the script, then bl_idname = “BUILTIN_KSI_location”)

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

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

    is_path_absolute
    :   Keying Set defines specific paths/settings to be keyframed (i.e. is not reliant on context info)

        Type:
        :   boolean, default False, (readonly)

    paths
    :   Keying Set Paths to define settings that get keyframed together

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

    type_info
    :   Callback function defines for built-in Keying Sets

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

    use_insertkey_needed
    :   Only insert keyframes where they’re needed in the relevant F-Curves

        Type:
        :   boolean, default False

    use_insertkey_override_needed
    :   Override default setting to only insert keyframes where they’re needed in the relevant F-Curves

        Type:
        :   boolean, default False

    use_insertkey_override_visual
    :   Override default setting to insert keyframes based on ‘visual transforms’

        Type:
        :   boolean, default False

    use_insertkey_visual
    :   Insert keyframes based on ‘visual transforms’

        Type:
        :   boolean, default False

    refresh()
    :   Refresh Keying Set to ensure that it is valid for the current context (call before each use of one)

    *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 StripTransform(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # StripTransform(bpy_struct)

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

*class* bpy.types.StripTransform(*bpy_struct*)
:   Transform parameters for a sequence strip

    filter
    :   Type of filter to use for image transformation

        - `AUTO`
          Auto – Automatically choose filter based on scaling factor.
        - `NEAREST`
          Nearest – Use nearest sample.
        - `BILINEAR`
          Bilinear – Interpolate between 2×2 samples.
        - `CUBIC_MITCHELL`
          Cubic Mitchell – Cubic Mitchell filter on 4×4 samples.
        - `CUBIC_BSPLINE`
          Cubic B-Spline – Cubic B-Spline filter (blurry but no ringing) on 4×4 samples.
        - `BOX`
          Box – Averages source image samples that fall under destination pixel.

        Type:
        :   enum in [`'AUTO'`, `'NEAREST'`, `'BILINEAR'`, `'CUBIC_MITCHELL'`, `'CUBIC_BSPLINE'`, `'BOX'`], default `'AUTO'`

    offset_x
    :   Move along X axis

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

    offset_y
    :   Move along Y axis

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

    origin
    :   Origin of image for transformation

        Type:
        :   float array of 2 items in [-inf, inf], default (0.0, 0.0)

    rotation
    :   Rotate around image center

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

    scale_x
    :   Scale along X axis

        Type:
        :   float in [0, inf], default 1.0

    scale_y
    :   Scale along Y axis

        Type:
        :   float in [0, inf], default 1.0

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # TextureNodeRGBToBW(TextureNode)

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

*class* bpy.types.TextureNodeRGBToBW(*TextureNode*)
:   *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 Polygonization in complete detail according to the official Blender documentation.

assistant: # Polygonization

The *Polygonization* modifier simplifies strokes as much as possible
(in other words, it transforms smooth strokes into jagged polylines).

Error
:   The maximum distance allowed between the new simplified stroke and the original one
    (the larger this value is, the more jagged/approximated the resulting polylines are).
user: Describe Curve Display from the Blender manual or Python API, including usage steps and snippets.

assistant: # Curve Display

When in Edit Mode, curves have special [overlays](../../editors/3dview/display/overlays.xhtml)
to control how curves are displayed in the 3D Viewport.

Handles
:   Controls the visibility of Bézier curve handles in edit mode.

    None:
    :   Hides all Bézier curve handles, providing an unobstructed view of the curve.

    Selected:
    :   Displays the handles only for selected control points.

    All:
    :   Displays the handles for all control points in the curve.

Normals
:   Toggles the display of the curve normals.

    Normal Size
    :   Length of the axis that points the direction of the normal.
user: What is Contrast Brushes and how is it used in Blender Python scripting?

assistant: [image reference removed]

Recognizable by their red thumbnail and cursor.
These brushes generally flatten or heighten the contrast of the surface.

Smooth
:   Brush Type: [Smooth](smooth.xhtml)

    Shortcut: `S`

    Smooths out irregularities in the surface and shrinks volumes by averaging the vertices positions.
    An essential brush that is frequently used.

Flatten/Contrast
:   Brush Type: [Plane](plane.xhtml)

    Pushes vertices to an average height to create a flat surfaces. Alternatively pushes them away from the center for
    more contrast.

Plateau
:   Brush Type: [Plane](plane.xhtml)

    Similar to Flatten but with a locked orientation and depth to create a consistently flat surface.

Fill/Deepen
:   Brush Type: [Plane](plane.xhtml)

    Pushes surfaces upwards towards a flat plane. Useful for filling in holes and crevices. Alternatively deepens
    existing holes when holding ‘Ctrl’.

Scrape/Fill
:   Brush Type: [Plane](plane.xhtml)

    Shortcut: `Shift` `T`

    Pushes surfaces inwards. Alternatively fills surfaces while holding ‘Ctrl’. This is the most common brush for
    flattening meshes.

Trim
:   Brush Type: [Plane](plane.xhtml)

    Pushes surfaces inwards toward a locked direction. The depth can be defined by going deeper towards surfaces along
    the stroke.

Scrape Multiplane
:   Brush Type: [Scrape Multiplane](multiplane_scrape.xhtml)

    Scrapes the mesh with two angled planes at the same time, producing a sharp edge between them.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`AssetRepresentation.metadata`](bpy.types.AssetRepresentation.html#bpy.types.AssetRepresentation.metadata "bpy.types.AssetRepresentation.metadata") - [`FileSelectEntry.asset_data`](bpy.types.FileSelectEntry.html#bpy.types.FileSelectEntry.asset_data "bpy.types.FileSelectEntry.asset_data") | - [`ID.asset_data`](bpy.types.ID.html#bpy.types.ID.asset_data "bpy.types.ID.asset_data") |
user: Provide the full official documentation entry for Bend, preserving all code examples.

assistant: # Bend

Bend Transform with Clamp on and off.

|  |  |  |
| --- | --- | --- |
| ../../../../../_images/modeling_meshes_editing_mesh_transform_bend_example-clamp-1.png   Before. | ../../../../../_images/modeling_meshes_editing_mesh_transform_bend_example-clamp-2.png   Clamp on. | ../../../../../_images/modeling_meshes_editing_mesh_transform_bend_example-clamp-3.png   Clamp off. |

This tool rotates a line of selected elements forming an arc between the mouse cursor and the 3D cursor.
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

Materials control the appearance of meshes, curves, volumes and other objects.
They define the substance that the object is made of, its color and texture,
and how light interacts with it.

Physically based materials can be created using
the [Principled BSDF](../shader_nodes/shader/principled.xhtml),
[Principled Hair](../shader_nodes/shader/hair_principled.xhtml),
and [Principled Volume](../shader_nodes/shader/volume_principled.xhtml) shaders.
With these uber shaders, a wide variety of materials including
plastic, glass, metal, cloth, skin, hair, smoke and fire can be created.

A flexible [shading nodes](../shader_nodes/introduction.xhtml) system is used
to set up textures and create entirely different types of materials like toon shading.
user: How do I use Shade Flat in Blender? Include parameters, examples, warnings and best practices.

assistant: Signify the object to render and display faces uniformly,
using the [Face Normal’s](../../../modeling/meshes/structure.xhtml#modeling-meshes-structure-normals) direction.
This is usually desirable for objects with flat surfaces.

This operator will also remove any [Smooth By Angle Modifiers](../../../modeling/modifiers/normals/smooth_by_angle.xhtml)

Keep Sharp Edges
:   Do not clear sharp edges (which are redundant with objects shaded as flat).
    This option is useful to not destroy data in case you want to revert changes later.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeForeachGeometryElementOutput.generation_items`](bpy.types.GeometryNodeForeachGeometryElementOutput.html#bpy.types.GeometryNodeForeachGeometryElementOutput.generation_items "bpy.types.GeometryNodeForeachGeometryElementOutput.generation_items") |  |