PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with Object Color in a Blender add-on or script – include code.

assistant: # Object Color

The colors that the Workbench uses to render objects can be changed.

Material:
:   Use the color that can be set per material
    in the Viewport Display [Material](display_settings.html#properties-material-viewport-display) panel.

Object:
:   Use the color that can be set per object
    in the Viewport Display [Object](display_settings.html#properties-object-viewport-display) panel.

Random:
:   A random color will be selected for every object in the scene.

Attribute:
:   Display the active [Color Attribute](../../modeling/meshes/properties/object_data.html#modeling-meshes-properties-object-data-color-attributes)
    of an object. When an object has no active Color Attribute it will be rendered in the color set
    in the Viewport Display [Object](display_settings.html#properties-object-viewport-display) panel.

Texture:
:   Show the texture from the active [Image Texture Node](../shader_nodes/textures/image.html)
    using the active UV map. If there is no active texture, the object will be
    rendered with the settings in the [Material](display_settings.html#properties-material-viewport-display)’s
    Viewport Display panel.

Custom:
:   Render the whole scene using a single color. The color can be chosen.
user: Give a detailed overview of Bake Items: syntax, arguments, return values, common patterns.

assistant: The *Bake Items* panel is used to manage the input sockets
of the node thus also managing what data is baked.

Bake Items List
:   Used to manage the inputs and outputs of the bake node.
    Items can be added, removed, renamed, and sorted.

Socket Type
:   The data ([Sockets](../../../../interface/controls/nodes/parts.html#bpy-types-nodelink)) of the input/output.

Attribute Domain
:   The [attribute domain](../../attributes_reference.html#attribute-domains) used to evaluate the input field on.

Is Attribute
:   Bake item is an attribute stored on a geometry.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Mouse X
:   The region-space mouse X location, in pixels, increasing from 0 at the left.

Mouse Y
:   The region-space mouse Y location, in pixels, increasing from 0 at the bottom.

Region Width
:   The total X size of the [region](../../../../interface/window_system/regions.xhtml) in pixels.

Region Height
:   The total Y size of the [region](../../../../interface/window_system/regions.xhtml) in pixels.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`KeyConfigurations.find_item_from_operator`](bpy.types.KeyConfigurations.html#bpy.types.KeyConfigurations.find_item_from_operator "bpy.types.KeyConfigurations.find_item_from_operator") - [`KeyMap.keymap_items`](bpy.types.KeyMap.html#bpy.types.KeyMap.keymap_items "bpy.types.KeyMap.keymap_items") - [`KeyMap.restore_item_to_default`](bpy.types.KeyMap.html#bpy.types.KeyMap.restore_item_to_default "bpy.types.KeyMap.restore_item_to_default") - [`KeyMapItem.compare`](#bpy.types.KeyMapItem.compare "bpy.types.KeyMapItem.compare") - [`KeyMapItems.find_from_operator`](bpy.types.KeyMapItems.html#bpy.types.KeyMapItems.find_from_operator "bpy.types.KeyMapItems.find_from_operator") - [`KeyMapItems.find_match`](bpy.types.KeyMapItems.html#bpy.types.KeyMapItems.find_match "bpy.types.KeyMapItems.find_match") - [`KeyMapItems.find_match`](bpy.types.KeyMapItems.html#bpy.types.KeyMapItems.find_match "bpy.types.KeyMapItems.find_match") - [`KeyMapItems.from_id`](bpy.types.KeyMapItems.html#bpy.types.KeyMapItems.from_id "bpy.types.KeyMapItems.from_id") | - [`KeyMapItems.match_event`](bpy.types.KeyMapItems.html#bpy.types.KeyMapItems.match_event "bpy.types.KeyMapItems.match_event") - [`KeyMapItems.new`](bpy.types.KeyMapItems.html#bpy.types.KeyMapItems.new "bpy.types.KeyMapItems.new") - [`KeyMapItems.new_from_item`](bpy.types.KeyMapItems.html#bpy.types.KeyMapItems.new_from_item "bpy.types.KeyMapItems.new_from_item") - [`KeyMapItems.new_from_item`](bpy.types.KeyMapItems.html#bpy.types.KeyMapItems.new_from_item "bpy.types.KeyMapItems.new_from_item") - [`KeyMapItems.new_modal`](bpy.types.KeyMapItems.html#bpy.types.KeyMapItems.new_modal "bpy.types.KeyMapItems.new_modal") - [`KeyMapItems.remove`](bpy.types.KeyMapItems.html#bpy.types.KeyMapItems.remove "bpy.types.KeyMapItems.remove") - [`UILayout.template_event_from_keymap_item`](bpy.types.UILayout.html#bpy.types.UILayout.template_event_from_keymap_item "bpy.types.UILayout.template_event_from_keymap_item") - [`UILayout.template_keymap_item_properties`](bpy.types.UILayout.html#bpy.types.UILayout.template_keymap_item_properties "bpy.types.UILayout.template_keymap_item_properties") |
user: Show practical ways to work with Kuwahara Node in a Blender add-on or script – include code.

assistant: # Kuwahara Node

[image reference removed]

The Kuwahara node implements the Kuwahara filter as well as its anisotropic
variant. The Kuwahara filter is a smoothing filter that tries to preserve the
edges in the image. The smoothing effect of the anisotropic variant is similar
to brush strokes, so the node can be used to create stylized painting effects.
user: Give a detailed overview of Separate: syntax, arguments, return values, common patterns.

assistant: Separate different elements into new Grease Pencil objects based on specific criteria.

Selection
:   Separates the selected points or strokes into a new object.

By Material
:   Separates the geometry by creating a new object for each material.

By Layer
:   Separates the geometry by creating a new object for each layer.
    See [2D Layers](../../properties/layers.xhtml) for more information.
user: Show practical ways to work with ActionChannelbag(bpy_struct) in a Blender add-on or script – include code.

assistant: # ActionChannelbag(bpy_struct)

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

*class* bpy.types.ActionChannelbag(*bpy_struct*)
:   Collection of animation channels, typically associated with an action slot

    fcurves
    :   The individual F-Curves that animate the slot

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

    groups
    :   Groupings of F-Curves for display purposes, in e.g. the dopesheet and graph editor

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

    slot
    :   The Slot that the Channelbag’s animation data is for

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

    slot_handle
    :   Type:
        :   int in [-inf, inf], default 0, (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: This example is a combination of all previous ones, and shows how to write a simple exporter
script.

```
import bpy

class OBJECT_OT_simple_exporter(bpy.types.Operator):
    """Simple (fake) exporter of selected objects"""
    bl_label = "DEG Export Selected"
    bl_idname = "object.simple_exporter"

    apply_modifiers: bpy.props.BoolProperty(name="Apply Modifiers")

    def execute(self, context):
        depsgraph = context.evaluated_depsgraph_get()
        for object_instance in depsgraph.object_instances:
            if not self.is_object_instance_from_selected(object_instance):
                # We only export selected objects.
                continue
            # NOTE: This will create a mesh for every instance, which is not ideal at all. In
            # reality destination format will support some sort of instancing mechanism, so the
            # code here will simply say "instance this object at object_instance.matrix_world".
            mesh = self.create_mesh_for_object_instance(object_instance)
            if mesh is None:
                # Happens for non-geometry objects.
                continue
            print(f"Exporting mesh with {len(mesh.vertices)} vertices "
                  f"at {object_instance.matrix_world}")

            self.clear_mesh_for_object_instance(object_instance)

        return {'FINISHED'}

    def is_object_instance_from_selected(self, object_instance):
        # For instanced objects we check selection of their instancer (more accurately: check
        # selection status of the original object corresponding to the instancer).
        if object_instance.parent:
            return object_instance.parent.original.select_get()
        # For non-instanced objects we check selection state of the original object.
        return object_instance.object.original.select_get()

    def create_mesh_for_object_instance(self, object_instance):
        if self.apply_modifiers:
            return object_instance.object.to_mesh()
        else:
            return object_instance.object.original.to_mesh()

    def clear_mesh_for_object_instance(self, object_instance):
        if self.apply_modifiers:
            return object_instance.object.to_mesh_clear()
        else:
            return object_instance.object.original.to_mesh_clear()

def register():
    bpy.utils.register_class(OBJECT_OT_simple_exporter)

def unregister():
    bpy.utils.unregister_class(OBJECT_OT_simple_exporter)

if __name__ == "__main__":
    register()
```
user: Describe Enabling Add-on from the Blender manual or Python API, including usage steps and snippets.

assistant: 1. Open Blender and go to [Add-ons](../../editors/preferences/addons.xhtml) section of the [Preferences](../../editors/preferences/index.xhtml).
2. Search “Manage UI Translations” and check the *Enable Add-on* checkbox.
user: Describe gpu_extras submodule (gpu_extras.batch) from the Blender manual or Python API, including usage steps and snippets.

assistant: # gpu_extras submodule (gpu_extras.batch)

gpu_extras.batch.batch_for_shader(*shader*, *type*, *content*, *\**, *indices=None*)
:   Return a batch already configured and compatible with the shader.

    Parameters:
    :   - **shader** (`gpu.types.GPUShader`) – shader for which a compatible format will be computed.
        - **type** (*str*) – “‘POINTS’, ‘LINES’, ‘TRIS’ or ‘LINES_ADJ’”.
        - **content** (*dict**[**str**,* *Buffer* *|* *Sequence**[**float**]* *|* *Sequence**[**int**]* *|* *Sequence**[**Sequence**[**float**]**]* *|* *Sequence**[**Sequence**[**int**]**]**]*) – Maps the name of the shader attribute with the data to fill the vertex buffer.
          For the dictionary values see documentation for [`gpu.types.GPUVertBuf.attr_fill`](gpu.types.html#gpu.types.GPUVertBuf.attr_fill "gpu.types.GPUVertBuf.attr_fill") data argument.

    Returns:
    :   compatible batch

    Return type:
    :   [`gpu.types.GPUBatch`](gpu.types.html#gpu.types.GPUBatch "gpu.types.GPUBatch")
user: What is AnnotationStrokePoint(bpy_struct) and how is it used in Blender Python scripting?

assistant: # AnnotationStrokePoint(bpy_struct)

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

*class* bpy.types.AnnotationStrokePoint(*bpy_struct*)
:   Data point for freehand stroke curve

    co
    :   Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], 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 Select Boundary Loop in Blender? Include parameters, examples, warnings and best practices.

assistant: *Select Boundary Loop* does the opposite of *Select Loop Inner-Region*,
based on all regions currently selected, it selects only the edges at the border (contour) of these islands.
It can operate in any select mode, but when in *Face* mode it will switch to *Edge* select mode after running.

All this is much more simple to illustrate with examples:

[image reference removed]

Select Boundary Loop does the opposite and forces into Edge Select Mode.
user: Show practical ways to work with Tool Settings in a Blender add-on or script – include code.

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

Use Duplicates
:   When enabled, will keep the original selected elements as separated islands in the mesh
    (i.e. unlinked to the result of the spin extrusion).

Axis
:   Specifies the axis to use as the pivot of the spin operation.
user: Provide the full official documentation entry for NodeInputs(bpy_struct), preserving all code examples.

assistant: # NodeInputs(bpy_struct)

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

*class* bpy.types.NodeInputs(*bpy_struct*)
:   Collection of Node Sockets

    new(*type*, *name*, *\**, *identifier=''*, *use_multi_input=False*)
    :   Add a socket to this node

        Parameters:
        :   - **type** (*string**,* *(**never None**)*) – Type, Data type
            - **name** (*string**,* *(**never None**)*) – Name
            - **identifier** (*string**,* *(**optional**,* *never None**)*) – Identifier, Unique socket identifier
            - **use_multi_input** (*boolean**,* *(**optional**)*) – Make the socket multi-input (valid for inputs only)

        Returns:
        :   New socket

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

    remove(*socket*)
    :   Remove a socket from this node

        Parameters:
        :   **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket")) – The socket to remove

    clear()
    :   Remove all sockets from this node

    move(*from_index*, *to_index*)
    :   Move a socket to another position

        Parameters:
        :   - **from_index** (*int in* *[**0**,* *inf**]*) – From Index, Index of the socket to move
            - **to_index** (*int in* *[**0**,* *inf**]*) – To Index, Target index for the 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: Provide the full official documentation entry for Replace Material Node, preserving all code examples.

assistant: # Replace Material Node

[image reference removed]

The *Replace Material* node swaps one material with another.
Replacing a material with this node is more efficient than creating a selection of all faces
with the old material with the [Material Selection Node](material_selection.xhtml)
and then using the [Set Material Node](set_material.xhtml).
user: Describe CompositorNodeDiffMatte(CompositorNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CompositorNodeDiffMatte(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.CompositorNodeDiffMatte(*CompositorNode*)
:   Produce a matte that isolates foreground content by comparing it with a reference 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: Describe Set Spline Cyclic Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Set Spline Cyclic Node

[image reference removed]

The *Set Spline Cyclic* node changes whether splines loop back on themselves –
that is, whether their first and last control points are connected.

You can use the [Is Spline Cyclic Node](../read/is_spline_cyclic.html)
to read this property.
user: Describe Brush Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: ### General

### Unique

Deformation
:   Drag:
    :   Smear colors along the direction of the stroke.

    Pinch:
    :   Smear colors inwards towards your brush center.

    Expand:
    :   Smear colors outwards away from your brush center.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Mode
:   The location to load the IES file from.

    Internal:
    :   Use IES profile from a file embedded in a text data-block in the blend-file, for easy distribution.

    External:
    :   Load IES profile from a file on the drive.
user: What is Header and how is it used in Blender Python scripting?

assistant: Only Show Selected
:   Displays the graph for only selected trackers.

Display Hidden
:   Displays channels from objects that are hidden.

Show Frames
:   Visualizes per-frame average reprojection error of all tracks in the active tracking object.

Show Tracks Motion
:   Shows curves for X and Y speed of tracks.

Show Tracks Error
:   Per-frame reprojection error of tracks.
user: Explain Shape in complete detail according to the official Blender documentation.

assistant: # Shape

[image reference removed]

Shape panel.

Dimensions
:   By default, new curves are set to be 3D, which means that control points can be placed anywhere in 3D space.
    Curves can also be set to 2D which constrain the control points to the curve’s local XY axis.

Resolution Preview/Render U
:   The *resolution* property defines the number of points that are computed between every pair of control points.
    Curves can be made more or less smooth by increasing and decreasing the resolution respectively.
    The *Preview U* setting determines the resolution in the 3D Viewport while the *Render U* setting
    determines the curve’s render resolution. If *Render U* is set to zero (0),
    then the *Preview U* setting is used for both the 3D Viewport and render resolution.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_shape_resolution-3.png   Curves with a resolution of 3. | ../../../_images/modeling_curves_properties_shape_resolution-12.png   Curves with a resolution of 12. |

Twist Method
:   A 3D curve has control points that are not located on the curve’s local XY plane.
    This gives the curve a twist which can affect the curve normals.
    You can alter how the twist of the curve is calculated by choosing from
    *Minimum, Tangent* and *Z-Up* options from the select menu.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_shape_resolution-12.png   Curves with a twist of Minimum. | ../../../_images/modeling_curves_properties_shape_twisting.png   Curves with a twist of Tangent. |

Smooth
:   Interactively removes twists from the curve. This is useful if a curve has noticeable “kinks”
    from over twisting; which can be possible when converting meshes to curves.

Fill Mode
:   Fill determines the way a curve is displayed when it is beveled (see below for details on Beveling).
    When set to *Half* the curve is displayed as half a cylinder.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_shape_fill-half.png   Curves with a fill of Half. | ../../../_images/modeling_curves_properties_shape_fill-full.png   Curves with a fill of Full. |

Curve Deform
:   Radius
    :   Causes the deformed object to be scaled by the set curve radius.
        Utilized when using a curve as a path or when using the [Curve Modifier](../../modifiers/deform/curve.html).

    Stretch
    :   The *Stretch* curve option allows you to let the mesh object stretch, or squeeze, over the entire curve.
        To get the expected result, use this together with the *Bounds Clamp* option.
        Utilized when using the [Curve Modifier](../../modifiers/deform/curve.html).

    Bounds Clamp
    :   When this option is enabled, the object and mesh offset along the deformation axis is ignored.
        This can be useful with the *Stretch* option or when using a negative axis.
        Utilized when using the [Curve Modifier](../../modifiers/deform/curve.html).
user: How do I use Pose in Blender? Include parameters, examples, warnings and best practices.

assistant: # Pose

Deform a model simulating armature-like workflow.
This can either be useful for posing a model without a rig,
adjusting the proportions of a mesh or other fast deformations.

The brush will automatically determine an origin point,
indicated with a while line on the brush cursor.

If the [Deformation Target](../../brush/brush_settings.html#bpy-types-brush-deform-target)
is changed, the brush can also be used for cloth sculpting.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Geometry
:   Standard geometry input, which is used as the default bake item.
    More bake items can be added by dragging sockets into the blank socket or in the *Bake Items* panel.
    Items can be renamed by `Ctrl`-`LMB` on the socket name or in the nodes *Properties* panel.
user: Provide the full official documentation entry for Lock/Mute, preserving all code examples.

assistant: Lock Strips `Ctrl`-`H`
:   Disables the strip from being transformed.

Unlock Strips `Ctrl`-`Alt`-`H`
:   Enables disabled strips allowing them to be transformed.

Mute/Unmute Strips `H`, `Alt`-`H`
:   Mute or unmute the selected strips.

Mute/Unmute Deselected Strips `Shift`-`H`, `Shift`-`Alt`-`H`
:   Mute or unmute all strips but the selected.
user: How do I use Fill Tool in Blender? Include parameters, examples, warnings and best practices.

assistant: # Fill Tool

The Fill tool is used to automatically fill closed strokes areas.

The Fill tool uses any of the Grease Pencil *Fill* draw mode brushes.
Activating a brush from an asset shelf or brush selector will also activate this tool for convenience.
user: What is Face Marks and how is it used in Blender Python scripting?

assistant: Face marks are useful for removing lines from certain areas of a mesh.

Internally, face marks are stored as the `freestyle_face`
[attribute](../../../modeling/geometry_nodes/attributes_reference.xhtml).

Marking faces is done as follows:

1. Select a mesh object and enter *Edit Mode*.
2. Select the faces you want to be marked.
3. Press `Ctrl`-`F` and select Face Data ‣ Mark Freestyle Face.

In this example, two faces of the default cube are marked like the image on the left.
On the right is a render without face marks activated.

|  |  |
| --- | --- |
| ../../../_images/render_freestyle_parameter-editor_line-set_face-marks-example-1.png   Marked faces (Edit Mode). | ../../../_images/render_freestyle_parameter-editor_line-set_face-marks-example-2.png   Render output. |

The line selection can be controlled via inclusion and faces options:

Negation
:   Whether to include or exclude edges matching defined face mark conditions from the line set.

Condition
:   One Face:
    :   (De)select all edges which have one or both neighbor faces marked.

    Both Faces:
    :   (De)select all edges which have both of their neighbor faces marked.

|  |  |
| --- | --- |
| ../../../_images/render_freestyle_parameter-editor_line-set_face-marks-example-3.png   Inclusive, One Face. | ../../../_images/render_freestyle_parameter-editor_line-set_face-marks-example-4.png   Inclusive, Both Faces. |
| ../../../_images/render_freestyle_parameter-editor_line-set_face-marks-example-5.png   Exclusive, One Face. | ../../../_images/render_freestyle_parameter-editor_line-set_face-marks-example-6.png   Exclusive, Both Faces. |
user: Provide the full official documentation entry for Visibility, preserving all code examples.

assistant: Use Light
:   Enables the Grease Pencil object to be affected by lights.

    This property affect the whole object, for more control with lights you can enable or disable
    the use of lights by layers. See [Layers](layers.html) for more information.

    [image reference removed]

    Lights disabled (left) and enabled (right).
user: Explain Keyframe Handle Type Items in complete detail according to the official Blender documentation.

assistant: # Keyframe Handle Type Items

FREE:
:   Free.

    Completely independent manually set handle.

ALIGNED:
:   Aligned.

    Manually set handle with rotation locked together with its pair.

VECTOR:
:   Vector.

    Automatic handles that create straight lines.

AUTO:
:   Automatic.

    Automatic handles that create smooth curves.

AUTO_CLAMPED:
:   Auto Clamped.

    Automatic handles that create smooth curves which only change direction at keyframes.
user: Describe Node Boolean Math Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Node Boolean Math Items

AND:
:   And.

    True when both inputs are true.

OR:
:   Or.

    True when at least one input is true.

NOT:
:   Not.

    Opposite of the input.

---

NAND:
:   Not And.

    True when at least one input is false.

NOR:
:   Nor.

    True when both inputs are false.

XNOR:
:   Equal.

    True when both inputs are equal (exclusive nor).

XOR:
:   Not Equal.

    True when both inputs are different (exclusive or).

---

IMPLY:
:   Imply.

    True unless the first input is true and the second is false.

NIMPLY:
:   Subtract.

    True when the first input is true and the second is false (not imply).
user: Describe Key Features from the Blender manual or Python API, including usage steps and snippets.

assistant: - Blender is a fully integrated 3D content creation suite, offering a broad range of essential tools, including
  [Modeling](../../modeling/introduction.html),
  [Rendering](../../render/introduction.html),
  [Animation & Rigging](../../animation/introduction.html),
  [Video Editing](../../video_editing/index.html),
  [VFX](../../movie_clip/index.html),
  [Compositing](../../compositing/introduction.html),
  [Texturing](../../editors/uv/introduction.html),
  and many types of [Simulations](../../physics/introduction.html).
- It is cross platform, with an OpenGL GUI that is uniform on all major platforms (and customizable with Python
  scripts).
- It has a high-quality 3D architecture, enabling fast and efficient creation workflow.
- It boasts active community support. See [blender.org/community](https://www.blender.org/community) for an
  extensive list of sites.
- It can be installed into and run from any directory without modifying the system.

You can download the latest version of Blender [here](https://www.blender.org/download/).

[image reference removed]

A rendered image being post-processed.

Blender makes it possible to perform a wide range of tasks, and it may seem daunting when first trying to grasp the
basics. However, with a bit of motivation and the right learning material, it is possible to familiarize yourself with
Blender after a few hours of practice.

This manual is a good start, though it serves more as a reference. There are also many online video tutorials from
specialized websites.

Despite everything Blender can do, it remains a tool. Great artists do not create masterpieces by pressing buttons or
manipulating brushes, but by learning and practicing subjects such as human anatomy, composition, lighting, animation
principles, etc.

3D creation software such as Blender have an added technical complexity and jargon associated with the underlying
technologies. Terms like UV maps, materials, shaders, meshes, and “subdivs” are the media of the digital artist, and
understanding them, even broadly, will help you to use Blender to its best.

So keep reading this manual, learn the great tool that Blender is, and keep your mind open to other artistic and
technological areas – and you, too, can become a great artist.
user: Give a detailed overview of NodeSocketColor(NodeSocketStandard): syntax, arguments, return values, common patterns.

assistant: # NodeSocketColor(NodeSocketStandard)

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

*class* bpy.types.NodeSocketColor(*NodeSocketStandard*)
:   RGBA color socket of a node

    default_value
    :   Input value used for unconnected socket

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

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

Limit Location constraint.

Minimum/Maximum X, Y, Z
:   The number fields determine the boundaries for each axis.
    The checkboxes determine whether each boundary applies.

Affect Transform
:   When the owner is manually moved around, restrict not just its
    [visual](../introduction.html#constraint-visual-transform) position but also its
    *Location* in the [Properties Editor](../../../editors/properties_editor.html)’s *Transform* panel.

[Owner](../interface/common.html#rigging-constraints-interface-common-space)
:   The space for determining and limiting the position of the owner.

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

assistant: Crease Angle
:   If two adjacent faces form an angle less than the defined *Crease Angle*,
    the edge between them will be rendered when using *Crease* edge type selection in a line set.
    The value also affects *Silhouette* edge type selection.

Culling
:   Ignore the edges that are out of view.
    (Saves some processing time and memory, but may reduce the quality of the result in some cases.)

Face Smoothness
:   Takes *Smooth Shading* into account for edges calculation.

Sphere Radius
:   Affects the calculation of curvatures for *Ridge*, *Valley*
    and *Suggestive Contour* edge type selection in a line set.
    The curvature at each vertex is computed by averaging the shape
    of the surface within the specified radius.
    Increasing the value reduces noise and detail.

Kr Derivative Epsilon
:   Controls the threshold on the minimum rate of change of curvature used to filter the output
    of the *Suggestive Contour* edge type selection. Increasing the value reduces the amount of
    rendered lines, starting from smoother areas of the object (further information in
    [this PDF](https://archive.blender.org/wiki/2015/index.php/File:Manual-2.6-Render-Freestyle-PrincetownLinestyle.pdf)).
user: Describe Normal Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Normal Node

[image reference removed]

The *Normal* node returns a vector for each evaluated point indicating the
[normal direction](../../../meshes/structure.html#modeling-meshes-structure-normals). The output can depend
on the attribute domain used in the node evaluating the field, but the output
is always a normalized [unit vector](https://en.wikipedia.org/wiki/Unit_vector).

Face:
:   On the face domain, the normal is the “up” direction of the face.

Mesh Vertices:
:   For mesh vertices, the normal is an average of the surrounding face normals.
    If the vertex does not have any connected faces, the output is simply the normalized position
    of that vertex.

Edge:
:   The normal output for each edge is the average of the edge’s two vertex normals.

Face Corner:
:   The output for each face corner is the same as the face normal of the corresponding face.

Curve Control Points:
:   The output of this node when used for curve geometry is the evaluated normal of the curve,
    which depends on the twist method. The normal vector is always perpendicular to the direction
    of the curve’s path at every point.
user: Explain ThemeRegionsScrubbing(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # ThemeRegionsScrubbing(bpy_struct)

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

*class* bpy.types.ThemeRegionsScrubbing(*bpy_struct*)
:   back
    :   Type:
        :   float array of 4 items in [0, 1], default (0.0, 0.0, 0.0, 0.0)

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

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

    time_marker_selected
    :   Type:
        :   float array of 4 items in [0, 1], default (0.0, 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: Give a detailed overview of Enabling Add-on: syntax, arguments, return values, common patterns.

assistant: 1. Open Blender and go to [Add-ons](../../editors/preferences/addons.html) section of the [Preferences](../../editors/preferences/index.html).
2. Search “Node Wrangler” and check the *Enable Add-on* checkbox.
user: What is Stroke Depth Order Items and how is it used in Blender Python scripting?

assistant: # Stroke Depth Order Items

2D:
:   2D Layers.

    Display strokes using Grease Pencil layer order and stroke order to define depth.

3D:
:   3D Location.

    Display strokes using real 3D position in 3D space.
user: Explain Cache in complete detail according to the official Blender documentation.

assistant: # Cache

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

assistant: # CompositorNodeConvolve(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.CompositorNodeConvolve(*CompositorNode*)
:   Convolves an image with a kernel

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

assistant: [image reference removed]

The Vertex Weight Edit modifier panel.

Vertex Group
:   The vertex group to affect.

Default Weight
:   The default weight to assign to all vertices not in the given vertex group.

Group Add
:   Adds vertices with a final weight over *Add Threshold* to the vertex group.

Group Remove
:   Removes vertices with a final weight below *Remove Threshold* from the vertex group.

Normalize Weights
:   Scale the weights in the vertex group to keep the relative weight
    but the lowest and highest values follow the full 0 - 1 range.

### Falloff

Falloff Type
:   Type of mapping.

    Linear
    :   No mapping.

    Custom Curve
    :   Allows you to manually define the mapping using a curve.

    Sharp, Smooth, Root and Sphere
    :   These are classical mapping functions, from spikiest to roundest.

    Random
    :   Uses a random value for each vertex.

    Median Step
    :   Creates binary weights (0.0 or 1.0), with 0.5 as cutting value.

Invert
:   Inverts the falloff.

### Influence

Those settings are the same for the three *Vertex Weight* modifiers.

Global Influence
:   The overall influence of the modifier
    (0.0 will leave the vertex group’s weights untouched, 1.0 is standard influence).

In addition, a per-vertex fine control of the effect is possible using either a vertex group or a texture
(both are mutually exclusive). The per-vertex values from those will be multiplied with the *Global Influence*.

See [common masking options](../common_options.xhtml#modifiers-common-options-masking) for a complete reference.
user: Describe Changing Tools from the Blender manual or Python API, including usage steps and snippets.

assistant: If you have *Alt Click Tool Prompt* enabled in the Keymap Preferences,
tapping `Alt` will display a tool prompt in the Status Bar.
You can then press a key to select the corresponding tool, or tap `Alt` again to cancel the prompt.

### Fallback Tool

The fallback tool is the one that’s selected by default (so the one at the top of the Toolbar).
You can change it by either holding `LMB` on the toolbar button or pressing `Alt`-`W`
to get a pie menu.

### Cycling Tools

If you bind a key to a tool which is part of a group, you can enable the *Cycle* option in the keymap editor.
Successive presses will then cycle through the tools in that group.

This is enabled by default for the selection tools in the 3D Viewport, for example:
pressing `W` will cycle between Select Box, Select Circle and so on.
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Creating an Alpha Mask

An often overlooked use case of the Color Ramp is to turn a black-and-white image
into a colored image with transparency.

[image reference removed]

In the example above, a black-and-white swirl image, which is lacking an alpha channel,
is fed into the Color Ramp node as a *Factor*.

The Color Ramp node is set to a purely transparent color on the left end of the gradient,
and a fully red color on the right. As you can see in the Viewer node,
the Color Ramp node outputs an image that is transparent where the input is black,
and opaque where the input is white.

### Colorizing an Image

In this example, multiple colors are added to the color gradient,
converting a black-and-white image into a flaming swirl.

[image reference removed]

The shades of gray in the input image are mapped to three colors:
blue, yellow, and red, all fully opaque. Where the image is black,
the Color Ramp substitutes blue (the first color stop). Where it is some shade of gray,
the Color Ramp outputs a corresponding color from the gradient (bluish, yellow, to reddish).
Where the image is fully white, the Color Ramp outputs red.