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

assistant: # Scale

Scaling means changing proportions of objects. Pressing `S` will enter
the *Scale* transformation mode where the selected element is scaled inward or
outward according to the mouse pointer’s location. The element’s scale will
increase as the mouse pointer is moved away from the Pivot Point and decrease as
the pointer is moved towards it. If the mouse pointer crosses from the original side of
the [Pivot Point](../../../../editors/3dview/controls/pivot_point/index.xhtml)
to the opposite side, the scale will continue in the negative direction and flip the element.

[image reference removed]

Basic scale usage. From left to right, the panels show: the original object,
a scaled down object, a scaled up object and a scale-flipped object.

The amount of scaling will be displayed in the header of the 3D Viewport.

[image reference removed]

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

assistant: [image reference removed]

The Hook modifier.

Object
:   The name of the object to hook points to.

Strength
:   Adjust this hooks influence on the stroke points, were (0.0 to 1.0) (no change to fully follow the hook).

### Falloff

Type
:   This can be used to adjust the type of curve for the Strength attenuation.
    You can also define a custom curve to get a much higher level of control.

Radius
:   The size of the hooks influence.

Uniform Falloff
:   This setting is useful when using hooks on scaled objects,
    especially in cases where non-uniform scale would stretch the result of the hook.

### Influence

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

assistant: # FunctionNodeCombineTransform(FunctionNode)

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

*class* bpy.types.FunctionNodeCombineTransform(*FunctionNode*)
:   Combine a translation vector, a rotation, and a scale vector into a transformation matrix

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: - Converting the string `"3.1415"` with *Float* selected outputs a value of `3.1415` and a length of `6`.
- Converting `"42abc"` with *Integer* selected outputs `42` and a length of `2`.
- Converting an invalid string such as `"hello"` outputs `0` and a length of `0`.
user: Give a detailed overview of Delete: syntax, arguments, return values, common patterns.

assistant: Opens a pop-up menu with operators to remove geometry from the Grease Pencil object.

Frames
:   Deletes all the strokes at the current frame and in the current layer/channel.

### Delete

Deletes the selected points.
When only one point remains, there is no more visible stroke,
and when all points are deleted, the stroke itself is deleted.

### Dissolve

Dissolving removes points between other points and connect the remaining points.

`Ctrl`-`X` Opens a pop-up to choose the dissolve type.

Dissolve
:   Deletes the selected points without splitting the stroke.
    The remaining points in the strokes stay connected.

Dissolve Between
:   Deletes all the points between the selected points without splitting the stroke.
    The remaining points in the strokes stay connected.

Dissolve Unselect
:   Deletes all the points that are not selected in the stroke without splitting the stroke.
    The remaining points in the strokes stay connected.

### Delete Active Keyframe (Active Layer)

Deletes all the strokes at the current frame in the active layer.

### Delete Active Keyframes (All Layers)

Deletes all the strokes at the current frame in all layer.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Geometry
:   Standard geometry input.

Pattern Mode
:   How the attributes to remove are chosen.

    Exact:
    :   Remove the one attribute with the given name.

    Wildcard:
    :   Remove all attributes that match the pattern which is allowed to contain a single wildcard (\*).

