pf.nodes

Submodules

• pf.nodes.compositor — procfunc.nodes.compositor

• pf.nodes.func — procfunc.nodes.func

• pf.nodes.geo — procfunc.nodes.geo

• pf.nodes.math — procfunc.nodes.math

• pf.nodes.shader — procfunc.nodes.shader

Members

class procfunc.nodes.ProcNode

Bases: Generic[T]

Result datatype for all functions that return shader nodes, geometry nodes or compositor nodes.

ProcNode stores the data necessary to construct a blender nodegroup upon later execution.

ProcNode defines dunders to allow concise construction of nodegraphs e.g. __getattr__ and __add__, which map to appropriate blender nodes.

__init__(node, known_value_type=None)

Parameters:

• node (Node)

• known_value_type (type | None)

astype(dtype)

Marks a node as having been converted to a different internal data type, similarly to np.astype

Currently this just adds runtime NodeType data to help subsequent type-inferred functions/operators make a correct choice of data_type.

e.g noise.color + (0.5, 0.5, 0.5) fails but noise.color.astype(t.Vector) + (0.5, 0.5, 0.5) works, because + is defined for Vector but not Color

Parameters:

dtype (type)

Return type:

ProcNode

classmethod from_nodetype(node_type, inputs, attrs)

Parameters:

• node_type (str)

• inputs (dict[str, Any])

• attrs (dict[str, Any])

Return type:

ProcNode

item()

Return type:

Node

property x: ProcNode[float]

property y: ProcNode[float]

property z: ProcNode[float]

Supported special methods: __add__, __mod__, __mul__, __pow__, __radd__, __req__, __rge__, __rgt__, __rle__, __rlt__, __rmod__, __rmul__, __rne__, __rpow__, __rsub__, __rtruediv__, __sub__, __truediv__

class procfunc.nodes.Shader

Bases: object

Used only for type-annotating nodes as returning a shader.

Anythnig that would be a green socket in a SHADER nodegraph should be ProcNode[Shader]

class procfunc.nodes.NodeDataType

Bases: Enum

INT = 'INT'

FLOAT = 'FLOAT'

RGBA = 'RGBA'

FLOAT_VECTOR = 'FLOAT_VECTOR'

FLOAT_VECTOR_2D = 'FLOAT2'

ROTATION = 'ROTATION'

STRING = 'STRING'

BOOLEAN = 'BOOLEAN'

FLOAT_MATRIX = 'FLOAT_MATRIX'

OBJECT = 'OBJECT'

GEOMETRY = 'GEOMETRY'

SHADER = 'SHADER'

COLLECTION = 'COLLECTION'

MATERIAL = 'MATERIAL'

classmethod from_str(s)

Parameters:

s (str)

Return type:

NodeDataType

Supported special methods: __contains__, __getitem__, __iter__, __len__

class procfunc.nodes.NodeGroupType

Bases: Enum

GEOMETRY = 'GeometryNodeTree'

SHADER = 'ShaderNodeTree'

COMPOSITOR = 'CompositorNodeTree'

TEXTURE = 'TextureNodeTree'

Supported special methods: __contains__, __getitem__, __iter__, __len__

class procfunc.nodes.SocketType

Bases: Enum

FLOAT = 'NodeSocketFloat'

INT = 'NodeSocketInt'

VECTOR = 'NodeSocketVector'

ROTATION = 'NodeSocketRotation'

COLOR = 'NodeSocketColor'

BOOLEAN = 'NodeSocketBool'

STRING = 'NodeSocketString'

GEOMETRY = 'NodeSocketGeometry'

SHADER = 'NodeSocketShader'

OBJECT = 'NodeSocketObject'

COLLECTION = 'NodeSocketCollection'

TEXTURE = 'NodeSocketTexture'

MATERIAL = 'NodeSocketMaterial'

Supported special methods: __contains__, __getitem__, __iter__, __len__

procfunc.nodes.as_nodegroup(graph, node_tree_type)

Parameters:

• graph (ComputeGraph)

• node_tree_type (NodeGroupType)

Return type:

NodeGroup

procfunc.nodes.to_aliases(geometry)

Convert instanced geometry into aliases - separate objects sharing the same mesh data.

Uses depsgraph to extract instance transforms and creates one bpy.data.object per instance. All aliases point directly to the original mesh data from the scene - no copying occurs. Each alias has its own transform (position, rotation, scale) but shares mesh data.

Note: Requires geometry nodes that use actual bpy.data.collections with real objects (via collection_info node), not just joined geometry. The instances must be visible in the viewport (show_viewport=True) to be detected by the depsgraph.

Parameters:

geometry (ProcNode[MeshObject]) – node producing instanced geometry (e.g., from instance_on_points)

Returns:

list of MeshObject, one per instance, with each instance pointing to the original mesh data from the scene

Return type:

list[MeshObject]

procfunc.nodes.to_compositor(results)

Parameters:

results (dict[str, ProcNode])

procfunc.nodes.to_curve_object(geometry)

WARNING: currently discards any bezier config or knots, only extracts the points.Any

TODO: Need a better geonodes -> curve op from blender, or need to engineer this in via attribute extraction.

Parameters:

geometry (ProcNode[CurveObject])

Return type:

CurveObject

procfunc.nodes.to_environment(surface=None, volume=None)

Parameters:

• surface (ProcNode[Shader] | None)

• volume (ProcNode[Shader] | None)

Return type:

World

procfunc.nodes.to_light(light, surface)

Apply a shader node graph to a light’s internal node tree.

Parameters:

• light (LightObject)

• surface (ProcNode[Shader])

Return type:

LightObject

procfunc.nodes.to_mesh_object(geometry, _skip_apply=False)

Parameters:

• geometry (ProcNode[MeshObject])

• _skip_apply (bool)

Return type:

MeshObject

procfunc.nodes.to_mesh_object_with_attributes(geometry, attributes=None)

Parameters:

• geometry (ProcNode[MeshObject])

• attributes (dict[str, ProcNode[Vector | Color | float | int | str | bool | Matrix | Quaternion]] | None)

Return type:

tuple[MeshObject, dict[str, Any]]

procfunc.nodes.to_objects_multi(geometries, attributes=None)

Convert a nodegroup which has multiple output geometries into multiple realized objects.

If the objects should have any attributes, provide node definitions for them in the ‘attributes’ argument.

Parameters:

• geometries (dict[str, ProcNode[MeshObject]]) – named output geometry nodes to be converted into objects

• attributes (dict[str, dict[str, ProcNode[Vector | Color | float | int | str | bool | Matrix | Quaternion]]] | None) – named data attributes which should be annotated on those objects. keys must be a subset of the keys of ‘geometries’

• input_obj – optional input object to use for the geometry nodegroups

Returns:

dict of {output_key: object}. output keys are the same as the keys of ‘geometries’

Return type:

• result_objects

procfunc.nodes.node_function(func)

Parameters:

func (Callable)

pf.nodes.compositor

Auto-generated Compositor Node bindings for Blender

class procfunc.nodes.compositor.RenderLayersResult

Bases: object

__init__(base)

Parameters:

base (ProcNode)

Supported special methods: __getattr__

procfunc.nodes.compositor.render_layers()

Uses a RenderLayers Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/input/scene/render_layers.html

Return type:

RenderLayersResult

procfunc.nodes.compositor.alpha_over(fac=1.0, image_0=(1, 1, 1, 1), image_1=(1, 1, 1, 1), premul=0.0, use_premultiply=False)

Uses a AlphaOver Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/mix/alpha_over.html

Parameters:

• fac (ProcNode[float] | float)

• image_0 (ProcNode[Color] | Color)

• image_1 (ProcNode[Color] | Color)

• premul (float)

• use_premultiply (bool)

Return type:

ProcNode

procfunc.nodes.compositor.anti_aliasing(image=(1, 1, 1, 1), contrast_limit=0.2, corner_rounding=0.25, threshold=1.0)

Uses a AntiAliasing Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/anti_aliasing.html

Parameters:

• image (ProcNode[Color] | Color)

• contrast_limit (float)

• corner_rounding (float)

• threshold (float)

Return type:

ProcNode

procfunc.nodes.compositor.bilateralblur(image=(1, 1, 1, 1), determinator=(1, 1, 1, 1), iterations=1, sigma_color=0.3, sigma_space=5.0)

Uses a Bilateralblur Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/blur/bilateral_blur.html

Parameters:

• image (ProcNode[Color] | Color)

• determinator (ProcNode[Color] | Color)

• iterations (int)

• sigma_color (float)

• sigma_space (float)

Return type:

ProcNode

procfunc.nodes.compositor.blur(image=(1, 1, 1, 1), size=1.0, aspect_correction='NONE', factor=0.0, factor_x=0.0, factor_y=0.0, filter_type='GAUSS', size_x=0, size_y=0, use_bokeh=False, use_extended_bounds=False, use_gamma_correction=False, use_relative=False, use_variable_size=False)

Uses a Blur Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/blur/blur.html

Parameters:

• image (ProcNode[Color] | Color)

• size (ProcNode[float] | float)

• aspect_correction (Literal['NONE', 'Y', 'X'])

• factor (float)

• factor_x (float)

• factor_y (float)

• filter_type (Literal['FLAT', 'TENT', 'QUAD', 'CUBIC', 'GAUSS', 'FAST_GAUSS', 'CATROM', 'MITCH'])

• size_x (int)

• size_y (int)

• use_bokeh (bool)

• use_extended_bounds (bool)

• use_gamma_correction (bool)

• use_relative (bool)

• use_variable_size (bool)

Return type:

ProcNode

procfunc.nodes.compositor.bokeh_blur(image=(0.8, 0.8, 0.8, 1), bokeh=(1, 1, 1, 1), size=1.0, bounding_box=1.0, blur_max=16.0, use_extended_bounds=False, use_variable_size=False)

Uses a BokehBlur Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/blur/bokeh_blur.html

Parameters:

• image (ProcNode[Color] | Color)

• bokeh (ProcNode[Color] | Color)

• size (ProcNode[float] | float)

• bounding_box (ProcNode[float] | float)

• blur_max (float)

• use_extended_bounds (bool)

• use_variable_size (bool)

Return type:

ProcNode

procfunc.nodes.compositor.bokeh_image(angle=0.0, catadioptric=0.0, flaps=5, rounding=0.0, shift=0.0)

Uses a BokehImage Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/input/bokeh_image.html

Parameters:

• angle (float)

• catadioptric (float)

• flaps (int)

• rounding (float)

• shift (float)

Return type:

ProcNode

procfunc.nodes.compositor.box_mask(mask=0.0, value=1.0, mask_height=0.1, mask_type='ADD', mask_width=0.2, rotation=0.0, x=0.5, y=0.5)

Uses a BoxMask Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/mask/box_mask.html

Parameters:

• mask (ProcNode[float] | float)

• value (ProcNode[float] | float)

• mask_height (float)

• mask_type (Literal['ADD', 'SUBTRACT', 'MULTIPLY', 'NOT'])

• mask_width (float)

• rotation (float)

• x (float)

• y (float)

Return type:

ProcNode

procfunc.nodes.compositor.bright_contrast(image=(1, 1, 1, 1), bright=0.0, contrast=0.0, use_premultiply=True)

Uses a BrightContrast Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/adjust/bright_contrast.html

Parameters:

• image (ProcNode[Color] | Color)

• bright (ProcNode[float] | float)

• contrast (ProcNode[float] | float)

• use_premultiply (bool)

Return type:

ProcNode

procfunc.nodes.compositor.channel_matte(image=(1, 1, 1, 1), color_space='RGB', limit_channel='R', limit_max=1.0, limit_method='MAX', limit_min=0.0, matte_channel='G')

Uses a ChannelMatte Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/keying/channel_key.html

Parameters:

• image (ProcNode[Color] | Color)

• color_space (Literal['RGB', 'HSV', 'YUV', 'YCC'])

• limit_channel (Literal['R', 'G', 'B'])

• limit_max (float)

• limit_method (Literal['SINGLE', 'MAX'])

• limit_min (float)

• matte_channel (Literal['R', 'G', 'B'])

Return type:

ProcNode

procfunc.nodes.compositor.chroma_matte(image=(1, 1, 1, 1), key_color=(1, 1, 1, 1), gain=1.0, lift=0.0, shadow_adjust=0.0, threshold=0.174533, tolerance=0.523599)

Uses a ChromaMatte Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/keying/chroma_key.html

Parameters:

• image (ProcNode[Color] | Color)

• key_color (ProcNode[Color] | Color)

• gain (float)

• lift (float)

• shadow_adjust (float)

• threshold (float)

• tolerance (float)

Return type:

ProcNode

procfunc.nodes.compositor.color_balance(fac=1.0, image=(1, 1, 1, 1), correction_method='LIFT_GAMMA_GAIN', gain=(1.0, 1.0, 1.0), gamma=(1.0, 1.0, 1.0), lift=(1.0, 1.0, 1.0), offset=(0.0, 0.0, 0.0), offset_basis=0.0, power=(1.0, 1.0, 1.0), slope=(1.0, 1.0, 1.0))

Uses a ColorBalance Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/adjust/color_balance.html

Parameters:

• fac (ProcNode[float] | float)

• image (ProcNode[Color] | Color)

• correction_method (Literal['LIFT_GAMMA_GAIN', 'OFFSET_POWER_SLOPE'])

• gain (tuple)

• gamma (tuple)

• lift (tuple)

• offset (tuple)

• offset_basis (float)

• power (tuple)

• slope (tuple)

Return type:

ProcNode

procfunc.nodes.compositor.color_correction(image=(1, 1, 1, 1), mask=1.0, blue=True, green=True, highlights_contrast=1.0, highlights_gain=1.0, highlights_gamma=1.0, highlights_lift=0.0, highlights_saturation=1.0, master_contrast=1.0, master_gain=1.0, master_gamma=1.0, master_lift=0.0, master_saturation=1.0, midtones_contrast=1.0, midtones_end=0.7, midtones_gain=1.0, midtones_gamma=1.0, midtones_lift=0.0, midtones_saturation=1.0, midtones_start=0.2, red=True, shadows_contrast=1.0, shadows_gain=1.0, shadows_gamma=1.0, shadows_lift=0.0, shadows_saturation=1.0)

Uses a ColorCorrection Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/adjust/color_correction.html

Parameters:

• image (ProcNode[Color] | Color)

• mask (ProcNode[float] | float)

• blue (bool)

• green (bool)

• highlights_contrast (float)

• highlights_gain (float)

• highlights_gamma (float)

• highlights_lift (float)

• highlights_saturation (float)

• master_contrast (float)

• master_gain (float)

• master_gamma (float)

• master_lift (float)

• master_saturation (float)

• midtones_contrast (float)

• midtones_end (float)

• midtones_gain (float)

• midtones_gamma (float)

• midtones_lift (float)

• midtones_saturation (float)

• midtones_start (float)

• red (bool)

• shadows_contrast (float)

• shadows_gain (float)

• shadows_gamma (float)

• shadows_lift (float)

• shadows_saturation (float)

Return type:

ProcNode

procfunc.nodes.compositor.color_matte(image=(1, 1, 1, 1), key_color=(1, 1, 1, 1), color_hue=0.01, color_saturation=0.1, color_value=0.1)

Uses a ColorMatte Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/keying/color_key.html

Parameters:

• image (ProcNode[Color] | Color)

• key_color (ProcNode[Color] | Color)

• color_hue (float)

• color_saturation (float)

• color_value (float)

Return type:

ProcNode

procfunc.nodes.compositor.color_spill(image=(1, 1, 1, 1), fac=1.0, channel='G', limit_channel='R', limit_method='SIMPLE', ratio=1.0, unspill_blue=0.0, unspill_green=0.0, unspill_red=0.0, use_unspill=False)

Uses a ColorSpill Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/keying/color_spill.html

Parameters:

• image (ProcNode[Color] | Color)

• fac (ProcNode[float] | float)

• channel (Literal['R', 'G', 'B'])

• limit_channel (Literal['R', 'G', 'B'])

• limit_method (Literal['SIMPLE', 'AVERAGE'])

• ratio (float)

• unspill_blue (float)

• unspill_green (float)

• unspill_red (float)

• use_unspill (bool)

Return type:

ProcNode

procfunc.nodes.compositor.comb_hsva(h=0.0, s=0.0, v=0.0, a=1.0)

Uses a CombHSVA Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/mix/combine_color.html

Parameters:

• h (ProcNode[float] | float)

• s (ProcNode[float] | float)

• v (ProcNode[float] | float)

• a (ProcNode[float] | float)

Return type:

ProcNode

procfunc.nodes.compositor.comb_rgba(r=0.0, g=0.0, b=0.0, a=1.0)

Uses a CombRGBA Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/mix/combine_color.html

Parameters:

• r (ProcNode[float] | float)

• g (ProcNode[float] | float)

• b (ProcNode[float] | float)

• a (ProcNode[float] | float)

Return type:

ProcNode

procfunc.nodes.compositor.comb_ycca(y=0.0, cb=0.5, cr=0.5, a=1.0, mode='ITUBT709')

Uses a CombYCCA Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/mix/combine_color.html

Parameters:

• y (ProcNode[float] | float)

• cb (ProcNode[float] | float)

• cr (ProcNode[float] | float)

• a (ProcNode[float] | float)

• mode (Literal['ITUBT601', 'ITUBT709', 'JFIF'])

Return type:

ProcNode

procfunc.nodes.compositor.comb_yuva(y=0.0, u=0.0, v=0.0, a=1.0)

Uses a CombYUVA Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/mix/combine_color.html

Parameters:

• y (ProcNode[float] | float)

• u (ProcNode[float] | float)

• v (ProcNode[float] | float)

• a (ProcNode[float] | float)

Return type:

ProcNode

procfunc.nodes.compositor.combine_color(red=0.0, green=0.0, blue=0.0, alpha=1.0, mode='RGB', ycc_mode='ITUBT709')

Uses a CombineColor Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/mix/combine_color.html

Parameters:

• red (ProcNode[float] | float)

• green (ProcNode[float] | float)

• blue (ProcNode[float] | float)

• alpha (ProcNode[float] | float)

• mode (Literal['RGB', 'HSV', 'HSL', 'YCC', 'YUV'])

• ycc_mode (Literal['ITUBT601', 'ITUBT709', 'JFIF'])

Return type:

ProcNode

procfunc.nodes.compositor.combine_xyz(x=0.0, y=0.0, z=0.0)

Uses a CombineXYZ Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/vector/combine_xyz.html

Parameters:

• x (ProcNode[float] | float)

• y (ProcNode[float] | float)

• z (ProcNode[float] | float)

Return type:

ProcNode

procfunc.nodes.compositor.composite(image=(0, 0, 0, 1), alpha=1.0, use_alpha=True)

Uses a Composite Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/output/composite.html

Parameters:

• image (ProcNode[Color] | Color)

• alpha (ProcNode[float] | float)

• use_alpha (bool)

Return type:

ProcNode

procfunc.nodes.compositor.convert_color_space(image=(1, 1, 1, 1), from_color_space='Linear Rec.709', to_color_space='Linear Rec.709')

Uses a ConvertColorSpace Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/convert_colorspace.html

Parameters:

• image (ProcNode[Color] | Color)

• from_color_space (Literal['ACES2065-1', 'ACEScg', 'AgX Base Display P3', 'AgX Base Rec.1886', 'AgX Base Rec.2020', 'AgX Base sRGB', 'AgX Log', 'Display P3', 'Filmic Log', 'Filmic sRGB', 'Khronos PBR Neutral sRGB', 'Linear CIE-XYZ D65', 'Linear CIE-XYZ E', 'Linear DCI-P3 D65', 'Linear FilmLight E-Gamut', 'Linear Rec.2020', 'Linear Rec.709', 'Non-Color', 'Rec.1886', 'Rec.2020', 'sRGB'])

• to_color_space (Literal['ACES2065-1', 'ACEScg', 'AgX Base Display P3', 'AgX Base Rec.1886', 'AgX Base Rec.2020', 'AgX Base sRGB', 'AgX Log', 'Display P3', 'Filmic Log', 'Filmic sRGB', 'Khronos PBR Neutral sRGB', 'Linear CIE-XYZ D65', 'Linear CIE-XYZ E', 'Linear DCI-P3 D65', 'Linear FilmLight E-Gamut', 'Linear Rec.2020', 'Linear Rec.709', 'Non-Color', 'Rec.1886', 'Rec.2020', 'sRGB'])

Return type:

ProcNode

procfunc.nodes.compositor.corner_pin(image=(1, 1, 1, 1), upper_left=(0, 1, 0), upper_right=(1, 1, 0), lower_left=(0, 0, 0), lower_right=(1, 0, 0))

Uses a CornerPin Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/transform/corner_pin.html

Parameters:

• image (ProcNode[Color] | Color)

• upper_left (ProcNode[Vector] | Vector)

• upper_right (ProcNode[Vector] | Vector)

• lower_left (ProcNode[Vector] | Vector)

• lower_right (ProcNode[Vector] | Vector)

Return type:

ProcNode

procfunc.nodes.compositor.crop(image=(1, 1, 1, 1), max_x=0, max_y=0, min_x=0, min_y=0, rel_max_x=0.0, rel_max_y=0.0, rel_min_x=0.0, rel_min_y=0.0, relative=False, use_crop_size=False)

Uses a Crop Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/transform/crop.html

Parameters:

• image (ProcNode[Color] | Color)

• max_x (int)

• max_y (int)

• min_x (int)

• min_y (int)

• rel_max_x (float)

• rel_max_y (float)

• rel_min_x (float)

• rel_min_y (float)

• relative (bool)

• use_crop_size (bool)

Return type:

ProcNode

procfunc.nodes.compositor.cryptomatte(image=(0, 0, 0, 1), crypto_00=(0, 0, 0, 1), crypto_01=(0, 0, 0, 1), crypto_02=(0, 0, 0, 1), add=(0.0, 0.0, 0.0), matte_id='', remove=(0.0, 0.0, 0.0))

Uses a Cryptomatte Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/mask/cryptomatte.html

Parameters:

• image (ProcNode[Color] | Color)

• crypto_00 (ProcNode[Color] | Color)

• crypto_01 (ProcNode[Color] | Color)

• crypto_02 (ProcNode[Color] | Color)

• add (tuple)

• matte_id (str)

• remove (tuple)

Return type:

ProcNode

procfunc.nodes.compositor.curve_rgb(fac=1.0, image=(1, 1, 1, 1), black_level=(0, 0, 0, 1), white_level=(1, 1, 1, 1))

Uses a CurveRGB Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/adjust/rgb_curves.html

Parameters:

• fac (ProcNode[float] | float)

• image (ProcNode[Color] | Color)

• black_level (ProcNode[Color] | Color)

• white_level (ProcNode[Color] | Color)

Return type:

ProcNode

procfunc.nodes.compositor.curve_vec(vector=(0, 0, 0))

Uses a CurveVec Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/adjust/rgb_curves.html

Parameters:

vector (ProcNode[Vector] | Vector)

Return type:

ProcNode

procfunc.nodes.compositor.d_blur(image=(1, 1, 1, 1), angle=0.0, center_x=0.5, center_y=0.5, distance=0.0, iterations=1, spin=0.0, zoom=0.0)

Uses a DBlur Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/blur/directional_blur.html

Parameters:

• image (ProcNode[Color] | Color)

• angle (float)

• center_x (float)

• center_y (float)

• distance (float)

• iterations (int)

• spin (float)

• zoom (float)

Return type:

ProcNode

procfunc.nodes.compositor.defocus(image=(1, 1, 1, 1), z=1.0, angle=0.0, blur_max=16.0, bokeh='CIRCLE', f_stop=128.0, scene=None, threshold=1.0, use_gamma_correction=False, use_preview=True, use_zbuffer=False, z_scale=1.0)

Uses a Defocus Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/blur/defocus.html

Parameters:

• image (ProcNode[Color] | Color)

• z (ProcNode[float] | float)

• angle (float)

• blur_max (float)

• bokeh (Literal['OCTAGON', 'HEPTAGON', 'HEXAGON', 'PENTAGON', 'SQUARE', 'TRIANGLE', 'CIRCLE'])

• f_stop (float)

• scene (Any)

• threshold (float)

• use_gamma_correction (bool)

• use_preview (bool)

• use_zbuffer (bool)

• z_scale (float)

Return type:

ProcNode

procfunc.nodes.compositor.denoise(image=(1, 1, 1, 1), normal=(0, 0, 0), albedo=(1, 1, 1, 1), prefilter='ACCURATE', use_hdr=True)

Uses a Denoise Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/denoise.html

Parameters:

• image (ProcNode[Color] | Color)

• normal (ProcNode[Vector] | Vector)

• albedo (ProcNode[Color] | Color)

• prefilter (Literal['NONE', 'FAST', 'ACCURATE'])

• use_hdr (bool)

Return type:

ProcNode

procfunc.nodes.compositor.despeckle(fac=1.0, image=(1, 1, 1, 1), threshold=0.5, threshold_neighbor=0.5)

Uses a Despeckle Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/despeckle.html

Parameters:

• fac (ProcNode[float] | float)

• image (ProcNode[Color] | Color)

• threshold (float)

• threshold_neighbor (float)

Return type:

ProcNode

procfunc.nodes.compositor.diff_matte(image_1=(1, 1, 1, 1), image_2=(1, 1, 1, 1), falloff=0.1, tolerance=0.1)

Uses a DiffMatte Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/keying/difference_key.html

