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

assistant: Instances
:   Standard geometry input.

Selection
:   Boolean field used to determine if an instance will be rotated.

Rotation
:   The [Euler](../../../glossary/index.xhtml#term-Euler) rotation to rotate the instances by.

Pivot Point
:   The position around which each instance is rotated. If the *Local Space* input is true,
    the location is relative to the initial transform of the instance.

Local Space
:   If enabled, the instances are rotated in local space. In other words,
    they are rotated around the axes described by the initial transform of each instance.
    When the input is disabled, the pivot point and rotation are specified in
    the local space of the modifier object.
user: Show practical ways to work with Rigid Body Properties in a Blender add-on or script – include code.

assistant: # Rigid Body Properties

Type
:   Role of the rigid body in the simulation.

    Active:
    :   The object is dynamic and is directly controlled by simulation results.

    Passive:
    :   The object remains static and is directly controlled by animation system,
        thus does not have [Dynamics](dynamics.xhtml) properties.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [[image reference removed]](../../../_images/modeling_modifiers_modify_mesh-cache_panel.png)

Mesh Cache Modifier.

Format
:   Specifies the input file format. The modifier currently supports `.mdd` and `.pc2`.

File Path
:   Path to the external cache file containing the animation data.

Influence
:   Controls the strength of the deformation. Lower values blend the cached animation with the original mesh shape.

Deform Mode
:   Determines how the cache data influences the mesh:

    Overwrite:
    :   Replaces vertex positions with those from the cache file.

    Integrate:
    :   Blends the cache deformation with existing deformations, such as shape keys or modifiers.

Interpolation
:   Controls how frames between cache data are handled:

    None:
    :   Uses only the raw frame data from the cache without interpolation.

    Linear:
    :   Blends between frames for smoother transitions, useful when cache frames do not align perfectly with the scene
        frames.

Vertex Group
:   If set, restrict the effect to the only vertices in that vertex group.

    Invert
    :   Inverts the influence of the selected vertex group, meaning that the group
        now represents vertices that will not be deformed by the modifier.

        The setting reverses the weight values of the group.

### Time Remapping

Time Mode
:   Defines how animation time is interpreted:

    Frame:
    :   Ignores timing data from the cache and plays back frames directly.
        This mode provides direct control over playback speed.

    Time:
    :   Uses the cache’s timing data, including offsets and frame durations.

    Factor:
    :   Maps the entire animation to a range between `0` and `1` for precise control.

Play Mode
:   Specifies how playback timing is determined:

    Scene:
    :   Uses the scene’s current frame for playback.

        Frame Start
        :   Defines the starting frame for playback.

        Frame Scale
        :   Adjusts the playback speed by scaling time.

    Custom:
    :   Allows manual control of animation timing.

        Evaluation Value
        :   Determines animation playback position, which can be animated for precise control.

### Axis Mapping

Forward/Up Axis
:   Specifies the forward and up axes of the imported animation, ensuring proper orientation.

Flip Axis
:   Flips the animation along a chosen axis if the imported data requires correction.
user: Give a detailed overview of Import: syntax, arguments, return values, common patterns.

assistant: ### General

Scale
:   Value by which to scale the imported objects in relation to the world’s origin.

Scene Unit
:   Apply current scene’s unit (as defined by unit scale) to imported data.

Forward Axis, Up Axis
:   Since many applications use a different axis for ‘Up’, these are axis conversion for these settings,
    Forward and Up axes – By mapping these to different axes you can convert rotations
    between applications default up and forward axes.

    Blender uses Y Forward, Z Up (since the front view looks along the +Y direction).
    For example, it’s common for applications to use Y as the up axis, in that case -Z Forward, Y Up is needed.

### Options

Merge Vertices
:   Attempts to combine co-located vertices where possible.

Import Vertex Colors
:   The color space that the color data in the ply-file was saved in.

    None:
    :   Does not import vertex color data.

    sRGB:
    :   Vertex colors in the file are in sRGB [Color Space](../../glossary/index.xhtml#term-Color-Space)

    Linear:
    :   Vertex colors in the file are in Linear [Color Space](../../glossary/index.xhtml#term-Color-Space)
user: What is Properties and how is it used in Blender Python scripting?

assistant: Data Type
:   The data type of the grid to which the transform is applied.
    Determines the kind of values stored in the grid
    (e.g. *Float*, *Integer*, *Boolean*, *Vector*), and must match the input grid’s data type.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

The Mirror modifier.

Axis
:   The X, Y, Z axis along which to mirror, i.e. the axis perpendicular to the mirror plane of symmetry.

    To understand how the axis applies to the mirror direction, if you were to mirror on the X axis,
    the positive X values of the original mesh would become the negative X values on the mirrored side.

    You can select more than one of these axes. And will then get more mirrored copies.
    With one axis you get a single mirror, with two axes four mirrors, and with all three axes eight mirrors.

Bisect
:   If the mesh is already on both sides of the mirror plane, it is cut by that plane,
    and only one side (the “positive” one by default) is kept to perform the mirror process.

Flip
:   When *Bisect* is enabled on an axis, you can use this setting to switch the side kept and mirrored
    (i.e. when it is enabled, the “negative” side will be kept, instead of the “positive” one).

Mirror Object
:   An [Object Selector](../../../interface/controls/templates/data_block.xhtml#ui-data-id) to select an object (usually an empty),
    which position and rotation will be used to define mirror planes
    (instead of using the ones from the modified object).

    You can animate it to move the mirror axis.

Clipping
:   Prevents vertices from moving through the mirror plane(s) when you transform them in Edit Mode.

    If it is enabled but vertices are beyond the mirror plane and outside of the *Merge Distance*,
    the vertices will not be merged. But as soon as the vertices are within *Merge Distance*
    they are snapped together and cannot be moved beyond the mirror plane.

Merge
:   Where a vertex is in the same place (within the *Merge Distance*) as its mirror
    it will be merged with the mirrored vertex.

    Merge Distance
    :   The maximum distance between a vertex and its mirror copy at which they are merged together
        (being snapped on the mirror plane). Needs *Merge* to be enabled.

Bisect Distance
:   Distance from the bisect plane within which vertices are removed.

### Data

Flip UV
:   With this option you can mirror the UV texture coordinates across the middle of the image.

    E.g. if you have a vertex with UV coordinates of (0.3, 0.9),
    its mirror copy will have UV coordinates of (0.7, 0.1).

UV Offsets
:   Amount to shift mirrored UVs on the U/V axes.

    It’s useful for baking (as overlapping UVs can cause artifacts to appear in the baked map),
    so the UVs can be moved outside the image and not used for baking, but still be used for display.

Vertex Groups
:   Try to mirror existing vertex groups, with the following specific prerequisites:

    - The vertex groups you want to mirror must be named following the usual left/right pattern
      (i.e. with suffixes like “.R”, “.right”, “.L”, etc.).
    - The mirror side vertex group must already exist (it will not be created automatically).
      It must also be completely empty (no vertices assigned to it).

Flip UDIM
:   Mirror the texture coordinates around each tile center.
user: What is ShaderNodeLightPath(ShaderNode) and how is it used in Blender Python scripting?

assistant: # ShaderNodeLightPath(ShaderNode)

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

*class* bpy.types.ShaderNodeLightPath(*ShaderNode*)
:   Retrieve the type of incoming ray for which the shader is being executed.
    Typically used for non-physically-based tricks

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # KeyingSetInfo(bpy_struct)

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

*class* bpy.types.KeyingSetInfo(*bpy_struct*)
:   Callback function defines for builtin Keying Sets

    bl_description
    :   A short description of the keying set

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

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

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

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

    bl_options
    :   Keying Set options to use when inserting keyframes

        Type:
        :   enum set in [Keying Flag Items](bpy_types_enum_items/keying_flag_items.html#rna-enum-keying-flag-items), default set()

    poll(*context*)
    :   Test if Keying Set can be used or not

        Return type:
        :   boolean

    iterator(*context*, *ks*)
    :   Call generate() on the structs which have properties to be keyframed

    generate(*context*, *ks*, *data*)
    :   Add Paths to the Keying Set to keyframe the properties of the given data

    *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 ThemeInfo(bpy_struct) in a Blender add-on or script – include code.

assistant: # ThemeInfo(bpy_struct)

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

*class* bpy.types.ThemeInfo(*bpy_struct*)
:   Theme settings for Info

    info_debug
    :   Background color of Debug icon

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

    info_debug_text
    :   Foreground color of Debug icon

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

    info_error_text
    :   Foreground color of Error icon

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

    info_info_text
    :   Foreground color of Info icon

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

    info_operator
    :   Background color of Operator icon

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

    info_operator_text
    :   Foreground color of Operator icon

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

    info_property
    :   Background color of Property icon

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

    info_property_text
    :   Foreground color of Property icon

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

    info_selected
    :   Background color of selected line

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

    info_selected_text
    :   Text color of selected line

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

    info_warning_text
    :   Foreground color of Warning icon

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

    space
    :   Settings for space

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: The title shows the name/type of the node;
it can be overridden by changing the node’s [Label](node_editors.xhtml#bpy-types-node-label).
On the left side of the title is the *collapse* toggle
which can be used to collapse the node. This can also be done with `H`.

[image reference removed]

How a node appears when collapsed.

### Preview

Previews are an overlay that shows a small image above the node displaying the node result.
Not all nodes support previews, but the ones that do can be toggled using
the / icons in the top right-hand corner of the node next to the title.

Previews can be disabled for the whole node tree by using
[Previews](node_editors.xhtml#bpy-types-spacenodeoverlay-show-previews) overlay toggle.
user: Provide the full official documentation entry for Drivers, preserving all code examples.

assistant: Upgrading to the latest graphics drivers often solves problems. Newer drivers have bug fixes that help Blender
function correctly.

On macOS, graphics drivers are built into the operating system and the only way to get newer drivers is to upgrade
macOS as a whole to the latest version.
user: Describe NodeSocketIntFactor(NodeSocketStandard) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeSocketIntFactor(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.NodeSocketIntFactor(*NodeSocketStandard*)
:   Integer number socket of a node

    default_value
    :   Input value used for unconnected socket

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

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

assistant: port issue on this page On this page Geometry Operators attribute_add() attribute_convert() attribute_remove() color_attribute_add() color_attribute_convert() color_attribute_duplicate() color_attribute_remove() color_attribute_render_set() execute_node_group() geometry_randomization()
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Geometry
:   Standard geometry input.

Selection
:   Boolean field for specifying which elements should be selected in the output geometry.
    Elements for which this field evaluates to false are implicitly de-selected.
user: What is Glow Strip and how is it used in Blender Python scripting?

assistant: # Glow Strip

This effect makes parts of an image glow brighter by working on
the luminance channel of an image.
The *Glow* is the superposition of the base image and a modified version,
where bright areas are blurred.

To “animate” the glow effect,
mix it with the base image using the Gamma Cross effect,
crossing from the base image to the glowing one.
user: Explain Bpy.Types.Texture in complete detail according to the official Blender documentation.

assistant: lt_value ParticleSettings.active_texture TextureNodeTexture.texture TextureSlot.texture VertexWeightEditModifier.mask_texture VertexWeightMixModifier.mask_texture VertexWeightProximityModifier.mask_texture VolumeDisplaceModifier.texture WarpModifier.texture WaveModifier.texture Next TextureNode(NodeInternal) Previous TextStrip(EffectStrip) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page Texture(ID) Texture Texture.animation_data Texture.color_ramp Texture.contrast Texture.factor_blue Texture.factor_green Texture.factor_red Texture.intensity Texture.node_tree Texture.saturation Texture.type Texture.use_clamp Texture.use_color_ramp Texture.use_nodes Texture.use_preview_alpha Texture.users_material Texture.users_object_modifier Texture.evaluate() Texture.bl_rna_get_subclass() Texture.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Give a detailed overview of Displace Node: syntax, arguments, return values, common patterns.

assistant: # Displace Node

[image reference removed]

The *Displace Node* displaces the pixel position based on an input vector.

This node could be used to model phenomena, like hot air distortion,
refractions of uneven glass or for surreal video effects.
user: How do I use Additional Workflows in Blender? Include parameters, examples, warnings and best practices.

assistant: 2D Grab Brush
:   If the [Falloff Shape](../../brush/falloff.xhtml#bpy-types-brush-falloff-shape) is set to *Projected*,
    the brush can grab infinitely deep into the viewport.
    This is especially useful for much broader changes to a sculpt.

    [image reference removed]

    The stroke can also be started outside of the mesh (like in empty 3D space)
    and grab the vertices within the brush radius.
    This can be useful for sculpting flat and tube-like meshes.
user: Explain Source in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Paint source panel.

*Paint* source setting lets you define how brush influence/intersection is defined.

Mesh Volume

The Brush affects all surface point inside the mesh volume.

[image reference removed]

Source: Mesh Volume.

Proximity

Only uses defined distance to the closest point on brush mesh surface.
Note that inside of the volume is not necessarily affected because it is not close to the surface.

[image reference removed]

Source: Proximity. Brush affects all canvas pixels around it.

Mesh Volume + Proximity

Same as volume type, but also has influence over defined distance.

Inner Proximity
:   Applies proximity inside the mesh volume.

Negate Volume
:   Negates brush alpha within mesh volume.

|  |  |
| --- | --- |
| ../../_images/physics_dynamic-paint_brush_source-mesh-volume-proximity-1.png   The Volume + Proximity brush with no additional settings. | ../../_images/physics_dynamic-paint_brush_source-mesh-volume-proximity-2.png   Inner Proximity. Proximity falloff is now visible inside the volume. |
| ../../_images/physics_dynamic-paint_brush_source-mesh-volume-proximity-3.png   Negate Volume. Inner side of the volume has become completely transparent. | ../../_images/physics_dynamic-paint_brush_source-mesh-volume-proximity-4.png   Inner Proximity and Negate Volume enabled together. |

Object Center

Instead of calculating proximity to the brush object mesh, which can be quite slow in some cases,
only distance to only center is calculated. This is much faster and often good enough.

[image reference removed]

Source: Object Center.

Particle System

Brush influence is defined by particles from a selected particle system.

[image reference removed]

Effect Solid Radius
:   Defines the distance, inside which paint is solid color.

Use Particle Radius
:   Uses the settings in the particle panel to determine solid radius size.
    Solid Radius size disabled while Particle Radius enabled.

Smooth Radius
:   An additional radius outside Solid Radius to add a smooth falloff.

    If you set “Smooth Radius” to zero, particle will be painted as a solid sphere.
    If you set “Solid Radius” to zero, it gets painted as a smooth halo.

    [image reference removed]

    [image reference removed]

    Source: Particle System.

### Common Options

Paint Distance
:   The maximum distance to mesh surface to affect paint.

Project
:   Projects brush to the canvas from a defined direction.
    Basically this can be considered as “direction aligned” proximity.

    [image reference removed]

    The Project option enabled. See how brush only affects canvas in normal direction.

Falloff
:   Sharp:
    :   Paints solid paint within the defined distance.

    Smooth:
    :   Makes paint to linearly fade out until becoming completely invisible
        when it reaches the maximum distance.

    Color Ramp:
    :   Allows you to manually make a custom falloff behavior.
user: What is Options and how is it used in Blender Python scripting?

assistant: [image reference removed]

Damped Track constraint.

[Target](../interface/common.xhtml#rigging-constraints-interface-common-target)
:   The object or bone to point towards.

Track Axis
:   The local axis of the owner that should point at the target.
    For bones, this should typically be Y.

    A negative axis will make the owner point away from the target instead.

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

assistant: In some configurations of the node, especially for low values of *Randomness*,
rendering artifacts may occur. This happens due to the same reasons described
in the [Notes section](../../../render/shader_nodes/textures/white_noise.html#shader-white-noise-notes) in the White Noise Texture page
and can be fixed in a similar manner as described there.
user: Give a detailed overview of Output: syntax, arguments, return values, common patterns.

assistant: Leading
:   The running total of values in the corresponding group, starting at the first value.

Trailing
:   The running total of values in the corresponding group, starting at zero.

Total
:   The total of all the values in the corresponding group.
user: Show practical ways to work with Tool-specific Nodes in a Blender add-on or script – include code.

assistant: The following nodes are only supported in the *Tool* context:

- [3D Cursor Node](input/scene/3d_cursor.xhtml)
- [Mouse Position Node](input/scene/mouse_position.xhtml)
- [Viewport Transform Node](input/scene/viewport_transform.xhtml)
- [Active Element Node](geometry/read/active_element.xhtml)
- [Selection Node](geometry/read/selection.xhtml)
- [Set Selection Node](geometry/write/set_selection.xhtml)
- [Face Set Node](mesh/read/face_set.xhtml)
- [Set Face Set Node](mesh/write/set_face_set.xhtml)
user: What is Stroke Placement and how is it used in Blender Python scripting?

assistant: # Stroke Placement

[image reference removed]

Stroke Placement pop-over.

The Stroke Placement selector helps to select the location in which strokes are drawn.

Origin:
:   Strokes are placed at Grease Pencil object origin.

3D Cursor:
:   Strokes are placed at 3D cursor.

Surface:
:   Strokes will stick on mesh surfaces.

    Offset
    :   Distance from the mesh surface to place the new strokes.

    Project Onto Selected
    :   Only project the strokes onto selected objects.

Stroke:
:   Strokes will stick on other strokes.

    Target
    :   All Points:
        :   All the points of the new stroke sticks to other strokes.

        End Points:
        :   Only the start and end points of the new stroke sticks to other strokes.

        First Point:
        :   Only the start point of the new stroke sticks to other strokes.

Stroke using different Stroke Placements.

|  |  |  |  |
| --- | --- | --- | --- |
| ../../../_images/grease-pencil_modes_draw_stroke-placement_origin.png   Origin. | ../../../_images/grease-pencil_modes_draw_stroke-placement_3D-cursor.png   3D Cursor. | ../../../_images/grease-pencil_modes_draw_stroke-placement_surface.png   Surface. | ../../../_images/grease-pencil_modes_draw_stroke-placement_stroke.png   Stroke. |
user: Show practical ways to work with Camera Positioning in a Blender add-on or script – include code.

assistant: There are several different ways to position the camera in your scene.
Some of them are explained below.

### Align Active Camera to View

Moves and rotates the camera so it perfectly matches your current viewport view.

### Camera Navigation

By enabling [Lock Camera to View](../sidebar.html#bpy-types-spaceview3d-lock-camera) in
Sidebar ‣ View and switching to camera view or toggle the lock navigation gizmo button
when in camera view, the camera will become “glued” to the view and follow it around as you navigate.

### Roll, Pan, Dolly, and Track

To perform these camera moves, the camera must first be selected so transform operations apply to it.
The following actions also assume that you are in camera view.
Having done so, you can now manipulate the camera using the same tools that are used to transform any object:

Roll
:   Press `R` to enter object rotation mode. The default will be to rotate the camera along its local Z axis
    (the axis orthogonal to the camera view), which is the definition of a camera “roll”.

Vertical Pan or Pitch
:   This is just a rotation along the local X axis. Press `R` to enter object rotation mode,
    then `X` twice. (The first press selects the *global* axis, the second the *local* axis.
    This works with any axis; see [Axis Locking](../../../scene_layout/object/editing/transform/control/axis_locking.html)).

Horizontal Pan or Yaw
:   This corresponds to a rotation around the camera’s local Y axis.
    Press `R`, then `Y` twice.

Dolly
:   To dolly the camera, press `G` then `MMB` (or `Z` twice).

Sideways Tracking
:   Press `G` and move the mouse (you can use `X` or `Y` twice
    to get purely horizontal or vertical tracking).
user: Give a detailed overview of ShaderNodeFloatCurve(ShaderNode): syntax, arguments, return values, common patterns.

assistant: # ShaderNodeFloatCurve(ShaderNode)

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

*class* bpy.types.ShaderNodeFloatCurve(*ShaderNode*)
:   Map an input float to a curve and outputs a float value

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: ### Noise Basis

Each noise-based Blender texture (except Voronoi and Simple Noise) has
a *Noise Basis* setting that allows the user to select
which algorithm is used to generate the texture.
This list includes the original Blender noise algorithm.
The *Noise Basis* settings makes the procedural textures extremely flexible (especially *Musgrave*).

The *Noise Basis* governs the structural appearance of the texture:

|  |  |  |
| --- | --- | --- |
| ../../../_images/render_materials_legacy-textures_introduction_noise-basis-blender-original.jpg   Blender Original. | ../../../_images/render_materials_legacy-textures_introduction_noise-basis-voronoi-f1.jpg   Voronoi F1. | ../../../_images/render_materials_legacy-textures_introduction_noise-basis-voronoi-f2-f1.jpg   Voronoi F2-F1. |
| ../../../_images/render_materials_legacy-textures_introduction_noise-basis-original-perlin.jpg   Original Perlin. | ../../../_images/render_materials_legacy-textures_introduction_noise-basis-voronoi-f2.jpg   Voronoi F2. | ../../../_images/render_materials_legacy-textures_introduction_noise-basis-voronoi-crackle.jpg   Voronoi Crackle. |
| ../../../_images/render_materials_legacy-textures_introduction_noise-basis-improved-perlin.jpg   Improved Perlin. | ../../../_images/render_materials_legacy-textures_introduction_noise-basis-voronoi-f3.jpg   Voronoi F3. | ../../../_images/render_materials_legacy-textures_introduction_noise-basis-cell-noise.jpg   Cell Noise. |
| ../../../_images/render_materials_legacy-textures_introduction_noise-basis-voronoi-f4.jpg   Voronoi F4. |  |  |

There are two more possible settings for *Noise Basis*, which are relatively similar to *Blender Original*:
Improved Perlin and Original Perlin.

### Nabla

Almost all procedural textures in Blender use derivatives for calculating normals for texture mapping
(except *Blend* and *Magic*). This is important for Normal and Displacement Maps.
The strength of the effect is controlled with the *Nabla* number field.
user: Show practical ways to work with Future Development in a Blender add-on or script – include code.

assistant: This section describes interesting avenues for further development.
Even though it is not an exhaustive list, it might help to better understand
the current functionality of Blender’s Asset Browser.

### Non-Data-Block Assets

Non-Blender assets, such as image or audio files, will likely be supported in a future version.
For such files, asset metadata is then stored in XMP sidecar files, similar to what other software is also doing.
Importers (USD, glTF, FBX, …) could add support for their file types as assets this way too.
Furthermore, it should become possible to enrich an asset with a Python script,
which can then provide code to be run when the asset is used.

### Cross Blend-File Editing

As described above, Blender itself is not allowed to write to other blend-files
than the currently open one. This rule helps to limit complexities; for example,
it is hard to reliably implement an undo system when manipulating other files.
The rule does get in the way of mass-updating assets when they are stored in various blend-files.

Since there is already tooling that can manipulate blend-files outside of Blender itself
(see [Blender Asset Tracer](https://projects.blender.org/blender/blender-asset-tracer)),
it’s possible to also create an external tool for doing such edits across blend-files.
Such a tool might even be implemented via Blender’s application templates system,
or as an add-on; the rule above applies to Blender itself, not to its add-ons.

### Asset Pushing

Asset **pushing** is a way of getting assets into the asset library, where you are working on a file
and want to copy the asset from that file into the library. This is a concept that appears deceptively simple.
In certain cases it is actually simple, but often enough it gets quite complex. For example,
when you want to push an object into an external asset library, should that also copy the materials?
What about the texture images referenced by those materials?
What about objects referenced by custom properties, constraints, or modifiers?
And in which files would they have to go?
Do they all go into one big `assets.blend`, individual blend-files,
or into a directory per asset type? Blender should not be making such decisions for you.

For specific cases, these things are all solvable. For this reason the pose library has been created as
an add-on which is enabled by default. Studios with specific needs can disable the add-on
and implement their own functionality; the building blocks are all in Blender’s core,
and thus do not need to be copied for this. Furthermore, add-ons can write to other blend-files,
so they could make the decisions for users.

Asset pushing is desirable. Because of the questions above, it is unknown how to
implement this well, in a way that still allows artists control over their assets.
user: Describe Brush Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: Density Mode
:   Determines whether the brush adds or removes curves.

    Auto:
    :   Either add or remove curves depending on the distance between existing curve roots under the cursor.

    Add:
    :   Add new curves between existing curves, taking the minimum distance into account.

    Remove:
    :   Remove curves whose root points are too close.

Distance Min
:   Goal distance between the curve roots.

    Edit Minimum Distance `R`
    :   Interactively sets the *Distance Min* value by displaying
        a graphic inside the brush cursor, giving a representation of the density.

        The density can be adjusted by moving the mouse cursor closer or farther from the paint cursor.
        The *Distance Min* will be changed once the operator is confirmed.

Count Max
:   The maximum amount of points that the brush tries to sample in the surface.
user: Give a detailed overview of Bpy.Types.Shadernodetexsky: syntax, arguments, return values, common patterns.

assistant:  NodeInternal.bl_rna_get_subclass NodeInternal.bl_rna_get_subclass_py ShaderNode.poll ShaderNode.bl_rna_get_subclass ShaderNode.bl_rna_get_subclass_py Next ShaderNodeTexVoronoi(ShaderNode) Previous ShaderNodeTexNoise(ShaderNode) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page ShaderNodeTexSky(ShaderNode) ShaderNodeTexSky ShaderNodeTexSky.aerosol_density ShaderNodeTexSky.air_density ShaderNodeTexSky.altitude ShaderNodeTexSky.color_mapping ShaderNodeTexSky.ground_albedo ShaderNodeTexSky.ozone_density ShaderNodeTexSky.sky_type ShaderNodeTexSky.sun_direction ShaderNodeTexSky.sun_disc ShaderNodeTexSky.sun_elevation ShaderNodeTexSky.sun_intensity ShaderNodeTexSky.sun_rotation ShaderNodeTexSky.sun_size ShaderNodeTexSky.texture_mapping ShaderNodeTexSky.turbidity ShaderNodeTexSky.is_registered_node_type() ShaderNodeTexSky.input_template() ShaderNodeTexSky.output_template() ShaderNodeTexSky.bl_rna_get_subclass() ShaderNodeTexSky.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Provide the full official documentation entry for With Envelope Weights, preserving all code examples.

assistant: Works in a similar way to *With Automatic Weights*. The difference is that the influences are calculated
based on the [Bone Envelopes](../bones/properties/deform.xhtml#armature-bones-envelope) settings.
It will assign a weight to each vertex group the vertices that is inside its bone’s influence volume,
depending on their distance to this bone.

This means newly included/excluded vertices or new envelope settings will not be taken into account.
You will have to apply Armature Deform With Envelope Weights parenting again.

[image reference removed]

Two sets of armatures, each with three bones.
user: Give a detailed overview of Controls: syntax, arguments, return values, common patterns.

assistant: :   Adds a new stop between the selected stop and the one before it.
:   Deletes the selected color stop.

Tools
:   Contains more operators for the color ramp.

    Flip Color Ramp
    :   Flips the gradient, mirroring the positions of the stops.

    Distribute Stops from Left
    :   Distribute the stops so that every step has the same space to the right.
        This is mostly useful when used with Constant interpolation mode.

    Distribute Stops Evenly
    :   Distribute the stops so that all neighbors have the same space between them.

    Eyedropper `E`
    :   An [Eyedropper](../buttons/eyedropper.xhtml#ui-eyedropper) to sample a color or gradient from the interface to be used in the color ramp.

    Reset Color Ramp
    :   Resets the color ramp to its default state.

Color Mode
:   Selection of the [Color Model](../../../glossary/index.xhtml#term-Color-Model) used for interpolation.

    RGB:
    :   Blends color by mixing each color channel and combining.

    HSV/HSL:
    :   Blends colors by first converting to HSV or HSL, mixing, then combining again.
        This has the advantage of maintaining saturation between different hues,
        where RGB would de-saturate. This allows for a richer gradient.

Color Interpolation
:   The interpolation method to use across the ramp.

    RGB
    :   B-Spline:
        :   Uses a B-spline interpolation for the color stops.

        Cardinal:
        :   Uses a cardinal interpolation for the color stops.

        Linear:
        :   Uses a linear interpolation for the color stops.

        Ease:
        :   Uses an ease interpolation for the color stops.

        Constant:
        :   Uses a constant interpolation for the color stops.

    HSV/HSL
    :   Clockwise:
        :   Clockwise interpolation around the HSV/HSL wheel.

        Counter-Clockwise:
        :   Counterclockwise around the HSV/HSL wheel.

        Near:
        :   Nearest route around the wheel.

        Far:
        :   Furthest route around the wheel.

        [image reference removed]

        HSV and HSL interpolation options.

Active Color Stop
:   Index of the active color stop (shown as a dashed line).
    Offers an alternative way of selecting a stop in case it’s so close to others
    that it’s hard to select it directly.

Position
:   This slider controls the position of the selected color stop in the range.

Color
:   A [color field](../buttons/fields.xhtml) where you can
    specify the color and alpha of the selected stop.

### Shortcuts

- `LMB` (drag) moves color stops.
- `Ctrl`-`LMB` (click) adds a new color stop.
user: What is Vertex Group and how is it used in Blender Python scripting?

assistant: [image reference removed]

Typical modifier Vertex Group options.

[Vertex Groups](../meshes/properties/vertex_groups/introduction.xhtml) are an easy way to control
which vertices are affected by a modifier, and to which extent (using their weights).
They are available when modifying meshes or lattices.

Vertex Group
:   The vertex group name.

    Invert
    :   Inverts the influence of the selected vertex group, meaning that the group
        now represents vertices that will not be deformed by the modifier.

        The setting reverses the weight values of the group.
        Only available in some modifiers.
user: What is Subsurface Scattering and how is it used in Blender Python scripting?

assistant: # Subsurface Scattering

[image reference removed]

The *Subsurface Scattering* node is used to add simple subsurface multiple scattering,
for materials such as skin, wax, marble, milk and others. For these materials,
rather than light being reflect directly off the surface, it will penetrate the surface and
bounce around internally before getting absorbed or leaving the surface at a nearby point.

How far the color scatters on average can be configured per RGB color channel. For example,
for skin, red colors scatter further, which gives distinctive red-colored shadows,
and a soft appearance.
user: What is Solve and how is it used in Blender Python scripting?

assistant: Tripod
:   Tripod Motion can be used for footage where the camera does not move and only rotates.
    Such footage can’t be tracked with a generic solver approach, and
    it is impossible to determine the actual feature points in space due to a lack of information.
    So this solver will solve only the relative camera rotation and then reproject the feature points into a sphere,
    with the same distance between feature and camera for all feature points.

Keyframe
:   Automatically select keyframes for initial reconstruction.
    This option enables complex algorithms which tries to find a keyframe pair
    with minimal reconstruction error and best scene scale guess.

Keyframe A/B
:   Start (A) and End (B) frame of the range used for reconstruction.

Refine
:   Specifies which parameters should be refined during solve.
    Such refining is useful when you are not sure about some camera intrinsics,
    and solver should try to find the best parameter for those intrinsics.
    But you still have to know approximate initial values –
    it will fail to find correct values if they were set completely incorrectly initially.

    Focal Length
    :   Refine the camera’s [Focal Length](../sidebar/track/camera.xhtml#bpy-types-movietrackingcamera-focal-length).

    Optical Center
    :   Refine the camera’s [Optical Center](../sidebar/track/camera.xhtml#bpy-types-movietrackingcamera-principal-point).

    Radial Distortion
    :   Refine the camera’s [Radial Distortion Parameters](../sidebar/track/camera.xhtml#bpy-types-movietrackingcamera-k).

    Tangential Distortion
    :   Refine the camera’s [Tangential Distortion Parameters](../sidebar/track/camera.xhtml#bpy-types-movietrackingcamera-brown-p).

Solve Camera/Object Motion
:   See [Solve Camera/Object Motion](../editing/track.xhtml#bpy-ops-clip-solve-camera).
user: What is Deleting Vertex Groups and how is it used in Blender Python scripting?

assistant: [image reference removed]

Delete a vertex group.

You delete a vertex group by first making it the active group
(select it in the panel) and then `LMB`
the  button at the right panel border.

Deleting a vertex group only deletes the vertex assignments to the group.
The vertices themselves are not deleted.
user: What is Separate and how is it used in Blender Python scripting?

assistant: The *Separate* operator removes the selected nodes from a node group
and places them in the parent node tree.
This is useful when nodes need to be edited outside of a group for clarity or reuse.

Copy
:   Duplicates the selected nodes into the parent node tree,
    while keeping the originals inside the group.
    This is useful when you want to reuse nodes outside of the group
    but still preserve the group definition.

Move
:   Moves the selected nodes to the parent node tree,
    removing them from the original group.
    This is useful when simplifying a group or exposing its contents directly.
user: What is Hook Modifier and how is it used in Blender Python scripting?

assistant: # Hook Modifier

The *Hook* modifier is used to deform a mesh, curve or lattice using another object
(usually an empty or a bone but it can be any object).
As an object specified as hook moves, it pulls vertices or control points from the geometry with it.
You can think of it as animated
[Proportional Editing](../../../editors/3dview/controls/proportional_editing.xhtml).

While hooks do not give you the fine control over vertices movement that shape keys do,
they have the advantage that you can select vertices directly for manipulation.

To assign selected vertices (in Edit Mode) you can use the *Assign* button on the modifier panel
or use the [Add Hook](../../meshes/editing/vertex/hooks.xhtml#bpy-ops-object-hook-add-selob) menu.
user: What is Inputs and how is it used in Blender Python scripting?

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

Scale
:   Overall texture scale.

Distortion
:   Amount of distortion of the wave.

Detail
:   Amount of distortion noise detail.

Detail Scale
:   Scale of distortion noise.

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

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

assistant: # Shadow Visual Effect

The *Shadow* Visual Effect shows a simulated shadow casting by the object.

For simulating the shadow a color silhouette of the object is displaced in
horizontal and/or vertical direction on the back of the object.