Vector 

classmethod Random(min=None, max=None, ID=None, seed=None, node_label=None, node_color=None)

Geometry node [Random Value].

Parameters

min – Vector
max – Vector
ID – Integer
seed – Integer
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

Node RandomValue

data_type = ‘FLOAT_VECTOR’

_{Blender reference : FunctionNodeRandomValue, Node ‘Random Value’}

from geonodes import nodes
nodes.RandomValue(min=min, max=max, ID=ID, seed=seed, data_type='FLOAT_VECTOR', label=node_label, node_color=node_color)

classmethod RotateEuler(rotation=None, rotate_by=None, axis=None, angle=None, space='OBJECT', type='EULER', node_label=None, node_color=None)

Geometry node [Rotate Euler].

Parameters

rotation – Vector
rotate_by – Vector
axis – Vector
angle – Float
space (str) – ‘OBJECT’ in [OBJECT, LOCAL]
type (str) – ‘EULER’ in [AXIS_ANGLE, EULER]
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

Node RotateEuler

_{Blender reference : FunctionNodeRotateEuler, Node ‘Rotate Euler’}

from geonodes import nodes
nodes.RotateEuler(rotation=rotation, rotate_by=rotate_by, axis=axis, angle=angle, space=space, type=type, label=node_label, node_color=node_color)

classmethod Rotation(value=(0, 0, 0), name='Rotation', description='')

Create a Rotation input socket in the Group Input Node

Parameters

value – The default value
name (str) – The socket name
description (str) – User tip

Returns

The Vector data socket

Return type

classmethod Translation(value=(0, 0, 0), name='Translation', description='')

Create a Translation input socket in the Group Input Node

Parameters

value – The default value
name (str) – The socket name
description (str) – User tip

Returns

The Vector data socket

Return type

classmethod VectorXYZ(value=(0, 0, 0), name='VectorXYZ', description='')

Create a Vector XYZ input socket in the Group Input Node

Parameters

value – The default value
name (str) – The socket name
description (str) – User tip

Returns

The Vector data socket

Return type

absolute(node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘ABSOLUTE’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, operation='ABSOLUTE', label=node_label, node_color=node_color)

accumulate_field(group_index=None, domain='POINT', node_label=None, node_color=None)

Geometry node [Accumulate Field].

Parameters

group_index – Integer
domain (str) – ‘POINT’ in [POINT, EDGE, FACE, CORNER, CURVE, INSTANCE]
node_label (str) – Node label
node_color (color) – Node background color

Returns

Sockets [leading (Vector), trailing (Vector), total (Vector)]

Node creation

Node AccumulateField

data_type = ‘FLOAT_VECTOR’

_{Blender reference : GeometryNodeAccumulateField, Node ‘Accumulate Field’}

from geonodes import nodes
nodes.AccumulateField(value=self, group_index=group_index, data_type='FLOAT_VECTOR', domain=domain, label=node_label, node_color=node_color)

add(vector1=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘ADD’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, operation='ADD', label=node_label, node_color=node_color)

align_to_vector(factor=None, vector=None, axis='X', pivot_axis='AUTO', node_label=None, node_color=None)

Geometry node [Align Euler to Vector].

Parameters

factor – Float
vector – Vector
axis (str) – ‘X’ in [X, Y, Z]
pivot_axis (str) – ‘AUTO’ in [AUTO, X, Y, Z]
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

Node AlignEulerToVector

_{Blender reference : FunctionNodeAlignEulerToVector, Node ‘Align Euler to Vector’}

from geonodes import nodes
nodes.AlignEulerToVector(rotation=self, factor=factor, vector=vector, axis=axis, pivot_axis=pivot_axis, label=node_label, node_color=node_color)

attribute_statistic(geometry=None, selection=None, domain='POINT', node_label=None, node_color=None)

Geometry node [Attribute Statistic].

Parameters

geometry – Geometry
selection – Boolean
domain (str) – ‘POINT’ in [POINT, EDGE, FACE, CORNER, CURVE, INSTANCE]
node_label (str) – Node label
node_color (color) – Node background color

Returns