Parameters:

• image_1 (ProcNode[Color] | Color)

• image_2 (ProcNode[Color] | Color)

• falloff (float)

• tolerance (float)

Return type:

ProcNode

procfunc.nodes.compositor.dilate_erode(mask=0.0, distance=0, edge=0.0, falloff='SMOOTH', mode='STEP')

Uses a DilateErode Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/dilate_erode.html

Parameters:

• mask (ProcNode[float] | float)

• distance (int)

• edge (float)

• falloff (Literal['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR'])

• mode (Literal['STEP', 'THRESHOLD', 'DISTANCE', 'FEATHER'])

Return type:

ProcNode

procfunc.nodes.compositor.displace(image=(1, 1, 1, 1), vector=(1, 1, 1), x_scale=0.0, y_scale=0.0)

Uses a Displace Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/transform/displace.html

Parameters:

• image (ProcNode[Color] | Color)

• vector (ProcNode[Vector] | Vector)

• x_scale (ProcNode[float] | float)

• y_scale (ProcNode[float] | float)

Return type:

ProcNode

procfunc.nodes.compositor.distance_matte(image=(1, 1, 1, 1), key_color=(1, 1, 1, 1), channel='RGB', falloff=0.1, tolerance=0.1)

Uses a DistanceMatte Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/keying/distance_key.html

Parameters:

• image (ProcNode[Color] | Color)

• key_color (ProcNode[Color] | Color)

• channel (Literal['RGB', 'YCC'])

• falloff (float)

• tolerance (float)

Return type:

ProcNode

procfunc.nodes.compositor.double_edge_mask(inner_mask=0.8, outer_mask=0.8, edge_mode='BLEED_OUT', inner_mode='ALL')

Uses a DoubleEdgeMask Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/mask/double_edge_mask.html

Parameters:

• inner_mask (ProcNode[float] | float)

• outer_mask (ProcNode[float] | float)

• edge_mode (Literal['BLEED_OUT', 'KEEP_IN'])

• inner_mode (Literal['ALL', 'ADJACENT_ONLY'])

Return type:

ProcNode

procfunc.nodes.compositor.ellipse_mask(mask=0.0, value=1.0, mask_height=0.1, mask_type='ADD', mask_width=0.2, rotation=0.0, x=0.5, y=0.5)

Uses a EllipseMask Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/mask/ellipse_mask.html

Parameters:

• mask (ProcNode[float] | float)

• value (ProcNode[float] | float)

• mask_height (float)

• mask_type (Literal['ADD', 'SUBTRACT', 'MULTIPLY', 'NOT'])

• mask_width (float)

• rotation (float)

• x (float)

• y (float)

Return type:

ProcNode

procfunc.nodes.compositor.exposure(image=(1, 1, 1, 1), exposure=0.0)

Uses a Exposure Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/adjust/exposure.html

Parameters:

• image (ProcNode[Color] | Color)

• exposure (ProcNode[float] | float)

Return type:

ProcNode

procfunc.nodes.compositor.filter(fac=1.0, image=(1, 1, 1, 1), filter_type='SOFTEN')

Uses a Filter Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/filter.html

Parameters:

• fac (ProcNode[float] | float)

• image (ProcNode[Color] | Color)

• filter_type (Literal['SOFTEN', 'SHARPEN', 'SHARPEN_DIAMOND', 'LAPLACE', 'SOBEL', 'PREWITT', 'KIRSCH', 'SHADOW'])

Return type:

ProcNode

procfunc.nodes.compositor.flip(image=(1, 1, 1, 1), axis='X')

Uses a Flip Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/transform/flip.html

Parameters:

• image (ProcNode[Color] | Color)

• axis (Literal['X', 'Y', 'XY'])

Return type:

ProcNode

procfunc.nodes.compositor.gamma(image=(1, 1, 1, 1), gamma=1.0)

Uses a Gamma Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/adjust/gamma.html

Parameters:

• image (ProcNode[Color] | Color)

• gamma (ProcNode[float] | float)

Return type:

ProcNode

procfunc.nodes.compositor.glare(image=(1, 1, 1, 1), angle_offset=0.0, color_modulation=0.25, fade=0.9, glare_type='STREAKS', iterations=3, mix=0.0, quality='MEDIUM', size=8, streaks=4, threshold=1.0, use_rotate_45=True)

Uses a Glare Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/glare.html

Parameters:

• image (ProcNode[Color] | Color)

• angle_offset (float)

• color_modulation (float)

• fade (float)

• glare_type (Literal['BLOOM', 'GHOSTS', 'STREAKS', 'FOG_GLOW', 'SIMPLE_STAR'])

• iterations (int)

• mix (float)

• quality (Literal['HIGH', 'MEDIUM', 'LOW'])

• size (int)

• streaks (int)

• threshold (float)

• use_rotate_45 (bool)

Return type:

ProcNode

procfunc.nodes.compositor.group(node_tree=None)

Uses a Group Compositor Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/group.html

Parameters:

node_tree (Any)

Return type:

ProcNode

procfunc.nodes.compositor.hue_correct(fac=1.0, image=(1, 1, 1, 1))

Uses a HueCorrect Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/adjust/hue_correct.html

Parameters:

• fac (ProcNode[float] | float)

• image (ProcNode[Color] | Color)

Return type:

ProcNode

procfunc.nodes.compositor.hue_sat(image=(1, 1, 1, 1), hue=0.5, saturation=1.0, value=1.0, fac=1.0)

Uses a HueSat Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/adjust/hue_saturation.html

Parameters:

• image (ProcNode[Color] | Color)

• hue (ProcNode[float] | float)

• saturation (ProcNode[float] | float)

• value (ProcNode[float] | float)

• fac (ProcNode[float] | float)

Return type:

ProcNode

procfunc.nodes.compositor.id_mask(id_value=1.0, index=0, use_antialiasing=False)

Uses a IDMask Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/mask/id_mask.html

Parameters:

• id_value (ProcNode[float] | float)

• index (int)

• use_antialiasing (bool)

Return type:

ProcNode

procfunc.nodes.compositor.image(frame_duration=1, frame_offset=0, frame_start=1, image=None, layer=None, view=None, use_auto_refresh=True, use_cyclic=False, use_straight_alpha_output=False)

Uses a Image Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/input/image.html

Parameters:

• frame_duration (int)

• frame_offset (int)

• frame_start (int)

• image (Any)

• layer (Literal['PLACEHOLDER'] | None)

• view (Literal['ALL'] | None)

• use_auto_refresh (bool)

• use_cyclic (bool)

• use_straight_alpha_output (bool)

Return type:

ProcNode

procfunc.nodes.compositor.inpaint(image=(1, 1, 1, 1), distance=0)

Uses a Inpaint Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/inpaint.html

Parameters:

• image (ProcNode[Color] | Color)

• distance (int)

Return type:

ProcNode

procfunc.nodes.compositor.invert(fac=1.0, color=(1, 1, 1, 1), invert_alpha=False, invert_rgb=True)

Uses a Invert Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/invert_color.html

Parameters:

• fac (ProcNode[float] | float)

• color (ProcNode[Color] | Color)

• invert_alpha (bool)

• invert_rgb (bool)

Return type:

ProcNode

procfunc.nodes.compositor.keying(image=(0.8, 0.8, 0.8, 1), key_color=(1, 1, 1, 1), garbage_matte=0.0, core_matte=0.0, blur_post=0, blur_pre=0, clip_black=0.0, clip_white=1.0, despill_balance=0.5, despill_factor=1.0, dilate_distance=0, edge_kernel_radius=3, edge_kernel_tolerance=0.1, feather_distance=0, feather_falloff='SMOOTH', screen_balance=0.5)

Uses a Keying Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/keying/keying.html

Parameters:

• image (ProcNode[Color] | Color)

• key_color (ProcNode[Color] | Color)

• garbage_matte (ProcNode[float] | float)

• core_matte (ProcNode[float] | float)

• blur_post (int)

• blur_pre (int)

• clip_black (float)

• clip_white (float)

• despill_balance (float)

• despill_factor (float)

• dilate_distance (int)

• edge_kernel_radius (int)

• edge_kernel_tolerance (float)

• feather_distance (int)

• feather_falloff (Literal['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR'])

• screen_balance (float)

Return type:

ProcNode

procfunc.nodes.compositor.keying_screen(clip=None, smoothness=0.0, tracking_object='')

Uses a KeyingScreen Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/keying/keying_screen.html

Parameters:

• clip (Any)

• smoothness (float)

• tracking_object (str)

Return type:

ProcNode

procfunc.nodes.compositor.kuwahara(image=(1, 1, 1, 1), size=6.0, eccentricity=1.0, sharpness=0.5, uniformity=4, use_high_precision=False, variation='CLASSIC')

Uses a Kuwahara Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/kuwahara.html

Parameters:

• image (ProcNode[Color] | Color)

• size (ProcNode[float] | float)

• eccentricity (float)

• sharpness (float)

• uniformity (int)

• use_high_precision (bool)

• variation (Literal['CLASSIC', 'ANISOTROPIC'])

Return type:

ProcNode

procfunc.nodes.compositor.lensdist(image=(1, 1, 1, 1), distortion=0.0, dispersion=0.0, use_fit=False, use_jitter=False, use_projector=False)

Uses a Lensdist Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/transform/lens_distortion.html

Parameters:

• image (ProcNode[Color] | Color)

• distortion (ProcNode[float] | float)

• dispersion (ProcNode[float] | float)

• use_fit (bool)

• use_jitter (bool)

• use_projector (bool)

Return type:

ProcNode

procfunc.nodes.compositor.levels(image=(0, 0, 0, 1), channel='COMBINED_RGB')

Uses a Levels Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/utilities/levels.html

Parameters:

• image (ProcNode[Color] | Color)

• channel (Literal['COMBINED_RGB', 'RED', 'GREEN', 'BLUE', 'LUMINANCE'])

Return type:

ProcNode

procfunc.nodes.compositor.luma_matte(image=(1, 1, 1, 1), limit_max=1.0, limit_min=0.0)

Uses a LumaMatte Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/keying/luminance_key.html

Parameters:

• image (ProcNode[Color] | Color)

• limit_max (float)

• limit_min (float)

Return type:

ProcNode

procfunc.nodes.compositor.map_range(value=1.0, from_min=0.0, from_max=1.0, to_min=0.0, to_max=1.0)

Uses a MapRange Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/utilities/map_range.html

Parameters:

• value (ProcNode[float] | float)

• from_min (ProcNode[float] | float)

• from_max (ProcNode[float] | float)

• to_min (ProcNode[float] | float)

• to_max (ProcNode[float] | float)

Return type:

ProcNode

procfunc.nodes.compositor.map_uv(image=(1, 1, 1, 1), uv=(1, 0, 0), alpha=0, filter_type='ANISOTROPIC')

Uses a MapUV Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/transform/map_uv.html

Parameters:

• image (ProcNode[Color] | Color)

• uv (ProcNode[Vector] | Vector)

• alpha (int)

• filter_type (Literal['NEAREST', 'ANISOTROPIC'])

Return type:

ProcNode

procfunc.nodes.compositor.map_value(value=1.0, max=(1.0,), min=(0.0,), offset=(0.0,), size=(1.0,), use_max=False, use_min=False)

Uses a MapValue Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/utilities/map_value.html

Parameters:

• value (ProcNode[float] | float)

• max (tuple)

• min (tuple)

• offset (tuple)

• size (tuple)

• use_max (bool)

• use_min (bool)

Return type:

ProcNode

procfunc.nodes.compositor.mask(mask=None, motion_blur_samples=16, motion_blur_shutter=0.5, size_source='SCENE', size_x=256, size_y=256, use_feather=True, use_motion_blur=False)

Uses a Mask Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/input/mask.html

Parameters:

• mask (Any)

• motion_blur_samples (int)

• motion_blur_shutter (float)

• size_source (Literal['SCENE', 'FIXED', 'FIXED_SCENE'])

• size_x (int)

• size_y (int)

• use_feather (bool)

• use_motion_blur (bool)

Return type:

ProcNode

procfunc.nodes.compositor.math(value_0=0.5, value_1=0.5)

Uses a Math Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/utilities/math.html

Parameters:

• value_0 (ProcNode[float] | float)

• value_1 (ProcNode[float] | float)

Return type:

ProcNode

procfunc.nodes.compositor.mix_rgb(fac=1.0, image_0=(1, 1, 1, 1), image_1=(1, 1, 1, 1), blend_type='MIX', use_alpha=False)

Uses a MixRGB Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/mix/mix_color.html

Parameters:

• fac (ProcNode[float] | float)

• image_0 (ProcNode[Color] | Color)

• image_1 (ProcNode[Color] | Color)

• blend_type (Literal['MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'])

• use_alpha (bool)

Return type:

ProcNode

class procfunc.nodes.compositor.MovieClipResult

Bases: NamedTuple

MovieClipResult(image, alpha, offset_x, offset_y, scale, angle)

image: ProcNode[Color]

Alias for field number 0

alpha: ProcNode[float]

Alias for field number 1

offset_x: ProcNode[float]

Alias for field number 2

offset_y: ProcNode[float]

Alias for field number 3

scale: ProcNode[float]

Alias for field number 4

angle: ProcNode[float]

Alias for field number 5

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.compositor.movie_clip(clip=None)

Uses a MovieClip Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/input/movie_clip.html

Parameters:

clip (Any)

Return type:

MovieClipResult

procfunc.nodes.compositor.movie_distortion(image=(0.8, 0.8, 0.8, 1), clip=None, distortion_type='UNDISTORT')

Uses a MovieDistortion Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/transform/movie_distortion.html

Parameters:

• image (ProcNode[Color] | Color)

• clip (Any)

• distortion_type (Literal['UNDISTORT', 'DISTORT'])

Return type:

ProcNode

procfunc.nodes.compositor.normal(normal=(0, 0, 1))

Uses a Normal Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/vector/normal.html

Parameters:

normal (ProcNode[Vector] | Vector)

Return type:

ProcNode

procfunc.nodes.compositor.normalize(value=1.0)

Uses a Normalize Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/utilities/normalize.html

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode

procfunc.nodes.compositor.output_file(active_input_index=0, base_path='/tmp/', slot_paths=None, format=None, **kwargs)

Uses a OutputFile Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/output/file_output.html

Parameters:

• active_input_index (int)

• base_path (str)

• slot_paths (dict | None)

• format (dict | None)

Return type:

ProcNode

procfunc.nodes.compositor.pixelate(color=(0.8, 0.8, 0.8, 1), pixel_size=1)

Uses a Pixelate Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/pixelate.html

Parameters:

• color (ProcNode[Color] | Color)

• pixel_size (int)

Return type:

ProcNode

procfunc.nodes.compositor.plane_track_deform(image=(0.8, 0.8, 0.8, 1), clip=None, motion_blur_samples=16, motion_blur_shutter=0.5, plane_track_name='', tracking_object='', use_motion_blur=False)

Uses a PlaneTrackDeform Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/tracking/plane_track_deform.html

Parameters:

• image (ProcNode[Color] | Color)

• clip (Any)

• motion_blur_samples (int)

• motion_blur_shutter (float)

• plane_track_name (str)

• tracking_object (str)

• use_motion_blur (bool)

Return type:

ProcNode

procfunc.nodes.compositor.posterize(image=(1, 1, 1, 1), steps=8.0)

Uses a Posterize Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/posterize.html

Parameters:

• image (ProcNode[Color] | Color)

• steps (ProcNode[float] | float)

Return type:

ProcNode

procfunc.nodes.compositor.premul_key(image=(1, 1, 1, 1), mapping='STRAIGHT_TO_PREMUL')

Uses a PremulKey Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/alpha_convert.html

Parameters:

• image (ProcNode[Color] | Color)

• mapping (Literal['STRAIGHT_TO_PREMUL', 'PREMUL_TO_STRAIGHT'])

Return type:

ProcNode

procfunc.nodes.compositor.rgb()

Uses a RGB Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/input/constant/rgb.html

Return type:

ProcNode

procfunc.nodes.compositor.rgb_to_bw(image=(0.8, 0.8, 0.8, 1))

Uses a RGBToBW Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/rgb_to_bw.html

Parameters:

image (ProcNode[Color] | Color)

Return type:

ProcNode

procfunc.nodes.compositor.rotate(image=(1, 1, 1, 1), degr=0.0, filter_type='BILINEAR')

Uses a Rotate Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/transform/rotate.html

Parameters:

• image (ProcNode[Color] | Color)

• degr (ProcNode[float] | float)

• filter_type (Literal['NEAREST', 'BILINEAR', 'BICUBIC'])

Return type:

ProcNode

procfunc.nodes.compositor.scale(image=(1, 1, 1, 1), x=1.0, y=1.0, frame_method='STRETCH', offset_x=0.0, offset_y=0.0, space='RELATIVE')

Uses a Scale Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/transform/scale.html

Parameters:

• image (ProcNode[Color] | Color)

• x (ProcNode[float] | float)

• y (ProcNode[float] | float)

• frame_method (Literal['STRETCH', 'FIT', 'CROP'])

• offset_x (float)

• offset_y (float)

• space (Literal['RELATIVE', 'ABSOLUTE', 'SCENE_SIZE', 'RENDER_SIZE'])

Return type:

ProcNode

class procfunc.nodes.compositor.SceneTimeResult

Bases: NamedTuple

SceneTimeResult(seconds, frame)

seconds: ProcNode[float]

Alias for field number 0

frame: ProcNode[float]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.compositor.scene_time()

Uses a SceneTime Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/input/scene/scene_time.html

Return type:

SceneTimeResult

class procfunc.nodes.compositor.SepHsvaResult

Bases: NamedTuple

SepHsvaResult(h, s, v, a)

h: ProcNode[float]

Alias for field number 0

s: ProcNode[float]

Alias for field number 1

v: ProcNode[float]

Alias for field number 2

a: ProcNode[float]

Alias for field number 3

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.compositor.sep_hsva(image=(1, 1, 1, 1))

Uses a SepHSVA Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/mix/separate_color.html

Parameters:

image (ProcNode[Color] | Color)

Return type:

SepHsvaResult

class procfunc.nodes.compositor.SepRgbaResult

Bases: NamedTuple

SepRgbaResult(r, g, b, a)

r: ProcNode[float]

Alias for field number 0

g: ProcNode[float]

Alias for field number 1

b: ProcNode[float]

Alias for field number 2

a: ProcNode[float]

Alias for field number 3

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.compositor.sep_rgba(image=(1, 1, 1, 1))

Uses a SepRGBA Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/mix/separate_color.html

Parameters:

image (ProcNode[Color] | Color)

Return type:

SepRgbaResult

class procfunc.nodes.compositor.SepYccaResult

Bases: NamedTuple

SepYccaResult(y, cb, cr, a)

y: ProcNode[float]

Alias for field number 0

cb: ProcNode[float]

Alias for field number 1

cr: ProcNode[float]

Alias for field number 2

a: ProcNode[float]

Alias for field number 3

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.compositor.sep_ycca(image=(1, 1, 1, 1), mode='ITUBT709')

Uses a SepYCCA Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/mix/separate_color.html

Parameters:

• image (ProcNode[Color] | Color)

• mode (Literal['ITUBT601', 'ITUBT709', 'JFIF'])

Return type:

SepYccaResult

class procfunc.nodes.compositor.SepYuvaResult

Bases: NamedTuple

SepYuvaResult(y, u, v, a)

y: ProcNode[float]

Alias for field number 0

u: ProcNode[float]

Alias for field number 1

v: ProcNode[float]

Alias for field number 2

a: ProcNode[float]

Alias for field number 3

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.compositor.sep_yuva(image=(1, 1, 1, 1))

Uses a SepYUVA Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/mix/separate_color.html

Parameters:

image (ProcNode[Color] | Color)

Return type:

SepYuvaResult

procfunc.nodes.compositor.set_alpha(image=(1, 1, 1, 1), alpha=1.0, mode='APPLY')

Uses a SetAlpha Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/set_alpha.html

Parameters:

• image (ProcNode[Color] | Color)

• alpha (ProcNode[float] | float)

• mode (Literal['APPLY', 'REPLACE_ALPHA'])

Return type:

ProcNode

procfunc.nodes.compositor.split(image_0=(0.8, 0.8, 0.8, 1), image_1=(0.8, 0.8, 0.8, 1), axis='X', factor=50)

Uses a Split Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/utilities/split.html

Parameters:

• image_0 (ProcNode[Color] | Color)

• image_1 (ProcNode[Color] | Color)

• axis (Literal['X', 'Y'])

• factor (int)

Return type:

ProcNode

procfunc.nodes.compositor.stabilize(image=(0.8, 0.8, 0.8, 1), clip=None, filter_type='BILINEAR', invert=False)

Uses a Stabilize Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/tracking/stabilize_2d.html

Parameters:

• image (ProcNode[Color] | Color)

• clip (Any)

• filter_type (Literal['NEAREST', 'BILINEAR', 'BICUBIC'])

• invert (bool)

Return type:

ProcNode

procfunc.nodes.compositor.sun_beams(image=(1, 1, 1, 1), ray_length=0.0, source=(0.5, 0.5))

Uses a SunBeams Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/sun_beams.html

Parameters:

• image (ProcNode[Color] | Color)

• ray_length (float)

• source (tuple)

Return type:

ProcNode

procfunc.nodes.compositor.switch(off=(0.8, 0.8, 0.8, 1), on=(0.8, 0.8, 0.8, 1), check=False)

Uses a Switch Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/utilities/switch.html

Parameters:

• off (ProcNode[Color] | Color)

• on (ProcNode[Color] | Color)

• check (bool)

Return type:

ProcNode

procfunc.nodes.compositor.switch_view(left=(0, 0, 0, 1), right=(0, 0, 0, 1))

Uses a SwitchView Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/utilities/switch.html

Parameters:

• left (ProcNode[Color] | Color)

• right (ProcNode[Color] | Color)

Return type:

ProcNode

procfunc.nodes.compositor.texture(offset=(0, 0, 0), scale=(1, 1, 1), node_output=0, texture=None)

Uses a Texture Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/input/texture.html

Parameters:

• offset (ProcNode[Vector] | Vector)

• scale (ProcNode[Vector] | Vector)

• node_output (int)

• texture (Any)

Return type:

ProcNode

procfunc.nodes.compositor.time(frame_end=250, frame_start=1)

Uses a Time Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/input/scene/scene_time.html

Parameters:

• frame_end (int)

• frame_start (int)

Return type:

ProcNode

procfunc.nodes.compositor.tonemap(image=(1, 1, 1, 1), adaptation=1.0, contrast=0.0, correction=0.0, gamma=1.0, intensity=0.0, key=0.18, offset=1.0, tonemap_type='RD_PHOTORECEPTOR')

Uses a Tonemap Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/adjust/tone_map.html

Parameters:

• image (ProcNode[Color] | Color)

• adaptation (float)

• contrast (float)

• correction (float)

• gamma (float)

• intensity (float)

• key (float)

• offset (float)

• tonemap_type (Literal['RD_PHOTORECEPTOR', 'RH_SIMPLE'])

Return type:

ProcNode

procfunc.nodes.compositor.track_pos(clip=None, frame_relative=0, position='ABSOLUTE', track_name='', tracking_object='')

Uses a TrackPos Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/tracking/track_position.html

Parameters:

• clip (Any)

• frame_relative (int)

• position (Literal['ABSOLUTE', 'RELATIVE_START', 'RELATIVE_FRAME', 'ABSOLUTE_FRAME'])

• track_name (str)

• tracking_object (str)

Return type:

ProcNode

procfunc.nodes.compositor.transform(image=(0.8, 0.8, 0.8, 1), x=0.0, y=0.0, angle=0.0, scale=1.0, filter_type='NEAREST')

Uses a Transform Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/transform/transform.html

Parameters:

• image (ProcNode[Color] | Color)

• x (ProcNode[float] | float)

• y (ProcNode[float] | float)

• angle (ProcNode[float] | float)

• scale (ProcNode[float] | float)

• filter_type (Literal['NEAREST', 'BILINEAR', 'BICUBIC'])

Return type:

ProcNode

procfunc.nodes.compositor.translate(image=(1, 1, 1, 1), x=0.0, y=0.0, interpolation='Nearest', use_relative=False, wrap_axis='NONE')

Uses a Translate Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/transform/translate.html

Parameters:

• image (ProcNode[Color] | Color)

• x (ProcNode[float] | float)

• y (ProcNode[float] | float)

• interpolation (Literal['Nearest', 'Bilinear', 'Bicubic'])

• use_relative (bool)

• wrap_axis (Literal['NONE', 'XAXIS', 'YAXIS', 'BOTH'])

Return type:

ProcNode

procfunc.nodes.compositor.val_to_rgb(fac=0.5)

Uses a ValToRGB Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/color_ramp.html

Parameters:

fac (ProcNode[float] | float)

Return type:

ProcNode

procfunc.nodes.compositor.value()

Uses a Value Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/input/constant/value.html

Return type:

ProcNode

procfunc.nodes.compositor.vec_blur(image=(1, 1, 1, 1), z=0.0, speed=(0, 0, 0), factor=0.25, samples=32, speed_max=0, speed_min=0, use_curved=False)

Uses a VecBlur Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/filter/blur/vector_blur.html

Parameters:

• image (ProcNode[Color] | Color)

• z (ProcNode[float] | float)

• speed (ProcNode[Vector] | Vector)

• factor (float)

• samples (int)

• speed_max (int)

• speed_min (int)