Name
:   The name of the attribute to remove.
user: What is GeometryNodeSDFGridBoolean(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeSDFGridBoolean(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.GeometryNodeSDFGridBoolean(*GeometryNode*)
:   Cut, subtract, or join multiple SDF volume grid inputs

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

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

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

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.html#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.html#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: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Color
:   Color of the surface, or physically speaking, the probability that light is transmitted for each wavelength.

Roughness
:   Influences sharpness of the refraction; perfectly sharp at 0.0 and smoother with higher values.

IOR
:   Index of refraction ([IOR](../../../glossary/index.html#term-IOR)) defining how much the ray changes direction. At 1.
    0 rays pass straight through like transparent; higher values give more refraction.

Normal
:   Normal used for shading.

### Thin Film Cycles Only

Thin Film simulates the effect of interference in a thin film sitting on top of the material.
This causes the specular reflection to be colored in a way which strongly depends on the view
angle as well as the film thickness and the index of refraction ([IOR](../../../glossary/index.html#term-IOR)) of the film and
the material itself.

This effect is commonly seen on e.g. oil films, soap bubbles or glass coatings. While its
influence is more obvious in specular highlights, it also affects transmission.

Thickness
:   The thickness of the film in nanometers. A value of 0 disables the simulation.
    The interference effect is strongest between roughly 100 and 1000 nanometers, since this is
    near the wavelengths of visible light.

IOR
:   Index of refraction ([IOR](../../../glossary/index.html#term-IOR)) of the thin film.
    The common range for this value is between 1.0 (vacuum and air) and roughly 2.0,
    though some materials can reach higher values.
    The default value of 1.33 is a good approximation for water.
    Note that when the value is set to 1.0 or to the main IOR of the material, the thin film
    effect disappears since the film optically blends into the air or the material.
user: Show practical ways to work with Physical Properties in a Blender add-on or script – include code.

assistant: # Physical Properties

Vertex Mass
:   The mass of the cloth material.

Air Viscosity
:   Air has some thickness which slows falling things down.

Bending Model
:   Linear:
    :   Cloth model with linear bending springs (old).

    Angular:
    :   Cloth model with angular bending springs.
user: Show practical ways to work with Usage in a Blender add-on or script – include code.

assistant: ### Aliases

Some variables and modules are available for convenience:

- `C`: Quick access to `bpy.context`.
- `D`: Quick access to `bpy.data`.
- `bpy`: Top level Blender Python API module.

### First Look at the Console Environment

To see the list of global functions and variables,
type `dir()` and press `Return` to execute it.

[image reference removed]

### Auto Completion

The Console can preview the available members of a module or variable.
As an example, type `bpy.` and press `Tab`:

[image reference removed]

The submodules are listed in green. Attributes and methods will be listed
in the same way, with methods being indicated by a trailing `(`.
user: Give a detailed overview of Subdivide: syntax, arguments, return values, common patterns.

assistant: # Subdivide

Subdividing adds resolution to the mesh by dividing faces or edges into smaller units.

This process follows a few rules depending on the situation:

- When only one edge of a triangle or [quad](../../../../glossary/index.xhtml#term-Quad) is selected,
  that face is turned into a quad or [N-gon](../../../../glossary/index.xhtml#term-N-gon) respectively.
  If the *Create N-Gons* option is disabled, the face is split into triangles instead.
- When two edges of a face are selected:

  - If the face is a triangle, a new edge is created between the two new vertices,
    subdividing the triangle into a triangle and a quad.
  - If the face is a quad and the edges are neighbors, the face is split according
    to the *Quad Corner Type* setting (see below).
  - If the face is a quad and the edges are opposite,
    the quad is just subdivided in two quads by the edge linking the two new vertices.
- When three edges of a face are selected:

  - If the face is a triangle, this means the whole face is selected and
    it is subdivided into four smaller triangles.
  - If the face is a quad, first the two opposite edges are subdivided as described above.
    Then, the “middle” edge is subdivided, affecting its new “sub-quad” as described above for only one edge.
- When all four edges of a quad are selected, the face is subdivided into four smaller quads.
- When one or more edges of an N-gon are selected,
  the individual edges will be subdivided but the face will stay unsubdivided.
user: Provide the full official documentation entry for Operators, preserving all code examples.

assistant: # Operators

Operators execute an action the moment they’re activated,
which makes them different from tools (which require some sort of input).
Operators can be started from [Operator Buttons](controls/buttons/buttons.xhtml#ui-operator-buttons),
[Popup Menus](controls/buttons/menus.xhtml#bpy-types-uipopupmenu), or [Menu Search](#bpy-ops-wm-search-menu).
Examples of operators include adding a new object,
deleting it, or setting its shading to smooth.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Color
:   RGB color from image. If the image has transparency, the color is premultiplied if the Alpha output is used,
    and unpremultiplied (straight) otherwise.

Alpha
:   Alpha channel from image.
user: What is Getting Started and how is it used in Blender Python scripting?

assistant: Manual links

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

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

External links

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

- [Python API: Quickstart](https://docs.blender.org/api/current/info_quickstart.html)
- [CG Cookie: Blender 2.8 Python Scripting Superpowers for Non-Programmers](https://cgcookie.com/posts/blender-2-8-python-scripting-superpowers-for-non-programmers)
- [Olav3D Tutorials: 3D Programming for Beginners Using Python](https://www.youtube.com/watch?v=rHzf3Dku_cE)
- [Blender Artists: Python Support Forum](https://blenderartists.org/c/coding/python-support)
user: Describe Instance Rotation Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Instance Rotation Node

[image reference removed]

The *Instance Rotation* outputs the XYZ [Euler](../../../glossary/index.xhtml#term-Euler) rotation of each top-level instance in the
local space of the modifier object.

The [Instances](../instances.xhtml) page contains more information about geometry instances.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Follow Track constraint.

Active Clip
:   Whether the tracking marker is in the scene’s [Active Clip](../../../scene_layout/scene/properties.html#bpy-types-scene-active-clip).
    If unchecked, a selector appears for choosing another clip.

3D Position
:   Whether to use the tracking marker’s reconstructed world position (instead of its position
    in the flat video).

Undistort
:   Whether to use the tracking marker’s video position after compensating for lens distortion
    (see [Lens settings](../../../movie_clip/tracking/clip/sidebar/track/camera.html#motion-tracking-camera-lens)).
    Not available when *3D Position* is checked.

Frame Method
:   How to handle a difference in aspect ratio between the tracked video footage and the rendered image.

    Stretch:
    :   The object is positioned as though the video were stretched to exactly match the size of the
        rendered image.

    Fit:
    :   The object is positioned as though the video were made as large as possible while still keeping
        its original aspect ratio and fitting inside the rendered image along both axes.

    Crop:
    :   The object is positioned as though the video were made as large as possible while still keeping
        its original aspect ratio and fitting inside the rendered image along one axis.

Object
:   The physical object containing the tracking marker to follow. See the
    [Objects Panel](../../../movie_clip/tracking/clip/sidebar/track/objects.html) in the Movie Clip Editor.
    If left empty, *Track* will list the markers used to reconstruct the physical camera.

Track
:   The tracking marker to follow.

Camera
:   The Blender camera in whose field of view the constrained object should appear.
    If left empty, the scene’s [active camera](../../../scene_layout/scene/properties.html#bpy-types-scene-camera) is used.

Depth Object
:   If this object is set, the constrained object will be projected onto its surface.
    This can be used to create a facial makeup effect, for example.
    Not available when *3D Position* is checked.

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

[Influence](../interface/common.html#bpy-types-constraint-influence)
:   How strongly the constraint affects its owner.
user: Explain Render in complete detail according to the official Blender documentation.

assistant: SMAA Threshold
:   Threshold for the edge detection algorithm used to correct aliasing for the final render,
    Higher values may result in loss of detail due to excessive blurring.

SSAA Samples
:   Number of samples used for super-sampling anti-aliasing in the final render.
    Higher values produce smoother lines but increase render time.

Motion Blur Steps
:   Controls accuracy of [motion blur](../../../glossary/index.xhtml#term-Motion-Blur), more steps result in longer render time.
    Only used when [Motion Blur](motion_blur.xhtml#bpy-types-rendersettings-use-motion-blur) is enabled.
    Set to 0 to disable motion blur for Grease Pencil objects.
user: Show practical ways to work with Detect Features in a Blender add-on or script – include code.

assistant: Detects all possible features on the current frame and places markers at these features.
This operator does not take other frames into account,
so it might place markers on features which belong to moving objects.
If the camera is turning away from this shot,
no markers could be present within the frames after the camera moved away.

There are several properties for this operator:

Placement
:   Controls where to place markers.

    Whole Frame
    :   Places markers throughout the whole frame.

    Inside Annotated Area
    :   Places markers inside the area outlined with the [Annotation Tools](../../../../interface/annotate_tool.html#tool-annotate).
        This can be used to outline some areas with interesting features
        and place markers only inside the outlined area.

    Outside Annotated Area
    :   Places markers outside the area outlined with the [Annotation Tools](../../../../interface/annotate_tool.html#tool-annotate).
        This can be used to outline areas of no interest (like trees, humans, etc.)
        and place markers outside of these areas.

Margin
:   Controls the distance from the image boundary for created markers.
    If markers are placed too close to the image boundary,
    they will fail to track really quickly and they should be deleted manually.
    To reduce the amount of manual clean-up, this parameter can be used.

Threshold
:   Limits minimal threshold for placing markers.
    This value comes from the feature detection algorithm and it means:
    low values means most probably this feature would fail to track very soon,
    high value means it is not much such track.
    Amount of markers to be added can be controlled with this value.

Distance
:   Defines the minimal distance between placed markers.
    It is needed to prevent markers from being placed too close to each other
    (such placement can confuse the camera solver).
user: How do I use Diffusion in Blender? Include parameters, examples, warnings and best practices.

assistant: # Diffusion

Liquid diffusion defines the physical properties of a liquid
and in turn define how a liquid interacts with its environment.
The main factors of diffusion are the *Viscosity* and *Surface Tension*.
These properties can be adjusted to create virtual liquids that behave like water,
oil, honey, or any other liquid. A couple presets exist to change the diffusion
for different substances are predefined and can be changed in the preset menu.
Fluid Diffusion settings can be enabled/disabled in the panel header.

Viscosity

The viscosity refers to the “thickness” of the fluid and actually the force needed to
move an object of a certain surface area through it at a certain speed.

For manual entry, please note that real-world viscosity
(the so-called dynamic viscosity) is normally measured in Pascal-seconds (\(Pa\cdot s\)),
or in Poise units (P, equal to 0.1 \(Pa\cdot s\)), and commonly centiPoise units (cP, equal to 0.001 \(Pa\cdot s\)).

Blender, on the other hand, uses the kinematic viscosity which is the dynamic viscosity divided by
the density, \(\frac{Pa\cdot s}{kg/m^{3}}\), which is \(m^{2}/s\). So for example, the viscosity
of water at room temperature is 1.002 cP, or 0.001002 \(Pa\cdot s\); the density of water is about
1000 \(kg/m^{3}\), which gives a kinematic viscosity of 0.000001002 \(m^{2}/s\) – so the entry would be
1.002 times 10 to the minus six (1.002×10-6 in scientific notation).

The table below gives some examples of fluids together with their dynamic and kinematic viscosities.

Blender viscosity unit conversion.

| Fluid | Dynamic viscosity (in cP) | Kinematic viscosity (Blender, in \(m^{2}/s\)) |
| --- | --- | --- |
| Water (20 °C) | 1.002×100 (1.002) | 1.002×10-6 (0.000001002) |
| Oil SAE 50 | 5.0×102 (500) | 5.0×10-5 (0.00005) |
| Honey (20 °C) | 1.0×104 (10,000) | 2.0×10-3 (0.002) |
| Chocolate Syrup | 3.0×104 (30,000) | 3.0×10-3 (0.003) |
| Ketchup | 1.0×105 (100,000) | 1.0×10-1 (0.1) |
| Melting Glass | 1.0×1015 | 1.0×100 (1.0) |

To simplify the input of these numbers, the viscosity is changed by entering values
in scientific notation by entering a base value and the exponent of that number.

Base
:   The base of the viscosity value (e.g. 1.002 in the case of water (20 °C)).

Exponent
:   The exponent of the viscosity value that will be multiplied by 10-1
    (e.g. 6 in the case of water (20 °C)).

Surface Tension
:   Surface tension in grid units. Higher value will produce liquids with greater surface tension.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: The inputs are dynamic, they become available if needed depending on the node properties.

Vector
:   Vector used as seed in 2D, 3D, and 4D dimensions.

W
:   Value used as seed in 1D and 4D dimensions.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Image
:   Standard color input.

Invert
:   Invert the stabilization. If the stabilization calculated is to move the movie clip up by 5 units,
    this will move the movie clip down by 5 units.

### Sampling

Filter
:   Determines how pixel values are interpolated when scaling or transforming images.

    Nearest:
    :   Uses the value of the closest pixel with no smoothing.
        This is the fastest method and is well-suited for pixel art or low-resolution images
        where sharp, blocky edges are desirable.
        In animations, motion appears in single-pixel steps, which can cause visible jittering.

    Bilinear:
    :   Averages the values of surrounding pixels to create a smoother result than *Nearest*.
        Provides a good balance between performance and visual quality.

    Bicubic:
    :   Computes a weighted average of a larger neighborhood of pixels for even smoother results.
        Ideal for photographic images or gradients where preserving fine detail is important.

    Anisotropic:
    :   Adjusts interpolation based on the direction and scale of the transformation.
        Helps reduce blurring or aliasing when scaling at steep angles or uneven resolutions,
        especially useful in textures viewed at oblique angles or in detailed 3D projections.
user: Show practical ways to work with Curve Segment in a Blender add-on or script – include code.

assistant: # Curve Segment

The *Curve Segment* node provides information about the segment connecting
each point on a curve to its previous point.
It is useful for analyzing or manipulating per-segment data, such as length,
direction, or connectivity, and for constructing effects that depend on local curve structure.
user: Explain Tool Settings in complete detail according to the official Blender documentation.

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

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

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

    Use Curve
    :   When enabled, the stroke use a curve profile to control the thickness along the curve.

Different thickness profile samples.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_curve_thickness-profile-01.png | ../../../../_images/grease-pencil_modes_draw_tools_curve_thickness-profile-02.png | ../../../../_images/grease-pencil_modes_draw_tools_curve_thickness-profile-03.png |

### Brush Asset

Picks the brush asset used by the tool.

See [Brush Asset](../tool_settings/brushes.xhtml) for more information.

See [Draw Brushes](../brushes/draw.xhtml) for a detailed list of all draw brushes and their options.

### Brush Settings

Parameters to control to look of the stroke.

See [Draw Brushes](../brushes/draw.xhtml) for details.

### Color

Settings to determine the color of strokes.

See [Color](../tool_settings/color.xhtml)
user: Provide the full official documentation entry for Decimate Modifier, preserving all code examples.

assistant: # Decimate Modifier

The *Decimate* modifier allows you to reduce the vertex/face count of a mesh with minimal shape changes.

This is not usually used on meshes which have been created by modeling carefully and economically
(where all vertices and faces are necessary to correctly define the shape).
But if the mesh is the result of complex modeling,
sculpting and/or applied [Subdivision Surface](subdivision_surface.xhtml)/
[Multiresolution](multiresolution.xhtml) modifiers,
the *Decimate* one can be used to reduce the polygon count for a performance increase,
or simply remove unnecessary vertices and edges.

Unlike the majority of existing modifiers, this one does not allow
you to visualize your changes in Edit Mode.

The modifier displays the number of remaining faces as a result of the *Decimate* modifier.
user: Provide the full official documentation entry for Header, preserving all code examples.

assistant: Action
:   A [data-block menu](../../../interface/controls/templates/data_block.xhtml#ui-data-block) that lets you change – or clear – the object’s active action.

Slot Display Name
:   Name of the slot, for display in the user interface.
    This name combined with the slot’s data-block type is unique within its Action.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Image
:   The color image from the *Image* input with the mask applied so that only the selected
    objects/materials remain. Everything else is made transparent.

Matte
:   A grayscale mask of the selected objects or materials.

Pick
:   A colored representation of the Cryptomatte which can be used for picking objects or materials.
user: What is Material Shader and how is it used in Blender Python scripting?

assistant: Grease Pencil materials use a special [shader](properties.html)
that define the appearance of the surface of the stroke and fill.

Stroke and fill components has it own section panel and
they can be enabled with a checkbox on the panel header.

*Stroke* only has effect on the lines and *Fill* only on the areas
determined by closed lines (by connecting the lines start and end points).
user: Provide the full official documentation entry for Online Editing, preserving all code examples.

assistant: # Online Editing

Welcome!
This page explains the process for contributing to Blender’s documentation through our online editing workflow.
Whether you’re fixing typos or adding entirely new sections, your contributions are valuable.

Below is an overview of the online editing process.
user: What is Placeholders & Editor Notes and how is it used in Blender Python scripting?

assistant: For content that needs future updates or completion:

Visible to readers:

```
.. todo:: Complete this section when feature is finalized.
```

Internal notes (not visible to readers):

```
.. Internal developer reminder goes here
```
user: Explain Types in complete detail according to the official Blender documentation.

assistant: Besides standard markers, *pose markers* are another type of markers,
which are specific to armatures and shape keys.
They are used to denote poses in the Action Editor mode and Shape Keys Editor of Dope Sheet.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Mask Type
:   Operation to use against the input mask.

    Add:
    :   This yields the *union* of the input mask and the generated mask:
        Areas covered by the generated mask are set to the specified *Value*.
        Other parts of the input masked are passed through unchanged, or set to black if there is no input mask.

    Subtract:
    :   Values of the input mask have the specified *Value* subtracted from them.

    Multiply:
    :   This yields the *intersection* of this generated mask and the input mask:
        Values of the input mask are multiplied by the specified *Value* for the area covered by the generated mask.
        All other areas become black.

    Not:
    :   Any area covered by both the input mask and the generated mask becomes black.
        Areas covered by the generated mask that are black on the input mask become the specified *Value*.
        Areas uncovered by the generated mask remain unchanged.

Mask
:   An optional mask to use as the base for mask operations.

Value
:   Intensity of the generated mask.

Position
:   Position of the center of the box as a fraction of the total width or height.
    (0.5, 0.5 creates a centered box; 0.0, 0.0 creates a box in the lower left.)

Size
:   Width/height of the box as a fraction of the total image width.

Rotation
:   Rotation of the box around its center point.
user: Give a detailed overview of Topology: syntax, arguments, return values, common patterns.

assistant: ### Loops

[image reference removed]

Edge and face loops.

*Edge* and *face* loops are sets of faces or edges that form continuous “loops” as shown in
Fig. [Edge and face loops.](#fig-mesh-topo-loop).

In the image above, loops that do not end in poles are cyclic (1 and 3).
They start and end at the same vertex and divide the model into two partitions.
Loops can be a quick and powerful tool to work with specific,
continuous regions of a mesh and are a prerequisite for organic character animation.
For a detailed description of how to work with loops in Blender, see:
[Select Edge Loops](selecting/loops.html#bpy-ops-mesh-loop-multi-select).

Edge Loops

Loops (1 and 2) in Fig. [Edge and face loops.](#fig-mesh-topo-loop) are edge loops.
They connect vertices so that each one on the loop has exactly two neighbors that are not on
the loop and placed on both sides of the loop (except the start and end vertex in case of poles).

Edge loops are an important concept especially in organic (subsurface)
modeling and character animation. When used correctly, they allow you to build models with
relatively few vertices that look very natural when used as subdivision surfaces and
deform very well in animation.

Take Fig. [Edge and face loops.](#fig-mesh-topo-loop) in organic modeling as an example: the edge loops follow
the natural contours and deformation lines of the skin and the underlying muscles.
The loops are denser in areas that deform more when the character moves, for example at the shoulders or knees.

Further details on working with edge loops can be found in [Select Edge Loops](selecting/loops.html#bpy-ops-mesh-loop-multi-select).

Face Loops

These are a logical extension of edge loops in that they consist of the faces between
two edge loops, as shown in loops (3 and 4) in Fig. [Edge and face loops.](#fig-mesh-topo-loop).
Note that for non-circular loops (4)
the faces containing the poles are not included in a face loop.

Further details on working with face loops can be found in
[Face Loop Selection](selecting/loops.html#modeling-meshes-selecting-face-loops).

### Poles

See [N-poles & E-poles](https://blender.stackexchange.com/a/133676/55).

### Non-Manifold

See [Non-manifold](../../glossary/index.html#term-Non-manifold).
user: Provide the full official documentation entry for ColorManagedDisplaySettings(bpy_struct), preserving all code examples.

assistant: # ColorManagedDisplaySettings(bpy_struct)

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

*class* bpy.types.ColorManagedDisplaySettings(*bpy_struct*)
:   Color management specific to display device

    display_device
    :   Display name. For viewing, this is the display device that will be emulated by limiting the gamut and HDR colors. For image and video output, this is the display space used for writing.

        Type:
        :   enum in [`'NONE'`], default `'NONE'`

    emulation
    :   Control how images in the chosen display are mapped to the physical display

        - `OFF`
          Off – Directly output image as produced by OpenColorIO. This is not correct in general, but may be used when the system configuration and actual display device is known to match the chosen display.
        - `AUTO`
          Automatic – Display images consistent with most other applications, to preview images and video for export. A best effort is made to emulate the chosen display on the actual display device..

        Type:
        :   enum in [`'OFF'`, `'AUTO'`], default `'AUTO'`

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

assistant: This is the basic chain rig, which bridges controls with B-Bones but does not add
any automation to the controls themselves.

When controls are merely moved, the chains behave as if using standard
automatic handles, but rotating and optionally scaling the controls will adjust the result.

B-Bone Segments
:   Specifies the number of segments to use. Setting this to 1 disables
    all advanced behavior and merely bridges the points with a Stretch To bone.

Merge Parent Rotation and Scale
:   This can be enabled to let the chain respond to rotation and scale induced by parents of
    controls owned by other chains that this chain’s control merged into.

Use Handle Scale
:   Enables using control scale to drive scale and/or easing of the B-Bone.

Connect With Mirror
:   Specifies whether the ends of the chain should smoothly connect when merging controls
    with its `.T`/`.B` `.L`/`.R` symmetry counterpart. The relevant option must be enabled
    on both chains to work.

Connect Matching Ends
:   Specifies whether the end of the chain should connect to the opposite end of a different chain
    when merging controls. Thus forming a continuous smooth chain in the same direction.
    The relevant options must be enabled on both chains.

Sharpen Corner
:   Specifies whether the rig should generate a mechanism to form a sharp corner at
    the relevant connected end, depending on the angle formed by adjacent control locations.
    When the control angle becomes sharper than the specified value, ease starts reducing from 1 to 0.

Orientation
:   Specifies that the controls should be oriented the same as the selected bone, rather than being
    aligned to the chain.

    Copy To Selected
    :   Copy to selected rigs that have the same option. Thus allowing to indiscriminately selecting bones
        without assigning unnecessary values.

Chain Priority
:   Allows overriding the heuristic used to select the primary owner when merging controls.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`CompositorNodeOutputFile.file_output_items`](bpy.types.CompositorNodeOutputFile.html#bpy.types.CompositorNodeOutputFile.file_output_items "bpy.types.CompositorNodeOutputFile.file_output_items") |  |
user: Describe Calculate Mass from the Blender manual or Python API, including usage steps and snippets.

assistant: Calculate mass values for rigid body objects based on their volume and density.
The volume is calculated automatically, the density needs to be given based on the object you want to simulate.

Material Preset
:   A list of preset density values for real-world materials,
    if a material is not given you can research the density and use the *Custom* preset to input the density manually.

Density
:   When the *Custom* *Material Preset* is selected, this is the input density, in kg/m3, to use.
user: Show practical ways to work with Example in a Blender add-on or script – include code.

assistant: In the example below the *Bokeh Image* is used to define the shape of the bokeh for
the [Bokeh Blur](../filter/blur/bokeh_blur.html) node.

[[image reference removed]](../../../_images/compositing_types_filter_bokeh-blur_example-1.png)

Example of *Bokeh Image* node.
user: Give a detailed overview of Vertex Groups: syntax, arguments, return values, common patterns.

assistant: Vertex groups can be used to assign a group or weighted group to some operator.
An object can have several weight groups and can be assigned in
[Weight Paint](vertex_groups/vertex_groups.xhtml) mode,
or in [Edit Mode](vertex_groups/assigning_vertex_group.xhtml) via this panel.

See [Vertex Groups](vertex_groups/introduction.xhtml) for more information.
user: Explain NodeTreeInterfaceSocketVectorXYZ4D(NodeTreeInterfaceSocket) in complete detail according to the official Blender documentation.

assistant: # NodeTreeInterfaceSocketVectorXYZ4D(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketVectorXYZ4D(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

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

assistant: ### Output

Videos can be rendered with both wide gamut and HDR color spaces. They use the scene display
by default, but can also be assigned a different color space by overriding the color management
settings in the output properties.

Saving HDR videos has a few additional requirements:

- Set color management display to Rec.2100 PQ or HLG
- Set codec to H.265 or AV1
- Set bit depth to 10 or 12

Video players and devices have different levels of support for HDR video.
Bit depth 10 with PQ encoding is a good default choice to maximize compatibility.

HDR videos are written with 100 nits diffuse white, to match the convention in most video
players and browsers.
user: What is Collection Info Node and how is it used in Blender Python scripting?

assistant: # Collection Info Node

[image reference removed]

The *Collection Info* node gets information from collections.
This can be useful to control parameters in the geometry node tree with an external collection.
user: How do I use Selecting Bones in Blender? Include parameters, examples, warnings and best practices.

assistant: # Selecting Bones

Selection in *Pose Mode* is very similar to the one in [Edit Mode](../bones/selecting.xhtml),
with a few deviations:
You can only select *whole bones* in *Pose Mode*, not roots/tips…
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

A strip is a container which carries frames provided by one or more sources (input).
It is defined by a *Start Frame* and a *Length*, and is displayed as a colored horizontal rectangle.

[image reference removed]

Strip schematic.
user: What is Duplicate and how is it used in Blender Python scripting?

assistant: Duplicate a strip to make an unlinked copy;
drag it to a time and channel, and drop it by `LMB` click.

For strips that reference an ID, for example scene strips, this will
duplicate the scene and use this new scene in the duplicated strip.
user: Provide the full official documentation entry for NodeGeometryCaptureAttributeItem(bpy_struct), preserving all code examples.

assistant: # NodeGeometryCaptureAttributeItem(bpy_struct)

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

*class* bpy.types.NodeGeometryCaptureAttributeItem(*bpy_struct*)
:   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)

    data_type
    :   Type:
        :   enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items), default `'FLOAT'`

    name
    :   Type:
        :   string, default “”, (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