Sockets [mean (Vector), median (Vector), sum (Vector), min (Vector), max (Vector), range (Vector), standard_deviation (Vector), variance (Vector)]

Node creation

Node AttributeStatistic

data_type = ‘FLOAT_VECTOR’

_{Blender reference : GeometryNodeAttributeStatistic, Node ‘Attribute Statistic’}

from geonodes import nodes
nodes.AttributeStatistic(attribute=self, geometry=geometry, selection=selection, data_type='FLOAT_VECTOR', domain=domain, label=node_label, node_color=node_color)

average_equal(b=None, epsilon=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
epsilon – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘AVERAGE’

operation = ‘EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, epsilon=epsilon, data_type='VECTOR', mode='AVERAGE', operation='EQUAL', label=node_label, node_color=node_color)

average_greater_equal(b=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘AVERAGE’

operation = ‘GREATER_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, data_type='VECTOR', mode='AVERAGE', operation='GREATER_EQUAL', label=node_label, node_color=node_color)

average_greater_than(b=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘AVERAGE’

operation = ‘GREATER_THAN’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, data_type='VECTOR', mode='AVERAGE', operation='GREATER_THAN', label=node_label, node_color=node_color)

average_less_equal(b=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘AVERAGE’

operation = ‘LESS_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, data_type='VECTOR', mode='AVERAGE', operation='LESS_EQUAL', label=node_label, node_color=node_color)

average_less_than(b=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘AVERAGE’

operation = ‘LESS_THAN’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, data_type='VECTOR', mode='AVERAGE', operation='LESS_THAN', label=node_label, node_color=node_color)

average_not_equal(b=None, epsilon=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
epsilon – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘AVERAGE’

operation = ‘NOT_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, epsilon=epsilon, data_type='VECTOR', mode='AVERAGE', operation='NOT_EQUAL', label=node_label, node_color=node_color)

property bl_idname: Shortcut for self.bsocket.bl_idname

property bnode: Shortcut for self.bsocket.node

bsocket: The wrapped geometry node socket

capture_attribute(geometry=None, domain='POINT', node_label=None, node_color=None)

Geometry node [Capture Attribute].

Parameters

geometry – Geometry
domain (str) – ‘POINT’ in [POINT, EDGE, FACE, CORNER, CURVE, INSTANCE]
node_label (str) – Node label
node_color (color) – Node background color

Returns

Sockets [geometry (Geometry), attribute (Vector)]

Node creation

Node CaptureAttribute

data_type = ‘FLOAT_VECTOR’

_{Blender reference : GeometryNodeCaptureAttribute, Node ‘Capture Attribute’}

from geonodes import nodes
nodes.CaptureAttribute(value=self, geometry=geometry, data_type='FLOAT_VECTOR', domain=domain, label=node_label, node_color=node_color)

ceil(node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘CEIL’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, operation='CEIL', label=node_label, node_color=node_color)

connected_sockets(): Returns the list of Socket instances linked to this socket.

cos(node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘COSINE’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, operation='COSINE', label=node_label, node_color=node_color)

cross(vector1=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘CROSS_PRODUCT’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, operation='CROSS_PRODUCT', label=node_label, node_color=node_color)

curves(fac=None, node_label=None, node_color=None)

Geometry node [Vector Curves].

Parameters

fac – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

Node VectorCurves

_{Blender reference : ShaderNodeVectorCurve, Node ‘Vector Curves’}

from geonodes import nodes
nodes.VectorCurves(vector=self, fac=fac, label=node_label, node_color=node_color)

data_socket: Used by domain

direction_equal(b=None, angle=None, epsilon=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
angle – Float
epsilon – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘DIRECTION’

operation = ‘EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, angle=angle, epsilon=epsilon, data_type='VECTOR', mode='DIRECTION', operation='EQUAL', label=node_label, node_color=node_color)

direction_greater_equal(b=None, angle=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
angle – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘DIRECTION’

operation = ‘GREATER_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, angle=angle, data_type='VECTOR', mode='DIRECTION', operation='GREATER_EQUAL', label=node_label, node_color=node_color)