• use_curved (bool)

Return type:

ProcNode

procfunc.nodes.compositor.viewer(image=(0, 0, 0, 1), alpha=1.0, use_alpha=True)

Uses a Viewer Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/output/viewer.html

Parameters:

• image (ProcNode[Color] | Color)

• alpha (ProcNode[float] | float)

• use_alpha (bool)

Return type:

ProcNode

procfunc.nodes.compositor.zcombine(image_0=(1, 1, 1, 1), z_0=1.0, image_1=(1, 1, 1, 1), z_1=1.0, use_alpha=False, use_antialias_z=True)

Uses a Zcombine Compositor Node.

See: https://docs.blender.org/manual/en/4.2/compositing/types/color/mix/z_combine.html

Parameters:

• image_0 (ProcNode[Color] | Color)

• z_0 (ProcNode[float] | float)

• image_1 (ProcNode[Color] | Color)

• z_1 (ProcNode[float] | float)

• use_alpha (bool)

• use_antialias_z (bool)

Return type:

ProcNode

pf.nodes.func

Auto-generated Function Node bindings for Blender

procfunc.nodes.func.constant(value)

Replaces all nodes which just store a constant e.g. ShaderNodeValue, ShaderNodeRGB, FunctionNodeInput*, etc

Parameters:

value (TConstant)

Return type:

ProcNode[TConstant]

procfunc.nodes.func.align_euler_to_vector(rotation=(0, 0, 0), factor=1.0, vector=(0, 0, 1), axis='X', pivot_axis='AUTO')

Uses a AlignEulerToVector Function Node.

See: http://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/align_euler_to_vector.html

Parameters:

• rotation (ProcNode[Vector] | Vector)

• factor (ProcNode[float] | float)

• vector (ProcNode[Vector] | Vector)

• axis (Literal['X', 'Y', 'Z'])

• pivot_axis (Literal['AUTO', 'X', 'Y', 'Z'])

Return type:

ProcNode[Vector]

procfunc.nodes.func.align_rotation_to_vector(rotation=(0, 0, 0), factor=1.0, vector=(0, 0, 1), axis='Z', pivot_axis='AUTO')

Uses a AlignRotationToVector Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/align_rotation_to_vector.html

Parameters:

• rotation (Any)

• factor (ProcNode[float] | float)

• vector (ProcNode[Vector] | Vector)

• axis (Literal['X', 'Y', 'Z'])

• pivot_axis (Literal['AUTO', 'X', 'Y', 'Z'])

Return type:

ProcNode[Vector]

procfunc.nodes.func.axes_to_rotation(primary_axis_vector=(0, 0, 1), secondary_axis_vector=(1, 0, 0), primary_axis='X', secondary_axis='Y')

Uses a AxesToRotation Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/axis_to_rotation.html

Parameters:

• primary_axis_vector (ProcNode[Vector] | Vector)

• secondary_axis_vector (ProcNode[Vector] | Vector)

• primary_axis (Literal['X', 'Y', 'Z'])

• secondary_axis (Literal['X', 'Y', 'Z'])

Return type:

ProcNode[Vector]

procfunc.nodes.func.axis_angle_to_rotation(axis=(0, 0, 1), angle=0.0)

Uses a AxisAngleToRotation Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/axis_angle_to_rotation.html

Parameters:

• axis (ProcNode[Vector] | Vector)

• angle (ProcNode[float] | float)

Return type:

ProcNode[Vector]

procfunc.nodes.func.boolean_or(a=False, b=False)

Parameters:

• a (ProcNode[bool] | bool)

• b (ProcNode[bool] | bool)

Return type:

ProcNode[bool]

procfunc.nodes.func.boolean_and(a=False, b=False)

Parameters:

• a (ProcNode[bool] | bool)

• b (ProcNode[bool] | bool)

Return type:

ProcNode[bool]

procfunc.nodes.func.boolean_xor(a=False, b=False)

Parameters:

• a (ProcNode[bool] | bool)

• b (ProcNode[bool] | bool)

Return type:

ProcNode[bool]

procfunc.nodes.func.boolean_not(a=False)

Uses a BooleanNot Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/math/boolean_math.html

Parameters:

a (ProcNode[bool] | bool)

Return type:

ProcNode[bool]

procfunc.nodes.func.combine_matrix(column_1_row_1=1.0, column_1_row_2=0.0, column_1_row_3=0.0, column_1_row_4=0.0, column_2_row_1=0.0, column_2_row_2=1.0, column_2_row_3=0.0, column_2_row_4=0.0, column_3_row_1=0.0, column_3_row_2=0.0, column_3_row_3=1.0, column_3_row_4=0.0, column_4_row_1=0.0, column_4_row_2=0.0, column_4_row_3=0.0, column_4_row_4=1.0)

Uses a CombineMatrix Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/combine_matrix.html

Parameters:

• column_1_row_1 (ProcNode[float] | float)

• column_1_row_2 (ProcNode[float] | float)

• column_1_row_3 (ProcNode[float] | float)

• column_1_row_4 (ProcNode[float] | float)

• column_2_row_1 (ProcNode[float] | float)

• column_2_row_2 (ProcNode[float] | float)

• column_2_row_3 (ProcNode[float] | float)

• column_2_row_4 (ProcNode[float] | float)

• column_3_row_1 (ProcNode[float] | float)

• column_3_row_2 (ProcNode[float] | float)

• column_3_row_3 (ProcNode[float] | float)

• column_3_row_4 (ProcNode[float] | float)

• column_4_row_1 (ProcNode[float] | float)

• column_4_row_2 (ProcNode[float] | float)

• column_4_row_3 (ProcNode[float] | float)

• column_4_row_4 (ProcNode[float] | float)

Return type:

ProcNode[Matrix]

procfunc.nodes.func.combine_transform(translation=(0, 0, 0), rotation=(0, 0, 0), scale=(1, 1, 1))

Uses a CombineTransform Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/combine_transform.html

Parameters:

• translation (ProcNode[Vector] | Vector)

• rotation (Any)

• scale (ProcNode[Vector] | Vector)

Return type:

ProcNode[Matrix]

procfunc.nodes.func.less_than(a=None, b=None)

Parameters:

• a (TCompareNumeric)

• b (TCompareNumeric)

Return type:

ProcNode[bool]

procfunc.nodes.func.less_equal(a=None, b=None)

Parameters:

• a (TCompareNumeric)

• b (TCompareNumeric)

Return type:

ProcNode[bool]

procfunc.nodes.func.greater_than(a=None, b=None)

Parameters:

• a (TCompareNumeric)

• b (TCompareNumeric)

Return type:

ProcNode[bool]

procfunc.nodes.func.greater_equal(a=None, b=None)

Parameters:

• a (TCompareNumeric)

• b (TCompareNumeric)

Return type:

ProcNode[bool]

procfunc.nodes.func.equal(a=None, b=None, epsilon=None)

Parameters:

• a (TCompareEqual)

• b (TCompareEqual)

• epsilon (ProcNode[float] | float | None)

Return type:

ProcNode[bool]

procfunc.nodes.func.not_equal(a=None, b=None, epsilon=None)

Parameters:

• a (TCompareEqual)

• b (TCompareEqual)

• epsilon (ProcNode[float] | float | None)

Return type:

ProcNode[bool]

procfunc.nodes.func.vector_compare_elementwise(a=(0, 0, 0), b=(0, 0, 0), epsilon=0.001, operation='EQUAL')

Parameters:

• a (ProcNode[Vector] | Vector)

• b (ProcNode[Vector] | Vector)

• epsilon (ProcNode[float] | float)

• operation (Literal['LESS_THAN', 'LESS_EQUAL', 'GREATER_THAN', 'GREATER_EQUAL', 'EQUAL', 'NOT_EQUAL'])

Return type:

ProcNode[bool]

procfunc.nodes.func.compare_color(a, b, operation, epsilon=0.001)

Parameters:

• a (ProcNode[Color] | Color)

• b (ProcNode[Color] | Color)

• operation (Literal['EQUAL', 'NOT_EQUAL', 'BRIGHTER', 'DARKER'])

• epsilon (ProcNode[float] | float)

Return type:

ProcNode[bool]

procfunc.nodes.func.euler_to_rotation(euler=(0, 0, 0))

Uses a EulerToRotation Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/euler_to_rotation.html

Parameters:

