PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe Transform Panel from the Blender manual or Python API, including usage steps and snippets.

assistant: # Transform Panel

This panel contains the properties of the selected control points.
If multiple points are selected, it shows the averages of the values,
and allows changing those values for all the points in one go.

Control Point
:   X, Y, Z
    :   The coordinates of the control point.

    W
    :   The [weight](../structure.xhtml#modeling-surfaces-weight) of the control point.
        The higher the weight, the more the control point pulls the surface towards itself.

Space
:   Whether the coordinates are in object space (Local) or in world space (Global).

Weight
:   The “goal weight” when using [Soft Body](../../../physics/soft_body/index.xhtml) physics.
    Higher values make the surface “stiffer” at that control point (as in, the control
    point will stay close to its original location, preventing deformation).

Radius
:   Not applicable for Surface objects.

Tilt
:   Not applicable for Surface objects.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Position
:   Position of the shading point.

Normal
:   Shading normal at the surface (includes smooth normals and bump mapping).

Tangent
:   Tangent at the surface.

True Normal
:   Geometry or flat normal of the surface.

Incoming
:   Vector pointing towards the point the shading point is being viewed from.

Parametric
:   Parametric coordinates of the shading point on the surface.
    To area lights it outputs its UV coordinates in planar mapping and
    in spherical coordinates to point lights.

Backfacing
:   1.0 if the face is being viewed from the back side, 0.0 for the front side.

Pointiness Cycles Only
:   An approximation of the curvature of the mesh per vertex.
    Lighter values indicate convex angles, darker values indicate concave angles.
    It allows you to do effects like dirt maps and wear-off effects.

Random per Island Cycles Only
:   A random value for each connected component (island) of the mesh.
    It is useful to add variations to meshes composed of separated units
    like tree leaves, wood planks, or curves of multiple splines.

    [image reference removed]

    Get a random value for each instance of the mesh when using an Array modifier.
user: Describe Adding Text from the Blender manual or Python API, including usage steps and snippets.

assistant: Generally, **you should always translate exactly what is in the text**, and avoid providing updates or extra
information.

But sometimes that is necessary, for example when talking about the manual itself: To a foreign reader it is not
clear, that they can contribute English text only, whereas this is obvious to an English reader.

In these (rare) cases you can and should provide extra information.
user: Explain EdgeSplitModifier(Modifier) in complete detail according to the official Blender documentation.

assistant: # EdgeSplitModifier(Modifier)

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

*class* bpy.types.EdgeSplitModifier(*Modifier*)
:   Edge splitting modifier to create sharp edges

    split_angle
    :   Angle above which to split edges

        Type:
        :   float in [0, 3.14159], default 0.523599

    use_edge_angle
    :   Split edges with high angle between faces

        Type:
        :   boolean, default True

    use_edge_sharp
    :   Split edges that are marked as sharp

        Type:
        :   boolean, default True

    *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 BoidRuleAverageSpeed(BoidRule), preserving all code examples.

assistant: # BoidRuleAverageSpeed(BoidRule)

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

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

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

    speed
    :   Percentage of maximum speed

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

    wander
    :   How fast velocity’s direction is randomized

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: The outputs of the *Evaluate Closure* node depend on its current configuration:

- **When a closure is connected** – Each output corresponds to an output socket of the *Closure Zone* with the same name.
- **When no closure is connected** – Outputs are defined manually through the *Output Items* section of the Sidebar.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Curves
:   Either plain curves or curve instances.

Selection
:   Either a curve or instance selection.

Instances as Layers
:   Create a separate layer for each instance. If instances are used, realized curve geometry will be
    ignored. Layer names will use the instance geometry name. If real curve geometry is used, a single
    layer is created with the input geometry’s name.
user: Provide the full official documentation entry for Multiple UV Maps, preserving all code examples.

assistant: A mesh can have more than one UV map, where each map can assign different UV coordinates
to the same 3D vertex. This is useful if, say, you need one UV map for textures and another
for storing [prebaked lighting](../../editing/uv.xhtml#bpy-ops-uv-lightmap-pack).

You can add and remove UV maps in the [UV Maps panel](../uv_texture_spaces.xhtml#uv-maps-panel).
user: Provide the full official documentation entry for Corners of Edge Node, preserving all code examples.

assistant: # Corners of Edge Node

[image reference removed]

Selects a neighboring face corner of an edge and outputs its index.

This node is a bit special because it operates in two different domains.
First, it evaluates a *Weight* for each corner in the geometry.
Then, for each item in the context domain, it will:

- Pick an edge from the geometry based on the *Edge Index*.
- Find *some* (not all) face corners connected to this edge – see below.
- Sort these corners by their associated weight.
- Pick a corner from the above sorted list based on the *Sort Index*,
  where 0 means the corner with the lowest weight,
  1 means the corner with the second-lowest weight and so on.
- Output the geometry-wide index of this corner.

[image reference removed]

A graphic for which corners are returned for a given edge

- Red: selected edge.
- Blue: the corners whose index can be retrieved using this node.
- Purple: the corners that can be retrieved by offsetting the blue corner indices using
  the [Offset Corner in Face Node](offset_corner_in_face.xhtml).
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Geometry
:   Standard geometry input.

Selection
:   Which top-level instances to realize.

Realize All
:   Realize all levels of nested instances for each top-level instances
    (overrides the value of the *Depth* input).

Depth
:   Number of levels of nested instances to realize for each top-level instance.
user: Show practical ways to work with FluidModifier(Modifier) in a Blender add-on or script – include code.

assistant: # FluidModifier(Modifier)

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

*class* bpy.types.FluidModifier(*Modifier*)
:   Fluid simulation modifier

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

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

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

    fluid_type
    :   - `NONE`
          None.
        - `DOMAIN`
          Domain – Container of the fluid simulation.
        - `FLOW`
          Flow – Add or remove fluid to a domain object.
        - `EFFECTOR`
          Effector – Deflect fluids and influence the fluid flow.

        Type:
        :   enum in [`'NONE'`, `'DOMAIN'`, `'FLOW'`, `'EFFECTOR'`], default `'NONE'`

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain NodeGeometryBakeItem(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # NodeGeometryBakeItem(bpy_struct)

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

*class* bpy.types.NodeGeometryBakeItem(*bpy_struct*)
:   attribute_domain
    :   Attribute domain where the attribute is stored in the baked data

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

    color
    :   Color of the corresponding socket type in the node editor

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

    is_attribute
    :   Bake item is an attribute stored on a geometry

        Type:
        :   boolean, default False

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

    socket_type
    :   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'`

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

assistant: Movie Clip
:   Used to select the movie clip whose plane track to use.
    For controls see [Data-Block Menu](../../../interface/controls/templates/data_block.xhtml#ui-data-block).

Object
:   Used to select the object to which the plane track is linked.

Track
:   Used to select the plane track to use.
user: How do I use Recovering Data in Blender? Include parameters, examples, warnings and best practices.

assistant: # Recovering Data

Computer crashes, power outages, or simply forgetting to save can result in the loss or corruption of your work. You
can use Blender’s *Auto Save* feature to reduce the chance of losing files when such events occur.

There are three options to help prevent accidental data loss:

- *Save Prompt* prompts you to save unsaved changes on exit
- *Save Versions* saves additional copies of your blend file with a number appended to the extension
- *Auto Save* saves your file automatically every few minutes (by default, every 2 minutes)
user: Show practical ways to work with Node-Based Tools in a Blender add-on or script – include code.

assistant: # Node-Based Tools

Geometry [node groups](../../interface/controls/nodes/groups.html) can not just be applied to
an object using a modifier. It’s also possible to turn them into tools that can be invoked
from the Blender menu.

You can create such tools in the [Tool Context](#tool-context), after which they appear in the
*Non-Assets* menu of the 3D Viewport. If you want to move them to a different menu,
reuse them in other blend-files, or share them with someone else, you need to turn
them into an asset as described below.

[image reference removed]

Node group tools integrated in the Curves menu.
user: Provide the full official documentation entry for Stanford PLY, preserving all code examples.

assistant: # Stanford PLY

Use the operator to import ASCII or binary PLY-files, you can select multiple files at once.
For exporting, you can choose to enable or disable the modifiers during the export
and you can choose which data you want to export (UV textures, Color Attributes, …).
user: Explain PathCompare(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # PathCompare(bpy_struct)

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

*class* bpy.types.PathCompare(*bpy_struct*)
:   Match paths against this value

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

    use_glob
    :   Enable wildcard globbing

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

assistant: # HueCorrectModifier(StripModifier)

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

*class* bpy.types.HueCorrectModifier(*StripModifier*)
:   Hue correction modifier for sequence strip

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

    open_mask_input_panel
    :   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 Drivers, preserving all code examples.

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

This section lists possible solutions for graphics glitches, problems with EEVEE and Cycles, and crashes related to
your GPU.

# Drivers

Upgrading to the latest graphics drivers often solves problems. Newer drivers have bug fixes that help Blender
function correctly.
user: What is 2D Offset and how is it used in Blender Python scripting?

assistant: # 2D Offset

The *2D Offset* modifier adds some two-dimensional offsets to the stroke backbone geometry.
It has two sets of independent options/effects:

Start, End
:   These two options add the given amount of offset to the start (or end) point of the stroke,
    along the (2D) normal at those points. The effect is blended over the whole stroke, if you for example,
    set only *Start* to 50, the start of the stroke is offset 50 pixels along its normal,
    the middle of the stroke, 25 pixels along its own normal, and the end point is not moved.

X, Y
:   These two options simply add a constant horizontal and/or vertical offset to the whole stroke.
user: How do I use Scenes & Layers in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

These [data-block menus](../controls/templates/data_block.xhtml#ui-data-block) are used to select
the current [Scene](../../scene_layout/scene/index.xhtml) and [View Layer](../../render/layers/index.xhtml).
user: Explain CompositorNodeTree(NodeTree) in complete detail according to the official Blender documentation.

assistant: # CompositorNodeTree(NodeTree)

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

*class* bpy.types.CompositorNodeTree(*NodeTree*)
:   Node tree consisting of linked nodes used for compositing

    use_viewer_border
    :   Use boundaries for viewer nodes and composite backdrop

        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: How do I use Rotation in Blender? Include parameters, examples, warnings and best practices.

assistant: # Rotation

These parameters specify how the individual particles are rotated at the start of,
and during, their lifetime. You can visualize their orientation by setting *Display As*
to *Axis* in the [Viewport Display](display.xhtml) panel.

Orientation Axis
:   Aligns the X axis of new particles to:

    None
    :   The global X axis.

    Normal
    :   The emitter’s surface normal.

    Normal-Tangent
    :   The emitter’s surface normal, additionally aligning the particle’s Y axis to the positive V
        direction in the emitter’s active UV map. This makes it possible to deform the emitter
        while keeping particle rotation consistent.

    Velocity / Hair
    :   The particle’s initial velocity vector/hair growth direction.

    Global X, Y, Z
    :   One of the global axes.

    Object X, Y, Z
    :   One of the emitter’s local axes.

Randomize
:   How much to randomize the particle’s initial rotation (along all axes).

Phase
:   Initial rotation around the particle’s X axis, going from -1 (-180°) to 1 (180°).

Randomize Phase
:   Maximum random rotation to add to the *Phase*, going from 0 (0°) to 2 (360°).

Dynamic
:   Whether the particles’ rotation can change over time.
user: Provide the full official documentation entry for FModifierFunctionGenerator(FModifier), preserving all code examples.

assistant: # FModifierFunctionGenerator(FModifier)

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

*class* bpy.types.FModifierFunctionGenerator(*FModifier*)
:   Generate values using a built-in function

    amplitude
    :   Scale factor determining the maximum/minimum values

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

    function_type
    :   Type of built-in function to use

        - `SIN`
          Sine.
        - `COS`
          Cosine.
        - `TAN`
          Tangent.
        - `SQRT`
          Square Root.
        - `LN`
          Natural Logarithm.
        - `SINC`
          Normalized Sine – sin(x) / x.

        Type:
        :   enum in [`'SIN'`, `'COS'`, `'TAN'`, `'SQRT'`, `'LN'`, `'SINC'`], default `'SIN'`

    phase_multiplier
    :   Scale factor determining the ‘speed’ of the function

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

    phase_offset
    :   Constant factor to offset time by for function

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

    use_additive
    :   Values generated by this modifier are applied on top of the existing values instead of overwriting them

        Type:
        :   boolean, default False

    value_offset
    :   Constant factor to offset values by

        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 Frame Range and how is it used in Blender Python scripting?

assistant: # Frame Range

[image reference removed]

Frame Range panel.

This panel defines how long an animation will last in terms of frames.
Frames can be divided by the scene’s [Frame Rate](format.html#bpy-types-rendersettings-fps)
to get the animation duration in terms of time.
For example, a 250 frame animation at a frame rate of 30 will last 8.3 seconds.

Frame Start, End
:   Set the *Start* and *End* frames for [Rendering Animations](../animation.html).

Step
:   Controls the number of frames to advance for each frame rendered, a value above 1 skips frames.
    This is also used when viewing rendered animations.
user: Give a detailed overview of Mesh: syntax, arguments, return values, common patterns.

assistant: Converts the selected curve, metaball, surface, or text object to a mesh object.
The actual defined resolution of these objects will be taken into account for the conversion.
Note that it also keeps the faces and volumes created by closed and extruded curves.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Fill Type
:   How the circles at the top and bottom are filled with faces when their radius is larger than zero.

    None:
    :   Do not fill the circles.

    N-Gon:
    :   Fill the innermost segment of the circles with a single face.

    Triangles:
    :   Fill the innermost segment of the circles with triangles connected to a new vertex on the Z axis.
user: Explain ShaderNodeGroup(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeGroup(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.ShaderNodeGroup(*ShaderNode*)
:   node_tree
    :   Type:
        :   [`NodeTree`](bpy.types.NodeTree.html#bpy.types.NodeTree "bpy.types.NodeTree")

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: ### Nearest Surface Point

This will select the nearest point over the surface of the shrunk target.

### Project

[[image reference removed]](../../../_images/grease-pencil_modifiers_deform_shrinkwrap_project.png)

Project mode.

This will project vertices along a chosen axis until they touch the shrink target.
Vertices that never touch the shrink target are left in their original position.

Limit
:   This is a distance limit between original point and surface.
    If the distance is larger than this limit point would not be projected onto the surface.

Subdivision Levels
:   This applies a (temporary) *Catmull-Clark* subdivision to the modified object’s geometry,
    before computing the wrap.

Axis
:   Along which local axis of the modified object the projection is done.
    These options can be combined with each other, yielding a “median axis” of projection.
    If none are selected, the normal direction is used.

Negative/Positive
:   This allows you to select the allowed direction(s) of the shrink along the selected axis.
    If both options are enabled, both ways are evaluated and the closest hit is selected.

Face Cull
:   Allows you to prevent any projection over the “front side”
    (respectively the “back side”) of the target’s faces. The “side” of a face is determined
    by its normal (front being the side “from where” the normal “originates”).

Invert Cull
:   If *Cull Faces* is enabled, and *Negative* direction along axis is allowed,
    this option can be used to invert the *Front* or *Back* cull choice
    for the *Negative* direction. This is useful when projecting in both directions.

Auxiliary Target
:   An additional object to project over.

### Nearest Vertex

This will snap vertices to the nearest vertex of the shrunk target. It adds no extra options.

This method doesn’t support the *Snap Mode* setting.

### Target Normal Project

This mode is similar to *Nearest Surface Point*, but produces a much smoother
projection in return for being significantly slower.

Instead of finding the closest point, it searches for the nearest point
that has its interpolated smooth normal pointing towards or away from the original point position.
Non-manifold boundary edges are specially handled as infinitely thin cylinders
that emit normals in all perpendicular directions; ignores flat shading.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Image
:   Standard color input.

Type
:   Undistort:
    :   Used to undistort the image received, and is usually used for the raw distorted movie clip.

    Distort:
    :   Used to distort the image received, and is usually used for rendered images.
user: Provide the full official documentation entry for Edges, preserving all code examples.

assistant: # Edges

Allow the edges in a mesh object to act like springs.
See [interior forces](../forces/interior.html).

Springs
:   Use a specified vertex group for spring strength values.

Pull
:   The spring stiffness for edges (how much the edges are allowed to stretch).
    A low value means very weak springs (a very elastic material),
    a high value is a strong spring (a stiffer material) that resists being pulled apart.

    A value of 0.5 is latex, 0.9 is like a sweater, 0.999 is a highly-starched napkin or leather.
    The soft body simulation tends to get unstable if you use a value of 0.999,
    so you should lower this value a bit if that happens.

Push
:   How much the soft body resists being scrunched together, like a compression spring.
    Low values for fabric, high values for inflated objects and stiff material.

Damp
:   The friction for edge springs. High values (max of 50) dampen the *Push*/*Pull* effect and calm down the cloth.

Plasticity
:   Permanent deformation of the object after a collision.
    The vertices take a new position without applying the modifier.

Bending
:   This option creates virtual connections between a vertex and the vertices connected to its neighbors.
    This includes diagonal edges. Damping also applies to these connections.

Length
:   The edges can shrink or be blown up. This value is given in percent,
    0 disables this function. 100% means no change, the body keeps 100% of its size.

Collision
:   Edge
    :   Checks for edges of the soft body mesh colliding.

    Face
    :   Checks for any portion of the face of the soft body mesh colliding (which is computationally intensive).
        While *Face* enabled can solve collision errors, there does not seem to be any dampening settings for it.
        So parts of the soft body object near a collision mesh tend to “jitter” as they bounce off and fall back,
        even when there is no motion of any meshes. Edge collision has dampening, so that can be controlled,
        but Deflection dampening value on a collision object does not seem to affect the face collision.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`WindowManager.xr_session_state`](bpy.types.WindowManager.html#bpy.types.WindowManager.xr_session_state "bpy.types.WindowManager.xr_session_state") - [`XrActionMaps.find`](bpy.types.XrActionMaps.html#bpy.types.XrActionMaps.find "bpy.types.XrActionMaps.find") - [`XrActionMaps.new`](bpy.types.XrActionMaps.html#bpy.types.XrActionMaps.new "bpy.types.XrActionMaps.new") | - [`XrActionMaps.new_from_actionmap`](bpy.types.XrActionMaps.html#bpy.types.XrActionMaps.new_from_actionmap "bpy.types.XrActionMaps.new_from_actionmap") - [`XrActionMaps.remove`](bpy.types.XrActionMaps.html#bpy.types.XrActionMaps.remove "bpy.types.XrActionMaps.remove") |
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`Action.layers`](bpy.types.Action.html#bpy.types.Action.layers "bpy.types.Action.layers") - [`ActionLayers.new`](bpy.types.ActionLayers.html#bpy.types.ActionLayers.new "bpy.types.ActionLayers.new") | - [`ActionLayers.remove`](bpy.types.ActionLayers.html#bpy.types.ActionLayers.remove "bpy.types.ActionLayers.remove") |
user: What is Fluid Flow and how is it used in Blender Python scripting?

assistant: # Fluid Flow

The *Fluid Flow* force field creates a force based on a [Fluid simulation](../../../fluid/index.html) air flow.
It applies the smoke simulation air flow velocity as a force to other simulations that use force fields.
To use it you need to add a *Fluid Flow* force field and select a domain object for it.
For example fire sparkles can realistically flow along the air turbulence near the simulated fire.
user: Show practical ways to work with ThemeCollectionColor(bpy_struct) in a Blender add-on or script – include code.

assistant: # ThemeCollectionColor(bpy_struct)

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

*class* bpy.types.ThemeCollectionColor(*bpy_struct*)
:   Theme settings for collection colors

    color
    :   Collection Color Tag

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.lightprobe`](bpy.context.html#bpy.context.lightprobe "bpy.context.lightprobe") - [`BlendData.lightprobes`](bpy.types.BlendData.html#bpy.types.BlendData.lightprobes "bpy.types.BlendData.lightprobes") | - [`BlendDataProbes.new`](bpy.types.BlendDataProbes.html#bpy.types.BlendDataProbes.new "bpy.types.BlendDataProbes.new") - [`BlendDataProbes.remove`](bpy.types.BlendDataProbes.html#bpy.types.BlendDataProbes.remove "bpy.types.BlendDataProbes.remove") |
user: Provide the full official documentation entry for Blueprint, preserving all code examples.

assistant: # Blueprint

The *Blueprint* modifier produces blueprint-like strokes using either circular,
elliptical, or square contours. A blueprint here refers to those lines drawn at the beginning
of free-hand drawing to capture the silhouette of objects with a simple shape such as circles,
ellipses and squares.

Shape
:   Which base shapes to use for this blueprint: *Circles*, *Ellipses* or *Squares*.

Rounds
:   How many rounds are generated, as if the pen draws the same stroke several times
    (i.e. how many times the process is repeated).

Random Radius, Center
:   For the *Circles* and *Ellipses* shapes.
    Adds some randomness to each round in the relevant aspect.
    Using more than one round with no randomness would be meaningless, as they would draw over each other exactly.

Backbone Length, Backbone
:   For the *Squares* shapes.
    The first adds some extra length to each edge of the generated squares (also affected by the second parameter).
    The second adds some randomness to the squares.

Note that the *Min 2D Length* feature from the *Strokes* settings is quite
handy here, to avoid the noise generated by small strokes…
user: Explain Collision in complete detail according to the official Blender documentation.

assistant: # Collision

There are two different collision types that you may use:
collision between different objects and internal collision.
We should set one thing straight from the start –
the primary targets of the collision calculation are the vertices of a soft body.
So if you have too few vertices too few collision takes place.
Secondarily, you can use edges and faces to improve the collision calculation.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Grid
:   The input signed distance field to offset.

Distance
:   The offset distance applied to the surface, in world units.
    Positive values expand the surface (dilation), and negative values contract it (erosion).
    The offset is applied uniformly in all directions, preserving smoothness and the signed distance property.
user: Explain CompositorNodeAlphaOver(CompositorNode) in complete detail according to the official Blender documentation.

assistant: # CompositorNodeAlphaOver(CompositorNode)

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

*class* bpy.types.CompositorNodeAlphaOver(*CompositorNode*)
:   Overlay a foreground image onto a background image

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

The Outline modifier.

Thickness
:   The thickness of the generated strokes outline.

    Keep shape
    :   The perimeter strokes are maintaining inside the original stroke perimeter trying to keep the original shape.

Subdivisions
:   controls the number of subdivision of the generated strokes outline.

Sample Length
:   Controls the accuracy of the perimeter conversion.

Outline Material
:   Defines the material to use on the generated strokes outline.

Target Object
:   Controls the origin of the cyclic strokes generated.

### Influence Filters

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: What is Handle Type Selection Node and how is it used in Blender Python scripting?

assistant: # Handle Type Selection Node

[image reference removed]

Creates a selection based on the handle types of the control points.

The handle type of each control point can be changed with the
[Set Handle Type Node](../write/set_handle_type.xhtml).
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: Target Object
:   Determines if the image empty is kept or replaced.

    New Object: Creates a new Grease Pencil object and keeps the image empty
    Selected Object: Replaces the image empty with the Grease Pencil object.

Radius
:   The thickness of the generated Grease Pencil strokes.

Color Threshold
:   Determine the [Luminance](../../../glossary/index.xhtml#term-Luminance) threshold above which strokes are generated.

Turn Policy
:   Determines how to resolve ambiguities during decomposition of an image into paths.

    Black:
    :   Prioritizes to connect black (foreground) components.

    White:
    :   Prioritizes to connect white (background) components.

    Left:
    :   Always take a left turn.

    Right:
    :   Always take a right turn.

    Minority:
    :   Prioritizes to connect the color (black or white) that occurs
        least frequently in the local neighborhood of the current position.

    Majority:
    :   Prioritizes to connect the color (black or white) that occurs
        most frequently in the local neighborhood of the current position.

    Random:
    :   Choose pseudo-randomly.

Mode
:   Determines if the image being traced is a single image or image sequence.

    Single:
    :   The image empty is a single image or the current frame of an image sequence.

    Sequence:
    :   The image empty is an [Image Sequence](../../../editors/image/image_settings.xhtml#image-sequence).

Start at Current Frame
:   When enabled, start the tracing process at the current image frame.

Trace Frame
:   Used to trace only one frame of the image sequence, set to zero to trace all.
user: What is Version Number Guidelines and how is it used in Blender Python scripting?

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: What is Inputs and how is it used in Blender Python scripting?

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

Factor
:   Scales the overall displacement strength.
    A value of 0.0 applies no displacement, while 1.0 applies the full displacement vector.

Shape
:   Defines how the displacement factor changes along the length of each curve.
    A value of 0.0 applies a constant displacement, while 0.5 results in a linear falloff from root to tip.

Object Space
:   The object whose transform defines the coordinate space of the displacement.
    If unset, displacement is applied in the modifier’s local space.

Displace Vector
:   The vector used to determine the direction and magnitude of the displacement.
    This can be driven by fields or other procedural inputs.

### Surface Normal

When enabled, displaces the curves along the normal of a surface, allowing for effects like
“pushing” or “lifting” hair away from a mesh.

Can be enabled from the header.

Surface Input Type
:   Determines how the surface data is provided for sampling the normals.
    The geometry input takes priority over the object input.

    Object:
    :   Use an object reference to sample surface normals.

    Geometry:
    :   Use a geometry input to sample normals directly.

Surface
:   The surface object used to sample the normals for displacement.

Surface UV Map
:   The UV map used when sampling the surface normals for displacement.

Surface Normal Displacement
:   Amount of displacement applied along the sampled surface normal.
    Can be positive or negative depending on the desired direction.
user: Show practical ways to work with CompositorNodePixelate(CompositorNode) in a Blender add-on or script – include code.

assistant: # CompositorNodePixelate(CompositorNode)

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

*class* bpy.types.CompositorNodePixelate(*CompositorNode*)
:   Reduce detail in an image by making individual pixels more prominent, for a blocky or mosaic-like appearance

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # ShaderNodeVectorCurve(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.ShaderNodeVectorCurve(*ShaderNode*)
:   Map input vector components with curves

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type