direction_greater_than(b=None, angle=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
angle – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘DIRECTION’

operation = ‘GREATER_THAN’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, angle=angle, data_type='VECTOR', mode='DIRECTION', operation='GREATER_THAN', label=node_label, node_color=node_color)

direction_less_equal(b=None, angle=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
angle – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘DIRECTION’

operation = ‘LESS_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, angle=angle, data_type='VECTOR', mode='DIRECTION', operation='LESS_EQUAL', label=node_label, node_color=node_color)

direction_less_than(b=None, angle=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
angle – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘DIRECTION’

operation = ‘LESS_THAN’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, angle=angle, data_type='VECTOR', mode='DIRECTION', operation='LESS_THAN', label=node_label, node_color=node_color)

direction_not_equal(b=None, angle=None, epsilon=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
angle – Float
epsilon – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘DIRECTION’

operation = ‘NOT_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, angle=angle, epsilon=epsilon, data_type='VECTOR', mode='DIRECTION', operation='NOT_EQUAL', label=node_label, node_color=node_color)

distance(vector1=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Float

Node creation

operation = ‘DISTANCE’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, operation='DISTANCE', label=node_label, node_color=node_color)

divide(vector1=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘DIVIDE’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, operation='DIVIDE', label=node_label, node_color=node_color)

static domain_data_type(value)

Returns the domain to which the socket belongs

Parameters: value (bpy.types.NodeSocket, Socket) – The socket
Returns: Domain code in [‘BOOLEAN’, ‘INT’, ‘FLOAT’, ‘FLOAT_VECTOR’, ‘FLOAT_COLOR’]
Return type: str

Correspondance table
Socket bl_idname	Domain code
NodeSocketBool	‘BOOLEAN’
NodeSocketInt	‘INT’
NodeSocketIntUnsigned	‘INT’
NodeSocketFloat	‘FLOAT’
NodeSocketFloatFactor	‘FLOAT’
NodeSocketFloatAngle	‘FLOAT’
NodeSocketFloatDistance	‘FLOAT’
NodeSocketVector	‘FLOAT_VECTOR’
NodeSocketVectorEuler	‘FLOAT_VECTOR’
NodeSocketVectorXYZ	‘FLOAT_VECTOR’
NodeSocketVectorTranslation	‘FLOAT_VECTOR’
NodeSocketColor	‘FLOAT_COLOR’
NodeSocketString	‘FLOAT_COLOR’

dot(vector1=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Float

Node creation

operation = ‘DOT_PRODUCT’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, operation='DOT_PRODUCT', label=node_label, node_color=node_color)

dot_product_equal(b=None, c=None, epsilon=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
c – Float
epsilon – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘DOT_PRODUCT’

operation = ‘EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, c=c, epsilon=epsilon, data_type='VECTOR', mode='DOT_PRODUCT', operation='EQUAL', label=node_label, node_color=node_color)

dot_product_greater_equal(b=None, c=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
c – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘DOT_PRODUCT’

operation = ‘GREATER_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, c=c, data_type='VECTOR', mode='DOT_PRODUCT', operation='GREATER_EQUAL', label=node_label, node_color=node_color)

dot_product_greater_than(b=None, c=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
c – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘DOT_PRODUCT’

operation = ‘GREATER_THAN’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, c=c, data_type='VECTOR', mode='DOT_PRODUCT', operation='GREATER_THAN', label=node_label, node_color=node_color)

dot_product_less_equal(b=None, c=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
c – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘DOT_PRODUCT’

operation = ‘LESS_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, c=c, data_type='VECTOR', mode='DOT_PRODUCT', operation='LESS_EQUAL', label=node_label, node_color=node_color)

dot_product_less_than(b=None, c=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
c – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘DOT_PRODUCT’

operation = ‘LESS_THAN’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, c=c, data_type='VECTOR', mode='DOT_PRODUCT', operation='LESS_THAN', label=node_label, node_color=node_color)

dot_product_not_equal(b=None, c=None, epsilon=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
c – Float
epsilon – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘DOT_PRODUCT’

operation = ‘NOT_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, c=c, epsilon=epsilon, data_type='VECTOR', mode='DOT_PRODUCT', operation='NOT_EQUAL', label=node_label, node_color=node_color)