euler (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.func.float_to_int(float=0.0, rounding_mode='ROUND')

Uses a FloatToInt Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/math/float_to_integer.html

Parameters:

• float (ProcNode[float] | float)

• rounding_mode (Literal['ROUND', 'FLOOR', 'CEILING', 'TRUNCATE'])

Return type:

ProcNode[int]

class procfunc.nodes.func.InputSpecialCharactersResult

Bases: NamedTuple

InputSpecialCharactersResult(line_break, tab)

line_break: ProcNode[str]

Alias for field number 0

tab: ProcNode[str]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.func.input_special_characters()

Uses a InputSpecialCharacters Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/text/special_characters.html

Return type:

InputSpecialCharactersResult

procfunc.nodes.func.input_string(string='')

Uses a InputString Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/string.html

Parameters:

string (str)

Return type:

ProcNode[str]

procfunc.nodes.func.input_vector(vector=(0.0, 0.0, 0.0))

Uses a InputVector Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/vector.html

Parameters:

vector (tuple)

Return type:

ProcNode[Vector]

class procfunc.nodes.func.InvertMatrixResult

Bases: NamedTuple

InvertMatrixResult(matrix, invertible)

matrix: ProcNode[Matrix]

Alias for field number 0

invertible: ProcNode[bool]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.func.invert_matrix(matrix=None)

Uses a InvertMatrix Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/invert_matrix.html

Parameters:

matrix (ProcNode[Matrix] | Matrix)

Return type:

InvertMatrixResult

procfunc.nodes.func.invert_rotation(rotation=(0, 0, 0))

Uses a InvertRotation Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/invert_rotation.html

Parameters:

rotation (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.func.matrix_multiply(matrix_0=None, matrix_1=None)

Uses a MatrixMultiply Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/multiply_matrices.html

Parameters:

• matrix_0 (ProcNode[Matrix] | Matrix)

• matrix_1 (ProcNode[Matrix] | Matrix)

Return type:

ProcNode[Matrix]

procfunc.nodes.func.project_point(vector=(0, 0, 0), transform=None)

Uses a ProjectPoint Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/project_point.html

Parameters:

• vector (ProcNode[Vector] | Vector)

• transform (ProcNode[Matrix] | Matrix)

Return type:

ProcNode[Vector]

procfunc.nodes.func.quaternion_to_rotation(w=1.0, x=0.0, y=0.0, z=0.0)

Uses a QuaternionToRotation Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/quaternion_to_rotation.html

Parameters:

• w (ProcNode[float] | float)

• x (ProcNode[float] | float)

• y (ProcNode[float] | float)

• z (ProcNode[float] | float)

Return type:

ProcNode[Vector]

procfunc.nodes.func.random_value(min=0.0, max=1.0, id=0, seed=0, data_type=None)

Uses a RandomValue Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/random_value.html

Parameters:

• min (ProcNode[TRandomValue] | TRandomValue)

• max (ProcNode[TRandomValue] | TRandomValue)

• id (ProcNode[int] | int)

• seed (ProcNode[int] | int)

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

ProcNode[TRandomValue]

procfunc.nodes.func.random_boolean(probability=0.5, id=0, seed=0)

Uses a RandomBoolean Function Node.

Parameters:

• probability (ProcNode[float] | float)

• id (ProcNode[int] | int)

• seed (ProcNode[int] | int)

Return type:

ProcNode[bool]

procfunc.nodes.func.replace_string(string='', find='', replace='')

Uses a ReplaceString Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/text/replace_string.html

Parameters:

• string (ProcNode[str] | str)

• find (ProcNode[str] | str)

• replace (ProcNode[str] | str)

Return type:

ProcNode[str]

procfunc.nodes.func.rotate_euler(rotation=(0, 0, 0), rotate_by=(0, 0, 0), rotation_type='EULER', space='OBJECT')

Uses a RotateEuler Function Node.

See: http://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/rotate_euler.html

Parameters:

• rotation (ProcNode[Vector] | Vector)

• rotate_by (ProcNode[Vector] | Vector)

• rotation_type (Literal['EULER', 'AXIS_ANGLE'])

• space (Literal['OBJECT', 'LOCAL'])

Return type:

ProcNode[Vector]

procfunc.nodes.func.rotate_rotation(rotation=(0, 0, 0), rotate_by=(0, 0, 0), rotation_space='GLOBAL')

Uses a RotateRotation Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/rotate_rotation.html

Parameters:

• rotation (Any)

• rotate_by (Any)

• rotation_space (Literal['GLOBAL', 'LOCAL'])

Return type:

ProcNode[Vector]

procfunc.nodes.func.rotate_vector(vector=(0, 0, 0), rotation=(0, 0, 0))

Uses a RotateVector Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/rotate_vector.html

Parameters:

• vector (ProcNode[Vector] | Vector)

• rotation (Any)

Return type:

ProcNode[Vector]

class procfunc.nodes.func.RotationToAxisAngleResult

Bases: NamedTuple

RotationToAxisAngleResult(axis, angle)

axis: ProcNode[Vector]

Alias for field number 0

angle: ProcNode[float]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.func.rotation_to_axis_angle(rotation=(0, 0, 0))

Uses a RotationToAxisAngle Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/axis_angle_to_rotation.html

Parameters:

rotation (ProcNode[Vector] | Vector)

Return type:

RotationToAxisAngleResult

procfunc.nodes.func.rotation_to_euler(rotation=(0, 0, 0))

Uses a RotationToEuler Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/rotation_to_euler.html

Parameters:

rotation (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

class procfunc.nodes.func.RotationToQuaternionResult

Bases: NamedTuple

RotationToQuaternionResult(w, x, y, z)

w: ProcNode[float]

Alias for field number 0

x: ProcNode[float]

Alias for field number 1

y: ProcNode[float]

Alias for field number 2

z: ProcNode[float]

Alias for field number 3

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.func.rotation_to_quaternion(rotation=(0, 0, 0))

Uses a RotationToQuaternion Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/rotation_to_quaternion.html

Parameters:

rotation (ProcNode[Vector] | Vector)

Return type:

RotationToQuaternionResult

class procfunc.nodes.func.SeparateColorResult

Bases: NamedTuple

SeparateColorResult(red, green, blue, alpha)

red: ProcNode[float]

Alias for field number 0

green: ProcNode[float]

Alias for field number 1

blue: ProcNode[float]

Alias for field number 2

alpha: ProcNode[float]

Alias for field number 3

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.func.separate_color(color=(1, 1, 1, 1), mode='RGB', ycc_mode='ITUBT709')

Uses a SeparateColor Function Node.

Context mapping: - Shader: ShaderNodeSeparateColor (input: Color, outputs: red/green/blue, mode: RGB only) - Compositor: CompositorNodeSeparateColor (input: Image, outputs: red/green/blue/alpha, modes: RGB/HSV/HSL/YCC/YUV, ycc_mode param) - Texture: TextureNodeSeparateColor (input: Color, modes: RGB/HSV/HSL) - Function: FunctionNodeSeparateColor (input: Color, outputs: red/green/blue/alpha)

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/color/separate_color.html

Parameters:

• color (ProcNode[Color] | Color)

• mode (Literal['RGB', 'HSV', 'HSL'])

• ycc_mode (Literal['ITUBT601', 'ITUBT709', 'JFIF'])

Return type:

SeparateColorResult

class procfunc.nodes.func.SeparateTransformResult

Bases: NamedTuple

SeparateTransformResult(translation, rotation, scale)

translation: ProcNode[Vector]

Alias for field number 0

rotation: ProcNode[Vector]

Alias for field number 1

scale: ProcNode[Vector]

Alias for field number 2

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.func.separate_transform(transform=None)

Uses a SeparateTransform Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/separate_transform.html

Parameters:

transform (ProcNode[Matrix] | Matrix)

Return type:

SeparateTransformResult

procfunc.nodes.func.slice_string(string='', position=0, length=10)

Uses a SliceString Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/text/slice_string.html

Parameters:

• string (ProcNode[str] | str)

• position (ProcNode[int] | int)

• length (ProcNode[int] | int)

Return type:

ProcNode[str]

procfunc.nodes.func.string_length(string='')

Uses a StringLength Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/text/string_length.html

Parameters:

string (ProcNode[str] | str)

Return type:

ProcNode[int]

procfunc.nodes.func.transform_direction(direction=(0, 0, 0), transform=None)

Uses a TransformDirection Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/transform_direction.html

Parameters:

• direction (ProcNode[Vector] | Vector)

• transform (ProcNode[Matrix] | Matrix)

Return type:

ProcNode[Vector]

procfunc.nodes.func.transform_point(vector=(0, 0, 0), transform=None)

Uses a TransformPoint Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/transform_point.html

Parameters:

• vector (ProcNode[Vector] | Vector)

• transform (ProcNode[Matrix] | Matrix)

Return type:

ProcNode[Vector]

procfunc.nodes.func.transpose_matrix(matrix=None)

Uses a TransposeMatrix Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/transpose_matrix.html

Parameters:

matrix (ProcNode[Matrix] | Matrix)

Return type:

ProcNode[Matrix]

procfunc.nodes.func.value_to_string(value=0.0, decimals=0)

Uses a ValueToString Function Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/text/value_to_string.html

Parameters:

• value (ProcNode[float] | float)

• decimals (ProcNode[int] | int)

Return type:

ProcNode[str]

procfunc.nodes.func.mix(a=None, b=None, factor=0.5, clamp_factor=True, factor_mode='UNIFORM', data_type=None)

Uses MixNode to mix float or vector fields

NOTE: procfunc forces all colors to be mixed via mix_rgb, since setting this function to type Color adds extra args & exactly matches the interface of mix_rgb

Parameters:

• a (TMix | None)

• b (TMix | None)

• factor (ProcNode[float] | float)

• clamp_factor (bool)

• factor_mode (Literal['UNIFORM', 'NON_UNIFORM'])

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

ProcNode[TMix]

procfunc.nodes.func.mix_rgb(factor=0.5, a=(0.5, 0.5, 0.5, 1), b=(0.5, 0.5, 0.5, 1), blend_type='MIX', clamp_result=False, clamp_factor=True)

Uses a Mix Node with datatype Color

NOTE: separated from float/vector mix() due to extra arguments

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/color/mix.html

Parameters:

• factor (ProcNode[float] | float)

• a (ProcNode[Color] | Color)

• b (ProcNode[Color] | Color)

• blend_type (Literal['MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'])

• clamp_result (bool)

• clamp_factor (bool)

Return type:

ProcNode[Color]

procfunc.nodes.func.rgb_curve(fac=1.0, color=(1, 1, 1, 1), curves=None)

Uses a RGBCurve Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/color/rgb_curves.html

Parameters:

• fac (ProcNode[float] | float)

• color (ProcNode[Color] | Color)

• curves (list[ndarray] | None)

Return type:

ProcNode

procfunc.nodes.func.combine_color(red=0.0, green=0.0, blue=0.0, mode='RGB')

Uses a CombineColor Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/combine_color.html

Parameters:

• red (ProcNode[float] | float)

• green (ProcNode[float] | float)

• blue (ProcNode[float] | float)

• mode (Literal['RGB', 'HSV', 'HSL'])

Return type:

ProcNode[Color]

procfunc.nodes.func.combine_rgb(red=0.0, green=0.0, blue=0.0, mode='RGB')

Uses a CombineColor Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/combine_color.html

Parameters:

• red (ProcNode[float] | float)

• green (ProcNode[float] | float)

• blue (ProcNode[float] | float)

• mode (Literal['RGB', 'HSV', 'HSL'])

Return type:

ProcNode[Color]

procfunc.nodes.func.combine_hsv(hue=0.0, saturation=0.0, value=0.0)

Uses a CombineColor Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/combine_color.html

Parameters:

• hue (ProcNode[float] | float)

• saturation (ProcNode[float] | float)

• value (ProcNode[float] | float)

Return type:

ProcNode[Color]

procfunc.nodes.func.combine_hsl(hue=0.0, saturation=0.0, lightness=0.0)

Uses a CombineHSV Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/combine_color.html

Parameters:

• hue (ProcNode[float] | float)

• saturation (ProcNode[float] | float)

• lightness (ProcNode[float] | float)

Return type:

ProcNode[Color]

procfunc.nodes.func.combine_xyz(x=0.0, y=0.0, z=0.0)

Uses a CombineXYZ Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/combine_xyz.html

Parameters:

• x (ProcNode[float] | float)

• y (ProcNode[float] | float)

• z (ProcNode[float] | float)

Return type:

ProcNode[Vector]

class procfunc.nodes.func.SeparateHsvResult

Bases: NamedTuple

SeparateHsvResult(h, s, v)

h: ProcNode[float]

Alias for field number 0

s: ProcNode[float]

Alias for field number 1

v: ProcNode[float]

Alias for field number 2

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.func.separate_hsv(color=(0.8, 0.8, 0.8, 1))

Uses a SeparateHSV Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/separate_color.html

Parameters:

color (ProcNode[Color] | Color)

Return type:

SeparateHsvResult

class procfunc.nodes.func.SeparateRgbResult

Bases: NamedTuple

SeparateRgbResult(r, g, b)

r: ProcNode[float]

Alias for field number 0

g: ProcNode[float]

Alias for field number 1

b: ProcNode[float]

Alias for field number 2

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.func.separate_rgb(image=(0.8, 0.8, 0.8, 1))

Uses a SeparateRGB Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/separate_color.html

Parameters:

image (ProcNode[Color] | Color)

Return type:

SeparateRgbResult

class procfunc.nodes.func.SeparateXyzResult

Bases: NamedTuple

SeparateXyzResult(x, y, z)

x: ProcNode[float]

Alias for field number 0

y: ProcNode[float]

Alias for field number 1

z: ProcNode[float]

Alias for field number 2

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.func.separate_xyz(vector=(0, 0, 0))

Uses a SeparateXYZ Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/separate_xyz.html

Parameters:

vector (ProcNode[Vector] | Vector)

Return type:

SeparateXyzResult

procfunc.nodes.func.map_range(value=1.0, from_max=1.0, from_min=0.0, to_max=1.0, to_min=0.0, clamp=True, interpolation_type='LINEAR', data_type=None)

Uses a MapRange Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/map_range.html

Parameters:

• value (ProcNode[float] | float)

• from_max (ProcNode[float] | float)

• from_min (ProcNode[float] | float)

• to_max (ProcNode[float] | float)

• to_min (ProcNode[float] | float)

• clamp (bool)

• interpolation_type (Literal['LINEAR', 'STEPPED_LINEAR', 'SMOOTHSTEP', 'SMOOTHERSTEP'])

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

ProcNode

procfunc.nodes.func.float_curve(factor=1.0, value=1.0, curve=None, handle_type='AUTO', use_clip=True)

Uses a FloatCurve Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/float_curve.html

Parameters:

• factor (ProcNode[float] | float)

• value (ProcNode[float] | float)

• curve (ndarray | None)

• handle_type (str)

• use_clip (bool)

Return type:

ProcNode[float]

procfunc.nodes.func.vector_curve(fac=1.0, vector=(0, 0, 0), curves=None)

Uses a VectorCurve Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/vector/curves.html

Parameters:

• fac (ProcNode[float] | float)

• vector (ProcNode[Vector] | Vector)

• curves (ndarray | None)

Return type:

ProcNode[Vector]

procfunc.nodes.func.index_switch(val_0=0, val_1=0, index=0, data_type=None)

Uses a IndexSwitch Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/index_switch.html

Parameters:

• val_0 (TIndexSwitch)

• val_1 (TIndexSwitch)

• index (ProcNode[int] | int)

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

ProcNode

procfunc.nodes.func.switch(switch=False, a=None, b=None, data_type=None)

Uses a Switch Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/switch.html

Parameters:

• switch (ProcNode[bool] | bool)

• a (ProcNode[TAnyDataVal] | TAnyDataVal | None)

• b (ProcNode[TAnyDataVal] | TAnyDataVal | None)

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

ProcNode[TAnyDataVal]

pf.nodes.geo

Auto-generated Geometry Node bindings for Blender

WARNING: These type annotations are not guaranteed to be exhaustive or precise.

places of particular concern: - What attribute nodes allow int/float/bool or also Color/Vector - What geometry operations should we allow to apply on mismatching inputs? e.g. realize instances on a Mesh with no instances

class procfunc.nodes.geo.AccumulateFieldResult

Bases: NamedTuple, Generic[TAttribute]

AccumulateFieldResult(leading, total, trailing)

leading: ProcNode[TAttribute]

Alias for field number 0

total: ProcNode[TAttribute]

Alias for field number 1

trailing: ProcNode[TAttribute]

Alias for field number 2

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.accumulate_field(value=None, group_id=0, domain='POINT', data_type=None)

Uses a AccumulateField Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/field/accumulate_field.html

Parameters:

• value (ProcNode[TAttribute] | None)

• group_id (ProcNode[int] | int)

• domain (Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'])

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

AccumulateFieldResult[TAttribute]

class procfunc.nodes.geo.AttributeDomainSizeResult

Bases: NamedTuple

AttributeDomainSizeResult(point_count, edge_count, face_count, face_corner_count, spline_count, instance_count)

point_count: ProcNode[int]

Alias for field number 0

edge_count: ProcNode[int]

Alias for field number 1

face_count: ProcNode[int]

Alias for field number 2

face_corner_count: ProcNode[int]

Alias for field number 3

spline_count: ProcNode[int]

Alias for field number 4

instance_count: ProcNode[int]

Alias for field number 5

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.attribute_domain_size(geometry, component='MESH')

Uses a AttributeDomainSize Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/attribute/domain_size.html

Parameters:

• geometry (ProcNode[MeshObject | CurveObject | Instances | VolumeObject])

• component (Literal['MESH', 'POINTCLOUD', 'CURVE', 'INSTANCES'])

Return type:

AttributeDomainSizeResult

class procfunc.nodes.geo.AttributeStatisticResult

Bases: NamedTuple, Generic[TAttribute]

AttributeStatisticResult(max, mean, median, min, range, standard_deviation, sum, variance)

max: ProcNode[TAttribute]

Alias for field number 0

mean: ProcNode[TAttribute]

Alias for field number 1

median: ProcNode[TAttribute]

Alias for field number 2

min: ProcNode[TAttribute]

Alias for field number 3

range: ProcNode[TAttribute]

Alias for field number 4

standard_deviation: ProcNode[TAttribute]

Alias for field number 5

sum: ProcNode[TAttribute]

Alias for field number 6

variance: ProcNode[TAttribute]

Alias for field number 7

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.attribute_statistic(geometry, attribute=None, selection=True, domain='POINT', data_type=None)

Uses a AttributeStatistic Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/attribute/attribute_statistic.html

Parameters:

• geometry (ProcNode[MeshObject | CurveObject | Instances | VolumeObject])

• attribute (ProcNode[TAttribute] | None)

• selection (ProcNode[bool] | bool)

• domain (Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'])

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

AttributeStatisticResult[TAttribute]

procfunc.nodes.geo.blur_attribute(value=None, iterations=1, weight=1.0, data_type=None)

Uses a BlurAttribute Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/attribute/blur_attribute.html

Parameters:

• value (ProcNode[TAttribute] | None)

• iterations (ProcNode[int] | int)

• weight (ProcNode[float] | float)

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

ProcNode[TAttribute]

class procfunc.nodes.geo.BoundBoxResult

Bases: NamedTuple

BoundBoxResult(bounding_box, min, max)

bounding_box: ProcNode[MeshObject]

Alias for field number 0

min: ProcNode[Vector]

Alias for field number 1

max: ProcNode[Vector]

Alias for field number 2

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.bound_box(geometry)

Uses a BoundBox Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/operations/bounding_box.html

Parameters:

geometry (ProcNode[MeshObject | CurveObject | Instances | VolumeObject])

Return type:

BoundBoxResult

class procfunc.nodes.geo.CaptureAttributeResult

Bases: Generic[TAnyGeometry]

CaptureAttributeResult(geometry: procfunc.nodes.types.ProcNode[~TAnyGeometry], attributes: dict[str, procfunc.nodes.types.ProcNode])

geometry: ProcNode[TAnyGeometry]

attributes: dict[str, ProcNode]

__init__(geometry, attributes)

Parameters:

• geometry (ProcNode[TAnyGeometry])

• attributes (dict[str, ProcNode])

Return type:

None

Supported special methods: __getattr__

procfunc.nodes.geo.capture_attribute(geometry, domain='POINT', **attributes)

Uses a CaptureAttribute Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/attribute/capture_attribute.html

Parameters:

• geometry (ProcNode[TAnyGeometry])

• domain (Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'])

• attributes (ProcNode[TAttribute] | TAttribute)

Return type:

CaptureAttributeResult[TAnyGeometry]

procfunc.nodes.geo.collection_info(collection, separate_children=False, reset_children=False, transform_space='ORIGINAL')

Uses a CollectionInfo Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/scene/collection_info.html

Parameters:

• collection (ProcNode[Collection] | Collection)

• separate_children (ProcNode[bool] | bool)

• reset_children (ProcNode[bool] | bool)

• transform_space (Literal['ORIGINAL', 'RELATIVE'])

Return type:

ProcNode[Instances]

procfunc.nodes.geo.convex_hull(geometry)

Uses a ConvexHull Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/operations/convex_hull.html

Parameters:

geometry (ProcNode[MeshObject | CurveObject | Instances | VolumeObject])

Return type:

ProcNode[MeshObject]

class procfunc.nodes.geo.CornerResult

Bases: NamedTuple

CornerResult(corner_index, total)

corner_index: ProcNode[int]

Alias for field number 0

total: ProcNode[int]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.corners_of_edge(edge_index=0, weights=0.0, sort_index=0)

Uses a CornersOfEdge Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/topology/corners_of_edge.html

Parameters:

• edge_index (ProcNode[int] | int)

• weights (ProcNode[float] | float)

• sort_index (ProcNode[int] | int)

Return type:

CornerResult

procfunc.nodes.geo.corners_of_face(face_index=0, weights=0.0, sort_index=0)

Uses a CornersOfFace Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/topology/corners_of_face.html

Parameters:

• face_index (ProcNode[int] | int)

• weights (ProcNode[float] | float)

• sort_index (ProcNode[int] | int)

Return type:

CornerResult

procfunc.nodes.geo.corners_of_vertex(vertex_index=0, weights=0.0, sort_index=0)

Uses a CornersOfVertex Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/topology/corners_of_vertex.html

Parameters:

• vertex_index (ProcNode[int] | int)

• weights (ProcNode[float] | float)

• sort_index (ProcNode[int] | int)

Return type:

CornerResult

procfunc.nodes.geo.curve_arc(resolution=16, radius=1.0, start_angle=0.0, sweep_angle=5.497787, connect_center=False, invert_arc=False, mode='RADIUS')

Uses a CurveArc Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/primitives/arc.html

Parameters:

• resolution (ProcNode[int] | int)

• radius (ProcNode[float] | float)

• start_angle (ProcNode[float] | float)

• sweep_angle (ProcNode[float] | float)

• connect_center (ProcNode[bool] | bool)

• invert_arc (ProcNode[bool] | bool)

• mode (Literal['POINTS', 'RADIUS'])

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.curve_endpoint_selection(start_size=1, end_size=1)

Uses a CurveEndpointSelection Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/read/endpoint_selection.html

Parameters:

• start_size (ProcNode[int] | int)

• end_size (ProcNode[int] | int)

Return type:

ProcNode[bool]

procfunc.nodes.geo.curve_length(curve)

Uses a CurveLength Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/read/curve_length.html

Parameters:

curve (ProcNode[CurveObject])

Return type:

ProcNode[float]

class procfunc.nodes.geo.CurveOfPointResult

Bases: NamedTuple

CurveOfPointResult(curve_index, index_in_curve)

curve_index: ProcNode[int]

Alias for field number 0

index_in_curve: ProcNode[int]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.curve_of_point(point_index=0)

Uses a CurveOfPoint Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/topology/curve_of_point.html

Parameters:

point_index (ProcNode[int] | int)

Return type:

CurveOfPointResult

procfunc.nodes.geo.curve_bezier_segment(resolution=16, start=(-1, 0, 0), start_handle=(-0.5, 0.5, 0), end_handle=(0, 0, 0), end=(1, 0, 0), mode='POSITION')

Uses a CurvePrimitiveBezierSegment Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/primitives/bezier_segment.html

Parameters:

• resolution (ProcNode[int] | int)

• start (ProcNode[Vector] | Vector)

• start_handle (ProcNode[Vector] | Vector)

• end_handle (ProcNode[Vector] | Vector)

• end (ProcNode[Vector] | Vector)

• mode (Literal['POSITION', 'OFFSET'])

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.curve_circle(resolution=32, radius=1.0, mode='RADIUS')

Uses a CurvePrimitiveCircle Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/primitives/curve_circle.html

Parameters:

• resolution (ProcNode[int] | int)

• radius (ProcNode[float] | float)

• mode (Literal['POINTS', 'RADIUS'])

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.curve_line(start=(0, 0, 0), end=(0, 0, 1))

Uses a CurvePrimitiveLine Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/primitives/curve_line.html

Parameters:

• start (ProcNode[Vector] | Vector)

• end (ProcNode[Vector] | Vector)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.curve_line_from_direction(start=(0, 0, 0), direction=(0, 0, 1), length=1.0)

Uses a CurveLineFromDirection Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/primitives/curve_line.html

Parameters:

• start (ProcNode[Vector] | Vector)

• direction (ProcNode[Vector] | Vector)

• length (ProcNode[float] | float)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.curve_quadrilateral(width=2.0, height=2.0, mode='RECTANGLE')

Uses a CurvePrimitiveQuadrilateral Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/primitives/quadrilateral.html

Parameters:

• width (ProcNode[float] | float)

• height (ProcNode[float] | float)

• mode (Literal['RECTANGLE', 'PARALLELOGRAM', 'TRAPEZOID', 'KITE', 'POINTS'])

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.curve_bezier(resolution=16, start=(-1, 0, 0), middle=(0, 2, 0), end=(1, 0, 0))

Uses a CurveQuadraticBezier Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/primitives/quadratic_bezier.html

Parameters:

• resolution (ProcNode[int] | int)

• start (ProcNode[Vector] | Vector)

• middle (ProcNode[Vector] | Vector)

• end (ProcNode[Vector] | Vector)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.curve_set_handles(curve, selection=True, handle_type='AUTO', mode='RIGHT')

Uses a CurveSetHandles Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/write/set_handle_type.html

Parameters:

• curve (ProcNode[CurveObject])

• selection (ProcNode[bool] | bool)

• handle_type (Literal['FREE', 'AUTO', 'VECTOR', 'ALIGN'])

• mode (Literal['LEFT', 'RIGHT'])

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.curve_spiral(resolution=32, rotations=2.0, start_radius=1.0, end_radius=2.0, height=2.0, reverse=False)

Uses a CurveSpiral Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/primitives/curve_spiral.html

Parameters:

• resolution (ProcNode[int] | int)

• rotations (ProcNode[float] | float)

• start_radius (ProcNode[float] | float)

• end_radius (ProcNode[float] | float)

• height (ProcNode[float] | float)

• reverse (ProcNode[bool] | bool)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.curve_spline_type(curve, selection=True, spline_type='POLY')

Uses a CurveSplineType Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/write/set_spline_type.html

Parameters:

• curve (ProcNode[CurveObject])

• selection (ProcNode[bool] | bool)

• spline_type (Literal['CATMULL_ROM', 'POLY', 'BEZIER', 'NURBS'])

Return type:

ProcNode[CurveObject]

class procfunc.nodes.geo.CurveStarResult

Bases: NamedTuple

CurveStarResult(curve, outer_points)

curve: ProcNode[CurveObject]

Alias for field number 0

outer_points: ProcNode[bool]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.curve_star(points=8, inner_radius=1.0, outer_radius=2.0, twist=0.0)

Uses a CurveStar Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/primitives/star.html

Parameters:

• points (ProcNode[int] | int)

• inner_radius (ProcNode[float] | float)

• outer_radius (ProcNode[float] | float)

• twist (ProcNode[float] | float)

Return type:

CurveStarResult

procfunc.nodes.geo.curve_to_mesh(curve, profile_curve=None, fill_caps=False)

Uses a CurveToMesh Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/operations/curve_to_mesh.html

Parameters:

• curve (ProcNode[CurveObject])

• profile_curve (ProcNode[CurveObject] | None)

• fill_caps (ProcNode[bool] | bool)

Return type:

ProcNode[MeshObject]

class procfunc.nodes.geo.CurveToPointsResult

Bases: NamedTuple

CurveToPointsResult(points, tangent, normal, rotation)

points: ProcNode[MeshObject]

Alias for field number 0

tangent: ProcNode[Vector]

Alias for field number 1

normal: ProcNode[Vector]

Alias for field number 2

rotation: ProcNode[Vector]

Alias for field number 3

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.curve_to_points(curve, count=10, length=1.0, mode='COUNT')

Uses a CurveToPoints Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/operations/curve_to_points.html

Parameters:

• curve (ProcNode[CurveObject])

• count (ProcNode[int] | int)

• length (ProcNode[float] | float)

• mode (Literal['EVALUATED', 'COUNT', 'LENGTH'])

Return type:

CurveToPointsResult

procfunc.nodes.geo.curve_to_points_evaluated(curve)

Uses a CurveToPoints Geometry Node with mode=”EVALUATED”.

From Blender docs: Creates points based on how the curve is evaluated. See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/operations/curve_to_points.html

Parameters:

curve (ProcNode[CurveObject])

Return type:

CurveToPointsResult

procfunc.nodes.geo.curve_to_points_count(curve, count=10)

Uses a CurveToPoints Geometry Node with mode=”COUNT”.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/operations/curve_to_points.html

Parameters:

• curve (ProcNode[CurveObject])

• count (ProcNode[int] | int)

Return type:

CurveToPointsResult

procfunc.nodes.geo.curve_to_points_length(curve, length=0.1)

Uses a CurveToPoints Geometry Node with mode=”LENGTH”.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/operations/curve_to_points.html

Parameters:

• curve (ProcNode[CurveObject])

• length (ProcNode[float] | float)

Return type:

CurveToPointsResult

procfunc.nodes.geo.deform_curves_on_surface(curves)

Uses a DeformCurvesOnSurface Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/operations/deform_curves_on_surface.html

Parameters:

curves (ProcNode[HairObject])

Return type:

ProcNode[HairObject]

procfunc.nodes.geo.delete_geometry(geometry, selection=True, domain='POINT', mode='ALL')

Uses a DeleteGeometry Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/operations/delete_geometry.html

Parameters:

• geometry (ProcNode[TDeleteGeometry])

• selection (ProcNode[bool] | bool)

• domain (Literal['POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'])

• mode (Literal['ALL', 'EDGE_FACE', 'ONLY_FACE'])

Return type:

ProcNode[TDeleteGeometry]

procfunc.nodes.geo.distribute_points_in_grid(grid=0.0, density=1.0, seed=0, mode='DENSITY_RANDOM')

Uses a DistributePointsInGrid Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/point/distribute_points_in_volume.html

Parameters:

• grid (ProcNode[float] | float)

• density (ProcNode[float] | float)

• seed (ProcNode[int] | int)

• mode (Literal['DENSITY_RANDOM', 'DENSITY_GRID'])

Return type:

ProcNode[MeshObject]

procfunc.nodes.geo.distribute_points_in_volume(volume, density=1.0, seed=0, mode='DENSITY_RANDOM')

Uses a DistributePointsInVolume Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/point/distribute_points_in_volume.html

Parameters:

• volume (ProcNode[VolumeObject])

• density (ProcNode[float] | float)

• seed (ProcNode[int] | int)

• mode (Literal['DENSITY_RANDOM', 'DENSITY_GRID'])

Return type:

ProcNode[VolumeObject]

class procfunc.nodes.geo.DistributePointsOnFacesResult

Bases: NamedTuple

DistributePointsOnFacesResult(points, normal, rotation)

points: ProcNode[MeshObject]

Alias for field number 0

normal: ProcNode[Vector]

Alias for field number 1

rotation: ProcNode[Vector]

Alias for field number 2

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.distribute_points_on_faces(mesh, selection=True, density=None, seed=0, use_legacy_normal=False)

Uses a DistributePointsOnFaces Geometry Node with RANDOM distribution.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/point/distribute_points_on_faces.html

Parameters:

• mesh (ProcNode[MeshObject])

• selection (ProcNode[bool] | bool)

• density (ProcNode[float] | float | None)

• seed (ProcNode[int] | int)

• use_legacy_normal (bool)

Return type:

DistributePointsOnFacesResult

procfunc.nodes.geo.distribute_points_on_faces_poisson(mesh, selection=True, distance_min=0.0, density_max=10.0, density_factor=1.0, seed=0, use_legacy_normal=False)

Uses a DistributePointsOnFaces Geometry Node with POISSON distribution.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/point/distribute_points_on_faces.html

Parameters:

• mesh (ProcNode[MeshObject])

• selection (ProcNode[bool] | bool)

• distance_min (ProcNode[float] | float)

• density_max (ProcNode[float] | float)

• density_factor (ProcNode[float] | float)

• seed (ProcNode[int] | int)

• use_legacy_normal (bool)

Return type:

DistributePointsOnFacesResult

procfunc.nodes.geo.dual_mesh(mesh, keep_boundaries=False)

Uses a DualMesh Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/operations/dual_mesh.html

Parameters:

• mesh (ProcNode[MeshObject])

• keep_boundaries (ProcNode[bool] | bool)

Return type:

ProcNode[MeshObject]

class procfunc.nodes.geo.DuplicateElementsResult

Bases: NamedTuple, Generic[TAnyGeometry]

DuplicateElementsResult(geometry, duplicate_index)

geometry: ProcNode[TAnyGeometry]

Alias for field number 0

duplicate_index: ProcNode[int]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.duplicate_elements(geometry, selection=True, amount=1, domain='POINT')

Uses a DuplicateElements Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/operations/duplicate_elements.html

Parameters:

• geometry (ProcNode[TAnyGeometry])

• selection (ProcNode[bool] | bool)

• amount (ProcNode[int] | int)

• domain (Literal['POINT', 'EDGE', 'FACE', 'SPLINE', 'INSTANCE'])

Return type:

DuplicateElementsResult[TAnyGeometry]

procfunc.nodes.geo.edge_paths_to_curves(mesh, start_vertices=True, next_vertex_index=-1)

Uses a EdgePathsToCurves Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/operations/edge_paths_to_curves.html

Parameters:

• mesh (ProcNode[MeshObject])

• start_vertices (ProcNode[bool] | bool)

• next_vertex_index (ProcNode[int] | int)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.edge_paths_to_selection(start_vertices=True, next_vertex_index=-1)

Uses a EdgePathsToSelection Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/operations/edge_paths_to_selection.html

Parameters:

• start_vertices (ProcNode[bool] | bool)

• next_vertex_index (ProcNode[int] | int)

Return type:

ProcNode[bool]

class procfunc.nodes.geo.EdgesOfCornerResult

Bases: NamedTuple

EdgesOfCornerResult(next_edge_index, previous_edge_index)

next_edge_index: ProcNode[int]

Alias for field number 0

previous_edge_index: ProcNode[int]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.edges_of_corner(corner_index=0)

Uses a EdgesOfCorner Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/topology/edges_of_corner.html

Parameters:

corner_index (ProcNode[int] | int)

Return type:

EdgesOfCornerResult

class procfunc.nodes.geo.EdgesOfVertexResult

Bases: NamedTuple

EdgesOfVertexResult(edge_index, total)

edge_index: ProcNode[int]

Alias for field number 0

total: ProcNode[int]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.edges_of_vertex(vertex_index=0, weights=0.0, sort_index=0)

Uses a EdgesOfVertex Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/topology/edges_of_vertex.html

Parameters:

• vertex_index (ProcNode[int] | int)

• weights (ProcNode[float] | float)

• sort_index (ProcNode[int] | int)

Return type:

EdgesOfVertexResult

procfunc.nodes.geo.edges_to_face_groups(boundary_edges=True)

Uses a EdgesToFaceGroups Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/read/edges_to_face_groups.html

Parameters:

boundary_edges (ProcNode[bool] | bool)

Return type:

ProcNode[int]

class procfunc.nodes.geo.ExtrudeMeshResult

Bases: NamedTuple

ExtrudeMeshResult(mesh, top, side)

mesh: ProcNode[MeshObject]

Alias for field number 0

top: ProcNode[bool]

Alias for field number 1

side: ProcNode[bool]

Alias for field number 2

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.extrude_mesh(mesh, selection=True, offset=(0, 0, 0), offset_scale=1.0, individual=True, mode='FACES')

Parameters:

• mesh (ProcNode[MeshObject])

• selection (ProcNode[bool] | bool)

• offset (ProcNode[Vector] | Vector)

• offset_scale (ProcNode[float] | float)

• individual (ProcNode[bool] | bool)

• mode (Literal['VERTICES', 'EDGES', 'FACES'])

Return type:

ExtrudeMeshResult

class procfunc.nodes.geo.FaceOfCornerResult

Bases: NamedTuple

FaceOfCornerResult(face_index, index_in_face)

face_index: ProcNode[int]

Alias for field number 0

index_in_face: ProcNode[int]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.face_of_corner(corner_index=0)

Uses a FaceOfCorner Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/topology/face_of_corner.html

Parameters:

corner_index (ProcNode[int] | int)

Return type:

FaceOfCornerResult

procfunc.nodes.geo.field_at_index(value=None, index=0, domain='POINT', data_type=None)

Uses a FieldAtIndex Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/field/evaluate_at_index.html

Parameters:

• value (TAttribute | None)

• index (ProcNode[int] | int)

• domain (Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'])

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

ProcNode[TAttribute]

procfunc.nodes.geo.field_on_domain(value=0, domain='POINT', data_type=None)

Uses a FieldOnDomain Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/field/evaluate_on_domain.html

Parameters:

• value (TFieldOnDomain)

• domain (Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'])

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

ProcNode[TFieldOnDomain]

procfunc.nodes.geo.fill_curve(curve, group_id=0, mode='TRIANGLES')

Uses a FillCurve Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/operations/fill_curve.html

Parameters:

• curve (ProcNode[CurveObject])

• group_id (ProcNode[int] | int)

• mode (Literal['TRIANGLES', 'NGONS'])

Return type:

ProcNode[MeshObject]

procfunc.nodes.geo.fillet_curve(curve, radius=0.25, limit_radius=False, count=1, mode='BEZIER')

Uses a FilletCurve Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/operations/fillet_curve.html

Parameters:

• curve (ProcNode[CurveObject])

• radius (ProcNode[float] | float)

• limit_radius (ProcNode[bool] | bool)

• count (ProcNode[int] | int)

• mode (Literal['BEZIER', 'POLY'])

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.flip_faces(mesh, selection=True)

Uses a FlipFaces Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/operations/flip_faces.html

Parameters:

• mesh (ProcNode[MeshObject])

• selection (ProcNode[bool] | bool)

Return type:

ProcNode[MeshObject]

procfunc.nodes.geo.geometry_to_instance(geometry)

Uses a GeometryToInstance Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/geometry_to_instance.html

Parameters:

geometry (ProcNode[TAnyGeometry])

Return type:

ProcNode[Instances]

procfunc.nodes.geo.get_named_grid(volume, name='', remove=True)

Uses a GetNamedGrid Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/volume/index.html

Parameters:

• volume (ProcNode[MeshObject | CurveObject | Instances | VolumeObject])

• name (ProcNode[str] | str)

• remove (ProcNode[bool] | bool)

Return type:

ProcNode

procfunc.nodes.geo.grid_to_mesh(grid=0.0, threshold=0.1, adaptivity=0.0)

Uses a GridToMesh Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/volume/operations/volume_to_mesh.html

Parameters:

• grid (ProcNode[float] | float)

• threshold (ProcNode[float] | float)

• adaptivity (ProcNode[float] | float)

Return type:

ProcNode[MeshObject]

class procfunc.nodes.geo.ImageInfoResult

Bases: NamedTuple

ImageInfoResult(width, height, has_alpha, frame_count, fps)

width: ProcNode[int]

Alias for field number 0

height: ProcNode[int]

Alias for field number 1

has_alpha: ProcNode[bool]

Alias for field number 2

frame_count: ProcNode[int]

Alias for field number 3

fps: ProcNode[float]

Alias for field number 4

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.image_info(image, frame=0)

Uses a ImageInfo Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/scene/image_info.html

Parameters:

• image (ProcNode[Image] | Image)

• frame (ProcNode[int] | int)

Return type:

ImageInfoResult

procfunc.nodes.geo.image_texture(image, vector=(0, 0, 0), frame=0, extension='REPEAT', interpolation='Linear')

Uses a ImageTexture Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/scene/image_info.html

Parameters:

• image (ProcNode[Image] | Image)

• vector (ProcNode[Vector] | Vector)

• frame (ProcNode[int] | int)

• extension (Literal['REPEAT', 'EXTEND', 'CLIP', 'MIRROR'])

• interpolation (Literal['Linear', 'Closest', 'Cubic'])

Return type:

ProcNode

procfunc.nodes.geo.index_of_nearest(position=(0, 0, 0), group_id=0)

Uses a IndexOfNearest Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/sample/index_of_nearest.html

Parameters:

• position (ProcNode[Vector] | Vector)

• group_id (ProcNode[int] | int)

Return type:

ProcNode[int]

procfunc.nodes.geo.input_active_camera()

Uses a InputActiveCamera Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/scene/active_camera.html

Return type:

ProcNode[Object]

class procfunc.nodes.geo.InputCurveHandlePositionsResult

Bases: NamedTuple

InputCurveHandlePositionsResult(left, right)

left: ProcNode[Vector]

Alias for field number 0

right: ProcNode[Vector]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.input_curve_handle_positions(relative=False)

Uses a InputCurveHandlePositions Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/read/curve_handle_position.html

Parameters:

relative (ProcNode[bool] | bool)

Return type:

InputCurveHandlePositionsResult

procfunc.nodes.geo.input_curve_tilt()

Uses a InputCurveTilt Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/read/curve_tilt.html

Return type:

ProcNode[float]

procfunc.nodes.geo.input_edge_smooth()

Uses a InputEdgeSmooth Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/read/is_edge_smooth.html

Return type:

ProcNode[bool]

procfunc.nodes.geo.input_id()

Uses a InputID Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/read/id.html

Return type:

ProcNode[int]

procfunc.nodes.geo.input_image(image=None)

Uses a InputImage Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/image.html

Parameters:

image (Any)

Return type:

ProcNode[Image]

procfunc.nodes.geo.input_index()

Uses a InputIndex Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/read/input_index.html

Return type:

ProcNode[int]

procfunc.nodes.geo.input_instance_rotation()

Uses a InputInstanceRotation Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/rotation.html

Return type:

ProcNode[Vector]

procfunc.nodes.geo.input_instance_scale()

Uses a InputInstanceScale Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/instances/instance_scale.html

Return type:

ProcNode[Vector]

procfunc.nodes.geo.input_material(material=None)

Uses a InputMaterial Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/material.html

Parameters:

material (Any)

Return type:

ProcNode[Material]

procfunc.nodes.geo.input_material_index()

Uses a InputMaterialIndex Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/material/material_index.html

Return type:

ProcNode[int]

class procfunc.nodes.geo.InputMeshEdgeAngleResult

Bases: NamedTuple

InputMeshEdgeAngleResult(unsigned_angle, signed_angle)

unsigned_angle: ProcNode[float]

Alias for field number 0

signed_angle: ProcNode[float]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.input_mesh_edge_angle()

Uses a InputMeshEdgeAngle Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/read/edge_angle.html

Return type:

InputMeshEdgeAngleResult

procfunc.nodes.geo.input_mesh_edge_neighbors()

Uses a InputMeshEdgeNeighbors Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/read/edge_neighbors.html

Return type:

ProcNode[int]

class procfunc.nodes.geo.InputMeshEdgeVerticesResult

Bases: NamedTuple

InputMeshEdgeVerticesResult(vertex_index_1, vertex_index_2, position_1, position_2)

vertex_index_1: ProcNode[int]

Alias for field number 0

vertex_index_2: ProcNode[int]

Alias for field number 1

position_1: ProcNode[Vector]

Alias for field number 2

position_2: ProcNode[Vector]

Alias for field number 3

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.input_mesh_edge_vertices()

Uses a InputMeshEdgeVertices Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/read/edge_vertices.html

Return type:

InputMeshEdgeVerticesResult

procfunc.nodes.geo.input_mesh_face_area()

Uses a InputMeshFaceArea Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/read/face_area.html

Return type:

ProcNode[float]

procfunc.nodes.geo.input_mesh_face_is_planar(threshold=0.01)

Uses a InputMeshFaceIsPlanar Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/read/face_is_planar.html

Parameters:

threshold (ProcNode[float] | float)

Return type:

ProcNode[bool]

class procfunc.nodes.geo.InputMeshFaceNeighborsResult

Bases: NamedTuple

InputMeshFaceNeighborsResult(vertex_count, face_count)

vertex_count: ProcNode[int]

Alias for field number 0

face_count: ProcNode[int]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.input_mesh_face_neighbors()

Uses a InputMeshFaceNeighbors Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/read/face_neighbors.html

Return type:

InputMeshFaceNeighborsResult

class procfunc.nodes.geo.InputMeshIslandResult

Bases: NamedTuple

InputMeshIslandResult(island_index, island_count)

island_index: ProcNode[int]

Alias for field number 0

island_count: ProcNode[int]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.input_mesh_island()

Uses a InputMeshIsland Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/read/mesh_island.html

Return type:

InputMeshIslandResult

class procfunc.nodes.geo.InputMeshVertexNeighborsResult

Bases: NamedTuple

InputMeshVertexNeighborsResult(vertex_count, face_count)

vertex_count: ProcNode[int]

Alias for field number 0

face_count: ProcNode[int]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.input_mesh_vertex_neighbors()

Uses a InputMeshVertexNeighbors Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/read/vertex_neighbors.html

Return type:

InputMeshVertexNeighborsResult

class procfunc.nodes.geo.InputNamedAttributeResult

Bases: NamedTuple

InputNamedAttributeResult(attribute, exists)

attribute: ProcNode

Alias for field number 0

exists: ProcNode[bool]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.input_named_attribute(name='', data_type=None)

Uses a InputNamedAttribute Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/read/named_attribute.html

Parameters:

• name (ProcNode[str] | str)

• data_type (NodeDataType | None)

Return type:

InputNamedAttributeResult

procfunc.nodes.geo.input_named_layer_selection(name='')

Uses a InputNamedLayerSelection Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/read/selection.html

Parameters:

name (ProcNode[str] | str)

Return type:

ProcNode[bool]

procfunc.nodes.geo.input_normal()

Uses a InputNormal Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/read/normal.html

Return type:

ProcNode[Vector]

procfunc.nodes.geo.input_position()

Uses a InputPosition Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/read/position.html

Return type:

ProcNode[Vector]

procfunc.nodes.geo.input_radius()

Uses a InputRadius Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/read/radius.html

Return type:

ProcNode[float]

class procfunc.nodes.geo.InputSceneTimeResult

Bases: NamedTuple

InputSceneTimeResult(seconds, frame)

seconds: ProcNode[float]

Alias for field number 0

frame: ProcNode[int]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.input_scene_time()

Uses a InputSceneTime Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/scene/scene_time.html

Return type:

InputSceneTimeResult

procfunc.nodes.geo.input_shade_smooth()

Uses a InputShadeSmooth Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/write/set_shade_smooth.html

Return type:

ProcNode[bool]

class procfunc.nodes.geo.InputShortestEdgePathsResult

Bases: NamedTuple

InputShortestEdgePathsResult(next_vertex_index, total_cost)

next_vertex_index: ProcNode[int]

Alias for field number 0

total_cost: ProcNode[float]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.input_shortest_edge_paths(end_vertex=False, edge_cost=1.0)

Uses a InputShortestEdgePaths Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/read/shortest_edge_paths.html

Parameters:

• end_vertex (ProcNode[bool] | bool)

• edge_cost (ProcNode[float] | float)

Return type:

InputShortestEdgePathsResult

procfunc.nodes.geo.input_spline_cyclic()

Uses a InputSplineCyclic Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/read/is_spline_cyclic.html

Return type:

ProcNode[bool]

procfunc.nodes.geo.input_spline_resolution()

Uses a InputSplineResolution Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/read/spline_resolution.html

Return type:

ProcNode[int]

procfunc.nodes.geo.input_tangent()

Uses a InputTangent Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/read/curve_tangent.html

Return type:

ProcNode[Vector]

procfunc.nodes.geo.instance_on_points(points=None, instance=None, selection=True, pick_instance=False, instance_index=0, rotation=(0, 0, 0), scale=(1, 1, 1))

Uses a InstanceOnPoints Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/instances/instance_on_points.html

Parameters:

• points (ProcNode[MeshObject | CurveObject | Instances | VolumeObject] | None)

• instance (ProcNode[MeshObject | CurveObject | Instances | VolumeObject] | None)

• selection (ProcNode[bool] | bool)

• pick_instance (ProcNode[bool] | bool)

• instance_index (ProcNode[int] | int)

• rotation (ProcNode[Vector] | Vector)

• scale (ProcNode[Vector] | Vector)

Return type:

ProcNode[Instances]

procfunc.nodes.geo.instance_transform()

Uses a InstanceTransform Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/instances/instance_transform.html

Return type:

ProcNode

procfunc.nodes.geo.instances_to_points(instances=None, selection=True, position=(0, 0, 0), radius=0.05)

Uses a InstancesToPoints Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/instances/instances_to_points.html

Parameters:

• instances (ProcNode[Instances] | None)

• selection (ProcNode[bool] | bool)

• position (ProcNode[Vector] | Vector)

• radius (ProcNode[float] | float)

Return type:

ProcNode[MeshObject | CurveObject]

class procfunc.nodes.geo.InterpolateCurvesResult

Bases: NamedTuple

InterpolateCurvesResult(curves, closest_index, closest_weight)

curves: ProcNode[HairObject]

Alias for field number 0

closest_index: ProcNode[int]

Alias for field number 1

closest_weight: ProcNode[float]

Alias for field number 2

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.interpolate_curves(guide_curves, points, guide_up=(0, 0, 0), guide_group_id=0, point_up=(0, 0, 0), point_group_id=0, max_neighbors=4)

Uses a InterpolateCurves Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/operations/interpolate_curves.html

Parameters:

• guide_curves (ProcNode[HairObject])

• points (ProcNode[MeshObject | CurveObject | Instances | VolumeObject])

• guide_up (ProcNode[Vector] | Vector)

• guide_group_id (ProcNode[int] | int)

• point_up (ProcNode[Vector] | Vector)

• point_group_id (ProcNode[int] | int)

• max_neighbors (ProcNode[int] | int)

Return type:

InterpolateCurvesResult

procfunc.nodes.geo.is_viewport()

Uses a IsViewport Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/scene/is_viewport.html

Return type:

ProcNode[bool]

procfunc.nodes.geo.join_geometry(geometries)

Uses a JoinGeometry Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/join_geometry.html

Parameters:

geometries (list[ProcNode[TAnyGeometry]])

Return type:

ProcNode[TAnyGeometry]

procfunc.nodes.geo.material_selection(material=None)

Uses a MaterialSelection Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/material/material_selection.html

Parameters:

material (ProcNode[Material] | Material)

Return type:

ProcNode[bool]

procfunc.nodes.geo.merge_by_distance(geometry, selection=True, distance=0.001, mode='ALL')

Uses a MergeByDistance Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/operations/merge_by_distance.html

Parameters:

• geometry (ProcNode[MeshObject | CurveObject | Instances | VolumeObject])

• selection (ProcNode[bool] | bool)

• distance (ProcNode[float] | float)

• mode (Literal['ALL', 'CONNECTED'])

Return type:

ProcNode[MeshObject | CurveObject | Instances | VolumeObject]

procfunc.nodes.geo.mesh_boolean(mesh_1=None, mesh_2=None, self_intersection=False, hole_tolerant=False, operation='DIFFERENCE', solver='FLOAT')

Uses a MeshBoolean Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/operations/mesh_boolean.html

Parameters:

• mesh_1 (ProcNode[MeshObject | CurveObject | Instances | VolumeObject] | None)

• mesh_2 (ProcNode[MeshObject | CurveObject | Instances | VolumeObject] | None)

• self_intersection (ProcNode[bool] | bool)

• hole_tolerant (ProcNode[bool] | bool)

• operation (Literal['INTERSECT', 'UNION', 'DIFFERENCE'])

• solver (Literal['EXACT', 'FLOAT'])

Return type:

ProcNode[MeshObject]

procfunc.nodes.geo.mesh_circle(vertices=32, radius=1.0, fill_type='NONE')

Uses a MeshCircle Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/primitives/mesh_circle.html

Parameters:

• vertices (ProcNode[int] | int)

• radius (ProcNode[float] | float)

• fill_type (Literal['NONE', 'NGON', 'TRIANGLE_FAN'])

Return type:

ProcNode[MeshObject]

class procfunc.nodes.geo.MeshResult

Bases: NamedTuple

MeshResult(mesh, uv_map)

mesh: ProcNode[MeshObject]

Alias for field number 0

uv_map: ProcNode[MeshObject]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

class procfunc.nodes.geo.MeshConeResult

Bases: NamedTuple

MeshConeResult(mesh, uv_map, top, bottom, side)

mesh: ProcNode[MeshObject]

Alias for field number 0

uv_map: ProcNode[MeshObject]

Alias for field number 1

top: ProcNode[MeshObject]

Alias for field number 2

bottom: ProcNode[MeshObject]

Alias for field number 3

side: ProcNode[MeshObject]

Alias for field number 4

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.mesh_cone(vertices=32, side_segments=1, fill_segments=1, radius_top=0.0, radius_bottom=1.0, depth=2.0, fill_type='NGON')

Uses a MeshCone Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/primitives/cone.html

Parameters:

• vertices (ProcNode[int] | int)

• side_segments (ProcNode[int] | int)

• fill_segments (ProcNode[int] | int)

• radius_top (ProcNode[float] | float)

• radius_bottom (ProcNode[float] | float)

• depth (ProcNode[float] | float)

• fill_type (Literal['NONE', 'NGON', 'TRIANGLE_FAN'])

Return type:

MeshConeResult

procfunc.nodes.geo.mesh_cube(size=(1, 1, 1), vertices_x=2, vertices_y=2, vertices_z=2)

Uses a MeshCube Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/primitives/cube.html

Parameters:

• size (ProcNode[Vector] | Vector)

• vertices_x (ProcNode[int] | int)

• vertices_y (ProcNode[int] | int)

• vertices_z (ProcNode[int] | int)

Return type:

MeshResult

class procfunc.nodes.geo.MeshCylinderResult

Bases: NamedTuple

MeshCylinderResult(mesh, top, side, bottom, uv_map)

mesh: ProcNode[MeshObject]

Alias for field number 0

top: ProcNode[MeshObject]

Alias for field number 1

side: ProcNode[MeshObject]

Alias for field number 2

bottom: ProcNode[MeshObject]

Alias for field number 3

uv_map: ProcNode[MeshObject]

Alias for field number 4

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.mesh_cylinder(vertices=32, side_segments=1, fill_segments=1, radius=1.0, depth=2.0, fill_type='NGON')

Uses a MeshCylinder Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/primitives/cylinder.html

Parameters:

• vertices (ProcNode[int] | int)

• side_segments (ProcNode[int] | int)

• fill_segments (ProcNode[int] | int)

• radius (ProcNode[float] | float)

• depth (ProcNode[float] | float)

• fill_type (Literal['NONE', 'NGON', 'TRIANGLE_FAN'])

Return type:

MeshCylinderResult

procfunc.nodes.geo.mesh_face_set_boundaries(face_group_id=0)

Uses a MeshFaceSetBoundaries Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/read/face_group_boundaries.html

Parameters:

face_group_id (ProcNode[int] | int)

Return type:

ProcNode[bool]

procfunc.nodes.geo.mesh_grid(size_x=1.0, size_y=1.0, vertices_x=3, vertices_y=3)

Uses a MeshGrid Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/primitives/grid.html

Parameters:

• size_x (ProcNode[float] | float)

• size_y (ProcNode[float] | float)

• vertices_x (ProcNode[int] | int)

• vertices_y (ProcNode[int] | int)

Return type:

MeshResult

procfunc.nodes.geo.mesh_icosphere(radius=1.0, subdivisions=1)

Uses a MeshIcoSphere Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/primitives/icosphere.html

Parameters:

• radius (ProcNode[float] | float)

• subdivisions (ProcNode[int] | int)

Return type:

MeshResult

procfunc.nodes.geo.mesh_line(start_location=(0, 0, 0), offset=(0, 0, 1), count=10, count_mode='TOTAL')

Uses a MeshLine Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/primitives/mesh_line.html

Parameters:

• start_location (ProcNode[Vector] | Vector)

• offset (ProcNode[Vector] | Vector)

• count (ProcNode[int] | int)

• count_mode (Literal['TOTAL', 'RESOLUTION'])

Return type:

ProcNode[MeshObject]

procfunc.nodes.geo.mesh_line_from_endpoints(start_location, end_location, count=10, count_mode='TOTAL')

Parameters:

• start_location (ProcNode[Vector] | Vector)

• end_location (ProcNode[Vector] | Vector)

• count (ProcNode[int] | int)

• count_mode (Literal['TOTAL', 'RESOLUTION'])

Return type:

ProcNode[MeshObject]

procfunc.nodes.geo.mesh_to_curve(mesh, selection=True)

Uses a MeshToCurve Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/operations/mesh_to_curve.html

Parameters:

• mesh (ProcNode[MeshObject])

• selection (ProcNode[bool] | bool)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.mesh_to_density_grid(mesh, density=1.0, voxel_size=0.3, gradient_width=0.2)

Uses a MeshToDensityGrid Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/operations/mesh_to_volume.html

Parameters:

• mesh (ProcNode[MeshObject])

• density (ProcNode[float] | float)

• voxel_size (ProcNode[float] | float)

• gradient_width (ProcNode[float] | float)

Return type:

ProcNode

procfunc.nodes.geo.mesh_to_points(mesh, selection=True, position=(0, 0, 0), radius=0.05, mode='VERTICES')

Uses a MeshToPoints Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/operations/mesh_to_points.html

Parameters:

• mesh (ProcNode[MeshObject])

• selection (ProcNode[bool] | bool)

• position (ProcNode[Vector] | Vector)

• radius (ProcNode[float] | float)

• mode (Literal['VERTICES', 'EDGES', 'FACES', 'CORNERS'])

Return type:

ProcNode[MeshObject | CurveObject]

procfunc.nodes.geo.mesh_to_sdf_grid(mesh, voxel_size=0.3, band_width=3)

Uses a MeshToSDFGrid Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/operations/mesh_to_volume.html

Parameters:

• mesh (ProcNode[MeshObject])

• voxel_size (ProcNode[float] | float)

• band_width (ProcNode[int] | int)

Return type:

ProcNode

procfunc.nodes.geo.mesh_to_volume(mesh, density=1.0, voxel_amount=64.0, interior_band_width=0.2, resolution_mode='VOXEL_AMOUNT')

Uses a MeshToVolume Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/operations/mesh_to_volume.html

Parameters:

• mesh (ProcNode[MeshObject])

• density (ProcNode[float] | float)

• voxel_amount (ProcNode[float] | float)

• interior_band_width (ProcNode[float] | float)

• resolution_mode (Literal['VOXEL_AMOUNT', 'VOXEL_SIZE'])

Return type:

ProcNode[VolumeObject]

procfunc.nodes.geo.mesh_uv_sphere(segments=32, rings=16, radius=1.0)

Uses a MeshUVSphere Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/primitives/uv_sphere.html

Parameters:

• segments (ProcNode[int] | int)

• rings (ProcNode[int] | int)

• radius (ProcNode[float] | float)

Return type:

MeshResult

class procfunc.nodes.geo.ObjectInfoResult

Bases: NamedTuple, Generic[TObjectInfo]

ObjectInfoResult(geometry, transform, location, rotation, scale)

geometry: ProcNode[TObjectInfo]

Alias for field number 0

transform: ProcNode[Vector]

Alias for field number 1

location: ProcNode[Vector]

Alias for field number 2

rotation: ProcNode[Vector]

Alias for field number 3

scale: ProcNode[Vector]

Alias for field number 4

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.object_info(object, as_instance=False, transform_space='ORIGINAL')

Uses a ObjectInfo Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/scene/object_info.html

Parameters:

• object (ProcNode[TObjectInfo] | TObjectInfo)

• as_instance (ProcNode[bool] | bool)

• transform_space (Literal['ORIGINAL', 'RELATIVE'])

Return type:

ObjectInfoResult[TObjectInfo]

procfunc.nodes.geo.offset_corner_in_face(corner_index=0, offset=0)

Uses a OffsetCornerInFace Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/topology/offset_corner_in_face.html

Parameters:

• corner_index (ProcNode[int] | int)

• offset (ProcNode[int] | int)

Return type:

ProcNode[int]

class procfunc.nodes.geo.OffsetPointInCurveResult

Bases: NamedTuple

OffsetPointInCurveResult(is_valid_offset, point_index)

is_valid_offset: ProcNode[bool]

Alias for field number 0

point_index: ProcNode[int]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.offset_point_in_curve(point_index=0, offset=0)

Uses a OffsetPointInCurve Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/topology/offset_point_in_curve.html

Parameters:

• point_index (ProcNode[int] | int)

• offset (ProcNode[int] | int)

Return type:

OffsetPointInCurveResult

procfunc.nodes.geo.points(count=1, position=(0, 0, 0), radius=0.1)

Uses a Points Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/point/points.html

Parameters:

• count (ProcNode[int] | int)

• position (ProcNode[Vector] | Vector)

• radius (ProcNode[float] | float)

Return type:

ProcNode[MeshObject | CurveObject]

class procfunc.nodes.geo.PointsOfCurveResult

Bases: NamedTuple

PointsOfCurveResult(point_index, total)

point_index: ProcNode[int]

Alias for field number 0

total: ProcNode[int]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.points_of_curve(curve_index=0, weights=0.0, sort_index=0)

Uses a PointsOfCurve Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/topology/points_of_curve.html

Parameters:

• curve_index (ProcNode[int] | int)

• weights (ProcNode[float] | float)

• sort_index (ProcNode[int] | int)

Return type:

PointsOfCurveResult

procfunc.nodes.geo.points_to_curves(points, curve_group_id=0, weight=0.0)

Uses a PointsToCurves Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/point/points_to_curves.html

Parameters:

• points (ProcNode[MeshObject | CurveObject | Instances | VolumeObject])

• curve_group_id (ProcNode[int] | int)

• weight (ProcNode[float] | float)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.points_to_sdf_grid(points, radius=0.5, voxel_size=0.3)

Uses a PointsToSDFGrid Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/point/points_to_volume.html

Parameters:

• points (ProcNode[MeshObject | CurveObject])

• radius (ProcNode[float] | float)

• voxel_size (ProcNode[float] | float)

Return type:

ProcNode

procfunc.nodes.geo.points_to_vertices(points, selection=True)

Uses a PointsToVertices Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/point/points_to_vertices.html

Parameters:

• points (ProcNode[MeshObject | CurveObject])

• selection (ProcNode[bool] | bool)

Return type:

ProcNode[MeshObject]

procfunc.nodes.geo.points_to_volume(points, density=1.0, voxel_amount=64.0, radius=0.5, resolution_mode='VOXEL_AMOUNT')

Uses a PointsToVolume Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/point/points_to_volume.html

Parameters:

• points (ProcNode[MeshObject | CurveObject])

• density (ProcNode[float] | float)

• voxel_amount (ProcNode[float] | float)

• radius (ProcNode[float] | float)

• resolution_mode (Literal['VOXEL_AMOUNT', 'VOXEL_SIZE'])

Return type:

ProcNode[VolumeObject]

class procfunc.nodes.geo.ProximityResult

Bases: NamedTuple

ProximityResult(position, distance, is_valid)

position: ProcNode[Vector]

Alias for field number 0

distance: ProcNode[float]

Alias for field number 1

is_valid: ProcNode[bool]

Alias for field number 2

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.proximity(geometry, group_id=0, sample_position=(0, 0, 0), sample_group_id=0, target_element='FACES')

Uses a Proximity Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/sample/geometry_proximity.html

Parameters:

• geometry (ProcNode[MeshObject])

• group_id (ProcNode[int] | int)

• sample_position (ProcNode[Vector] | Vector)

• sample_group_id (ProcNode[int] | int)

• target_element (Literal['POINTS', 'EDGES', 'FACES'])

Return type:

ProximityResult

class procfunc.nodes.geo.RaycastResult

Bases: NamedTuple

RaycastResult(attribute, hit_distance, hit_normal, hit_position, is_hit)

attribute: ProcNode[Vector]

Alias for field number 0

hit_distance: ProcNode[float]

Alias for field number 1

hit_normal: ProcNode[Vector]

Alias for field number 2

hit_position: ProcNode[Vector]

Alias for field number 3

is_hit: ProcNode[bool]

Alias for field number 4

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.raycast(geometry, attribute=0, ray_direction=(0, 0, -1), ray_length=100.0, source_position=(0, 0, 0), mapping='INTERPOLATED', data_type=None)

Uses a Raycast Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/sample/raycast.html

Parameters:

• geometry (ProcNode[MeshObject])

• attribute (TRaycast)

• ray_direction (ProcNode[Vector] | Vector)

• ray_length (ProcNode[float] | float)

• source_position (ProcNode[Vector] | Vector)

• mapping (Literal['INTERPOLATED', 'NEAREST'])

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

RaycastResult

procfunc.nodes.geo.realize_instances(geometry, selection=True, realize_all=True, depth=0)

Uses a RealizeInstances Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/instances/realize_instances.html

Parameters:

• geometry (ProcNode[MeshObject | CurveObject | Instances | VolumeObject] | ProcNode[Instances])

• selection (ProcNode[bool] | bool)

• realize_all (ProcNode[bool] | bool)

• depth (ProcNode[int] | int)

Return type:

ProcNode[MeshObject | CurveObject | Instances | VolumeObject]

procfunc.nodes.geo.remove_attribute(geometry, name='', pattern_mode='EXACT')

Uses a RemoveAttribute Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/attribute/remove_named_attribute.html

Parameters:

• geometry (ProcNode[TAnyGeometry])

• name (ProcNode[str] | str)

• pattern_mode (Literal['EXACT', 'WILDCARD'])

Return type:

ProcNode[TAnyGeometry]

procfunc.nodes.geo.replace_material(geometry, old=None, new=None)

Uses a ReplaceMaterial Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/material/replace_material.html

Parameters:

• geometry (ProcNode[MeshObject])

• old (ProcNode[Material] | Material | None)

• new (ProcNode[Material] | Material | None)

Return type:

ProcNode[MeshObject]

procfunc.nodes.geo.resample_curve_evaluated(curve, selection=True)

Uses a ResampleCurve Geometry Node with mode=”EVALUATED”.

From Blender docs: Evaluate the spline’s points based on the resolution attribute for NURBS and Bézier splines. Changes nothing for poly splines. https://docs.blender.org/manual/en/latest/modeling/geometry_nodes/curve/operations/resample_curve.html

Parameters:

• curve (ProcNode[CurveObject])

• selection (ProcNode[bool] | bool)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.resample_curve_count(curve, selection=True, count=10)

Uses a ResampleCurve Geometry Node with mode=”COUNT”. https://docs.blender.org/manual/en/latest/modeling/geometry_nodes/curve/operations/resample_curve.html

Parameters:

• curve (ProcNode[CurveObject])

• selection (ProcNode[bool] | bool)

• count (ProcNode[int] | int)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.resample_curve_length(curve, selection=True, length=1.0)

Uses a ResampleCurve Geometry Node with mode=”LENGTH”. https://docs.blender.org/manual/en/latest/modeling/geometry_nodes/curve/operations/resample_curve.html

Parameters:

• curve (ProcNode[CurveObject])

• selection (ProcNode[bool] | bool)

• length (ProcNode[float] | float)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.reverse_curve(curve, selection=True)

Uses a ReverseCurve Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/operations/reverse_curve.html

Parameters:

• curve (ProcNode[CurveObject])

• selection (ProcNode[bool] | bool)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.rotate_instances(instances, selection=True, rotation=(0, 0, 0), pivot_point=(0, 0, 0), local_space=True)

Uses a RotateInstances Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/instances/rotate_instances.html

Parameters:

• instances (ProcNode[Instances])

• selection (ProcNode[bool] | bool)

• rotation (Any)

• pivot_point (ProcNode[Vector] | Vector)

• local_space (ProcNode[bool] | bool)

Return type:

ProcNode[Instances]

procfunc.nodes.geo.sdf_grid_boolean(grid_1=0.0, grid_2=0.0)

Uses a SDFGridBoolean Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/volume/index.html

Parameters:

• grid_1 (ProcNode[float] | float)

• grid_2 (ProcNode[float] | float)

Return type:

ProcNode[MeshObject | CurveObject | Instances | VolumeObject]

class procfunc.nodes.geo.SampleCurveResult

Bases: NamedTuple

SampleCurveResult(normal, position, tangent, value)

normal: ProcNode[Vector]

Alias for field number 0

position: ProcNode[Vector]

Alias for field number 1

tangent: ProcNode[Vector]

Alias for field number 2

value: ProcNode[TAttribute]

Alias for field number 3

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.sample_curve(curves, curve_index=0, factor=0.0, value=None, mode='FACTOR', use_all_curves=False, data_type=None)

Uses a SampleCurve Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/sample/sample_curve.html

Parameters:

• curves (ProcNode[MeshObject | CurveObject | Instances | VolumeObject])

• curve_index (ProcNode[int] | int)

• factor (ProcNode[float] | float)

• value (ProcNode[TAttribute] | TAttribute | None)

• mode (Literal['FACTOR', 'LENGTH'])

• use_all_curves (bool)

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

SampleCurveResult

procfunc.nodes.geo.sample_curve_length(curves, length=0.0, curve_index=0, value=None, use_all_curves=False, data_type=None)

Uses a SampleCurve Geometry Node with LENGTH mode.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/sample/sample_curve.html

Parameters:

• curves (ProcNode[MeshObject | CurveObject | Instances | VolumeObject])

• length (ProcNode[float] | float)

• curve_index (ProcNode[int] | int)

• value (ProcNode[TAttribute] | TAttribute | None)

• use_all_curves (bool)

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

SampleCurveResult

procfunc.nodes.geo.sample_index(geometry, index=0, value=None, clamp=False, domain='POINT', data_type=None)

Uses a SampleIndex Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/sample/sample_index.html

Parameters:

• geometry (ProcNode[TAnyGeometry])

• index (ProcNode[int] | int)

• value (ProcNode[TAttribute] | None)

• clamp (bool)

• domain (Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'])

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

ProcNode[TAttribute]

procfunc.nodes.geo.sample_nearest(geometry, sample_position=(0, 0, 0), domain='POINT')

Uses a SampleNearest Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/sample/sample_nearest.html

Parameters:

• geometry (ProcNode[MeshObject | CurveObject])

• sample_position (ProcNode[Vector] | Vector)

• domain (Literal['POINT', 'EDGE', 'FACE', 'CORNER'])

Return type:

ProcNode[int]

class procfunc.nodes.geo.SampleResult

Bases: NamedTuple, Generic[TAttribute]

SampleResult(value, is_valid)

value: ProcNode[TAttribute]

Alias for field number 0

is_valid: ProcNode[bool]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.sample_nearest_surface(mesh, value=None, group_id=0, sample_group_id=0, sample_position=(0, 0, 0), data_type=None)

Uses a SampleNearestSurface Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/sample/sample_nearest_surface.html

Parameters:

• mesh (ProcNode[MeshObject])

• value (ProcNode[TAttribute] | None)

• group_id (ProcNode[int] | int)

• sample_group_id (ProcNode[int] | int)

• sample_position (ProcNode[Vector] | Vector)

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

SampleResult[TAttribute]

procfunc.nodes.geo.sample_uv_surface(mesh, value=None, sample_uv=(0, 0, 0), uv_map=(0, 0, 0), data_type=None)

Uses a SampleUVSurface Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/sample/sample_uv_surface.html

Parameters:

• mesh (ProcNode[MeshObject])

• value (ProcNode[TAttribute] | None)

• sample_uv (ProcNode[Vector] | Vector)

• uv_map (ProcNode[Vector] | Vector)

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

SampleResult[TAttribute]

procfunc.nodes.geo.scale_elements(geometry, selection=True, scale=1.0, center=(0, 0, 0), axis=None, domain='FACE', scale_mode='UNIFORM')

Uses a ScaleElements Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/operations/scale_elements.html

Parameters:

• geometry (ProcNode[MeshObject | CurveObject | Instances | VolumeObject])

• selection (ProcNode[bool] | bool)

• scale (ProcNode[float] | float)

• center (ProcNode[Vector] | Vector)

• axis (ProcNode[Vector] | Vector | None)

• domain (Literal['FACE', 'EDGE'])

• scale_mode (Literal['UNIFORM', 'SINGLE_AXIS'])

Return type:

ProcNode[MeshObject | CurveObject | Instances | VolumeObject]

procfunc.nodes.geo.scale_instances(instances, selection=True, scale=(1, 1, 1), center=(0, 0, 0), local_space=True)

Uses a ScaleInstances Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/instances/scale_instances.html

Parameters:

• instances (ProcNode[Instances])

• selection (ProcNode[bool] | bool)

• scale (ProcNode[Vector] | Vector)

• center (ProcNode[Vector] | Vector)

• local_space (ProcNode[bool] | bool)

Return type:

ProcNode[Instances]

procfunc.nodes.geo.self_object()

Uses a SelfObject Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/scene/self_object.html

Return type:

ProcNode[Object]

class procfunc.nodes.geo.SeparateComponentsResult

Bases: NamedTuple

SeparateComponentsResult(mesh, curve, point_cloud, volume, instances)

mesh: ProcNode[MeshObject]

Alias for field number 0

curve: ProcNode[CurveObject]

Alias for field number 1

point_cloud: ProcNode[MeshObject | CurveObject]

Alias for field number 2

volume: ProcNode[VolumeObject]

Alias for field number 3

instances: ProcNode[Instances]

Alias for field number 4

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.separate_components(geometry)

Uses a SeparateComponents Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/operations/separate_components.html

Parameters:

geometry (ProcNode[MeshObject | CurveObject | Instances | VolumeObject])

Return type:

SeparateComponentsResult

class procfunc.nodes.geo.SeparateGeometryResult

Bases: NamedTuple, Generic[TMeshOrCurve]

SeparateGeometryResult(selection, inverted)

selection: ProcNode[TMeshOrCurve]

Alias for field number 0

inverted: ProcNode[TMeshOrCurve]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.separate_geometry(geometry, selection=True, domain='POINT')

Uses a SeparateGeometry Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/operations/separate_geometry.html

Parameters:

• geometry (ProcNode[TMeshOrCurve])

• selection (ProcNode[bool] | bool)

• domain (Literal['POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'])

Return type:

SeparateGeometryResult[TMeshOrCurve]

procfunc.nodes.geo.set_curve_handle_positions(curve, selection=True, position=(0, 0, 0), offset=(0, 0, 0), mode='LEFT')

Uses a SetCurveHandlePositions Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/write/set_handle_positions.html

Parameters:

• curve (ProcNode[CurveObject])

• selection (ProcNode[bool] | bool)

• position (ProcNode[Vector] | Vector)

• offset (ProcNode[Vector] | Vector)

• mode (Literal['LEFT', 'RIGHT'])

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.set_curve_normal(curve, selection=True, mode='MINIMUM_TWIST', normal=(0, 0, 1))

Uses a SetCurveNormal Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/write/set_curve_normal.html

Parameters:

• curve (ProcNode[CurveObject])

• selection (ProcNode[bool] | bool)

• mode (Literal['MINIMUM_TWIST', 'Z_UP', 'FREE'])

• normal (ProcNode[Vector] | Vector)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.set_curve_radius(curve, selection=True, radius=0.005)

Uses a SetCurveRadius Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/write/set_curve_radius.html

Parameters:

• curve (ProcNode[CurveObject])

• selection (ProcNode[bool] | bool)

• radius (ProcNode[float] | float)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.set_curve_tilt(curve, selection=True, tilt=0.0)

Uses a SetCurveTilt Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/write/set_curve_tilt.html

Parameters:

• curve (ProcNode[CurveObject])

• selection (ProcNode[bool] | bool)

• tilt (ProcNode[float] | float)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.set_id(geometry, selection=True, id=0)

Uses a SetID Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/write/set_id.html

Parameters:

• geometry (ProcNode[TAnyGeometry])

• selection (ProcNode[bool] | bool)

• id (ProcNode[int] | int)

Return type:

ProcNode[TAnyGeometry]

procfunc.nodes.geo.set_instance_transform(instances, transform=None, selection=True)

Uses a SetInstanceTransform Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/instances/set_instance_transform.html

Parameters:

• instances (ProcNode[Instances])

• transform (ProcNode[Matrix] | Matrix | None)

• selection (ProcNode[bool] | bool)

Return type:

ProcNode[Instances]

procfunc.nodes.geo.set_material(geometry, material=None, selection=None)

Uses a SetMaterial Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/material/set_material.html

Parameters:

• geometry (ProcNode[MeshObject])

• material (ProcNode[Material] | Material)

• selection (ProcNode[bool] | bool)

Return type:

ProcNode[MeshObject]

procfunc.nodes.geo.set_material_index(geometry, selection=True, material_index=0)

Uses a SetMaterialIndex Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/material/set_material_index.html

Parameters:

• geometry (ProcNode[MeshObject])

• selection (ProcNode[bool] | bool)

• material_index (ProcNode[int] | int)

Return type:

ProcNode[MeshObject]

procfunc.nodes.geo.set_point_radius(points, selection=True, radius=0.05)

Uses a SetPointRadius Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/point/set_point_radius.html

Parameters:

• points (ProcNode[PointCloudObject])

• selection (ProcNode[bool] | bool)

• radius (ProcNode[float] | float)

Return type:

ProcNode[PointCloudObject]

procfunc.nodes.geo.set_position(geometry, selection=True, position=(0, 0, 0), offset=(0, 0, 0))

Uses a SetPosition Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/write/set_position.html

Parameters:

• geometry (ProcNode[TAnyGeometry])

• selection (ProcNode[bool] | bool)

• position (ProcNode[Vector] | Vector)

• offset (ProcNode[Vector] | Vector)

Return type:

ProcNode[TAnyGeometry]

procfunc.nodes.geo.set_shade_smooth(geometry, selection=True, shade_smooth=True, domain='FACE')

Uses a SetShadeSmooth Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/write/set_shade_smooth.html

Parameters:

• geometry (ProcNode[MeshObject])

• selection (ProcNode[bool] | bool)

• shade_smooth (ProcNode[bool] | bool)

• domain (Literal['EDGE', 'FACE'])

Return type:

ProcNode[MeshObject]

procfunc.nodes.geo.set_spline_cyclic(curve, selection=True, cyclic=False)

Uses a SetSplineCyclic Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/write/set_spline_cyclic.html

Parameters:

• curve (ProcNode[CurveObject])

• selection (ProcNode[bool] | bool)

• cyclic (ProcNode[bool] | bool)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.set_spline_resolution(curve, selection=True, resolution=12)

Uses a SetSplineResolution Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/write/set_spline_resolution.html

Parameters:

• curve (ProcNode[CurveObject])

• selection (ProcNode[bool] | bool)

• resolution (ProcNode[int] | int)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.sort_elements(geometry, selection=True, group_id=0, sort_weight=0.0, domain='POINT')

Uses a SortElements Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/operations/sort_elements.html

Parameters:

• geometry (ProcNode[TAnyGeometry])

• selection (ProcNode[bool] | bool)

• group_id (ProcNode[int] | int)

• sort_weight (ProcNode[float] | float)

• domain (Literal['POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE'])

Return type:

ProcNode[TAnyGeometry]

class procfunc.nodes.geo.SplineLengthResult

Bases: NamedTuple

SplineLengthResult(length, point_count)

length: ProcNode[float]

Alias for field number 0

point_count: ProcNode[int]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.spline_length()

Uses a SplineLength Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/read/spline_length.html

Return type:

SplineLengthResult

class procfunc.nodes.geo.SplineParameterResult

Bases: NamedTuple

SplineParameterResult(factor, length, index)

factor: ProcNode[float]

Alias for field number 0

length: ProcNode[float]

Alias for field number 1

index: ProcNode[int]

Alias for field number 2

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.spline_parameter()

Uses a SplineParameter Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/read/spline_parameter.html

Return type:

SplineParameterResult

procfunc.nodes.geo.split_edges(mesh, selection=True)

Uses a SplitEdges Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/operations/split_edges.html

Parameters:

• mesh (ProcNode[MeshObject])

• selection (ProcNode[bool] | bool)

Return type:

ProcNode[MeshObject]

class procfunc.nodes.geo.SplitToInstancesResult

Bases: NamedTuple

SplitToInstancesResult(instances, group_id)

instances: ProcNode[Instances]

Alias for field number 0

group_id: ProcNode[int]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.split_to_instances(geometry, selection=True, group_id=0, domain='POINT')

Uses a SplitToInstances Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/operations/split_to_instances.html

Parameters:

• geometry (ProcNode[MeshObject])

• selection (ProcNode[bool] | bool)

• group_id (ProcNode[int] | int)

• domain (Literal['POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'])

Return type:

SplitToInstancesResult

procfunc.nodes.geo.store_named_attribute(geometry, name='', selection=True, value=None, domain='POINT', data_type=None)

Uses a StoreNamedAttribute Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/attribute/store_named_attribute.html

Parameters:

• geometry (ProcNode[TMeshOrCurve])

• name (ProcNode[str] | str)

• selection (ProcNode[bool] | bool)

• value (ProcNode[TAttribute] | TAttribute | None)

• domain (Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'])

• data_type (NodeDataType | RuntimeResolveDataType | None)

Return type:

ProcNode[TMeshOrCurve]

procfunc.nodes.geo.store_named_grid(volume, grid=0.0, name='')

Uses a StoreNamedGrid Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/volume/index.html

Parameters:

• volume (ProcNode[MeshObject | CurveObject | Instances | VolumeObject])

• grid (ProcNode[float] | float)

• name (ProcNode[str] | str)

Return type:

ProcNode

procfunc.nodes.geo.string_join(strings, delimiter='')

Uses a StringJoin Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/text/join_strings.html

Parameters:

• strings (list[ProcNode[str] | str])

• delimiter (ProcNode[str] | str)

Return type:

ProcNode[str]

class procfunc.nodes.geo.StringToCurvesResult

Bases: NamedTuple

StringToCurvesResult(curve_instances, line, pivot_point)

curve_instances: ProcNode[Instances]

Alias for field number 0

line: ProcNode[CurveObject]

Alias for field number 1

pivot_point: ProcNode[Vector]

Alias for field number 2

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.string_to_curves(string, size=1.0, character_spacing=1.0, word_spacing=1.0, line_spacing=1.0, text_box_width=0.0, align_x='LEFT', align_y='TOP_BASELINE', overflow='OVERFLOW', pivot_mode='BOTTOM_LEFT')

Uses a StringToCurves Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/text/string_to_curves.html

Parameters:

• string (ProcNode[str] | str)

• size (ProcNode[float] | float)

• character_spacing (ProcNode[float] | float)

• word_spacing (ProcNode[float] | float)

• line_spacing (ProcNode[float] | float)

• text_box_width (ProcNode[float] | float)

• align_x (Literal['LEFT', 'CENTER', 'RIGHT', 'JUSTIFY', 'FLUSH'])

• align_y (Literal['TOP', 'TOP_BASELINE', 'MIDDLE', 'BOTTOM_BASELINE', 'BOTTOM'])

• overflow (Literal['OVERFLOW', 'SCALE_TO_FIT', 'TRUNCATE'])

• pivot_mode (Literal['MIDPOINT', 'TOP_LEFT', 'TOP_CENTER', 'TOP_RIGHT', 'BOTTOM_LEFT', 'BOTTOM_CENTER', 'BOTTOM_RIGHT'])

Return type:

StringToCurvesResult

procfunc.nodes.geo.subdivide_curve(curve, cuts=1)

Uses a SubdivideCurve Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/operations/subdivide_curve.html

Parameters:

• curve (ProcNode[CurveObject])

• cuts (ProcNode[int] | int)

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.subdivide_mesh(mesh, level=1)

Uses a SubdivideMesh Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/operations/subdivide_mesh.html

Parameters:

• mesh (ProcNode[MeshObject])

• level (ProcNode[int] | int)

Return type:

ProcNode[MeshObject]

procfunc.nodes.geo.subdivision_surface(mesh, level=1, edge_crease=0.0, vertex_crease=0.0, boundary_smooth='ALL', uv_smooth='PRESERVE_BOUNDARIES')

Uses a SubdivisionSurface Geometry Node.

See: http://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/operations/mesh/subdivision_surface.html

Parameters:

• mesh (ProcNode[MeshObject])

• level (ProcNode[int] | int)

• edge_crease (ProcNode[float] | float)

• vertex_crease (ProcNode[float] | float)

• boundary_smooth (Literal['PRESERVE_CORNERS', 'ALL'])

• uv_smooth (Literal['NONE', 'PRESERVE_CORNERS', 'PRESERVE_CORNERS_AND_JUNCTIONS', 'PRESERVE_CORNERS_JUNCTIONS_AND_CONCAVE', 'PRESERVE_BOUNDARIES', 'SMOOTH_ALL'])

Return type:

ProcNode[MeshObject]

procfunc.nodes.geo.transform(geometry, translation=(0, 0, 0), rotation=(0, 0, 0), scale=(1, 1, 1))

Uses a Transform Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/geometry/operations/transform_geometry.html

Parameters:

• geometry (ProcNode[TMeshOrCurve])

• translation (ProcNode[Vector] | Vector)

• rotation (Any)

• scale (ProcNode[Vector] | Vector)

Return type:

ProcNode[TMeshOrCurve]

procfunc.nodes.geo.transform_by_matrix(geometry, matrix)

Parameters:

• geometry (ProcNode[TMeshOrCurve])

• matrix (ProcNode[Matrix] | Matrix)

procfunc.nodes.geo.translate_instances(instances, selection=True, translation=(0, 0, 0), local_space=True)

Uses a TranslateInstances Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/instances/translate_instances.html

Parameters:

• instances (ProcNode[Instances])

• selection (ProcNode[bool] | bool)

• translation (ProcNode[Vector] | Vector)

• local_space (ProcNode[bool] | bool)

Return type:

ProcNode[Instances]

procfunc.nodes.geo.triangulate(mesh, selection=True, minimum_vertices=4, ngon_method='BEAUTY', quad_method='SHORTEST_DIAGONAL')

Uses a Triangulate Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/operations/triangulate.html

Parameters:

• mesh (ProcNode[MeshObject])

• selection (ProcNode[bool] | bool)

• minimum_vertices (ProcNode[int] | int)

• ngon_method (Literal['BEAUTY', 'CLIP'])

• quad_method (Literal['BEAUTY', 'FIXED', 'FIXED_ALTERNATE', 'SHORTEST_DIAGONAL', 'LONGEST_DIAGONAL'])

Return type:

ProcNode[MeshObject]

procfunc.nodes.geo.trim_curve(curve, selection=True, start=0.0, end=1.0, mode='FACTOR')

Uses a TrimCurve Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/curve/operations/trim_curve.html

Parameters:

• curve (ProcNode[CurveObject])

• selection (ProcNode[bool] | bool)

• start (ProcNode[float] | float)

• end (ProcNode[float] | float)

• mode (Literal['FACTOR', 'LENGTH'])

Return type:

ProcNode[CurveObject]

procfunc.nodes.geo.uv_pack_islands(uv=(0, 0, 0), selection=True, margin=0.001, rotate=True)

Uses a UVPackIslands Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/uv/pack_uv_islands.html

Parameters:

• uv (ProcNode[Vector] | Vector)

• selection (ProcNode[bool] | bool)

• margin (ProcNode[float] | float)

• rotate (ProcNode[bool] | bool)

Return type:

ProcNode[Vector]

procfunc.nodes.geo.uv_unwrap(selection=True, seam=False, margin=0.001, fill_holes=True, method='ANGLE_BASED')

Uses a UVUnwrap Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/uv/uv_unwrap.html

Parameters:

• selection (ProcNode[bool] | bool)

• seam (ProcNode[bool] | bool)

• margin (ProcNode[float] | float)

• fill_holes (ProcNode[bool] | bool)

• method (Literal['ANGLE_BASED', 'CONFORMAL'])

Return type:

ProcNode[Vector]

procfunc.nodes.geo.vertex_of_corner(corner_index=0)

Uses a VertexOfCorner Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/mesh/topology/vertex_of_corner.html

Parameters:

corner_index (ProcNode[int] | int)

Return type:

ProcNode[int]

class procfunc.nodes.geo.TViewer

def viewer(

geometry: t.ProcNode[t.Geometry], value: TViewer = 0, domain: TDomain = “AUTO”, data_type: NodeDataType | RuntimeResolveDataType | None = None,

) -> t.ProcNode:

“”” Uses a Viewer Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/output/viewer.html “”” if data_type is None:

data_type = RuntimeResolveDataType(

[NodeDataType.BOOLEAN, NodeDataType.INT, NodeDataType.FLOAT], [“Value”],

)

return t.ProcNode.from_nodetype(

node_type=”GeometryNodeViewer”, inputs={“Geometry”: geometry, “Value”: value}, attrs={

“domain”: domain, “data_type”: data_type,

},

)

alias of TypeVar(‘TViewer’, ~procfunc.nodes.types.ProcNode[bool] | bool, ~procfunc.nodes.types.ProcNode[int] | int, ~procfunc.nodes.types.ProcNode[float] | float)

class procfunc.nodes.geo.ViewportTransformResult

Bases: NamedTuple

ViewportTransformResult(projection, view, is_orthographic)

projection: ProcNode

Alias for field number 0

view: ProcNode

Alias for field number 1

is_orthographic: ProcNode[bool]

Alias for field number 2

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.geo.viewport_transform()

Uses a ViewportTransform Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/scene/viewport_transform.html

Return type:

ViewportTransformResult

procfunc.nodes.geo.volume_cube(density=1.0, background=0.0, min=(-1, -1, -1), max=(1, 1, 1), resolution_x=32, resolution_y=32, resolution_z=32)

Uses a VolumeCube Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/volume/primitives/volume_cube.html

Parameters:

• density (ProcNode[float] | float)

• background (ProcNode[float] | float)

• min (ProcNode[Vector] | Vector)

• max (ProcNode[Vector] | Vector)

• resolution_x (ProcNode[int] | int)

• resolution_y (ProcNode[int] | int)

• resolution_z (ProcNode[int] | int)

Return type:

ProcNode[VolumeObject]

procfunc.nodes.geo.volume_to_mesh(volume, threshold=0.1, adaptivity=0.0, resolution_mode='GRID')

Uses a VolumeToMesh Geometry Node.

See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/volume/operations/volume_to_mesh.html

Parameters:

• volume (ProcNode[VolumeObject])

• threshold (ProcNode[float] | float)

• adaptivity (ProcNode[float] | float)

• resolution_mode (Literal['GRID', 'VOXEL_AMOUNT', 'VOXEL_SIZE'])

Return type:

ProcNode[MeshObject]

pf.nodes.math

Math and Vector Math Node bindings for Blender

procfunc.nodes.math.clamp(value=1.0, min=0.0, max=1.0, clamp_type='MINMAX')

Uses a Clamp Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/clamp.html

Parameters:

• value (ProcNode[float] | float)

• min (ProcNode[float] | float)

• max (ProcNode[float] | float)

• clamp_type (Literal['MINMAX', 'RANGE'])

Return type:

ProcNode[float]

procfunc.nodes.math.add(a=0.5, b=0.5)

Parameters:

• a (ProcNode[float] | float)

• b (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.subtract(a=0.5, b=0.5)

Parameters:

• a (ProcNode[float] | float)

• b (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.multiply(a=0.5, b=0.5)

Parameters:

• a (ProcNode[float] | float)

• b (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.multiply_add(a=0.5, b=0.5, addend=0.0)

Parameters:

• a (ProcNode[float] | float)

• b (ProcNode[float] | float)

• addend (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.divide(numerator=0.5, denominator=0.5)

Parameters:

• numerator (ProcNode[float] | float)

• denominator (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.power(base=0.5, exponent=0.5)

Parameters:

• base (ProcNode[float] | float)

• exponent (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.logarithm(value=0.5, base=0.5)

Parameters:

• value (ProcNode[float] | float)

• base (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.sqrt(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.inverse_sqrt(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.absolute(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.exponent(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.minimum(a=0.5, b=0.5)

Parameters:

• a (ProcNode[float] | float)

• b (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.maximum(a=0.5, b=0.5)

Parameters:

• a (ProcNode[float] | float)

• b (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.less_than(a=0.5, b=0.5)

Parameters:

• a (ProcNode[float] | float)

• b (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.greater_than(a=0.5, b=0.5)

Parameters:

• a (ProcNode[float] | float)

• b (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.sign(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.compare(a=0.5, b=0.5, epsilon=0.001)

Parameters:

• a (ProcNode[float] | float)

• b (ProcNode[float] | float)

• epsilon (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.smooth_minimum(a=0.5, b=0.5, distance=0.0)

Parameters:

• a (ProcNode[float] | float)

• b (ProcNode[float] | float)

• distance (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.smooth_maximum(a=0.5, b=0.5, distance=0.0)

Parameters:

• a (ProcNode[float] | float)

• b (ProcNode[float] | float)

• distance (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.round(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.floor(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.ceil(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.truncate(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.fraction(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.modulo(a=0.5, b=0.5)

Parameters:

• a (ProcNode[float] | float)

• b (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.floor_mod(a=0.5, b=0.5)

Parameters:

• a (ProcNode[float] | float)

• b (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.wrap(value=0.5, max_val=1.0, min_val=0.0)

Parameters:

• value (ProcNode[float] | float)

• max_val (ProcNode[float] | float)

• min_val (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.snap(value=0.5, increment=1.0)

Parameters:

• value (ProcNode[float] | float)

• increment (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.pingpong(value=0.5, scale=1.0)

Parameters:

• value (ProcNode[float] | float)

• scale (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.sin(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.cos(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.tan(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.asin(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.acos(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.atan(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.atan2(y=0.5, x=0.5)

Parameters:

• y (ProcNode[float] | float)

• x (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.sinh(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.cosh(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.tanh(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.deg_to_rad(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.rad_to_deg(value=0.5)

Parameters:

value (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.math.vector_add(a=(0, 0, 0), b=(0, 0, 0))

Add two vectors.

Parameters:

• a (ProcNode[Vector] | Vector)

• b (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_subtract(a=(0, 0, 0), b=(0, 0, 0))

Parameters:

• a (ProcNode[Vector] | Vector)

• b (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_multiply(a=(0, 0, 0), b=(0, 0, 0))

Parameters:

• a (ProcNode[Vector] | Vector)

• b (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_multiply_add(a=(0, 0, 0), b=(0, 0, 0), addend=(0, 0, 0))

Parameters:

• a (ProcNode[Vector] | Vector)

• b (ProcNode[Vector] | Vector)

• addend (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_divide(a=(0, 0, 0), b=(0, 0, 0))

Parameters:

• a (ProcNode[Vector] | Vector)

• b (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_cross_product(a=(0, 0, 0), b=(0, 0, 0))

Parameters:

• a (ProcNode[Vector] | Vector)

• b (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_project(vector=(0, 0, 0), onto=(0, 0, 0))

Parameters:

• vector (ProcNode[Vector] | Vector)

• onto (ProcNode[Vector] | Vector)

Return type:

ProcNode[float]

procfunc.nodes.math.vector_reflect(a=(0, 0, 0), normal=(0, 0, 0))

Parameters:

• a (ProcNode[Vector] | Vector)

• normal (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_refract(incident=(0, 0, 0), normal=(0, 0, 0), ior=1.0)

Parameters:

• incident (ProcNode[Vector] | Vector)

• normal (ProcNode[Vector] | Vector)

• ior (ProcNode[float] | float)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_faceforward(vector=(0, 0, 0), surface=(0, 0, 0), normal=(0, 0, 0))

Parameters:

• vector (ProcNode[Vector] | Vector)

• surface (ProcNode[Vector] | Vector)

• normal (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_dot_product(a=(0, 0, 0), b=(0, 0, 0))

Parameters:

• a (ProcNode[Vector] | Vector)

• b (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_distance(a=(0, 0, 0), b=(0, 0, 0))

Parameters:

• a (ProcNode[Vector] | Vector)

• b (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_length(vector=(0, 0, 0))

Parameters:

vector (ProcNode[Vector] | Vector)

Return type:

ProcNode[float]

procfunc.nodes.math.vector_scale(vector=(0, 0, 0), scale=1.0)

Parameters:

• vector (ProcNode[Vector] | Vector)

• scale (ProcNode[float] | float)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_normalize(vector=(0, 0, 0))

Parameters:

vector (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_wrap(vector=(0, 0, 0), max_val=(1, 1, 1), min_val=(0, 0, 0))

Parameters:

• vector (ProcNode[Vector] | Vector)

• max_val (ProcNode[Vector] | Vector)

• min_val (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_snap(a=(0, 0, 0), b=(1, 1, 1))

Parameters:

• a (ProcNode[Vector] | Vector)

• b (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_floor(vector=(0, 0, 0))

Parameters:

vector (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_ceil(vector=(0, 0, 0))

Parameters:

vector (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_modulo(a=(0, 0, 0), b=(1, 1, 1))

Parameters:

• a (ProcNode[Vector] | Vector)

• b (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_fraction(vector=(0, 0, 0))

Parameters:

vector (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_round(vector=(0, 0, 0))

Parameters:

vector (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_truncate(vector=(0, 0, 0))

Parameters:

vector (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_absolute(vector=(0, 0, 0))

Parameters:

vector (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_minimum(a=(0, 0, 0), b=(0, 0, 0))

Parameters:

• a (ProcNode[Vector] | Vector)

• b (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_maximum(a=(0, 0, 0), b=(0, 0, 0))

Parameters:

• a (ProcNode[Vector] | Vector)

• b (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_sine(vector=(0, 0, 0))

Parameters:

vector (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_cosine(vector=(0, 0, 0))

Parameters:

vector (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_tangent(vector=(0, 0, 0))

Parameters:

vector (ProcNode[Vector] | Vector)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_rotate_axis_angle(vector=(0, 0, 0), center=(0, 0, 0), axis=(0, 0, 1), angle=0.0, invert=False)

Uses a VectorRotate Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/vector/vector_rotate.html

Parameters:

• vector (ProcNode[Vector] | Vector)

• center (ProcNode[Vector] | Vector)

• axis (ProcNode[Vector] | Vector)

• angle (ProcNode[float] | float)

• invert (bool)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_rotate_euler(vector=(0, 0, 0), center=(0, 0, 0), rotation=(0, 0, 0), invert=False)

Parameters:

• vector (ProcNode[Vector] | Vector)

• center (ProcNode[Vector] | Vector)

• rotation (ProcNode[Vector] | Vector)

• invert (bool)

Return type:

ProcNode[Vector]

procfunc.nodes.math.vector_transform(vector=(0.5, 0.5, 0.5), convert_from='WORLD', convert_to='OBJECT', vector_type='VECTOR')

Uses a VectorTransform Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/vector/transform.html

Parameters:

• vector (ProcNode[Vector] | Vector)

• convert_from (Literal['WORLD', 'OBJECT', 'CAMERA'])

• convert_to (Literal['WORLD', 'OBJECT', 'CAMERA'])

• vector_type (Literal['POINT', 'VECTOR', 'NORMAL'])

Return type:

ProcNode[Vector]

pf.nodes.shader

Auto-generated Shader Node bindings for Blender

procfunc.nodes.shader.add_shader(shader_0=None, shader_1=None)

Uses a AddShader Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/add.html

Parameters:

• shader_0 (ProcNode[Shader] | None)

• shader_1 (ProcNode[Shader] | None)

Return type:

ProcNode[Shader]

class procfunc.nodes.shader.AmbientOcclusionResult

Bases: NamedTuple

AmbientOcclusionResult(color, ao)

color: ProcNode[Color]

Alias for field number 0

ao: ProcNode[float]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.ambient_occlusion(color=(1, 1, 1, 1), distance=1.0, normal=None, inside=False, only_local=False, samples=16)

Uses a AmbientOcclusion Shader Node.

Parameters:

• normal (ProcNode[Vector] | Vector) – Avoid using this input. We recommend using the shader’s Displacement output instead, which supports bumpmapping OR real mesh render/export.

• color (ProcNode[Color] | Color)

• distance (ProcNode[float] | float)

• inside (bool)

• only_local (bool)

• samples (int)

Return type:

AmbientOcclusionResult

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/ao.html

class procfunc.nodes.shader.AttributeResult

Bases: NamedTuple

AttributeResult(color, vector, fac, alpha)

color: ProcNode[Color]

Alias for field number 0

vector: ProcNode[Vector]

Alias for field number 1

fac: ProcNode[float]

Alias for field number 2

alpha: ProcNode[float]

Alias for field number 3

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.attribute(attribute_name='', attribute_type='GEOMETRY')

Uses a Attribute Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/attribute.html

Parameters:

• attribute_name (str)

• attribute_type (Literal['GEOMETRY', 'OBJECT', 'INSTANCER', 'VIEW_LAYER'])

Return type:

AttributeResult

procfunc.nodes.shader.background(color=(0.8, 0.8, 0.8, 1), strength=1.0)

Uses a Background Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/background.html

Parameters:

• color (ProcNode[Color] | Color)

• strength (ProcNode[float] | float)

Return type:

ProcNode[Shader]

procfunc.nodes.shader.bevel(radius=0.05, normal=None, samples=4)

Uses a Bevel Shader Node.

Parameters:

• normal (ProcNode[Vector] | Vector) – Avoid using this input. We recommend using the shader’s Displacement output instead, which supports bumpmapping OR real mesh render/export.

• radius (ProcNode[float] | float)

• samples (int)

Return type:

ProcNode[Vector]

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/bevel.html

procfunc.nodes.shader.blackbody(temperature=1500.0)

Uses a Blackbody Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/blackbody.html

Parameters:

temperature (ProcNode[float] | float)

Return type:

ProcNode[Color]

procfunc.nodes.shader.bright_contrast(color=(1, 1, 1, 1), bright=0.0, contrast=0.0)

Uses a BrightContrast Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/color/bright_contrast.html

Parameters:

• color (ProcNode[Color] | Color)

• bright (ProcNode[float] | float)

• contrast (ProcNode[float] | float)

Return type:

ProcNode[Color]

procfunc.nodes.shader.anisotropic_bsdf(color=(0.8, 0.8, 0.8, 1), roughness=0.5, anisotropy=0.0, rotation=0.0, normal=None, tangent=(0, 0, 0), distribution='MULTI_GGX')

Uses a BsdfAnisotropic Shader Node.

Parameters:

• normal (ProcNode[Vector] | Vector) – Avoid using this input. We recommend using the shader’s Displacement output instead, which supports bumpmapping OR real mesh render/export.

• color (ProcNode[Color] | Color)

• roughness (ProcNode[float] | float)

• anisotropy (ProcNode[float] | float)

• rotation (ProcNode[float] | float)

• tangent (ProcNode[Vector] | Vector)

• distribution (Literal['BECKMANN', 'GGX', 'ASHIKHMIN_SHIRLEY', 'MULTI_GGX'])

Return type:

ProcNode[Shader]

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/principled.html

procfunc.nodes.shader.diffuse_bsdf(color=(0.8, 0.8, 0.8, 1), roughness=0.0, normal=None)

Uses a BsdfDiffuse Shader Node.

Parameters:

• normal (ProcNode[Vector] | Vector) – Avoid using this input. We recommend using the shader’s Displacement output instead, which supports bumpmapping OR real mesh render/export.

• color (ProcNode[Color] | Color)

• roughness (ProcNode[float] | float)

Return type:

ProcNode[Shader]

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/diffuse.html

procfunc.nodes.shader.glass_bsdf(color=(1, 1, 1, 1), roughness=0.0, ior=1.5, normal=None, distribution='MULTI_GGX')

Uses a BsdfGlass Shader Node.

Parameters:

• normal (ProcNode[Vector] | Vector) – Avoid using this input. We recommend using the shader’s Displacement output instead, which supports bumpmapping OR real mesh render/export.

• color (ProcNode[Color] | Color)

• roughness (ProcNode[float] | float)

• ior (ProcNode[float] | float)

• distribution (Literal['BECKMANN', 'GGX', 'MULTI_GGX'])

Return type:

ProcNode[Shader]

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/glass.html

procfunc.nodes.shader.hair_bsdf(color=(0.8, 0.8, 0.8, 1), offset=0.0, roughness_u=0.1, roughness_v=1.0, tangent=(0, 0, 0), component='Reflection')

Uses a BsdfHair Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/hair.html

Parameters:

• color (ProcNode[Color] | Color)

• offset (ProcNode[float] | float)

• roughness_u (ProcNode[float] | float)

• roughness_v (ProcNode[float] | float)

• tangent (ProcNode[Vector] | Vector)

• component (Literal['Reflection', 'Transmission'])

Return type:

ProcNode[Shader]

procfunc.nodes.shader.principled_hair_bsdf(color=(0.017513, 0.005763, 0.002059, 1), roughness=0.3, radial_roughness=0.3, coat=0.0, ior=1.55, offset=0.034907, random_roughness=0.0, random=0.0, model='CHIANG', parametrization='COLOR')

Uses a BsdfHairPrincipled Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/hair_principled.html

Parameters:

• color (ProcNode[Color] | Color)

• roughness (ProcNode[float] | float)

• radial_roughness (ProcNode[float] | float)

• coat (ProcNode[float] | float)

• ior (ProcNode[float] | float)

• offset (ProcNode[float] | float)

• random_roughness (ProcNode[float] | float)

• random (ProcNode[float] | float)

• model (Literal['CHIANG', 'HUANG'])

• parametrization (Literal['ABSORPTION', 'MELANIN', 'COLOR'])

Return type:

ProcNode[Shader]

procfunc.nodes.shader.principled_bsdf(base_color=(0.8, 0.8, 0.8, 1), metallic=0.0, roughness=0.5, ior=1.5, alpha=1.0, normal=(0.0, 0.0, 0.0), subsurface_method='RANDOM_WALK', subsurface_weight=0.0, subsurface_radius=(1, 0.2, 0.1), subsurface_scale=0.05, subsurface_ior=None, subsurface_anisotropy=None, distribution='MULTI_GGX', specular_ior_level=0.5, specular_tint=(1, 1, 1, 1), anisotropic=0.0, anisotropic_rotation=0.0, tangent=(0, 0, 0), transmission_weight=0.0, coat_weight=0.0, coat_roughness=0.03, coat_ior=1.5, coat_tint=(1, 1, 1, 1), coat_normal=(0.0, 0.0, 0.0), sheen_weight=0.0, sheen_roughness=0.5, sheen_tint=(1, 1, 1, 1), emission_color=(1, 1, 1, 1), emission_strength=0.0, thin_film_thickness=0.0, thin_film_ior=1.33)

Uses a BsdfPrincipled Shader Node.

Parameters:

• normal (ProcNode[Vector] | Vector) – Avoid using this input. We recommend using the shader’s Displacement output instead, which supports bumpmapping OR real mesh render/export.

• subsurface_ior (ProcNode[float] | float | None) – Only supported if subsurface_method is RANDOM_WALK_SKIN.

• distribution (Literal['GGX', 'MULTI_GGX']) – configurs specular shading

• base_color (ProcNode[Color] | Color)

• metallic (ProcNode[float] | float)

• roughness (ProcNode[float] | float)

• ior (ProcNode[float] | float)

• alpha (ProcNode[float] | float)

• subsurface_method (Literal['BURLEY', 'RANDOM_WALK', 'RANDOM_WALK_SKIN'])

• subsurface_weight (ProcNode[float] | float)

• subsurface_radius (ProcNode[Vector] | Vector)

• subsurface_scale (ProcNode[float] | float)

• subsurface_anisotropy (ProcNode[float] | float | None)

• specular_ior_level (ProcNode[float] | float)

• specular_tint (ProcNode[Color] | Color)

• anisotropic (ProcNode[float] | float)

• anisotropic_rotation (ProcNode[float] | float)

• tangent (ProcNode[Vector] | Vector)

• transmission_weight (ProcNode[float] | float)

• coat_weight (ProcNode[float] | float)

• coat_roughness (ProcNode[float] | float)

• coat_ior (ProcNode[float] | float)

• coat_tint (ProcNode[Color] | Color)

• coat_normal (ProcNode[Vector] | Vector)

• sheen_weight (ProcNode[float] | float)

• sheen_roughness (ProcNode[float] | float)

• sheen_tint (ProcNode[Color] | Color)

• emission_color (ProcNode[Color] | Color)

• emission_strength (ProcNode[float] | float)

• thin_film_thickness (ProcNode[float] | float)

• thin_film_ior (ProcNode[float] | float)

Return type:

ProcNode[Shader]

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/principled.html

procfunc.nodes.shader.ray_portal_bsdf(color=(1, 1, 1, 1), position=(0, 0, 0), direction=(0, 0, 0))

Uses a BsdfRayPortal Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/ray_portal.html

Parameters:

• color (ProcNode[Color] | Color)

• position (ProcNode[Vector] | Vector)

• direction (ProcNode[Vector] | Vector)

Return type:

ProcNode[Shader]

procfunc.nodes.shader.refraction_bsdf(color=(1, 1, 1, 1), roughness=0.0, ior=1.45, normal=None, distribution='BECKMANN')

Uses a BsdfRefraction Shader Node.

Parameters:

• normal (ProcNode[Vector] | Vector) – Avoid using this input. We recommend using the shader’s Displacement output instead, which supports bumpmapping OR real mesh render/export.

• color (ProcNode[Color] | Color)

• roughness (ProcNode[float] | float)

• ior (ProcNode[float] | float)

• distribution (Literal['BECKMANN', 'GGX'])

Return type:

ProcNode[Shader]

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/refraction.html

procfunc.nodes.shader.sheen_bsdf(color=(0.8, 0.8, 0.8, 1), roughness=0.5, normal=None, distribution='MICROFIBER')

Uses a BsdfSheen Shader Node.

Parameters:

• normal (ProcNode[Vector] | Vector) – Avoid using this input. We recommend using the shader’s Displacement output instead, which supports bumpmapping OR real mesh render/export.

• color (ProcNode[Color] | Color)

• roughness (ProcNode[float] | float)

• distribution (Literal['ASHIKHMIN', 'MICROFIBER'])

Return type:

ProcNode[Shader]

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/sheen.html

procfunc.nodes.shader.toon_bsdf(color=(0.8, 0.8, 0.8, 1), size=0.5, smooth=0.0, normal=None, component='DIFFUSE')

Uses a BsdfToon Shader Node.

Parameters:

• normal (ProcNode[Vector] | Vector) – Avoid using this input. We recommend using the shader’s Displacement output instead, which supports bumpmapping OR real mesh render/export.

• color (ProcNode[Color] | Color)

• size (ProcNode[float] | float)

• smooth (ProcNode[float] | float)

• component (Literal['DIFFUSE', 'GLOSSY'])

Return type:

ProcNode[Shader]

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/toon.html

procfunc.nodes.shader.translucent_bsdf(color=(0.8, 0.8, 0.8, 1), normal=None)

Uses a BsdfTranslucent Shader Node.

Parameters:

• normal (ProcNode[Vector] | Vector) – Avoid using this input. We recommend using the shader’s Displacement output instead, which supports bumpmapping OR real mesh render/export.

• color (ProcNode[Color] | Color)

Return type:

ProcNode[Shader]

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/translucent.html

procfunc.nodes.shader.transparent_bsdf(color=(1, 1, 1, 1))

Uses a BsdfTransparent Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/transparent.html

Parameters:

color (ProcNode[Color] | Color)

Return type:

ProcNode[Shader]

procfunc.nodes.shader.bump(strength=1.0, distance=1.0, height=1.0, normal=None, invert=False)

Uses a Bump Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/vector/bump.html

Parameters:

• strength (ProcNode[float] | float)

• distance (ProcNode[float] | float)

• height (ProcNode[float] | float)

• normal (ProcNode[Vector] | Vector)

• invert (bool)

Return type:

ProcNode[Vector]

class procfunc.nodes.shader.CameraDataResult

Bases: NamedTuple

CameraDataResult(view_vector, view_z_depth, view_distance)

view_vector: ProcNode[Vector]

Alias for field number 0

view_z_depth: ProcNode[float]

Alias for field number 1

view_distance: ProcNode[float]

Alias for field number 2

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.camera_data()

Uses a CameraData Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/camera_data.html

Return type:

CameraDataResult

procfunc.nodes.shader.displacement(height=0.0, midlevel=0.5, scale=1.0, normal=None, space='OBJECT')

Uses a Displacement Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/vector/displacement.html

Parameters:

• height (ProcNode[float] | float)

• midlevel (ProcNode[float] | float)

• scale (ProcNode[float] | float)

• normal (ProcNode[Vector] | Vector)

• space (Literal['OBJECT', 'WORLD'])

Return type:

ProcNode[Vector]

procfunc.nodes.shader.eevee_specular(base_color=(0.8, 0.8, 0.8, 1), specular=(0.03, 0.03, 0.03, 1), roughness=0.2, emissive_color=(0, 0, 0, 1), transparency=0.0, normal=None, clear_coat=0.0, clear_coat_roughness=0.0, clear_coat_normal=None)

Uses a EeveeSpecular Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/specular_bsdf.html

Parameters:

• base_color (ProcNode[Color] | Color)

• specular (ProcNode[Color] | Color)

• roughness (ProcNode[float] | float)

• emissive_color (ProcNode[Color] | Color)

• transparency (ProcNode[float] | float)

• normal (ProcNode[Vector] | Vector)

• clear_coat (ProcNode[float] | float)

• clear_coat_roughness (ProcNode[float] | float)

• clear_coat_normal (ProcNode[Vector] | Vector)

Return type:

ProcNode[Shader]

procfunc.nodes.shader.emission(color=(1, 1, 1, 1), strength=1.0)

Uses a Emission Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/emission.html

Parameters:

• color (ProcNode[Color] | Color)

• strength (ProcNode[float] | float)

Return type:

ProcNode[Shader]

procfunc.nodes.shader.fresnel(ior=1.5, normal=None)

Uses a Fresnel Shader Node.

Parameters:

• normal (ProcNode[Vector] | Vector) – Avoid using this input. We recommend using the shader’s Displacement output instead, which supports bumpmapping OR real mesh render/export.

• ior (ProcNode[float] | float)

Return type:

ProcNode[float]

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/fresnel.html

procfunc.nodes.shader.gamma(color=(1, 1, 1, 1), gamma=1.0)

Uses a Gamma Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/color/gamma.html

Parameters:

• color (ProcNode[Color] | Color)

• gamma (ProcNode[float] | float)

Return type:

ProcNode[Color]

class procfunc.nodes.shader.HairInfoResult

Bases: NamedTuple

HairInfoResult(is_strand, intercept, length, thickness, tangent_normal, random)

is_strand: ProcNode[float]

Alias for field number 0

intercept: ProcNode[float]

Alias for field number 1

length: ProcNode[float]

Alias for field number 2

thickness: ProcNode[float]

Alias for field number 3

tangent_normal: ProcNode[Vector]

Alias for field number 4

random: ProcNode[float]

Alias for field number 5

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.hair_info()

Uses a HairInfo Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/hair_info.html

Return type:

HairInfoResult

procfunc.nodes.shader.holdout()

Uses a Holdout Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/holdout.html

Return type:

ProcNode[Shader]

procfunc.nodes.shader.hue_saturation(hue=0.5, saturation=1.0, value=1.0, fac=1.0, color=(0.8, 0.8, 0.8, 1))

Uses a HueSaturation Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/color/hue_saturation.html

Parameters:

• hue (ProcNode[float] | float)

• saturation (ProcNode[float] | float)

• value (ProcNode[float] | float)

• fac (ProcNode[float] | float)

• color (ProcNode[Color] | Color)

Return type:

ProcNode[Color]

procfunc.nodes.shader.invert(fac=1.0, color=(0, 0, 0, 1))

Uses a Invert Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/color/invert_color.html

Parameters:

• fac (ProcNode[float] | float)

• color (ProcNode[Color] | Color)

Return type:

ProcNode[Color]

class procfunc.nodes.shader.LayerWeightResult

Bases: NamedTuple

LayerWeightResult(fresnel, facing)

fresnel: ProcNode[float]

Alias for field number 0

facing: ProcNode[float]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.layer_weight(blend=0.5, normal=(0.0, 0.0, 0.0))

Uses a LayerWeight Shader Node.

Parameters:

• normal (ProcNode[Vector] | Vector) – Avoid using this input. We recommend using the shader’s Displacement output instead, which supports bumpmapping OR real mesh render/export.

• blend (ProcNode[float] | float)

Return type:

LayerWeightResult

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/layer_weight.html

class procfunc.nodes.shader.LightFalloffResult

Bases: NamedTuple

LightFalloffResult(quadratic, linear, constant)

quadratic: ProcNode[float]

Alias for field number 0

linear: ProcNode[float]

Alias for field number 1

constant: ProcNode[float]

Alias for field number 2

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.light_falloff(strength=100.0, smooth=0.0)

Uses a LightFalloff Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/color/light_falloff.html

Parameters:

• strength (ProcNode[float] | float)

• smooth (ProcNode[float] | float)

Return type:

LightFalloffResult

class procfunc.nodes.shader.LightPathResult

Bases: NamedTuple

LightPathResult(is_camera_ray, is_shadow_ray, is_diffuse_ray, is_glossy_ray, is_singular_ray, is_reflection_ray, is_transmission_ray, ray_length, ray_depth, diffuse_depth, glossy_depth, transparent_depth, transmission_depth)

is_camera_ray: ProcNode[float]

Alias for field number 0

is_shadow_ray: ProcNode[float]

Alias for field number 1

is_diffuse_ray: ProcNode[float]

Alias for field number 2

is_glossy_ray: ProcNode[float]

Alias for field number 3

is_singular_ray: ProcNode[float]

Alias for field number 4

is_reflection_ray: ProcNode[float]

Alias for field number 5

is_transmission_ray: ProcNode[float]

Alias for field number 6

ray_length: ProcNode[float]

Alias for field number 7

ray_depth: ProcNode[float]

Alias for field number 8

diffuse_depth: ProcNode[float]

Alias for field number 9

glossy_depth: ProcNode[float]

Alias for field number 10

transparent_depth: ProcNode[float]

Alias for field number 11

transmission_depth: ProcNode[float]

Alias for field number 12

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.light_path()

Uses a LightPath Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/light_path.html

Return type:

LightPathResult

procfunc.nodes.shader.mapping(vector=(0, 0, 0), location=(0, 0, 0), rotation=(0, 0, 0), scale=(1, 1, 1), vector_type='POINT')

Uses a Mapping Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/vector/mapping.html

Parameters:

• vector (ProcNode[Vector] | Vector)

• location (ProcNode[Vector] | Vector)

• rotation (ProcNode[Vector] | Vector)

• scale (ProcNode[Vector] | Vector)

• vector_type (Literal['POINT', 'TEXTURE', 'VECTOR', 'NORMAL'])

Return type:

ProcNode[Vector]

procfunc.nodes.shader.mix_shader(factor=0.5, a=None, b=None)

Uses a MixShader Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/mix.html

Parameters:

• factor (ProcNode[float] | float)

• a (ProcNode[Shader] | None)

• b (ProcNode[Shader] | None)

Return type:

ProcNode[Shader]

class procfunc.nodes.shader.NormalResult

Bases: NamedTuple

NormalResult(normal, dot)

normal: ProcNode[Vector]

Alias for field number 0

dot: ProcNode[float]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.normal(normal=(0, 0, 1))

Uses a Normal Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/vector/normal.html

Parameters:

normal (ProcNode[Vector] | Vector)

Return type:

NormalResult

procfunc.nodes.shader.normal_map(strength=1.0, color=(0.5, 0.5, 1, 1), space='TANGENT', uv_map='')

Uses a NormalMap Shader Node.

This node is discouraged. We recommend using the shader’s Displacement output instead, which supports bumpmapping OR real mesh render/export.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/vector/normal_map.html

Parameters:

• strength (ProcNode[float] | float)

• color (ProcNode[Color] | Color)

• space (Literal['TANGENT', 'OBJECT', 'WORLD', 'BLENDER_OBJECT', 'BLENDER_WORLD'])

• uv_map (str)

Return type:

ProcNode[Vector]

class procfunc.nodes.shader.ObjectInfoResult

Bases: NamedTuple

ObjectInfoResult(location, color, alpha, object_index, material_index, random)

location: ProcNode[Vector]

Alias for field number 0

color: ProcNode[Color]

Alias for field number 1

alpha: ProcNode[float]

Alias for field number 2

object_index: ProcNode[int]

Alias for field number 3

material_index: ProcNode[int]

Alias for field number 4

random: ProcNode[float]

Alias for field number 5

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.object_info()

Uses a ObjectInfo Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/object_info.html

Return type:

ObjectInfoResult

class procfunc.nodes.shader.ParticleInfoResult

Bases: NamedTuple

ParticleInfoResult(index, random, age, lifetime, location, size, velocity, angular_velocity)

index: ProcNode[int]

Alias for field number 0

random: ProcNode[float]

Alias for field number 1

age: ProcNode[float]

Alias for field number 2

lifetime: ProcNode[float]

Alias for field number 3

location: ProcNode[Vector]

Alias for field number 4

size: ProcNode[float]

Alias for field number 5

velocity: ProcNode[Vector]

Alias for field number 6

angular_velocity: ProcNode[Vector]

Alias for field number 7

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.particle_info()

Uses a ParticleInfo Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/particle_info.html

Return type:

ParticleInfoResult

class procfunc.nodes.shader.PointInfoResult

Bases: NamedTuple

PointInfoResult(position, radius, random)

position: ProcNode[Vector]

Alias for field number 0

radius: ProcNode[float]

Alias for field number 1

random: ProcNode[float]

Alias for field number 2

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.point_info()

Uses a PointInfo Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/point_info.html

Return type:

PointInfoResult

procfunc.nodes.shader.rgb()

Uses a RGB Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/rgb.html

Return type:

ProcNode[Color]

procfunc.nodes.shader.rgb_to_bw(color=(0.5, 0.5, 0.5, 1))

Uses a RGBToBW Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/rgb_to_bw.html

Parameters:

color (ProcNode[Color] | Color)

Return type:

ProcNode[float]

procfunc.nodes.shader.script(bytecode='', bytecode_hash='', filepath='', mode='INTERNAL', script=None, use_auto_update=False)

Uses a Script Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/osl.html

Parameters:

• bytecode (str)

• bytecode_hash (str)

• filepath (str)

• mode (Literal['INTERNAL', 'EXTERNAL'])

• script (Any)

• use_auto_update (bool)

Return type:

ProcNode[Shader]

procfunc.nodes.shader.shader_to_rgb(shader=None)

Uses a ShaderToRGB Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/shader_to_rgb.html

Parameters:

shader (ProcNode[Shader] | None)

Return type:

ProcNode[Color]

procfunc.nodes.shader.squeeze(value=0.0, width=1.0, center=0.0)

Uses a Squeeze Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/map_range.html

Parameters:

• value (ProcNode[float] | float)

• width (ProcNode[float] | float)

• center (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.shader.subsurface_scattering(color=(0.8, 0.8, 0.8, 1), scale=0.05, radius=(1, 0.2, 0.1), ior=1.4, roughness=1.0, anisotropy=0.0, normal=(0.0, 0.0, 0.0), falloff='RANDOM_WALK')

Uses a SubsurfaceScattering Shader Node.

Parameters:

• normal (ProcNode[Vector] | Vector) – Avoid using this input. We recommend using the shader’s Displacement output instead, which supports bumpmapping OR real mesh render/export.

• color (ProcNode[Color] | Color)

• scale (ProcNode[float] | float)

• radius (ProcNode[Vector] | Vector)

• ior (ProcNode[float] | float)

• roughness (ProcNode[float] | float)

• anisotropy (ProcNode[float] | float)

• falloff (Literal['BURLEY', 'RANDOM_WALK', 'RANDOM_WALK_SKIN'])

Return type:

ProcNode[Shader]

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/volume_scatter.html

procfunc.nodes.shader.tangent(axis='Z', direction_type='RADIAL', uv_map='')

Uses a Tangent Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/tangent.html

Parameters:

• axis (Literal['X', 'Y', 'Z'])

• direction_type (Literal['RADIAL', 'UV_MAP'])

• uv_map (str)

Return type:

ProcNode[Vector]

class procfunc.nodes.shader.TextureResult

Bases: NamedTuple

TextureResult(fac, color)

fac: ProcNode[float]

Alias for field number 0

color: ProcNode[Color]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.brick(vector, color1=(0.8, 0.8, 0.8, 1), color2=(0.2, 0.2, 0.2, 1), mortar=(0, 0, 0, 1), scale=5.0, mortar_size=0.02, mortar_smooth=0.1, bias=0.0, brick_width=0.5, row_height=0.25, offset=0.5, offset_frequency=2, squash=1.0, squash_frequency=2)

Uses a TexBrick Shader Node.

Infinigen requires an explicit vector input - node will not default to using texture coordinate or world coordinate like blender

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/textures/brick.html

Parameters:

• vector (ProcNode[Vector] | Vector)

• color1 (ProcNode[Color] | Color)

• color2 (ProcNode[Color] | Color)

• mortar (ProcNode[Color] | Color)

• scale (ProcNode[float] | float)

• mortar_size (ProcNode[float] | float)

• mortar_smooth (ProcNode[float] | float)

• bias (ProcNode[float] | float)

• brick_width (ProcNode[float] | float)

• row_height (ProcNode[float] | float)

• offset (float)

• offset_frequency (int)

• squash (float)

• squash_frequency (int)

Return type:

TextureResult

procfunc.nodes.shader.checker(vector, color1=(0.8, 0.8, 0.8, 1), color2=(0.2, 0.2, 0.2, 1), scale=5.0)

Uses a TexChecker Shader Node.

Infinigen requires an explicit vector input - node will not default to using texture coordinate or world coordinate like blender

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/textures/checker.html

Parameters:

• vector (ProcNode[Vector] | Vector)

• color1 (ProcNode[Color] | Color)

• color2 (ProcNode[Color] | Color)

• scale (ProcNode[float] | float)

Return type:

TextureResult

class procfunc.nodes.shader.CoordResult

Bases: NamedTuple

CoordResult(generated, normal, uv, object, camera, window)

generated: ProcNode[Vector]

Alias for field number 0

normal: ProcNode[Vector]

Alias for field number 1

uv: ProcNode[Vector]

Alias for field number 2

object: ProcNode[Vector]

Alias for field number 3

camera: ProcNode[Vector]

Alias for field number 4

window: ProcNode[Vector]

Alias for field number 5

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.coord(from_instancer=False, object=None)

Uses a TexCoord Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/texture_coordinate.html

Parameters:

• from_instancer (bool)

• object (Any)

Return type:

CoordResult

class procfunc.nodes.shader.GeometryResult

Bases: NamedTuple

GeometryResult(position, normal, tangent, true_normal, incoming, parametric, backfacing, pointiness, random_per_island)

position: ProcNode[Vector]

Alias for field number 0

normal: ProcNode[Vector]

Alias for field number 1

tangent: ProcNode[Vector]

Alias for field number 2

true_normal: ProcNode[Vector]

Alias for field number 3

incoming: ProcNode[Vector]

Alias for field number 4

parametric: ProcNode[Vector]

Alias for field number 5

backfacing: ProcNode[float]

Alias for field number 6

pointiness: ProcNode[float]

Alias for field number 7

random_per_island: ProcNode[float]

Alias for field number 8

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.geometry()

Return type:

GeometryResult

procfunc.nodes.shader.environment(vector, image=None, interpolation='Linear', projection='EQUIRECTANGULAR')

Uses a TexEnvironment Shader Node.

Infinigen requires an explicit vector input - node will not default to using texture coordinate or world coordinate like blender

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/textures/environment.html

Parameters:

• vector (ProcNode[Vector] | Vector)

• image (Any)

• interpolation (Literal['Linear', 'Closest', 'Cubic', 'Smart'])

• projection (Literal['EQUIRECTANGULAR', 'MIRROR_BALL'])

Return type:

ProcNode[Color]

procfunc.nodes.shader.gradient(vector, gradient_type='LINEAR')

Uses a TexGradient Shader Node.

Infinigen requires an explicit vector input - node will not default to using texture coordinate or world coordinate like blender

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/textures/gradient.html

Parameters:

• vector (ProcNode[Vector] | Vector)

• gradient_type (Literal['LINEAR', 'QUADRATIC', 'EASING', 'DIAGONAL', 'SPHERICAL', 'QUADRATIC_SPHERE', 'RADIAL'])

Return type:

TextureResult

procfunc.nodes.shader.ies(vector, strength=1.0, filepath='', ies=None, mode='INTERNAL')

Uses a TexIES Shader Node.

Infinigen requires an explicit vector input - node will not default to using texture coordinate or world coordinate like blender

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/textures/ies.html

Parameters:

• vector (ProcNode[Vector] | Vector)

• strength (ProcNode[float] | float)

• filepath (str)

• ies (Any)

• mode (Literal['INTERNAL', 'EXTERNAL'])

Return type:

ProcNode[float]

procfunc.nodes.shader.image(vector, extension='REPEAT', image=None, interpolation='Linear', projection='FLAT', projection_blend=0.0)

Uses a TexImage Shader Node.

Infinigen requires an explicit vector input - node will not default to using texture coordinate or world coordinate like blender

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/textures/image.html

Parameters:

• vector (ProcNode[Vector] | Vector)

• extension (Literal['REPEAT', 'EXTEND', 'CLIP', 'MIRROR'])

• image (Any)

• interpolation (Literal['Linear', 'Closest', 'Cubic', 'Smart'])

• projection (Literal['FLAT', 'BOX', 'SPHERE', 'CUBE'])

• projection_blend (float)

Return type:

TextureResult

procfunc.nodes.shader.magic(vector, scale=5.0, distortion=1.0, turbulence_depth=2)

Uses a TexMagic Shader Node.

Infinigen requires an explicit vector input - node will not default to using texture coordinate or world coordinate like blender

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/textures/magic.html

Parameters:

• vector (ProcNode[Vector] | Vector)

• scale (ProcNode[float] | float)

• distortion (ProcNode[float] | float)

• turbulence_depth (int)

Return type:

TextureResult

procfunc.nodes.shader.noise(vector=(0.0, 0.0, 0.0), scale=5.0, detail=2.0, roughness=0.5, lacunarity=2.0, offset=0.0, gain=1.0, distortion=0.0, noise_dimensions='3D', noise_type='FBM', normalize=True, w=0.0)

Uses a TexNoise Shader Node.

Parameters:

• offset (-) – Only supported for RIDGED_MULTIFRACTAL, HYBRID_MULTIFRACTAL, HETERO_TERRAIN noise types

• gain (-) – Only supported for RIDGED_MULTIFRACTAL and HYBRID_MULTIFRACTAL noise types

• distortion (-) – Only supported for RIDGED_MULTIFRACTAL, HYBRID_MULTIFRACTAL, HETERO_TERRAIN noise types

• w (-) – Only supported for 1D and 4D noise dimensions

• vector (ProcNode[Vector] | Vector)

• scale (ProcNode[float] | float)

• detail (ProcNode[float] | float)

• roughness (ProcNode[float] | float)

• lacunarity (ProcNode[float] | float)

• noise_dimensions (Literal['1D', '2D', '3D', '4D'])

• noise_type (Literal['MULTIFRACTAL', 'FBM', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL', 'HETERO_TERRAIN'])

• normalize (bool)

Return type:

TextureResult

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/textures/noise.html

class procfunc.nodes.shader.PointDensityResult

Bases: NamedTuple

PointDensityResult(color, density)

color: ProcNode[Color]

Alias for field number 0

density: ProcNode[float]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.point_density(vector, interpolation='Linear', object=None, particle_color_source='PARTICLE_AGE', particle_system=None, point_source='PARTICLE_SYSTEM', radius=0.3, resolution=100, space='OBJECT', vertex_attribute_name='', vertex_color_source='VERTEX_COLOR')

Uses a TexPointDensity Shader Node.

Infinigen requires an explicit vector input - node will not default to using texture coordinate or world coordinate like blender

TODO: vertex_attribute_name and vertex_color_source are only available for point_source OBJECT

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/textures/point_density.html

Parameters:

• vector (ProcNode[Vector] | Vector)

• interpolation (Literal['Closest', 'Linear', 'Cubic'])

• object (Any)

• particle_color_source (Literal['PARTICLE_AGE', 'PARTICLE_SPEED', 'PARTICLE_VELOCITY'])

• particle_system (Any)

• point_source (Literal['OBJECT', 'PARTICLE_SYSTEM'])

• radius (float)

• resolution (int)

• space (Literal['OBJECT', 'WORLD'])

• vertex_attribute_name (str)

• vertex_color_source (Literal['VERTEX_COLOR', 'VERTEX_NORMAL', 'VERTEX_WEIGHT'])

Return type:

PointDensityResult

procfunc.nodes.shader.sky(air_density=1.0, altitude=0.0, dust_density=1.0, ground_albedo=0.3, ozone_density=1.0, sky_type='NISHITA', sun_direction=(0.0, 0.0, 1.0), sun_disc=True, sun_elevation=0.261799, sun_intensity=1.0, sun_rotation=0.0, sun_size=0.009512, turbidity=2.2)

Uses a TexSky Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/textures/sky.html

Parameters:

• air_density (float)

• altitude (float)

• dust_density (float)

• ground_albedo (float)

• ozone_density (float)

• sky_type (Literal['NISHITA', 'HOSEK_WILKIE', 'PREETHAM'])

• sun_direction (tuple)

• sun_disc (bool)

• sun_elevation (float)

• sun_intensity (float)

• sun_rotation (float)

• sun_size (float)

• turbidity (float)

Return type:

ProcNode[Color]

class procfunc.nodes.shader.VoronoiResult

Bases: NamedTuple

VoronoiResult(color, distance, position, w)

color: ProcNode[Color]

Alias for field number 0

distance: ProcNode[float]

Alias for field number 1

position: ProcNode[Vector]

Alias for field number 2

w: ProcNode[float] | None

Alias for field number 3

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.voronoi(vector, scale=5.0, detail=0.0, roughness=0.5, lacunarity=2.0, randomness=1.0, exponent=0.0, distance='EUCLIDEAN', feature='F1', normalize=False, voronoi_dimensions='3D', w=0.0)

Uses a TexVoronoi Shader Node.

Parameters:

• exponent (ProcNode[float] | float) – Only supported for Minkowski distance.

• vector (ProcNode[Vector] | Vector)

• scale (ProcNode[float] | float)

• detail (ProcNode[float] | float)

• roughness (ProcNode[float] | float)

• lacunarity (ProcNode[float] | float)

• randomness (ProcNode[float] | float)

• distance (Literal['EUCLIDEAN', 'MANHATTAN', 'CHEBYCHEV', 'MINKOWSKI'])

• feature (Literal['F1', 'F2'])

• normalize (bool)

• voronoi_dimensions (Literal['1D', '2D', '3D', '4D'])

• w (ProcNode[float] | float)

Return type:

VoronoiResult

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/textures/voronoi.html

procfunc.nodes.shader.voronoi_distance(vector, scale=5.0, detail=0.0, roughness=0.5, lacunarity=2.0, randomness=1.0, normalize=False, voronoi_dimensions='3D', w=0.0)

Parameters:

• vector (ProcNode[Vector] | Vector)

• scale (ProcNode[float] | float)

• detail (ProcNode[float] | float)

• roughness (ProcNode[float] | float)

• lacunarity (ProcNode[float] | float)

• randomness (ProcNode[float] | float)

• normalize (bool)

• voronoi_dimensions (Literal['1D', '2D', '3D', '4D'])

• w (ProcNode[float] | float)

Return type:

ProcNode[float]

procfunc.nodes.shader.voronoi_smooth_f1(vector, scale=5.0, detail=0.0, roughness=0.5, lacunarity=2.0, smoothness=0.5, randomness=1.0, distance='EUCLIDEAN', normalize=False, voronoi_dimensions='3D', w=0.0)

Parameters:

• vector (ProcNode[Vector] | Vector)

• scale (ProcNode[float] | float)

• detail (ProcNode[float] | float)

• roughness (ProcNode[float] | float)

• lacunarity (ProcNode[float] | float)

• smoothness (ProcNode[float] | float)

• randomness (ProcNode[float] | float)

• distance (Literal['EUCLIDEAN', 'MANHATTAN', 'CHEBYCHEV', 'MINKOWSKI'])

• normalize (bool)

• voronoi_dimensions (Literal['1D', '2D', '3D', '4D'])

• w (ProcNode[float] | float)

Return type:

VoronoiResult

procfunc.nodes.shader.voronoi_n_spheres_distance(vector, scale=5.0, randomness=1.0, normalize=False)

Parameters:

• vector (ProcNode[Vector] | Vector)

• scale (ProcNode[float] | float)

• randomness (ProcNode[float] | float)

• normalize (bool)

Return type:

ProcNode[float]

procfunc.nodes.shader.wave(vector, scale=5.0, distortion=0.0, detail=2.0, detail_scale=1.0, detail_roughness=0.5, phase_offset=0.0, bands_direction='X', rings_direction='X', wave_profile='SIN', wave_type='BANDS')

Uses a TexWave Shader Node.

TODO: bands_direction and rings_direction are only available for wave_type BANDS or RINGS respectively

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/textures/wave.html

Parameters:

• vector (ProcNode[Vector] | Vector)

• scale (ProcNode[float] | float)

• distortion (ProcNode[float] | float)

• detail (ProcNode[float] | float)

• detail_scale (ProcNode[float] | float)

• detail_roughness (ProcNode[float] | float)

• phase_offset (ProcNode[float] | float)

• bands_direction (Literal['X', 'Y', 'Z', 'SPHERICAL'])

• rings_direction (Literal['X', 'Y', 'Z', 'SPHERICAL'])

• wave_profile (Literal['SIN', 'SAW', 'TRI'])

• wave_type (Literal['BANDS', 'RINGS'])

Return type:

TextureResult

procfunc.nodes.shader.white_noise(vector=None, noise_dimensions='3D', w=None)

Uses a TexWhiteNoise Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/textures/white_noise.html

Parameters:

• vector (ProcNode[Vector] | Vector | None)

• noise_dimensions (Literal['1D', '2D', '3D', '4D'])

• w (ProcNode[float] | float)

Return type:

TextureResult

procfunc.nodes.shader.uv_along_stroke(use_tips=False)

Uses a UVAlongStroke Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/uv_map.html

Parameters:

use_tips (bool)

Return type:

ProcNode[Vector]

procfunc.nodes.shader.uv_map(from_instancer=False, uv_map='')

Uses a UVMap Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/uv_map.html

Parameters:

• from_instancer (bool)

• uv_map (str)

Return type:

ProcNode[Vector]

class procfunc.nodes.shader.ColorRampResult

Bases: NamedTuple

ColorRampResult(color, alpha)

color: ProcNode[Color]

Alias for field number 0

alpha: ProcNode[float]

Alias for field number 1

Supported special methods: __add__, __contains__, __getitem__, __getnewargs__, __iter__, __len__, __mul__, __rmul__

procfunc.nodes.shader.color_ramp(fac=0.5, points=None, mode='RGB', interpolation='LINEAR')

Uses a ValToRGB (ColorRamp) Shader Node with points support.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/color_ramp.html

Parameters:

• fac (ProcNode[float] | float)

• points (list[tuple[float, Color]] | None)

• mode (Literal['RGB', 'HSV', 'HSL'])

• interpolation (Literal['EASE', 'CARDINAL', 'LINEAR', 'B_SPLINE', 'CONSTANT'])

Return type:

ColorRampResult

procfunc.nodes.shader.value()

Uses a Value Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/value.html

Return type:

ProcNode[float]

procfunc.nodes.shader.vector_displacement(vector=(0.8, 0.8, 0.8, 1), midlevel=0.0, scale=1.0, space='TANGENT')

Uses a VectorDisplacement Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/vector/vector_displacement.html

Parameters:

• vector (ProcNode[Color] | Color)

• midlevel (ProcNode[float] | float)

• scale (ProcNode[float] | float)

• space (Literal['TANGENT', 'OBJECT', 'WORLD'])

Return type:

ProcNode[Vector]

procfunc.nodes.shader.vertex_color(layer_name='')

Uses a VertexColor Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/vertex_color.html

Parameters:

layer_name (str)

Return type:

ProcNode[Color]

procfunc.nodes.shader.volume_absorption(color=(0.8, 0.8, 0.8, 1), density=1.0)

Uses a VolumeAbsorption Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/volume_absorption.html

Parameters:

• color (ProcNode[Color] | Color)

• density (ProcNode[float] | float)

Return type:

ProcNode[Shader]

procfunc.nodes.shader.volume_info()

Uses a VolumeInfo Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/volume_info.html

Return type:

ProcNode

procfunc.nodes.shader.volume_principled(color=(0.5, 0.5, 0.5, 1), color_attribute='', density=1.0, density_attribute='density', anisotropy=0.0, absorption_color=(0, 0, 0, 1), emission_strength=0.0, emission_color=(1, 1, 1, 1), blackbody_intensity=0.0, blackbody_tint=(1, 1, 1, 1), temperature=1000.0, temperature_attribute='temperature')

Uses a VolumePrincipled Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/volume_principled.html

Parameters:

• color (ProcNode[Color] | Color)

• color_attribute (ProcNode[str] | str)

• density (ProcNode[float] | float)

• density_attribute (ProcNode[str] | str)

• anisotropy (ProcNode[float] | float)

• absorption_color (ProcNode[Color] | Color)

• emission_strength (ProcNode[float] | float)

• emission_color (ProcNode[Color] | Color)

• blackbody_intensity (ProcNode[float] | float)

• blackbody_tint (ProcNode[Color] | Color)

• temperature (ProcNode[float] | float)

• temperature_attribute (ProcNode[str] | str)

Return type:

ProcNode[Shader]

procfunc.nodes.shader.volume_scatter(color=(0.8, 0.8, 0.8, 1), density=1.0, anisotropy=0.0)

Uses a VolumeScatter Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/shader/volume_scatter.html

Parameters:

• color (ProcNode[Color] | Color)

• density (ProcNode[float] | float)

• anisotropy (ProcNode[float] | float)

Return type:

ProcNode[Shader]

procfunc.nodes.shader.wavelength(wavelength=500.0)

Uses a Wavelength Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/wavelength.html

Parameters:

wavelength (ProcNode[float] | float)

Return type:

ProcNode[Color]

procfunc.nodes.shader.wireframe(size=0.01, use_pixel_size=False)

Uses a Wireframe Shader Node.

See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/input/wireframe.html

Parameters:

• size (ProcNode[float] | float)

• use_pixel_size (bool)

Return type:

ProcNode[float]