element_equal(b=None, epsilon=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
epsilon – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘ELEMENT’

operation = ‘EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, epsilon=epsilon, data_type='VECTOR', mode='ELEMENT', operation='EQUAL', label=node_label, node_color=node_color)

element_greater_equal(b=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘ELEMENT’

operation = ‘GREATER_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, data_type='VECTOR', mode='ELEMENT', operation='GREATER_EQUAL', label=node_label, node_color=node_color)

element_greater_than(b=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘ELEMENT’

operation = ‘GREATER_THAN’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, data_type='VECTOR', mode='ELEMENT', operation='GREATER_THAN', label=node_label, node_color=node_color)

element_less_equal(b=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘ELEMENT’

operation = ‘LESS_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, data_type='VECTOR', mode='ELEMENT', operation='LESS_EQUAL', label=node_label, node_color=node_color)

element_less_than(b=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘ELEMENT’

operation = ‘LESS_THAN’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, data_type='VECTOR', mode='ELEMENT', operation='LESS_THAN', label=node_label, node_color=node_color)

element_not_equal(b=None, epsilon=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
epsilon – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘ELEMENT’

operation = ‘NOT_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, epsilon=epsilon, data_type='VECTOR', mode='ELEMENT', operation='NOT_EQUAL', label=node_label, node_color=node_color)

equal(b=None, c=None, angle=None, epsilon=None, mode='ELEMENT', node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
c – Float
angle – Float
epsilon – Float
mode (str) – ‘ELEMENT’ in [ELEMENT, LENGTH, AVERAGE, DOT_PRODUCT, DIRECTION]
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

operation = ‘EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, c=c, angle=angle, epsilon=epsilon, data_type='VECTOR', mode=mode, operation='EQUAL', label=node_label, node_color=node_color)

faceforward(vector1=None, vector2=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
vector2 – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘FACEFORWARD’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, vector2=vector2, operation='FACEFORWARD', label=node_label, node_color=node_color)

field_at_index(index=None, domain='POINT', node_label=None, node_color=None)

Geometry node [Field at Index].

Parameters

index – Integer
domain (str) – ‘POINT’ in [POINT, EDGE, FACE, CORNER, CURVE, INSTANCE]
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

Node FieldAtIndex

data_type = ‘FLOAT_VECTOR’

_{Blender reference : GeometryNodeFieldAtIndex, Node ‘Field at Index’}

from geonodes import nodes
nodes.FieldAtIndex(value=self, index=index, data_type='FLOAT_VECTOR', domain=domain, label=node_label, node_color=node_color)

field_of: Used by field to implement transfer attribute mechanism. This property is set to all node output sockets.

floor(node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘FLOOR’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, operation='FLOOR', label=node_label, node_color=node_color)

fraction(node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘FRACTION’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, operation='FRACTION', label=node_label, node_color=node_color)

static get_bl_idname(class_name)

Get the node socket bl_idname name from the Socket class

Parameters: class_name (str) – The class name
Returns: The bl_idname associated to this class name
Return type: str

Used to create a new group input socket. Called in DataClass.Input method to determine which socket type must be created.

Note that here the class_name argument accepts additional values which correspond to sub classes:

Unsigned	Integer sub class (NodeSocketIntUnsigned)
Factor	Float sub class (NodeSocketFloatFactor)
Angle	Float sub class (NodeSocketFloatAngle)
Distance	Float sub class (NodeSocketFloatDistance)
Rotation	Vector sub class (NodeSocketVectorEuler)
xyz	Vector sub class (NodeSocketVectorXYZ)
Translation	Vector sub class (NodeSocketVectorTranslation)

These additional values allow to enter angle, distance, factor… as group input values.

get_blender_socket()

Overrides the standard behavior of :class:DataSocket super class

If the x, y, z properties have been read or modified, a Combine XYZ node is necessary to recompose the Vector.

_{Blender reference : ShaderNodeCombineXYZ, Node ‘Combine XYZ’}

static get_class_name(socket, with_sub_class=False)

Get the DataSocket class name corresponding to the socket type and name.

Parameters

socket – The socket to determine the class of
with_sub_class (bool) – Return the sub class if True

Typ socket

bpy.types.NodeSocket, Socket

Returns

The name of the class associated to the bl_idname of the socket

Return type

str

Correspondance table
NodeSocket	class name	sub class name
NodeSocketBool	‘Boolean’
NodeSocketInt	‘Integer’
NodeSocketIntUnsigned	‘Integer’	‘Unsigned’
NodeSocketFloat	‘Float’
NodeSocketFloatFactor	‘Float’	‘Factor’
NodeSocketFloatAngle	‘Float’	‘Angle’
NodeSocketFloatDistance	‘Float’	‘Distance’
NodeSocketVector	‘Vector’
NodeSocketVectorEuler	‘Vector’	‘Rotation’
NodeSocketVectorXYZ	‘Vector’	‘xyz’
NodeSocketVectorTranslation	‘Vector’	‘Translation’
NodeSocketColor	‘Color’
NodeSocketString’	‘String’
NodeSocketCollection	‘Collection’
NodeSocketImage	‘Image’
NodeSocketMaterial	‘Material’
NodeSocketObject	‘Object’
NodeSocketTexture	‘Texture’
NodeSocketGeometry	‘Geometry’

If the name of the socket is in [‘Mesh’, ‘Points’, ‘Instances’, ‘Volume’, ‘Spline’, ‘Curve’], the name is chosen as the class name.

static gives_bsocket(value)

Test if the argument provides a valid output socket.

Parameters: value (any) – The value to test
Returns: True if value is or wraps a socket
Return type: bool

Returns True if value is:

A Blender Geometry Node Socket
An instance of Socket

greater_equal(b=None, c=None, angle=None, mode='ELEMENT', node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
c – Float
angle – Float
mode (str) – ‘ELEMENT’ in [ELEMENT, LENGTH, AVERAGE, DOT_PRODUCT, DIRECTION]
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

operation = ‘GREATER_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, c=c, angle=angle, data_type='VECTOR', mode=mode, operation='GREATER_EQUAL', label=node_label, node_color=node_color)

greater_than(b=None, c=None, angle=None, mode='ELEMENT', node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
c – Float
angle – Float
mode (str) – ‘ELEMENT’ in [ELEMENT, LENGTH, AVERAGE, DOT_PRODUCT, DIRECTION]
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

operation = ‘GREATER_THAN’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, c=c, angle=angle, data_type='VECTOR', mode=mode, operation='GREATER_THAN', label=node_label, node_color=node_color)

init_domains()

Initialize the geometry domains

To be overloaded by sub classes.

init_socket()

Complementary init

Called at the end of initialization for further operations.

property is_multi_input: Shortcut for self.bsocket.is_multi_output

property is_output: Shortcut for self.bsocket.is_output

static is_socket(value)

An alternative to isinstance(value, Socket)

Parameters: value (any) – The value to test
Returns: True if value is an instance of Socket
Return type: bool

length(node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

node_label (str) – Node label
node_color (color) – Node background color

Returns

Float

Node creation

operation = ‘LENGTH’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, operation='LENGTH', label=node_label, node_color=node_color)

length_equal(b=None, epsilon=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
epsilon – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘LENGTH’

operation = ‘EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, epsilon=epsilon, data_type='VECTOR', mode='LENGTH', operation='EQUAL', label=node_label, node_color=node_color)

length_greater_equal(b=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘LENGTH’

operation = ‘GREATER_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, data_type='VECTOR', mode='LENGTH', operation='GREATER_EQUAL', label=node_label, node_color=node_color)

length_greater_than(b=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘LENGTH’

operation = ‘GREATER_THAN’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, data_type='VECTOR', mode='LENGTH', operation='GREATER_THAN', label=node_label, node_color=node_color)

length_less_equal(b=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘LENGTH’

operation = ‘LESS_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, data_type='VECTOR', mode='LENGTH', operation='LESS_EQUAL', label=node_label, node_color=node_color)

length_less_than(b=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘LENGTH’

operation = ‘LESS_THAN’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, data_type='VECTOR', mode='LENGTH', operation='LESS_THAN', label=node_label, node_color=node_color)

length_not_equal(b=None, epsilon=None, node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
epsilon – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

mode = ‘LENGTH’

operation = ‘NOT_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, epsilon=epsilon, data_type='VECTOR', mode='LENGTH', operation='NOT_EQUAL', label=node_label, node_color=node_color)

less_equal(b=None, c=None, angle=None, mode='ELEMENT', node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
c – Float
angle – Float
mode (str) – ‘ELEMENT’ in [ELEMENT, LENGTH, AVERAGE, DOT_PRODUCT, DIRECTION]
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

operation = ‘LESS_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, c=c, angle=angle, data_type='VECTOR', mode=mode, operation='LESS_EQUAL', label=node_label, node_color=node_color)

less_than(b=None, c=None, angle=None, mode='ELEMENT', node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
c – Float
angle – Float
mode (str) – ‘ELEMENT’ in [ELEMENT, LENGTH, AVERAGE, DOT_PRODUCT, DIRECTION]
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

operation = ‘LESS_THAN’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, c=c, angle=angle, data_type='VECTOR', mode=mode, operation='LESS_THAN', label=node_label, node_color=node_color)

property links: Shortcut for self.bsocket.links

map_range(from_min=None, from_max=None, to_min=None, to_max=None, clamp=True, interpolation_type='LINEAR', node_label=None, node_color=None)

Geometry node [Map Range].

Parameters

from_min – Vector
from_max – Vector
to_min – Vector
to_max – Vector
clamp (bool) – True
interpolation_type (str) – ‘LINEAR’ in [LINEAR, STEPPED, SMOOTHSTEP, SMOOTHERSTEP]
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

Node MapRange

data_type = ‘FLOAT_VECTOR’

_{Blender reference : ShaderNodeMapRange, Node ‘Map Range’}

from geonodes import nodes
nodes.MapRange(vector=self, from_min=from_min, from_max=from_max, to_min=to_min, to_max=to_max, clamp=clamp, data_type='FLOAT_VECTOR', interpolation_type=interpolation_type, label=node_label, node_color=node_color)

max(vector1=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘MAXIMUM’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, operation='MAXIMUM', label=node_label, node_color=node_color)

min(vector1=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘MINIMUM’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, operation='MINIMUM', label=node_label, node_color=node_color)

modulo(vector1=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘MODULO’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, operation='MODULO', label=node_label, node_color=node_color)

multiply(vector1=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘MULTIPLY’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, operation='MULTIPLY', label=node_label, node_color=node_color)

multiply_add(vector1=None, vector2=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
vector2 – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘MULTIPLY_ADD’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, vector2=vector2, operation='MULTIPLY_ADD', label=node_label, node_color=node_color)

property name: Shortcut for self.bsocket.name

node: The owning node

property node_chain_label: Shortcut for self.node.chain_label

normalize(node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘NORMALIZE’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, operation='NORMALIZE', label=node_label, node_color=node_color)

not_equal(b=None, c=None, angle=None, epsilon=None, mode='ELEMENT', node_label=None, node_color=None)

Geometry node [Compare].

Parameters

b – Vector
c – Float
angle – Float
epsilon – Float
mode (str) – ‘ELEMENT’ in [ELEMENT, LENGTH, AVERAGE, DOT_PRODUCT, DIRECTION]
node_label (str) – Node label
node_color (color) – Node background color

Returns

Boolean

Node creation

Node Compare

data_type = ‘VECTOR’

operation = ‘NOT_EQUAL’

_{Blender reference : FunctionNodeCompare, Node ‘Compare’}

from geonodes import nodes
nodes.Compare(a=self, b=b, c=c, angle=angle, epsilon=epsilon, data_type='VECTOR', mode=mode, operation='NOT_EQUAL', label=node_label, node_color=node_color)

plug(*values)

Plug values in the socket (input sockets only)

Parameters: values (array of bpy.types.NodeSocket, Socket, values) – The output sockets. More than one values can be passed if the input socket is multi input.

see plug_bsocket()

static plug_bsocket(bsocket, *values)

Plug the values to the input Blender socket.

Parameters

bsocket (bpy.types.NodeSocket, Socket) – The input socket to plug into
values (array of bpy.types.NodeSocket, Socket, values) – The output sockets. More than one values can be passed if the input socket is multi input.

Warning

bsocket must be an input socket and values must be output sockets-like.

This static method is called by the DataClass method plug().

This method is the one which links an output socket of a node to the input socket of another one.

If the socket is multi input, the plug method is called once per provided value. If a value is None, nothing happens.

A not None value can be:

either a valid value for the socket (eg: 123 for Integer socket)
or an output socket of another Node

When it is a socket, it can be a Blender socket or a DataSocket

project(vector1=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘PROJECT’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, operation='PROJECT', label=node_label, node_color=node_color)

raycast(target_geometry=None, source_position=None, ray_direction=None, ray_length=None, mapping='INTERPOLATED', node_label=None, node_color=None)

Geometry node [Raycast].

Parameters

target_geometry – Geometry
source_position – Vector
ray_direction – Vector
ray_length – Float
mapping (str) – ‘INTERPOLATED’ in [INTERPOLATED, NEAREST]
node_label (str) – Node label
node_color (color) – Node background color

Returns

Sockets [is_hit (Boolean), hit_position (Vector), hit_normal (Vector), hit_distance (Float), attribute (Vector)]

Node creation

Node Raycast

data_type = ‘FLOAT_VECTOR’

_{Blender reference : GeometryNodeRaycast, Node ‘Raycast’}

from geonodes import nodes
nodes.Raycast(attribute=self, target_geometry=target_geometry, source_position=source_position, ray_direction=ray_direction, ray_length=ray_length, data_type='FLOAT_VECTOR', mapping=mapping, label=node_label, node_color=node_color)

reflect(vector1=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘REFLECT’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, operation='REFLECT', label=node_label, node_color=node_color)

refract(vector1=None, scale=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
scale – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘REFRACT’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, scale=scale, operation='REFRACT', label=node_label, node_color=node_color)

reroute(): Reroute all output links

reset_properties()

Reset the properties

Properties such as components are cached.

After a node is called, the wrapped socket changes and this makes the cache obsolete. After a change, the cache is erased.

Example

class Vector(...):
    def __init__(self, ...):
         ...
         self.reset_properties()
         ...

     def reset_properties(self):
         super().reset_properties()
         self.separate_ = None      # Created by property self.seperate() with node SeparateXyz

rotate(center=None, axis=None, angle=None, rotation=None, invert=False, rotation_type='AXIS_ANGLE', node_label=None, node_color=None)

Geometry node [Vector Rotate].

Parameters

center – Vector
axis – Vector
angle – Float
rotation – Vector
invert (bool) – False
rotation_type (str) – ‘AXIS_ANGLE’ in [AXIS_ANGLE, X_AXIS, Y_AXIS, Z_AXIS, EULER_XYZ]
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

Node VectorRotate

_{Blender reference : ShaderNodeVectorRotate, Node ‘Vector Rotate’}

from geonodes import nodes
nodes.VectorRotate(vector=self, center=center, axis=axis, angle=angle, rotation=rotation, invert=invert, rotation_type=rotation_type, label=node_label, node_color=node_color)

rotate_euler(rotate_by=None, axis=None, angle=None, space='OBJECT', type='EULER', node_label=None, node_color=None)

Geometry node [Rotate Euler].

Parameters

rotate_by – Vector
axis – Vector
angle – Float
space (str) – ‘OBJECT’ in [OBJECT, LOCAL]
type (str) – ‘EULER’ in [AXIS_ANGLE, EULER]
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

Node RotateEuler

_{Blender reference : FunctionNodeRotateEuler, Node ‘Rotate Euler’}

from geonodes import nodes
nodes.RotateEuler(rotation=self, rotate_by=rotate_by, axis=axis, angle=angle, space=space, type=type, label=node_label, node_color=node_color)

scale(scale=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

scale – Float
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘SCALE’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, scale=scale, operation='SCALE', label=node_label, node_color=node_color)

property separate

Geometry node [Separate XYZ].

Returns: Sockets [x (Float), y (Float), z (Float)]

Node creation

_{Blender reference : ShaderNodeSeparateXYZ, Node ‘Separate XYZ’}

from geonodes import nodes
nodes.SeparateXyz(vector=self, label=f"{self.node_chain_label}.separate")

sin(node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘SINE’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, operation='SINE', label=node_label, node_color=node_color)

snap(vector1=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘SNAP’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, operation='SNAP', label=node_label, node_color=node_color)

property socket_index

Return the index of the socket within the list of node sockets.

Depending on the _is_output_ property, the socket belongs either to node.inputs or node.outputs.

stack(node)

Change the wrapped socket

Parameters: node (Node) – The new node owning the output socket to wrap
Returns: self

Methods are implemented in two modes:

Creation
Transformation

In creation mode, the node is considered as creating new data. The result is a new instance of DataSocket.

In transformation mode, the node is considered as transforming data which is kept in the result of the method. After the method returns, the calling DataSocket instance refers to a new Blender output socket. The stack method changes the socket the instance refers to and reinitialize properties

# 1. Creation mode
#
# to_mesh method creates a new mesh from a curve.
# The curve instance refers to the same output node socket
# We need to get the result of the method in a new variable

new_mesh = curve.to_mesh(profile_curve=circle)

# 2. Transformation mode
#
# set_shade_smooth method transforms the mesh.
# After the call, the mesh instance refers to the output socket of the
# newly created node "Set Shade Smooth". There is no need to get the result
# of the method.

mesh.set_shade_smooth()

# Note that a transformation method returns self and so, the following line
# is equivallent:

mesh = mesh.set_shade_smooth()

subtract(vector1=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘SUBTRACT’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, operation='SUBTRACT', label=node_label, node_color=node_color)

switch(switch=None, true=None, node_label=None, node_color=None)

Geometry node [Switch].

Parameters

switch – Boolean
true – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

Node Switch

input_type = ‘VECTOR’

_{Blender reference : GeometryNodeSwitch, Node ‘Switch’}

from geonodes import nodes
nodes.Switch(false=self, switch=switch, true=true, input_type='VECTOR', label=node_label, node_color=node_color)

tan(node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘TANGENT’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, operation='TANGENT', label=node_label, node_color=node_color)

to_output(name=None)

Plug the data socket to the group output

Parameters: name (str) – The name to give to the modifier output

The socket is added to the outputs of the geometry nodes tree.

Note

To define a data socket as the result geometry of the tree, use tree.output_geometry = my_geometry.

view()

Link the data socket to the viewer

If the data socket is a geometry (Curve, Mesh…) it is linked to the geometry input of the viewer.

If it ias a value (Integer, Float,…) it is linked to the value socket and the viewer is configured accordingly.

wrap(vector1=None, vector2=None, node_label=None, node_color=None)

Geometry node [Vector Math].

Parameters

vector1 – Vector
vector2 – Vector
node_label (str) – Node label
node_color (color) – Node background color

Returns

Vector

Node creation

operation = ‘WRAP’

_{Blender reference : ShaderNodeVectorMath, Node ‘Vector Math’}

from geonodes import nodes
nodes.VectorMath(vector0=self, vector1=vector1, vector2=vector2, operation='WRAP', label=node_label, node_color=node_color)

property x

Geometry node [Separate XYZ].

Returns: Sockets [x (Float), y (Float), z (Float)]

Node creation

_{Blender reference : ShaderNodeSeparateXYZ, Node ‘Separate XYZ’}

from geonodes import nodes
nodes.SeparateXyz(vector=self, label=f"{self.node_chain_label}.x")

property y

Geometry node [Separate XYZ].

Returns: Sockets [x (Float), y (Float), z (Float)]

Node creation

_{Blender reference : ShaderNodeSeparateXYZ, Node ‘Separate XYZ’}

from geonodes import nodes
nodes.SeparateXyz(vector=self, label=f"{self.node_chain_label}.y")

property z

Geometry node [Separate XYZ].

Returns: Sockets [x (Float), y (Float), z (Float)]

Node creation