Cross Reference
3D Cursor
bl_idname : GeometryNodeTool3DCursor
nd
AOV Output
bl_idname : ShaderNodeOutputAOV
class Color
Color.aov_output(self, value: Float = None, aov_name = '')
snd
nd.aov_output(cls, color: Color = None, value: Float = None, aov_name = '')
Accumulate Field
bl_idname : GeometryNodeAccumulateField
class Point
Mesh.points.accumulate_field(cls, value: Float | Integer | Vector | Matrix = None, group_id: Integer = None)
class Edge
Mesh.edges.accumulate_field(cls, value: Float | Integer | Vector | Matrix = None, group_id: Integer = None)
class Face
Mesh.faces.accumulate_field(cls, value: Float | Integer | Vector | Matrix = None, group_id: Integer = None)
class Corner
Mesh.corners.accumulate_field(cls, value: Float | Integer | Vector | Matrix = None, group_id: Integer = None)
class Spline
Spline.splines.accumulate_field(cls, value: Float | Integer | Vector | Matrix = None, group_id: Integer = None)
class Instance
Instances.insts.accumulate_field(cls, value: Float | Integer | Vector | Matrix = None, group_id: Integer = None)
class Layer
GreasePencil.layers.accumulate_field(cls, value: Float | Integer | Vector | Matrix = None, group_id: Integer = None)
nd
nd.accumulate_field(cls,
value: Float = None,
group_id: Integer = None,
data_type: Literal['FLOAT', 'INT', 'FLOAT_VECTOR', 'TRANSFORM'] = 'FLOAT',
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
Active Camera
bl_idname : GeometryNodeInputActiveCamera
class Object
nd
Active Element
bl_idname : GeometryNodeToolActiveElement
class Point
Mesh.points.active_element(cls)
class Edge
Mesh.edges.active_element(cls)
class Face
Mesh.faces.active_element(cls)
class Layer
GreasePencil.layers.active_element(cls)
nd
nd.active_element(cls, domain: Literal['POINT', 'EDGE', 'FACE', 'LAYER'] = 'POINT')
Add Shader
bl_idname : ShaderNodeAddShader
class Shader
Shader.add(self, shader: Shader = None)
snd
nd.add_shader(cls, shader: Shader = None, shader_1: Shader = None)
Advect Grid
bl_idname : GeometryNodeGridAdvect
class Float
Float.advect_grid(self,
velocity: Vector = None,
time_step: Float = None,
integration_scheme: Literal['Semi-Lagrangian', 'Midpoint', 'Runge-Kutta 3', 'Runge-Kutta 4', 'MacCormack', 'BFECC'] = None,
limiter: Literal['None', 'Clamp', 'Revert'] = None)
class Integer
Integer.advect_grid(self,
velocity: Vector = None,
time_step: Float = None,
integration_scheme: Literal['Semi-Lagrangian', 'Midpoint', 'Runge-Kutta 3', 'Runge-Kutta 4', 'MacCormack', 'BFECC'] = None,
limiter: Literal['None', 'Clamp', 'Revert'] = None)
class Vector
Vector.advect_grid(self,
velocity: Vector = None,
time_step: Float = None,
integration_scheme: Literal['Semi-Lagrangian', 'Midpoint', 'Runge-Kutta 3', 'Runge-Kutta 4', 'MacCormack', 'BFECC'] = None,
limiter: Literal['None', 'Clamp', 'Revert'] = None)
nd
nd.advect_grid(cls,
grid: Float = None,
velocity: Vector = None,
time_step: Float = None,
integration_scheme: Literal['Semi-Lagrangian', 'Midpoint', 'Runge-Kutta 3', 'Runge-Kutta 4', 'MacCormack', 'BFECC'] = None,
limiter: Literal['None', 'Clamp', 'Revert'] = None,
data_type: Literal['FLOAT', 'INT', 'VECTOR'] = 'FLOAT')
Align Rotation to Vector
bl_idname : FunctionNodeAlignRotationToVector
class Rotation
Rotation.AlignToVector(cls,
vector: Vector = None,
factor: Float = None,
axis: Literal['X', 'Y', 'Z'] = 'Z',
pivot_axis: Literal['AUTO', 'X', 'Y', 'Z'] = 'AUTO')
Rotation.AlignXToVector(cls,
vector: Vector = None,
factor: Float = None,
pivot_axis: Literal['AUTO', 'X', 'Y', 'Z'] = 'AUTO')
Rotation.AlignYToVector(cls,
vector: Vector = None,
factor: Float = None,
pivot_axis: Literal['AUTO', 'X', 'Y', 'Z'] = 'AUTO')
Rotation.AlignZToVector(cls,
vector: Vector = None,
factor: Float = None,
pivot_axis: Literal['AUTO', 'X', 'Y', 'Z'] = 'AUTO')
Rotation.align_to_vector(self,
vector: Vector = None,
factor: Float = None,
axis: Literal['X', 'Y', 'Z'] = 'Z',
pivot_axis: Literal['AUTO', 'X', 'Y', 'Z'] = 'AUTO')
Rotation.align_x_to_vector(self,
vector: Vector = None,
factor: Float = None,
pivot_axis: Literal['AUTO', 'X', 'Y', 'Z'] = 'AUTO')
Rotation.align_y_to_vector(self,
vector: Vector = None,
factor: Float = None,
pivot_axis: Literal['AUTO', 'X', 'Y', 'Z'] = 'AUTO')
Rotation.align_z_to_vector(self,
vector: Vector = None,
factor: Float = None,
pivot_axis: Literal['AUTO', 'X', 'Y', 'Z'] = 'AUTO')
nd
nd.align_rotation_to_vector(cls,
rotation: Rotation = None,
vector: Vector = None,
factor: Float = None,
axis: Literal['X', 'Y', 'Z'] = 'Z',
pivot_axis: Literal['AUTO', 'X', 'Y', 'Z'] = 'AUTO')
Ambient Occlusion
bl_idname : ShaderNodeAmbientOcclusion
class Color
Color.ambient_occlusion(self,
distance: Float = None,
normal: Vector = None,
inside = False,
only_local = False,
samples = 16)
snd
nd.ambient_occlusion(cls,
color: Color = None,
distance: Float = None,
normal: Vector = None,
inside = False,
only_local = False,
samples = 16)
Arc
bl_idname : GeometryNodeCurveArc
class Curve
Curve.ArcPoints(cls,
resolution: Integer = None,
start: Vector = None,
middle: Vector = None,
end: Vector = None,
offset_angle: Float = None,
connect_center: Boolean = None,
invert_arc: Boolean = None)
Curve.ArcRadius(cls,
resolution: Integer = None,
radius: Float = None,
start_angle: Float = None,
sweep_angle: Float = None,
connect_center: Boolean = None,
invert_arc: Boolean = None)
Curve.Arc(cls,
resolution: Integer = None,
radius: Float = None,
start_angle: Float = None,
sweep_angle: Float = None,
connect_center: Boolean = None,
invert_arc: Boolean = None,
mode: Literal['POINTS', 'RADIUS'] = 'RADIUS')
nd
nd.arc(cls,
resolution: Integer = None,
start: Vector = None,
middle: Vector = None,
end: Vector = None,
radius: Float = None,
start_angle: Float = None,
sweep_angle: Float = None,
offset_angle: Float = None,
connect_center: Boolean = None,
invert_arc: Boolean = None,
mode: Literal['POINTS', 'RADIUS'] = 'RADIUS')
Attribute
bl_idname : ShaderNodeAttribute
snd
nd.attribute(cls,
attribute_name = '',
attribute_type: Literal['GEOMETRY', 'OBJECT', 'INSTANCER', 'VIEW_LAYER'] = 'GEOMETRY')
Attribute Statistic
bl_idname : GeometryNodeAttributeStatistic
class Point
Mesh.points.attribute_statistic(self, attribute: Float | Vector = None)
class Edge
Mesh.edges.attribute_statistic(self, attribute: Float | Vector = None)
class Face
Mesh.faces.attribute_statistic(self, attribute: Float | Vector = None)
class Corner
Mesh.corners.attribute_statistic(self, attribute: Float | Vector = None)
class Spline
Spline.splines.attribute_statistic(self, attribute: Float | Vector = None)
class Instance
Instances.insts.attribute_statistic(self, attribute: Float | Vector = None)
class Layer
GreasePencil.layers.attribute_statistic(self, attribute: Float | Vector = None)
nd
nd.attribute_statistic(cls,
geometry: Geometry = None,
selection: Boolean = None,
attribute: Float = None,
data_type: Literal['FLOAT', 'FLOAT_VECTOR'] = 'FLOAT',
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
Axes to Rotation
bl_idname : FunctionNodeAxesToRotation
class Rotation
Rotation.FromAxes(cls,
primary_axis_1: Vector = None,
secondary_axis_1: Vector = None,
primary_axis: Literal['X', 'Y', 'Z'] = 'Z',
secondary_axis: Literal['X', 'Y', 'Z'] = 'X')
Rotation.FromXYAxes(cls, primary_axis: Vector = None, secondary_axis: Vector = None)
Rotation.FromYXAxes(cls, primary_axis: Vector = None, secondary_axis: Vector = None)
Rotation.FromXZAxes(cls, primary_axis: Vector = None, secondary_axis: Vector = None)
Rotation.FromZXAxes(cls, primary_axis: Vector = None, secondary_axis: Vector = None)
Rotation.FromYZAxes(cls, primary_axis: Vector = None, secondary_axis: Vector = None)
Rotation.FromZYAxes(cls, primary_axis: Vector = None, secondary_axis: Vector = None)
nd
nd.axes_to_rotation(cls,
primary_axis_1: Vector = None,
secondary_axis_1: Vector = None,
primary_axis: Literal['X', 'Y', 'Z'] = 'Z',
secondary_axis: Literal['X', 'Y', 'Z'] = 'X')
Axis Angle to Rotation
bl_idname : FunctionNodeAxisAngleToRotation
class Rotation
Rotation.FromAxisAngle(cls, axis: Vector = None, angle: Float = None)
nd
nd.axis_angle_to_rotation(cls, axis: Vector = None, angle: Float = None)
Background
bl_idname : ShaderNodeBackground
class Color
Color.background(self, strength: Float = None)
snd
nd.background(cls, color: Color = None, strength: Float = None, weight: Float = None)
Bake
bl_idname : GeometryNodeBake
nd
nd.bake(cls, named_sockets: dict = {}, **sockets)
Bevel
bl_idname : ShaderNodeBevel
class Float
Float.bevel(self, normal: Vector = None, samples = 4)
snd
nd.bevel(cls, radius: Float = None, normal: Vector = None, samples = 4)
Bit Math
bl_idname : FunctionNodeBitMath
class Integer
Integer.bw_and(self, b: Integer = None)
Integer.bw_or(self, b: Integer = None)
Integer.bw_xor(self, b: Integer = None)
Integer.bw_shift(self, shift: Integer = None)
Integer.bw_rotate(self, shift: Integer = None)
class gnmath
gnmath.bw_and(a: Integer = None, b: Integer = None)
gnmath.bw_or(a: Integer = None, b: Integer = None)
gnmath.bw_xor(a: Integer = None, b: Integer = None)
gnmath.bw_not(a: Integer = None)
gnmath.bw_shift(a: Integer = None, shift: Integer = None)
gnmath.bw_rotate(a: Integer = None, shift: Integer = None)
nd
nd.bit_math(cls,
a: Integer = None,
b: Integer = None,
shift: Integer = None,
operation: Literal['AND', 'OR', 'XOR', 'NOT', 'SHIFT', 'ROTATE'] = 'AND')
Blackbody
bl_idname : ShaderNodeBlackbody
class Color
Color.Blackbody(cls, temperature: Float = None)
nd
nd.blackbody(cls, temperature: Float = None)
snd
nd.blackbody(cls, temperature: Float = None)
Blur Attribute
bl_idname : GeometryNodeBlurAttribute
class Float
Float.blur(self, iterations: Integer = None, weight: Float = None)
class Integer
Integer.blur(self, iterations: Integer = None, weight: Float = None)
class Vector
Vector.blur(self, iterations: Integer = None, weight: Float = None)
class Color
Color.blur(self, iterations: Integer = None, weight: Float = None)
nd
nd.blur_attribute(cls,
value: Float = None,
iterations: Integer = None,
weight: Float = None,
data_type: Literal['FLOAT', 'INT', 'FLOAT_VECTOR', 'FLOAT_COLOR'] = 'FLOAT')
Bone Info
bl_idname : GeometryNodeBoneInfo
class Object
Object.bone_info(self,
bone_name: String = None,
transform_space: Literal['ORIGINAL', 'RELATIVE'] = 'ORIGINAL')
nd
nd.bone_info(cls,
armature: Object = None,
bone_name: String = None,
transform_space: Literal['ORIGINAL', 'RELATIVE'] = 'ORIGINAL')
Boolean
bl_idname : FunctionNodeInputBool
nd
nd.boolean(cls, boolean = False)
Boolean Math
bl_idname : FunctionNodeBooleanMath
class Boolean
Boolean.band(self, boolean: Boolean = None)
Boolean.bor(self, boolean: Boolean = None)
Boolean.not_and(self, boolean: Boolean = None)
Boolean.nor(self, boolean: Boolean = None)
Boolean.xnor(self, boolean: Boolean = None)
Boolean.xor(self, boolean: Boolean = None)
Boolean.imply(self, boolean: Boolean = None)
Boolean.nimply(self, boolean: Boolean = None)
class gnmath
gnmath.band(boolean: Boolean = None, boolean_1: Boolean = None)
gnmath.bor(boolean: Boolean = None, boolean_1: Boolean = None)
gnmath.bnot(boolean: Boolean = None)
gnmath.not_and(boolean: Boolean = None, boolean_1: Boolean = None)
gnmath.nor(boolean: Boolean = None, boolean_1: Boolean = None)
gnmath.xnor(boolean: Boolean = None, boolean_1: Boolean = None)
gnmath.xor(boolean: Boolean = None, boolean_1: Boolean = None)
gnmath.imply(boolean: Boolean = None, boolean_1: Boolean = None)
gnmath.nimply(boolean: Boolean = None, boolean_1: Boolean = None)
nd
nd.boolean_math(cls,
boolean: Boolean = None,
boolean_1: Boolean = None,
operation: Literal['AND', 'OR', 'NOT', 'NAND', 'NOR', 'XNOR', 'XOR', 'IMPLY', 'NIMPLY'] = 'AND')
Bounding Box
bl_idname : GeometryNodeBoundBox
class Geometry
Geometry.bounding_box(self, use_radius: Boolean = None)
nd
nd.bounding_box(cls, geometry: Geometry = None, use_radius: Boolean = None)
Brick Texture
bl_idname : ShaderNodeTexBrick
class Color
Color.Brick(cls,
vector: Vector = None,
color1: Color = None,
color2: Color = None,
mortar: Color = None,
scale: Float = None,
mortar_size: Float = None,
mortar_smooth: Float = None,
bias: Float = None,
brick_width: Float = None,
row_height: Float = None,
offset = 0.5,
offset_frequency = 2,
squash = 1.0,
squash_frequency = 2)
class Texture
Texture.Brick(cls,
vector: Vector = None,
color1: Color = None,
color2: Color = None,
mortar: Color = None,
scale: Float = None,
mortar_size: Float = None,
mortar_smooth: Float = None,
bias: Float = None,
brick_width: Float = None,
row_height: Float = None,
offset = 0.5,
offset_frequency = 2,
squash = 1.0,
squash_frequency = 2)
nd
nd.brick_texture(cls,
vector: Vector = None,
color1: Color = None,
color2: Color = None,
mortar: Color = None,
scale: Float = None,
mortar_size: Float = None,
mortar_smooth: Float = None,
bias: Float = None,
brick_width: Float = None,
row_height: Float = None,
offset = 0.5,
offset_frequency = 2,
squash = 1.0,
squash_frequency = 2)
snd
nd.brick_texture(cls,
vector: Vector = None,
color1: Color = None,
color2: Color = None,
mortar: Color = None,
scale: Float = None,
mortar_size: Float = None,
mortar_smooth: Float = None,
bias: Float = None,
brick_width: Float = None,
row_height: Float = None,
offset = 0.5,
offset_frequency = 2,
squash = 1.0,
squash_frequency = 2)
Brightness/Contrast
bl_idname : ShaderNodeBrightContrast
class Color
Color.brightness_contrast(self, brightness: Float = None, contrast: Float = None)
snd
nd.brightness_contrast(cls, color: Color = None, brightness: Float = None, contrast: Float = None)
Bump
bl_idname : ShaderNodeBump
class Float
Float.bump(self,
distance: Float = None,
filter_width: Float = None,
height: Float = None,
normal: Vector = None,
invert = False)
snd
nd.bump(cls,
strength: Float = None,
distance: Float = None,
filter_width: Float = None,
height: Float = None,
normal: Vector = None,
invert = False)
Bézier Segment
bl_idname : GeometryNodeCurvePrimitiveBezierSegment
class Curve
Curve.BeziersegmentPosition(cls,
resolution: Integer = None,
start: Vector = None,
start_handle: Vector = None,
end_handle: Vector = None,
end: Vector = None)
Curve.BeziersegmentOffset(cls,
resolution: Integer = None,
start: Vector = None,
start_handle: Vector = None,
end_handle: Vector = None,
end: Vector = None)
Curve.BezierSegment(cls,
resolution: Integer = None,
start: Vector = None,
start_handle: Vector = None,
end_handle: Vector = None,
end: Vector = None,
mode: Literal['POSITION', 'OFFSET'] = 'POSITION')
nd
nd.bezier_segment(cls,
resolution: Integer = None,
start: Vector = None,
start_handle: Vector = None,
end_handle: Vector = None,
end: Vector = None,
mode: Literal['POSITION', 'OFFSET'] = 'POSITION')
Camera Data
bl_idname : ShaderNodeCameraData
snd
Camera Info
bl_idname : GeometryNodeCameraInfo
class Object
nd
nd.camera_info(cls, camera: Object = None)
Capture Attribute
bl_idname : GeometryNodeCaptureAttribute
class Domain
Domain.capture_attribute(attribute=None, **attributes)
Domain.capture(attribute=None, **attributes)
Checker Texture
bl_idname : ShaderNodeTexChecker
class Color
Color.Checker(cls,
vector: Vector = None,
color1: Color = None,
color2: Color = None,
scale: Float = None)
class Texture
Texture.Checker(cls,
vector: Vector = None,
color1: Color = None,
color2: Color = None,
scale: Float = None)
nd
nd.checker_texture(cls,
vector: Vector = None,
color1: Color = None,
color2: Color = None,
scale: Float = None)
snd
nd.checker_texture(cls,
vector: Vector = None,
color1: Color = None,
color2: Color = None,
scale: Float = None)
Clamp
bl_idname : ShaderNodeClamp
class Float
Float.clamp(self,
min: Float = None,
max: Float = None,
clamp_type: Literal['MINMAX', 'RANGE'] = 'MINMAX')
Float.clamp_minmax(self, min: Float = None, max: Float = None)
Float.clamp_range(self, min: Float = None, max: Float = None)
nd
nd.clamp(cls,
value: Float = None,
min: Float = None,
max: Float = None,
clamp_type: Literal['MINMAX', 'RANGE'] = 'MINMAX')
snd
nd.clamp(cls,
value: Float = None,
min: Float = None,
max: Float = None,
clamp_type: Literal['MINMAX', 'RANGE'] = 'MINMAX')
Clip Grid
bl_idname : GeometryNodeGridClip
class Float
Float.clip_grid(self,
min_x: Integer = None,
min_y: Integer = None,
min_z: Integer = None,
max_x: Integer = None,
max_y: Integer = None,
max_z: Integer = None)
class Integer
Integer.clip_grid(self,
min_x: Integer = None,
min_y: Integer = None,
min_z: Integer = None,
max_x: Integer = None,
max_y: Integer = None,
max_z: Integer = None)
class Boolean
Boolean.clip_grid(self,
min_x: Integer = None,
min_y: Integer = None,
min_z: Integer = None,
max_x: Integer = None,
max_y: Integer = None,
max_z: Integer = None)
class Vector
Vector.clip_grid(self,
min_x: Integer = None,
min_y: Integer = None,
min_z: Integer = None,
max_x: Integer = None,
max_y: Integer = None,
max_z: Integer = None)
nd
nd.clip_grid(cls,
grid: Float = None,
min_x: Integer = None,
min_y: Integer = None,
min_z: Integer = None,
max_x: Integer = None,
max_y: Integer = None,
max_z: Integer = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT')
bl_idname : NodeClosureInput
nd
snd
Closure Output
bl_idname : NodeClosureOutput
nd
nd.closure_output(cls, active_input_index = 0, active_output_index = 0, define_signature = False)
snd
nd.closure_output(cls, active_input_index = 0, active_output_index = 0, define_signature = False)
Collection
bl_idname : GeometryNodeInputCollection
nd
nd.collection(cls, collection = None)
Collection Info
bl_idname : GeometryNodeCollectionInfo
class Collection
Collection.info(self,
separate_children: Boolean = None,
reset_children: Boolean = None,
transform_space: Literal['ORIGINAL', 'RELATIVE'] = 'ORIGINAL')
nd
nd.collection_info(cls,
collection: Collection = None,
separate_children: Boolean = None,
reset_children: Boolean = None,
transform_space: Literal['ORIGINAL', 'RELATIVE'] = 'ORIGINAL')
Color
bl_idname : ShaderNodeRGB
snd
Color Attribute
bl_idname : ShaderNodeVertexColor
class Color
Color.ColorAttribute(cls, layer_name = '')
snd
nd.color_attribute(cls, layer_name = '')
Color Ramp
bl_idname : ShaderNodeValToRGB
nd
nd.color_ramp(fac=None, stops=None, interpolation='LINEAR')
snd
nd.color_ramp(fac=None, stops=None, interpolation='LINEAR')
Combine Bundle
bl_idname : NodeCombineBundle
class Bundle
Bundle.Combine(cls, named_sockets: dict = {}, define_signature = False, **sockets)
nd
nd.combine_bundle(cls, named_sockets: dict = {}, define_signature = False, **sockets)
snd
nd.combine_bundle(cls, named_sockets: dict = {}, define_signature = False, **sockets)
Combine Color
bl_idname : ShaderNodeCombineColor
class Float
Float.combine_color_RGB(self, green: Float = None, blue: Float = None)
Float.combine_color_HSV(self, saturation: Float = None, value: Float = None)
Float.combine_color_HSL(self, saturation: Float = None, lightness: Float = None)
Float.combine_color(self,
green: Float = None,
blue: Float = None,
mode: Literal['RGB', 'HSV', 'HSL'] = 'RGB')
snd
nd.combine_color(cls,
red: Float = None,
green: Float = None,
blue: Float = None,
mode: Literal['RGB', 'HSV', 'HSL'] = 'RGB')
Combine Matrix
bl_idname : FunctionNodeCombineMatrix
class Matrix
Matrix.Combine(cls,
column_1_row_1: Float = None,
column_1_row_2: Float = None,
column_1_row_3: Float = None,
column_1_row_4: Float = None,
column_2_row_1: Float = None,
column_2_row_2: Float = None,
column_2_row_3: Float = None,
column_2_row_4: Float = None,
column_3_row_1: Float = None,
column_3_row_2: Float = None,
column_3_row_3: Float = None,
column_3_row_4: Float = None,
column_4_row_1: Float = None,
column_4_row_2: Float = None,
column_4_row_3: Float = None,
column_4_row_4: Float = None)
nd
nd.combine_matrix(cls,
column_1_row_1: Float = None,
column_1_row_2: Float = None,
column_1_row_3: Float = None,
column_1_row_4: Float = None,
column_2_row_1: Float = None,
column_2_row_2: Float = None,
column_2_row_3: Float = None,
column_2_row_4: Float = None,
column_3_row_1: Float = None,
column_3_row_2: Float = None,
column_3_row_3: Float = None,
column_3_row_4: Float = None,
column_4_row_1: Float = None,
column_4_row_2: Float = None,
column_4_row_3: Float = None,
column_4_row_4: Float = None)
bl_idname : FunctionNodeCombineTransform
class Matrix
Matrix.CombineTransform(cls,
translation: Vector = None,
rotation: Rotation = None,
scale: Vector = None)
nd
nd.combine_transform(cls,
translation: Vector = None,
rotation: Rotation = None,
scale: Vector = None)
Combine XYZ
bl_idname : ShaderNodeCombineXYZ
class Vector
Vector.CombineXYZ(cls, x: Float = None, y: Float = None, z: Float = None)
nd
nd.combine_xyz(cls, x: Float = None, y: Float = None, z: Float = None)
snd
nd.combine_xyz(cls, x: Float = None, y: Float = None, z: Float = None)
Compare
bl_idname : FunctionNodeCompare
class Float
Float.less_than(self, b: Float = None)
Float.less_equal(self, b: Float = None)
Float.greater_than(self, b: Float = None)
Float.greater_equal(self, b: Float = None)
Float.equal(self, b: Float = None, epsilon: Float = None)
Float.not_equal(self, b: Float = None, epsilon: Float = None)
class Integer
Integer.less_than(self, b: Integer = None)
Integer.less_equal(self, b: Integer = None)
Integer.greater_than(self, b: Integer = None)
Integer.greater_equal(self, b: Integer = None)
Integer.equal(self, b: Integer = None)
Integer.not_equal(self, b: Integer = None)
class Vector
Vector.less_than(self, b: Vector = None)
Vector.less_equal(self, b: Vector = None)
Vector.greater_than(self, b: Vector = None)
Vector.greater_equal(self, b: Vector = None)
Vector.equal(self, b: Vector = None, epsilon: Float = None)
Vector.not_equal(self, b: Vector = None, epsilon: Float = None)
class String
String.equal(self, b: String = None)
String.not_equal(self, b: String = None)
class Color
Color.equal(self, b: Color = None, epsilon: Float = None)
Color.not_equal(self, b: Color = None, epsilon: Float = None)
Color.brighter(self, b: Color = None)
Color.darker(self, b: Color = None)
nd
nd.compare(cls,
a: Float = None,
b: Float = None,
a_1: Integer = None,
b_1: Integer = None,
a_2: Vector = None,
b_2: Vector = None,
a_3: Color = None,
b_3: Color = None,
a_4: String = None,
b_4: String = None,
c: Float = None,
angle: Float = None,
epsilon: Float = None,
data_type: Literal['FLOAT', 'INT', 'VECTOR', 'RGBA', 'STRING'] = 'FLOAT',
mode: Literal['ELEMENT', 'LENGTH', 'AVERAGE', 'DOT_PRODUCT', 'DIRECTION'] = 'ELEMENT',
operation: Literal['LESS_THAN', 'LESS_EQUAL', 'GREATER_THAN', 'GREATER_EQUAL', 'EQUAL', 'NOT_EQUAL'] = 'GREATER_THAN')
Cone
bl_idname : GeometryNodeMeshCone
class Mesh
Mesh.Cone(cls,
vertices: Integer = None,
side_segments: Integer = None,
fill_segments: Integer = None,
radius_top: Float = None,
radius_bottom: Float = None,
depth: Float = None,
fill_type: Literal['NONE', 'NGON', 'TRIANGLE_FAN'] = 'NGON')
nd
nd.cone(cls,
vertices: Integer = None,
side_segments: Integer = None,
fill_segments: Integer = None,
radius_top: Float = None,
radius_bottom: Float = None,
depth: Float = None,
fill_type: Literal['NONE', 'NGON', 'TRIANGLE_FAN'] = 'NGON')
Convex Hull
bl_idname : GeometryNodeConvexHull
class Geometry
Geometry.convex_hull(self)
nd
nd.convex_hull(cls, geometry: Geometry = None)
Corners of Edge
bl_idname : GeometryNodeCornersOfEdge
class Mesh
Mesh.corners_of_edge(cls,
edge_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
class Edge
Mesh.edges.corners(cls,
edge_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
Mesh.edges.corner_index(cls,
edge_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
Mesh.edges.corners_total(cls,
edge_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
nd
nd.corners_of_edge(cls,
edge_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
Corners of Face
bl_idname : GeometryNodeCornersOfFace
class Mesh
Mesh.corners_of_face(cls,
face_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
class Face
Mesh.faces.corners(cls,
face_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
Mesh.faces.corner_index(cls,
face_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
Mesh.faces.corners_total(cls,
face_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
nd
nd.corners_of_face(cls,
face_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
Corners of Vertex
bl_idname : GeometryNodeCornersOfVertex
class Mesh
Mesh.corners_of_vertex(cls,
vertex_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
class Vertex
Mesh.points.corners(cls,
vertex_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
Mesh.points.corner_index(cls,
vertex_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
Mesh.points.corners_total(cls,
vertex_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
nd
nd.corners_of_vertex(cls,
vertex_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
Cube
bl_idname : GeometryNodeMeshCube
class Mesh
Mesh.Cube(cls,
size: Vector = None,
vertices_x: Integer = None,
vertices_y: Integer = None,
vertices_z: Integer = None)
nd
nd.cube(cls,
size: Vector = None,
vertices_x: Integer = None,
vertices_y: Integer = None,
vertices_z: Integer = None)
Cube Grid Topology
bl_idname : GeometryNodeCubeGridTopology
class Boolean
Boolean.CubeGridTopology(cls,
bounds_min: Vector = None,
bounds_max: Vector = None,
resolution_x: Integer = None,
resolution_y: Integer = None,
resolution_z: Integer = None,
min_x: Integer = None,
min_y: Integer = None,
min_z: Integer = None)
nd
nd.cube_grid_topology(cls,
bounds_min: Vector = None,
bounds_max: Vector = None,
resolution_x: Integer = None,
resolution_y: Integer = None,
resolution_z: Integer = None,
min_x: Integer = None,
min_y: Integer = None,
min_z: Integer = None)
Curve Circle
bl_idname : GeometryNodeCurvePrimitiveCircle
class Curve
Curve.CirclePoints(cls,
resolution: Integer = None,
point_1: Vector = None,
point_2: Vector = None,
point_3: Vector = None)
Curve.CircleRadius(cls, resolution: Integer = None, radius: Float = None)
Curve.Circle(cls,
resolution: Integer = None,
radius: Float = None,
mode: Literal['POINTS', 'RADIUS'] = 'RADIUS')
nd
nd.curve_circle(cls,
resolution: Integer = None,
point_1: Vector = None,
point_2: Vector = None,
point_3: Vector = None,
radius: Float = None,
mode: Literal['POINTS', 'RADIUS'] = 'RADIUS')
Curve Handle Positions
bl_idname : GeometryNodeInputCurveHandlePositions
class Curve
Curve.handle_positions(cls, relative: Boolean = None)
prop = Curve.left_handle_position
prop = Curve.right_handle_position
prop = Curve.left_handle_offset
prop = Curve.right_handle_offset
nd
nd.curve_handle_positions(cls, relative: Boolean = None)
Curve Length
bl_idname : GeometryNodeCurveLength
class Curve
nd
nd.curve_length(cls, curve: Curve = None)
Curve Line
bl_idname : GeometryNodeCurvePrimitiveLine
class Curve
Curve.LinePoints(cls, start: Vector = None, end: Vector = None)
Curve.LineDirection(cls, start: Vector = None, direction: Vector = None, length: Float = None)
Curve.Line(cls,
start: Vector = None,
end: Vector = None,
mode: Literal['POINTS', 'DIRECTION'] = 'POINTS')
nd
nd.curve_line(cls,
start: Vector = None,
end: Vector = None,
direction: Vector = None,
length: Float = None,
mode: Literal['POINTS', 'DIRECTION'] = 'POINTS')
Curve Tangent
bl_idname : GeometryNodeInputTangent
class Curve
nd
Curve Tilt
bl_idname : GeometryNodeInputCurveTilt
class Curve
class Spline
prop = Spline.splines.tilt
nd
Curve of Point
bl_idname : GeometryNodeCurveOfPoint
class Curve
Curve.curve_of_point(cls, point_index: Integer = None)
class SplinePoint
Spline.points.curve_of_point(cls, point_index: Integer = None)
Spline.points.curve_index(cls, point_index: Integer = None)
Spline.points.index_in_curve(cls, point_index: Integer = None)
nd
nd.curve_of_point(cls, point_index: Integer = None)
Curve to Mesh
bl_idname : GeometryNodeCurveToMesh
class Curve
Curve.to_mesh(self,
profile_curve: Curve = None,
scale: Float = None,
fill_caps: Boolean = None)
nd
nd.curve_to_mesh(cls,
curve: Curve = None,
profile_curve: Curve = None,
scale: Float = None,
fill_caps: Boolean = None)
Curve to Points
bl_idname : GeometryNodeCurveToPoints
class Curve
Curve.to_points_evaluated(self)
Curve.to_points_count(self, count: Integer = None)
Curve.to_points_length(self, length: Float = None)
Curve.to_points(self,
count: Integer = None,
mode: Literal['EVALUATED', 'COUNT', 'LENGTH'] = 'COUNT')
class SplinePoint
Spline.points.to_points_evaluated(self)
Spline.points.to_points_count(self, count: Integer = None)
Spline.points.to_points_length(self, length: Float = None)
Spline.points.to_points(self,
count: Integer = None,
mode: Literal['EVALUATED', 'COUNT', 'LENGTH'] = 'COUNT')
nd
nd.curve_to_points(cls,
curve: Curve = None,
count: Integer = None,
length: Float = None,
mode: Literal['EVALUATED', 'COUNT', 'LENGTH'] = 'COUNT')
Curves Info
bl_idname : ShaderNodeHairInfo
snd
Curves to Grease Pencil
bl_idname : GeometryNodeCurvesToGreasePencil
class Curve
Curve.to_grease_pencil(self, instances_as_layers: Boolean = None)
nd
nd.curves_to_grease_pencil(cls,
curves: Curve = None,
selection: Boolean = None,
instances_as_layers: Boolean = None)
Cylinder
bl_idname : GeometryNodeMeshCylinder
class Mesh
Mesh.Cylinder(cls,
vertices: Integer = None,
side_segments: Integer = None,
fill_segments: Integer = None,
radius: Float = None,
depth: Float = None,
fill_type: Literal['NONE', 'NGON', 'TRIANGLE_FAN'] = 'NGON')
nd
nd.cylinder(cls,
vertices: Integer = None,
side_segments: Integer = None,
fill_segments: Integer = None,
radius: Float = None,
depth: Float = None,
fill_type: Literal['NONE', 'NGON', 'TRIANGLE_FAN'] = 'NGON')
bl_idname : GeometryNodeDeformCurvesOnSurface
class Curve
Curve.deform_on_surface(self)
nd
nd.deform_curves_on_surface(cls, curves: Curve = None)
Delete Geometry
bl_idname : GeometryNodeDeleteGeometry
class Point
Mesh.points.delete_geometry_all(self)
Mesh.points.delete_geometry_edge_face(self)
Mesh.points.delete_geometry_only_face(self)
Mesh.points.delete_geometry(self, mode: Literal['ALL', 'EDGE_FACE', 'ONLY_FACE'] = 'ALL')
Mesh.points.delete_all(self)
Mesh.points.delete_edge_face(self)
Mesh.points.delete_only_face(self)
Mesh.points.delete(self, mode: Literal['ALL', 'EDGE_FACE', 'ONLY_FACE'] = 'ALL')
class Edge
Mesh.edges.delete_geometry_all(self)
Mesh.edges.delete_geometry_edge_face(self)
Mesh.edges.delete_geometry_only_face(self)
Mesh.edges.delete_geometry(self, mode: Literal['ALL', 'EDGE_FACE', 'ONLY_FACE'] = 'ALL')
Mesh.edges.delete_all(self)
Mesh.edges.delete_edge_face(self)
Mesh.edges.delete_only_face(self)
Mesh.edges.delete(self, mode: Literal['ALL', 'EDGE_FACE', 'ONLY_FACE'] = 'ALL')
class Face
Mesh.faces.delete_geometry_all(self)
Mesh.faces.delete_geometry_edge_face(self)
Mesh.faces.delete_geometry_only_face(self)
Mesh.faces.delete_geometry(self, mode: Literal['ALL', 'EDGE_FACE', 'ONLY_FACE'] = 'ALL')
Mesh.faces.delete_all(self)
Mesh.faces.delete_edge_face(self)
Mesh.faces.delete_only_face(self)
Mesh.faces.delete(self, mode: Literal['ALL', 'EDGE_FACE', 'ONLY_FACE'] = 'ALL')
class Spline
Spline.splines.delete_geometry_all(self)
Spline.splines.delete_geometry_edge_face(self)
Spline.splines.delete_geometry_only_face(self)
Spline.splines.delete_geometry(self, mode: Literal['ALL', 'EDGE_FACE', 'ONLY_FACE'] = 'ALL')
Spline.splines.delete_all(self)
Spline.splines.delete_edge_face(self)
Spline.splines.delete_only_face(self)
Spline.splines.delete(self, mode: Literal['ALL', 'EDGE_FACE', 'ONLY_FACE'] = 'ALL')
class Instance
Instances.insts.delete_geometry_all(self)
Instances.insts.delete_geometry_edge_face(self)
Instances.insts.delete_geometry_only_face(self)
Instances.insts.delete_geometry(self, mode: Literal['ALL', 'EDGE_FACE', 'ONLY_FACE'] = 'ALL')
Instances.insts.delete_all(self)
Instances.insts.delete_edge_face(self)
Instances.insts.delete_only_face(self)
Instances.insts.delete(self, mode: Literal['ALL', 'EDGE_FACE', 'ONLY_FACE'] = 'ALL')
class Layer
GreasePencil.layers.delete_geometry_all(self)
GreasePencil.layers.delete_geometry_edge_face(self)
GreasePencil.layers.delete_geometry_only_face(self)
GreasePencil.layers.delete_geometry(self, mode: Literal['ALL', 'EDGE_FACE', 'ONLY_FACE'] = 'ALL')
GreasePencil.layers.delete_all(self)
GreasePencil.layers.delete_edge_face(self)
GreasePencil.layers.delete_only_face(self)
GreasePencil.layers.delete(self, mode: Literal['ALL', 'EDGE_FACE', 'ONLY_FACE'] = 'ALL')
nd
nd.delete_geometry(cls,
geometry: Geometry = None,
selection: Boolean = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT',
mode: Literal['ALL', 'EDGE_FACE', 'ONLY_FACE'] = 'ALL')
Dial Gizmo
bl_idname : GeometryNodeGizmoDial
class Float
Float.dial_gizmo(self,
*value: Float,
position: Vector = None,
up: Vector = None,
screen_space: Boolean = None,
radius: Float = None,
color_id: Literal['PRIMARY', 'SECONDARY', 'X', 'Y', 'Z'] = 'PRIMARY')
nd
nd.dial_gizmo(cls,
*value: Float,
position: Vector = None,
up: Vector = None,
screen_space: Boolean = None,
radius: Float = None,
color_id: Literal['PRIMARY', 'SECONDARY', 'X', 'Y', 'Z'] = 'PRIMARY')
Diffuse BSDF
bl_idname : ShaderNodeBsdfDiffuse
class Shader
Shader.Diffuse(cls, color: Color = None, roughness: Float = None, normal: Vector = None)
snd
nd.diffuse_bsdf(cls,
color: Color = None,
roughness: Float = None,
normal: Vector = None,
weight: Float = None)
Displacement
bl_idname : ShaderNodeDisplacement
class Float
Float.displacement(self,
midlevel: Float = None,
scale: Float = None,
normal: Vector = None,
space: Literal['OBJECT', 'WORLD'] = 'OBJECT')
snd
nd.displacement(cls,
height: Float = None,
midlevel: Float = None,
scale: Float = None,
normal: Vector = None,
space: Literal['OBJECT', 'WORLD'] = 'OBJECT')
Distribute Points in Grid
bl_idname : GeometryNodeDistributePointsInGrid
class Float
Float.distribute_points_in_grid_density_random(self, density: Float = None, seed: Integer = None)
Float.distribute_points_in_grid_density_grid(self, spacing: Vector = None, threshold: Float = None)
Float.distribute_points_in_grid(self,
density: Float = None,
seed: Integer = None,
mode: Literal['DENSITY_RANDOM', 'DENSITY_GRID'] = 'DENSITY_RANDOM')
nd
nd.distribute_points_in_grid(cls,
grid: Float = None,
density: Float = None,
seed: Integer = None,
spacing: Vector = None,
threshold: Float = None,
mode: Literal['DENSITY_RANDOM', 'DENSITY_GRID'] = 'DENSITY_RANDOM')
Distribute Points in Volume
bl_idname : GeometryNodeDistributePointsInVolume
class Volume
Volume.distribute_points(self,
mode: Literal['Random', 'Grid'] = None,
density: Float = None,
seed: Integer = None,
spacing: Vector = None,
threshold: Float = None)
nd
nd.distribute_points_in_volume(cls,
volume: Volume = None,
mode: Literal['Random', 'Grid'] = None,
density: Float = None,
seed: Integer = None,
spacing: Vector = None,
threshold: Float = None)
Distribute Points on Faces
bl_idname : GeometryNodeDistributePointsOnFaces
class Mesh
Mesh.distribute_points_on_faces(self,
density: Float = None,
seed: Integer = None,
distribute_method: Literal['RANDOM', 'POISSON'] = 'RANDOM')
Mesh.distribute_points_on_faces_random(self, density: Float = None, seed: Integer = None)
Mesh.distribute_points_on_faces_poisson(self,
distance_min: Float = None,
density_max: Float = None,
density_factor: Float = None,
seed: Integer = None)
class Face
Mesh.faces.distribute_points(self,
density: Float = None,
seed: Integer = None,
distribute_method: Literal['RANDOM', 'POISSON'] = 'RANDOM')
Mesh.faces.distribute_points_random(self, density: Float = None, seed: Integer = None)
Mesh.faces.distribute_points_poisson(self,
distance_min: Float = None,
density_max: Float = None,
density_factor: Float = None,
seed: Integer = None)
nd
nd.distribute_points_on_faces(cls,
mesh: Mesh = None,
selection: Boolean = None,
distance_min: Float = None,
density_max: Float = None,
density: Float = None,
density_factor: Float = None,
seed: Integer = None,
distribute_method: Literal['RANDOM', 'POISSON'] = 'RANDOM')
Domain Size
bl_idname : GeometryNodeAttributeDomainSize
class Mesh
class Curve
class Cloud
class Instances
Instances.domain_size(self)
class GreasePencil
GreasePencil.domain_size(self)
nd
nd.domain_size(cls,
geometry: Geometry = None,
component: Literal['MESH', 'POINTCLOUD', 'CURVE', 'INSTANCES', 'GREASEPENCIL'] = 'MESH')
Dual Mesh
bl_idname : GeometryNodeDualMesh
class Mesh
Mesh.dual(self, keep_boundaries: Boolean = None)
nd
nd.dual_mesh(cls, mesh: Mesh = None, keep_boundaries: Boolean = None)
Duplicate Elements
bl_idname : GeometryNodeDuplicateElements
class Point
Mesh.points.duplicate(self, amount: Integer = None)
class Edge
Mesh.edges.duplicate(self, amount: Integer = None)
class Face
Mesh.faces.duplicate(self, amount: Integer = None)
class Spline
Spline.splines.duplicate(self, amount: Integer = None)
class Layer
GreasePencil.layers.duplicate(self, amount: Integer = None)
class Instance
Instances.insts.duplicate(self, amount: Integer = None)
nd
nd.duplicate_elements(cls,
geometry: Geometry = None,
selection: Boolean = None,
amount: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'SPLINE', 'LAYER', 'INSTANCE'] = 'POINT')
Edge Angle
bl_idname : GeometryNodeInputMeshEdgeAngle
class Mesh
prop = Mesh.unsigned_edge_angle
prop = Mesh.signed_edge_angle
class Edge
prop = Mesh.edges.edge_angle
prop = Mesh.edges.unsigned_angle
prop = Mesh.edges.signed_angle
nd
Edge Neighbors
bl_idname : GeometryNodeInputMeshEdgeNeighbors
class Mesh
prop = Mesh.edge_neighbors
class Edge
prop = Mesh.edges.face_count
nd
Edge Paths to Curves
bl_idname : GeometryNodeEdgePathsToCurves
class Mesh
Mesh.edge_paths_to_curves(self, start_vertices: Boolean = None, next_vertex_index: Integer = None)
class Edge
Mesh.edges.paths_to_curves(self, start_vertices: Boolean = None, next_vertex_index: Integer = None)
nd
nd.edge_paths_to_curves(cls,
mesh: Mesh = None,
start_vertices: Boolean = None,
next_vertex_index: Integer = None)
Edge Paths to Selection
bl_idname : GeometryNodeEdgePathsToSelection
class Mesh
Mesh.edge_paths_to_selection(cls, start_vertices: Boolean = None, next_vertex_index: Integer = None)
class Edge
Mesh.edges.paths_to_selection(cls, start_vertices: Boolean = None, next_vertex_index: Integer = None)
nd
nd.edge_paths_to_selection(cls, start_vertices: Boolean = None, next_vertex_index: Integer = None)
Edge Vertices
bl_idname : GeometryNodeInputMeshEdgeVertices
class Mesh
prop = Mesh.edge_vertices
class Edge
prop = Mesh.edges.edge_vertices
prop = Mesh.edges.vertex_index_1
prop = Mesh.edges.vertex_index_2
prop = Mesh.edges.position_1
prop = Mesh.edges.position_2
nd
Edges of Corner
bl_idname : GeometryNodeEdgesOfCorner
class Mesh
Mesh.edges_of_corner(cls, corner_index: Integer = None)
class Corner
Mesh.corners.edges(cls, corner_index: Integer = None)
Mesh.corners.next_edge_index(cls, corner_index: Integer = None)
Mesh.corners.previous_edge_index(cls, corner_index: Integer = None)
nd
nd.edges_of_corner(cls, corner_index: Integer = None)
Edges of Vertex
bl_idname : GeometryNodeEdgesOfVertex
class Mesh
Mesh.edges_of_vertex(cls,
vertex_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
class Vertex
Mesh.points.edges(cls,
vertex_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
Mesh.points.edge_index(cls,
vertex_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
Mesh.points.edges_total(cls,
vertex_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
nd
nd.edges_of_vertex(cls,
vertex_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
Edges to Face Groups
bl_idname : GeometryNodeEdgesToFaceGroups
class Mesh
Mesh.edges_to_face_groups(cls, boundary_edges: Boolean = None)
class Edge
Mesh.edges.to_face_groups(cls, boundary_edges: Boolean = None)
nd
nd.edges_to_face_groups(cls, boundary_edges: Boolean = None)
Emission
bl_idname : ShaderNodeEmission
class Shader
Shader.Emission(cls, color: Color = None, strength: Float = None)
snd
nd.emission(cls, color: Color = None, strength: Float = None, weight: Float = None)
Enable Output
bl_idname : NodeEnableOutput
class Float
Float.enable_output(self, enable: Boolean = None)
class Integer
Integer.enable_output(self, enable: Boolean = None)
class Boolean
Boolean.enable_output(self, enable: Boolean = None)
class Vector
Vector.enable_output(self, enable: Boolean = None)
class Color
Color.enable_output(self, enable: Boolean = None)
class Rotation
Rotation.enable_output(self, enable: Boolean = None)
class Matrix
Matrix.enable_output(self, enable: Boolean = None)
class String
String.enable_output(self, enable: Boolean = None)
Menu.enable_output(self, enable: Boolean = None)
class Object
Object.enable_output(self, enable: Boolean = None)
class Image
Image.enable_output(self, enable: Boolean = None)
class Geometry
Geometry.enable_output(self, enable: Boolean = None)
class Collection
Collection.enable_output(self, enable: Boolean = None)
class Material
Material.enable_output(self, enable: Boolean = None)
class Bundle
Bundle.enable_output(self, enable: Boolean = None)
class Closure
Closure.enable_output(self, enable: Boolean = None)
class Font
Font.enable_output(self, enable: Boolean = None)
nd
nd.enable_output(cls,
enable: Boolean = None,
value: Float = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT')
Endpoint Selection
bl_idname : GeometryNodeCurveEndpointSelection
class Curve
Curve.endpoint_selection(cls, start_size: Integer = None, end_size: Integer = None)
nd
nd.endpoint_selection(cls, start_size: Integer = None, end_size: Integer = None)
Environment Texture
bl_idname : ShaderNodeTexEnvironment
class Vector
Vector.environment_texture(self,
image = None,
interpolation: Literal['Linear', 'Closest', 'Cubic', 'Smart'] = 'Linear',
projection: Literal['EQUIRECTANGULAR', 'MIRROR_BALL'] = 'EQUIRECTANGULAR')
snd
nd.environment_texture(cls,
vector: Vector = None,
image = None,
interpolation: Literal['Linear', 'Closest', 'Cubic', 'Smart'] = 'Linear',
projection: Literal['EQUIRECTANGULAR', 'MIRROR_BALL'] = 'EQUIRECTANGULAR')
Euler to Rotation
bl_idname : FunctionNodeEulerToRotation
class Rotation
Rotation.FromEuler(cls, euler: Vector = None)
class Vector
nd
nd.euler_to_rotation(cls, euler: Vector = None)
Evaluate Closure
bl_idname : NodeEvaluateClosure
nd
nd.evaluate_closure(cls,
closure: Closure = None,
active_input_index = 0,
active_output_index = 0,
define_signature = False)
snd
nd.evaluate_closure(cls,
closure: Closure = None,
active_input_index = 0,
active_output_index = 0,
define_signature = False)
Evaluate at Index
bl_idname : GeometryNodeFieldAtIndex
class Point
Mesh.points.evaluate_at_index(cls,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
index: Integer = None)
class Edge
Mesh.edges.evaluate_at_index(cls,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
index: Integer = None)
class Face
Mesh.faces.evaluate_at_index(cls,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
index: Integer = None)
class Corner
Mesh.corners.evaluate_at_index(cls,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
index: Integer = None)
class Spline
Spline.splines.evaluate_at_index(cls,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
index: Integer = None)
class Instance
Instances.insts.evaluate_at_index(cls,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
index: Integer = None)
class Layer
GreasePencil.layers.evaluate_at_index(cls,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
index: Integer = None)
nd
nd.evaluate_at_index(cls,
value: Float = None,
index: Integer = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT',
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
Evaluate on Domain
bl_idname : GeometryNodeFieldOnDomain
class Point
Mesh.points.evaluate_on_domain(cls,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None)
class Edge
Mesh.edges.evaluate_on_domain(cls,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None)
class Face
Mesh.faces.evaluate_on_domain(cls,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None)
class Corner
Mesh.corners.evaluate_on_domain(cls,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None)
class Spline
Spline.splines.evaluate_on_domain(cls,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None)
class Instance
Instances.insts.evaluate_on_domain(cls,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None)
class Layer
GreasePencil.layers.evaluate_on_domain(cls,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None)
nd
nd.evaluate_on_domain(cls,
value: Float = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT',
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
Extrude Mesh
bl_idname : GeometryNodeExtrudeMesh
class Mesh
Mesh.extrude_vertices(self, offset: Vector = None, offset_scale: Float = None)
Mesh.extrude_edges(self, offset: Vector = None, offset_scale: Float = None)
Mesh.extrude_faces(self,
offset: Vector = None,
offset_scale: Float = None,
individual: Boolean = None)
Mesh.extrude(self,
offset: Vector = None,
offset_scale: Float = None,
individual: Boolean = None,
mode: Literal['VERTICES', 'EDGES', 'FACES'] = 'FACES')
class Vertex
Mesh.points.extrude(self, offset: Vector = None, offset_scale: Float = None)
class Edge
Mesh.edges.extrude(self, offset: Vector = None, offset_scale: Float = None)
class Face
Mesh.faces.extrude(self,
offset: Vector = None,
offset_scale: Float = None,
individual: Boolean = None)
nd
nd.extrude_mesh(cls,
mesh: Mesh = None,
selection: Boolean = None,
offset: Vector = None,
offset_scale: Float = None,
individual: Boolean = None,
mode: Literal['VERTICES', 'EDGES', 'FACES'] = 'FACES')
Face Area
bl_idname : GeometryNodeInputMeshFaceArea
class Mesh
class Face
nd
Face Group Boundaries
bl_idname : GeometryNodeMeshFaceSetBoundaries
class Mesh
Mesh.face_group_boundaries(cls, face_group_id: Integer = None)
nd
nd.face_group_boundaries(cls, face_group_id: Integer = None)
Face Neighbors
bl_idname : GeometryNodeInputMeshFaceNeighbors
class Mesh
prop = Mesh.face_neighbors
class Face
prop = Mesh.faces.neighbors
prop = Mesh.faces.neighbors_vertex_count
prop = Mesh.faces.neighbors_face_count
nd
Face Set
bl_idname : GeometryNodeToolFaceSet
nd
Face of Corner
bl_idname : GeometryNodeFaceOfCorner
class Mesh
Mesh.face_of_corner(cls, corner_index: Integer = None)
class Corner
Mesh.corners.face(cls, corner_index: Integer = None)
Mesh.corners.face_index(cls, corner_index: Integer = None)
Mesh.corners.index_in_face(cls, corner_index: Integer = None)
nd
nd.face_of_corner(cls, corner_index: Integer = None)
Field Average
bl_idname : GeometryNodeFieldAverage
class Point
Mesh.points.field_average(cls,
value: Float | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Edge
Mesh.edges.field_average(cls,
value: Float | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Face
Mesh.faces.field_average(cls,
value: Float | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Corner
Mesh.corners.field_average(cls,
value: Float | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Spline
Spline.splines.field_average(cls,
value: Float | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Instance
Instances.insts.field_average(cls,
value: Float | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Layer
GreasePencil.layers.field_average(cls,
value: Float | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
nd
nd.field_average(cls,
value: Float = None,
group_id: Integer = None,
data_type: Literal['FLOAT', 'FLOAT_VECTOR'] = 'FLOAT',
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
Field Min & Max
bl_idname : GeometryNodeFieldMinAndMax
class Point
Mesh.points.field_min_max(cls,
value: Float | Integer | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Edge
Mesh.edges.field_min_max(cls,
value: Float | Integer | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Face
Mesh.faces.field_min_max(cls,
value: Float | Integer | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Corner
Mesh.corners.field_min_max(cls,
value: Float | Integer | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Spline
Spline.splines.field_min_max(cls,
value: Float | Integer | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Instance
Instances.insts.field_min_max(cls,
value: Float | Integer | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Layer
GreasePencil.layers.field_min_max(cls,
value: Float | Integer | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
nd
nd.field_min_max(cls,
value: Float = None,
group_id: Integer = None,
data_type: Literal['FLOAT', 'INT', 'FLOAT_VECTOR'] = 'FLOAT',
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
Field Variance
bl_idname : GeometryNodeFieldVariance
class Point
Mesh.points.field_variance(cls,
value: Float | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Edge
Mesh.edges.field_variance(cls,
value: Float | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Face
Mesh.faces.field_variance(cls,
value: Float | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Corner
Mesh.corners.field_variance(cls,
value: Float | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Spline
Spline.splines.field_variance(cls,
value: Float | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Instance
Instances.insts.field_variance(cls,
value: Float | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
class Layer
GreasePencil.layers.field_variance(cls,
value: Float | Vector = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
nd
nd.field_variance(cls,
value: Float = None,
group_id: Integer = None,
data_type: Literal['FLOAT', 'FLOAT_VECTOR'] = 'FLOAT',
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
Field to Grid
bl_idname : GeometryNodeFieldToGrid
class Float
Float.field_to_grid(self, named_sockets: dict = {}, **sockets)
class Integer
Integer.field_to_grid(self, named_sockets: dict = {}, **sockets)
class Boolean
Boolean.field_to_grid(self, named_sockets: dict = {}, **sockets)
class Vector
Vector.field_to_grid(self, named_sockets: dict = {}, **sockets)
nd
nd.field_to_grid(cls,
named_sockets: dict = {},
topology: Float = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT',
**sockets)
Field to List
bl_idname : GeometryNodeFieldToList
nd
nd.field_to_list(cls, named_sockets: dict = {}, count: Integer = None, **sockets)
Fill Curve
bl_idname : GeometryNodeFillCurve
class Curve
Curve.fill(self,
group_id: Integer = None,
mode: Literal['Triangles', 'N-gons'] = None,
fill_rule: Literal['Even-Odd', 'Non-Zero'] = None)
nd
nd.fill_curve(cls,
curve: Curve = None,
group_id: Integer = None,
mode: Literal['Triangles', 'N-gons'] = None,
fill_rule: Literal['Even-Odd', 'Non-Zero'] = None)
Fillet Curve
bl_idname : GeometryNodeFilletCurve
class Curve
Curve.fillet(self,
radius: Float = None,
limit_radius: Boolean = None,
mode: Literal['Bézier', 'Poly'] = None,
count: Integer = None)
nd
nd.fillet_curve(cls,
curve: Curve = None,
radius: Float = None,
limit_radius: Boolean = None,
mode: Literal['Bézier', 'Poly'] = None,
count: Integer = None)
Find in String
bl_idname : FunctionNodeFindInString
class String
String.find_in_string(self, search: String = None)
String.find(self, search: String = None)
nd
nd.find_in_string(cls, string: String = None, search: String = None)
Flip Faces
bl_idname : GeometryNodeFlipFaces
class Mesh
nd
nd.flip_faces(cls, mesh: Mesh = None, selection: Boolean = None)
Float Curve
bl_idname : ShaderNodeFloatCurve
nd
nd.float_curve(cls, value: Float = None, factor: Float = None)
snd
nd.float_curve(cls, value: Float = None, factor: Float = None)
Float to Integer
bl_idname : FunctionNodeFloatToInt
class Float
Float.to_integer(self,
rounding_mode: Literal['ROUND', 'FLOOR', 'CEILING', 'TRUNCATE'] = 'ROUND')
nd
nd.float_to_integer(cls,
float: Float = None,
rounding_mode: Literal['ROUND', 'FLOOR', 'CEILING', 'TRUNCATE'] = 'ROUND')
bl_idname : GeometryNodeForeachGeometryElementInput
class Domain
with GeoNodes("For Each Element example"):
for feel in Mesh.Cube().points.for_each(position=nd.position):
cube = Mesh.Cube(size=0.3)
cube.transform(translation=feel.position)
feel.geometry = cube
feel.generated.out()
For Each Geometry Element Output
bl_idname : GeometryNodeForeachGeometryElementOutput
class Domain
with GeoNodes("For Each Element example"):
for feel in Mesh.Cube().points.for_each(position=nd.position):
cube = Mesh.Cube(size=0.3)
cube.transform(translation=feel.position)
feel.geometry = cube
feel.generated.out()
bl_idname : FunctionNodeFormatString
class String
String.format(self, named_sockets: dict = {}, **sockets)
String.Format(cls, named_sockets: dict = {}, format: String = None, **sockets)
nd
nd.format_string(cls, named_sockets: dict = {}, format: String = None, **sockets)
Frame
bl_idname : NodeFrame
class Layout
with GeoNodes("Layout Example"):
geo = Geometry()
tr = Vector(name="Translaion")
with Layout("Group node in a Frame"):
geo += Geometry(geo).transform(translation=tr)
geo.out()
Fresnel
bl_idname : ShaderNodeFresnel
class Float
Float.fresnel(self, normal: Vector = None)
snd
nd.fresnel(cls, ior: Float = None, normal: Vector = None)
Gabor Texture
bl_idname : ShaderNodeTexGabor
class Float
Float.Gabor(cls,
vector: Vector = None,
scale: Float = None,
frequency: Float = None,
anisotropy: Float = None,
orientation: Float = None,
gabor_type: Literal['2D', '3D'] = '2D')
class Texture
Texture.Gabor(cls,
vector: Vector = None,
scale: Float = None,
frequency: Float = None,
anisotropy: Float = None,
orientation: Float = None,
gabor_type: Literal['2D', '3D'] = '2D')
nd
nd.gabor_texture(cls,
vector: Vector = None,
scale: Float = None,
frequency: Float = None,
anisotropy: Float = None,
orientation: Float = None,
orientation_1: Vector = None,
gabor_type: Literal['2D', '3D'] = '2D')
snd
nd.gabor_texture(cls,
vector: Vector = None,
scale: Float = None,
frequency: Float = None,
anisotropy: Float = None,
orientation: Float = None,
orientation_1: Vector = None,
gabor_type: Literal['2D', '3D'] = '2D')
Gamma
bl_idname : ShaderNodeGamma
class Color
Color.gamma(self, gamma: Float = None)
nd
nd.gamma(cls, color: Color = None, gamma: Float = None)
snd
nd.gamma(cls, color: Color = None, gamma: Float = None)
Geometry
bl_idname : ShaderNodeNewGeometry
snd
Geometry Proximity
bl_idname : GeometryNodeProximity
class Geometry
Geometry.proximity(self,
group_id: Integer = None,
sample_position: Vector = None,
sample_group_id: Integer = None,
target_element: Literal['POINTS', 'EDGES', 'FACES'] = 'FACES')
Geometry.proximity_points(self,
group_id: Integer = None,
sample_position: Vector = None,
sample_group_id: Integer = None)
Geometry.proximity_edges(self,
group_id: Integer = None,
sample_position: Vector = None,
sample_group_id: Integer = None)
Geometry.proximity_faces(self,
group_id: Integer = None,
sample_position: Vector = None,
sample_group_id: Integer = None)
nd
nd.geometry_proximity(cls,
geometry: Geometry = None,
group_id: Integer = None,
sample_position: Vector = None,
sample_group_id: Integer = None,
target_element: Literal['POINTS', 'EDGES', 'FACES'] = 'FACES')
Geometry to Instance
bl_idname : GeometryNodeGeometryToInstance
class Geometry
Geometry.to_instance(self, *geometry: Geometry)
class Instances
Instances.FromGeometry(cls, *geometry: Geometry)
nd
nd.geometry_to_instance(cls, *geometry: Geometry)
Get Bundle Item
bl_idname : NodeGetBundleItem
class Bundle
Bundle.get_item(self,
path: String = None,
remove: Boolean = None,
socket_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT',
structure_type: Literal['AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'] = 'AUTO')
nd
nd.get_bundle_item(cls,
bundle: Bundle = None,
path: String = None,
remove: Boolean = None,
socket_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT',
structure_type: Literal['AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'] = 'AUTO')
Get Geometry Bundle
bl_idname : GeometryNodeGetGeometryBundle
nd
nd.get_geometry_bundle(cls, geometry: Geometry = None, remove: Boolean = None)
Get List Item
bl_idname : GeometryNodeListGetItem
nd
nd.get_list_item(cls,
list: Float = None,
index: Integer = None,
socket_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT',
structure_type: Literal['AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'] = 'AUTO')
Get Named Grid
bl_idname : GeometryNodeGetNamedGrid
class Volume
Volume.get_named_grid(self,
name: String = None,
remove: Boolean = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT')
nd
nd.get_named_grid(cls,
volume: Volume = None,
name: String = None,
remove: Boolean = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT')
Glass BSDF
bl_idname : ShaderNodeBsdfGlass
class Shader
Shader.Glass(cls,
color: Color = None,
roughness: Float = None,
ior: Float = None,
normal: Vector = None,
thin_film_thickness: Float = None,
thin_film_ior: Float = None,
distribution: Literal['BECKMANN', 'GGX', 'MULTI_GGX'] = 'MULTI_GGX')
snd
nd.glass_bsdf(cls,
color: Color = None,
roughness: Float = None,
ior: Float = None,
normal: Vector = None,
weight: Float = None,
thin_film_thickness: Float = None,
thin_film_ior: Float = None,
distribution: Literal['BECKMANN', 'GGX', 'MULTI_GGX'] = 'MULTI_GGX')
Glossy BSDF
bl_idname : ShaderNodeBsdfAnisotropic
class Shader
Shader.Glossy(cls,
color: Color = None,
roughness: Float = None,
anisotropy: Float = None,
rotation: Float = None,
normal: Vector = None,
tangent: Vector = None,
distribution: Literal['BECKMANN', 'GGX', 'ASHIKHMIN_SHIRLEY', 'MULTI_GGX'] = 'MULTI_GGX')
snd
nd.glossy_bsdf(cls,
color: Color = None,
roughness: Float = None,
anisotropy: Float = None,
rotation: Float = None,
normal: Vector = None,
tangent: Vector = None,
weight: Float = None,
distribution: Literal['BECKMANN', 'GGX', 'ASHIKHMIN_SHIRLEY', 'MULTI_GGX'] = 'MULTI_GGX')
Gradient Texture
bl_idname : ShaderNodeTexGradient
class Color
Color.Gradient(cls,
vector: Vector = None,
gradient_type: Literal['LINEAR', 'QUADRATIC', 'EASING', 'DIAGONAL', 'SPHERICAL', 'QUADRATIC_SPHERE', 'RADIAL'] = 'LINEAR')
class Texture
Texture.Gradient(cls,
vector: Vector = None,
gradient_type: Literal['LINEAR', 'QUADRATIC', 'EASING', 'DIAGONAL', 'SPHERICAL', 'QUADRATIC_SPHERE', 'RADIAL'] = 'LINEAR')
nd
nd.gradient_texture(cls,
vector: Vector = None,
gradient_type: Literal['LINEAR', 'QUADRATIC', 'EASING', 'DIAGONAL', 'SPHERICAL', 'QUADRATIC_SPHERE', 'RADIAL'] = 'LINEAR')
snd
nd.gradient_texture(cls,
vector: Vector = None,
gradient_type: Literal['LINEAR', 'QUADRATIC', 'EASING', 'DIAGONAL', 'SPHERICAL', 'QUADRATIC_SPHERE', 'RADIAL'] = 'LINEAR')
Grease Pencil to Curves
bl_idname : GeometryNodeGreasePencilToCurves
class GreasePencil
GreasePencil.to_curves(self, layers_as_instances: Boolean = None)
nd
nd.grease_pencil_to_curves(cls,
grease_pencil: GreasePencil = None,
selection: Boolean = None,
layers_as_instances: Boolean = None)
Grid
bl_idname : GeometryNodeMeshGrid
class Mesh
Mesh.Grid(cls,
size_x: Float = None,
size_y: Float = None,
vertices_x: Integer = None,
vertices_y: Integer = None)
nd
nd.grid(cls,
size_x: Float = None,
size_y: Float = None,
vertices_x: Integer = None,
vertices_y: Integer = None)
Grid Curl
bl_idname : GeometryNodeGridCurl
class Vector
nd
nd.grid_curl(cls, grid: Vector = None)
Grid Dilate & Erode
bl_idname : GeometryNodeGridDilateAndErode
class Float
Float.grid_dilate_erode(self,
connectivity: Literal['Face', 'Edge', 'Vertex'] = None,
tiles: Literal['Ignore', 'Expand', 'Preserve'] = None,
steps: Integer = None)
class Integer
Integer.grid_dilate_erode(self,
connectivity: Literal['Face', 'Edge', 'Vertex'] = None,
tiles: Literal['Ignore', 'Expand', 'Preserve'] = None,
steps: Integer = None)
class Boolean
Boolean.grid_dilate_erode(self,
connectivity: Literal['Face', 'Edge', 'Vertex'] = None,
tiles: Literal['Ignore', 'Expand', 'Preserve'] = None,
steps: Integer = None)
class Vector
Vector.grid_dilate_erode(self,
connectivity: Literal['Face', 'Edge', 'Vertex'] = None,
tiles: Literal['Ignore', 'Expand', 'Preserve'] = None,
steps: Integer = None)
nd
nd.grid_dilate_erode(cls,
grid: Float = None,
connectivity: Literal['Face', 'Edge', 'Vertex'] = None,
tiles: Literal['Ignore', 'Expand', 'Preserve'] = None,
steps: Integer = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT')
Grid Divergence
bl_idname : GeometryNodeGridDivergence
class Vector
Vector.grid_divergence(self)
nd
nd.grid_divergence(cls, grid: Vector = None)
Grid Gradient
bl_idname : GeometryNodeGridGradient
class Float
Float.grid_gradient(self)
nd
nd.grid_gradient(cls, grid: Float = None)
Grid Info
bl_idname : GeometryNodeGridInfo
class Float
class Integer
class Boolean
class Vector
nd
nd.grid_info(cls,
grid: Float = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT')
Grid Laplacian
bl_idname : GeometryNodeGridLaplacian
class Float
Float.grid_laplacian(self)
nd
nd.grid_laplacian(cls, grid: Float = None)
Grid Mean
bl_idname : GeometryNodeGridMean
class Float
Float.grid_mean(self, width: Integer = None, iterations: Integer = None)
class Integer
Integer.grid_mean(self, width: Integer = None, iterations: Integer = None)
class Vector
Vector.grid_mean(self, width: Integer = None, iterations: Integer = None)
nd
nd.grid_mean(cls,
grid: Float = None,
width: Integer = None,
iterations: Integer = None,
data_type: Literal['FLOAT', 'INT', 'VECTOR'] = 'FLOAT')
bl_idname : GeometryNodeGridMedian
class Float
Float.grid_median(self, width: Integer = None, iterations: Integer = None)
class Integer
Integer.grid_median(self, width: Integer = None, iterations: Integer = None)
class Vector
Vector.grid_median(self, width: Integer = None, iterations: Integer = None)
nd
nd.grid_median(cls,
grid: Float = None,
width: Integer = None,
iterations: Integer = None,
data_type: Literal['FLOAT', 'INT', 'VECTOR'] = 'FLOAT')
Grid to Mesh
bl_idname : GeometryNodeGridToMesh
class Float
Float.grid_to_mesh(self, threshold: Float = None, adaptivity: Float = None)
nd
nd.grid_to_mesh(cls, grid: Float = None, threshold: Float = None, adaptivity: Float = None)
Grid to Points
bl_idname : GeometryNodeGridToPoints
class Float
Float.grid_to_points(self)
class Integer
Integer.grid_to_points(self)
class Boolean
Boolean.grid_to_points(self)
class Vector
Vector.grid_to_points(self)
nd
nd.grid_to_points(cls,
grid: Float = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT')
Group
bl_idname : ShaderNodeGroup
class Group
with GeoNodes("Multiply by Two", is_group=True):
a = Float(name="Value")
(a + 2).out("Double")
with GeoNodes("Calling a group example"):
v = Float(0, "Your value")
dbl = Group("Multiply by Two", value=v).double
dbl.out("Double")
# Alternaticve way
again = G().multiply_by_two(dbl)
again.out("Double Double")
bl_idname : NodeGroupInput
nd
snd
Group Output
bl_idname : NodeGroupOutput
nd
nd.group_output(cls, is_active_output = True)
snd
nd.group_output(cls, is_active_output = True)
Hair BSDF
bl_idname : ShaderNodeBsdfHair
class Shader
Shader.Hair(cls,
color: Color = None,
offset: Float = None,
roughnessu: Float = None,
roughnessv: Float = None,
tangent: Vector = None,
component: Literal['Reflection', 'Transmission'] = 'Reflection')
snd
nd.hair_bsdf(cls,
color: Color = None,
offset: Float = None,
roughnessu: Float = None,
roughnessv: Float = None,
tangent: Vector = None,
weight: Float = None,
component: Literal['Reflection', 'Transmission'] = 'Reflection')
Handle Type Selection
bl_idname : GeometryNodeCurveHandleTypeSelection
class Curve
Curve.handle_type_selection(cls,
handle_type: Literal['FREE', 'AUTO', 'VECTOR', 'ALIGN'] = 'AUTO',
mode = {'LEFT', 'RIGHT'})
nd
nd.handle_type_selection(cls,
handle_type: Literal['FREE', 'AUTO', 'VECTOR', 'ALIGN'] = 'AUTO',
mode = {'LEFT', 'RIGHT'})
Hash Value
bl_idname : FunctionNodeHashValue
class Float
Float.hash_value(self, seed: Integer = None)
class Integer
Integer.hash_value(self, seed: Integer = None)
class Vector
Vector.hash_value(self, seed: Integer = None)
class Color
Color.hash_value(self, seed: Integer = None)
class Rotation
Rotation.hash_value(self, seed: Integer = None)
class Matrix
Matrix.hash_value(self, seed: Integer = None)
class String
String.hash_value(self, seed: Integer = None)
nd
nd.hash_value(cls,
value: Integer = None,
seed: Integer = None,
data_type: Literal['FLOAT', 'INT', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING'] = 'INT')
Holdout
bl_idname : ShaderNodeHoldout
class Shader
snd
nd.holdout(cls, weight: Float = None)
Hue/Saturation/Value
bl_idname : ShaderNodeHueSaturation
class Float
Float.hue_saturation_value(self,
saturation: Float = None,
value: Float = None,
color: Color = None,
factor: Float = None)
class Color
Color.hue_saturation_value(self,
hue: Float = None,
saturation: Float = None,
value: Float = None,
factor: Float = None)
snd
nd.hue_saturation_value(cls,
hue: Float = None,
saturation: Float = None,
value: Float = None,
color: Color = None,
factor: Float = None)
ID
bl_idname : GeometryNodeInputID
class Geometry
nd
IES Texture
bl_idname : ShaderNodeTexIES
class Vector
Vector.ies_texture_internal(self, strength: Float = None, filepath = '', ies = None)
Vector.ies_texture_external(self, strength: Float = None, filepath = '', ies = None)
Vector.ies_texture(self,
strength: Float = None,
filepath = '',
ies = None,
mode: Literal['INTERNAL', 'EXTERNAL'] = 'INTERNAL')
snd
nd.ies_texture(cls,
vector: Vector = None,
strength: Float = None,
filepath = '',
ies = None,
mode: Literal['INTERNAL', 'EXTERNAL'] = 'INTERNAL')
Ico Sphere
bl_idname : GeometryNodeMeshIcoSphere
class Mesh
Mesh.IcoSphere(cls, radius: Float = None, subdivisions: Integer = None)
nd
nd.ico_sphere(cls, radius: Float = None, subdivisions: Integer = None)
Image
bl_idname : GeometryNodeInputImage
nd
nd.image(cls, image = None)
Image Info
bl_idname : GeometryNodeImageInfo
class Image
Image.info(self, frame: Integer = None)
Image.width(self, frame: Integer = None)
Image.height(self, frame: Integer = None)
Image.has_alpha(self, frame: Integer = None)
Image.frame_count(self, frame: Integer = None)
Image.fps(self, frame: Integer = None)
nd
nd.image_info(cls, image: Image = None, frame: Integer = None)
Image Texture
bl_idname : ShaderNodeTexImage
class Vector
Vector.image_texture(self,
extension: Literal['REPEAT', 'EXTEND', 'CLIP', 'MIRROR'] = 'REPEAT',
image = None,
interpolation: Literal['Linear', 'Closest', 'Cubic', 'Smart'] = 'Linear',
projection: Literal['FLAT', 'BOX', 'SPHERE', 'TUBE'] = 'FLAT',
projection_blend = 0.0)
snd
nd.image_texture(cls,
vector: Vector = None,
extension: Literal['REPEAT', 'EXTEND', 'CLIP', 'MIRROR'] = 'REPEAT',
image = None,
interpolation: Literal['Linear', 'Closest', 'Cubic', 'Smart'] = 'Linear',
projection: Literal['FLAT', 'BOX', 'SPHERE', 'TUBE'] = 'FLAT',
projection_blend = 0.0)
Import CSV
bl_idname : GeometryNodeImportCSV
class Cloud
Cloud.ImportCSV(cls, path: String = None, delimiter: String = None)
nd
nd.import_csv(cls, path: String = None, delimiter: String = None)
Import OBJ
bl_idname : GeometryNodeImportOBJ
class Instances
Instances.ImportOBJ(cls, path: String = None)
nd
nd.import_obj(cls, path: String = None)
Import PLY
bl_idname : GeometryNodeImportPLY
class Mesh
Mesh.ImportPLY(cls, path: String = None)
nd
nd.import_ply(cls, path: String = None)
Import STL
bl_idname : GeometryNodeImportSTL
class Mesh
Mesh.ImportSTL(cls, path: String = None)
nd
nd.import_stl(cls, path: String = None)
Import Text
bl_idname : GeometryNodeImportText
class String
String.ImportText(cls, path: String = None)
nd
nd.import_text(cls, path: String = None)
Import VDB
bl_idname : GeometryNodeImportVDB
class Volume
Volume.ImportVDB(cls, path: String = None)
nd
nd.import_vdb(cls, path: String = None)
Index
bl_idname : GeometryNodeInputIndex
class Geometry
nd
Index Switch
bl_idname : GeometryNodeIndexSwitch
class Socket
Socket.IndexSwitch(*values, index=0)
Socket.index_switch(*values, index=0)
Index of Nearest
bl_idname : GeometryNodeIndexOfNearest
class Geometry
Geometry.index_of_nearest(cls, position: Vector = None, group_id: Integer = None)
nd
nd.index_of_nearest(cls, position: Vector = None, group_id: Integer = None)
Instance Bounds
bl_idname : GeometryNodeInputInstanceBounds
nd
nd.instance_bounds(cls, use_radius: Boolean = None)
Instance Rotation
bl_idname : GeometryNodeInputInstanceRotation
class Instances
prop = Instances.rotation
nd
nd.instance_rotation(self)
Instance Scale
bl_idname : GeometryNodeInputInstanceScale
class Instances
prop = Instances.instance_scale
nd
bl_idname : GeometryNodeInstanceTransform
class Instances
prop = Instances.transform
nd
nd.instance_transform(self)
Instance on Points
bl_idname : GeometryNodeInstanceOnPoints
class Geometry
Geometry.instance_on_points(self,
instance: Instances = None,
pick_instance: Boolean = None,
instance_index: Integer = None,
rotation: Rotation = None,
scale: Vector = None)
class Cloud
Cloud.instance_on(self,
instance: Instances = None,
pick_instance: Boolean = None,
instance_index: Integer = None,
rotation: Rotation = None,
scale: Vector = None)
class Point
Mesh.points.instance_on(self,
instance: Instances = None,
pick_instance: Boolean = None,
instance_index: Integer = None,
rotation: Rotation = None,
scale: Vector = None)
nd
nd.instance_on_points(cls,
points: Cloud = None,
selection: Boolean = None,
instance: Instances = None,
pick_instance: Boolean = None,
instance_index: Integer = None,
rotation: Rotation = None,
scale: Vector = None)
Instances to Points
bl_idname : GeometryNodeInstancesToPoints
class Instances
Instances.to_points(self, position: Vector = None, radius: Float = None)
nd
nd.instances_to_points(cls,
instances: Instances = None,
selection: Boolean = None,
position: Vector = None,
radius: Float = None)
Integer
bl_idname : FunctionNodeInputInt
nd
nd.integer(cls, integer = 0)
Integer Math
bl_idname : FunctionNodeIntegerMath
class Integer
Integer.add(self, value: Integer = None)
Integer.subtract(self, value: Integer = None)
Integer.multiply(self, value: Integer = None)
Integer.divide(self, value: Integer = None)
Integer.multiply_add(self, multiplier: Integer = None, addend: Integer = None)
Integer.power(self, exponent: Integer = None)
Integer.min(self, value: Integer = None)
Integer.max(self, value: Integer = None)
Integer.divide_round(self, value: Integer = None)
Integer.divide_floor(self, value: Integer = None)
Integer.divide_ceil(self, value: Integer = None)
Integer.floored_modulo(self, value: Integer = None)
Integer.modulo(self, value: Integer = None)
Integer.gcd(self, value: Integer = None)
Integer.lcm(self, value: Integer = None)
class gnmath
gnmath.iadd(value: Integer = None, value_1: Integer = None)
gnmath.isubtract(value: Integer = None, value_1: Integer = None)
gnmath.imultiply(value: Integer = None, value_1: Integer = None)
gnmath.idivide(value: Integer = None, value_1: Integer = None)
gnmath.imultiply_add(value: Integer = None, multiplier: Integer = None, addend: Integer = None)
gnmath.iabs(value: Integer = None)
gnmath.negate(value: Integer = None)
gnmath.ipower(base: Integer = None, exponent: Integer = None)
gnmath.imin(value: Integer = None, value_1: Integer = None)
gnmath.imax(value: Integer = None, value_1: Integer = None)
gnmath.isign(value: Integer = None)
gnmath.divide_round(value: Integer = None, value_1: Integer = None)
gnmath.divide_floor(value: Integer = None, value_1: Integer = None)
gnmath.divide_ceil(value: Integer = None, value_1: Integer = None)
gnmath.ifloored_modulo(value: Integer = None, value_1: Integer = None)
gnmath.imodulo(value: Integer = None, value_1: Integer = None)
gnmath.gcd(value: Integer = None, value_1: Integer = None)
gnmath.lcm(value: Integer = None, value_1: Integer = None)
nd
nd.integer_math(cls,
value: Integer = None,
value_1: Integer = None,
value_2: Integer = None,
operation: Literal['ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'ABSOLUTE', 'NEGATE', 'POWER', 'MINIMUM', 'MAXIMUM', 'SIGN', 'DIVIDE_ROUND', 'DIVIDE_FLOOR', 'DIVIDE_CEIL', 'FLOORED_MODULO', 'MODULO', 'GCD', 'LCM'] = 'ADD')
Interpolate Curves
bl_idname : GeometryNodeInterpolateCurves
class Curve
Curve.Interpolate(cls,
guide_curves: Curve = None,
guide_up: Vector = None,
guide_group_id: Integer = None,
points: Cloud = None,
point_up: Vector = None,
point_group_id: Integer = None,
max_neighbors: Integer = None)
Curve.interpolate(self,
guide_up: Vector = None,
guide_group_id: Integer = None,
points: Cloud = None,
point_up: Vector = None,
point_group_id: Integer = None,
max_neighbors: Integer = None)
class Cloud
Cloud.interpolate_curves(self,
guide_curves: Curve = None,
guide_up: Vector = None,
guide_group_id: Integer = None,
point_up: Vector = None,
point_group_id: Integer = None,
max_neighbors: Integer = None)
nd
nd.interpolate_curves(cls,
guide_curves: Curve = None,
guide_up: Vector = None,
guide_group_id: Integer = None,
points: Cloud = None,
point_up: Vector = None,
point_group_id: Integer = None,
max_neighbors: Integer = None)
Invert Color
bl_idname : ShaderNodeInvert
class Color
Color.invert_color(self, factor: Float = None)
snd
nd.invert_color(cls, color: Color = None, factor: Float = None)
Invert Matrix
bl_idname : FunctionNodeInvertMatrix
class Matrix
nd
nd.invert_matrix(cls, matrix: Matrix = None)
Invert Rotation
bl_idname : FunctionNodeInvertRotation
class Rotation
nd
nd.invert_rotation(cls, rotation: Rotation = None)
Is Edge Smooth
bl_idname : GeometryNodeInputEdgeSmooth
class Edge
prop = Mesh.edges.shade_smooth
nd
Is Face Planar
bl_idname : GeometryNodeInputMeshFaceIsPlanar
class Mesh
Mesh.is_face_planar(cls, threshold: Float = None)
class Face
Mesh.faces.is_planar(cls, threshold: Float = None)
nd
nd.is_face_planar(cls, threshold: Float = None)
Is Face Smooth
bl_idname : GeometryNodeInputShadeSmooth
class Face
prop = Mesh.faces.shade_smooth
nd
Is Spline Cyclic
bl_idname : GeometryNodeInputSplineCyclic
class Curve
class Spline
prop = Spline.splines.is_cyclic
nd
nd.is_spline_cyclic(self)
Is Viewport
bl_idname : GeometryNodeIsViewport
class Boolean
prop = Boolean.is_viewport
nd
Join Bundle
bl_idname : NodeJoinBundle
class Bundle
Bundle.join(self, *bundle: Bundle)
Bundle.join_bundle(self, *bundle: Bundle)
nd
nd.join_bundle(cls, *bundle: Bundle)
snd
nd.join_bundle(cls, *bundle: Bundle)
Join Geometry
bl_idname : GeometryNodeJoinGeometry
class Geometry
Geometry.join(self, *geometry: Geometry)
Geometry.Join(cls, *geometry: Geometry)
nd
nd.join_geometry(cls, *geometry: Geometry)
Join Strings
bl_idname : GeometryNodeStringJoin
class String
String.join(self, *strings: String)
String.Join(cls, *strings: String, delimiter: String = None)
nd
nd.join_strings(cls, *strings: String, delimiter: String = None)
Layer Weight
bl_idname : ShaderNodeLayerWeight
class Float
Float.layer_weight(self, normal: Vector = None)
snd
nd.layer_weight(cls, blend: Float = None, normal: Vector = None)
Light Falloff
bl_idname : ShaderNodeLightFalloff
class Float
Float.light_falloff(self, smooth: Float = None)
snd
nd.light_falloff(cls, strength: Float = None, smooth: Float = None)
Light Output
bl_idname : ShaderNodeOutputLight
class Shader
Shader.light_output(self,
is_active_output = True,
target: Literal['ALL', 'EEVEE', 'CYCLES'] = 'ALL')
snd
nd.light_output(cls,
surface: Shader = None,
is_active_output = True,
target: Literal['ALL', 'EEVEE', 'CYCLES'] = 'ALL')
Light Path
bl_idname : ShaderNodeLightPath
snd
Line Style Output
bl_idname : ShaderNodeOutputLineStyle
class Color
Color.line_style_output(self,
color_fac: Float = None,
alpha: Float = None,
alpha_fac: Float = None,
blend_type: Literal['MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'] = 'MIX',
is_active_output = True,
target: Literal['ALL', 'EEVEE', 'CYCLES'] = 'ALL',
use_alpha = False,
use_clamp = False)
snd
nd.line_style_output(cls,
color: Color = None,
color_fac: Float = None,
alpha: Float = None,
alpha_fac: Float = None,
blend_type: Literal['MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'] = 'MIX',
is_active_output = True,
target: Literal['ALL', 'EEVEE', 'CYCLES'] = 'ALL',
use_alpha = False,
use_clamp = False)
Linear Gizmo
bl_idname : GeometryNodeGizmoLinear
class Float
Float.linear_gizmo(self,
*value: Float,
position: Vector = None,
direction: Vector = None,
color_id: Literal['PRIMARY', 'SECONDARY', 'X', 'Y', 'Z'] = 'PRIMARY',
draw_style: Literal['ARROW', 'CROSS', 'BOX'] = 'ARROW')
nd
nd.linear_gizmo(cls,
*value: Float,
position: Vector = None,
direction: Vector = None,
color_id: Literal['PRIMARY', 'SECONDARY', 'X', 'Y', 'Z'] = 'PRIMARY',
draw_style: Literal['ARROW', 'CROSS', 'BOX'] = 'ARROW')
List Length
bl_idname : GeometryNodeListLength
nd
nd.list_length(cls,
list: Float = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT')
Magic Texture
bl_idname : ShaderNodeTexMagic
class Color
Color.Magic(cls,
vector: Vector = None,
scale: Float = None,
distortion: Float = None,
turbulence_depth = 2)
class Texture
Texture.Magic(cls,
vector: Vector = None,
scale: Float = None,
distortion: Float = None,
turbulence_depth = 2)
nd
nd.magic_texture(cls,
vector: Vector = None,
scale: Float = None,
distortion: Float = None,
turbulence_depth = 2)
snd
nd.magic_texture(cls,
vector: Vector = None,
scale: Float = None,
distortion: Float = None,
turbulence_depth = 2)
Map Range
bl_idname : ShaderNodeMapRange
class Float
Float.map_range(self,
from_min: Float | Vector = None,
from_max: Float | Vector = None,
to_min: Float | Vector = None,
to_max: Float | Vector = None,
clamp = True,
interpolation_type: Literal['LINEAR', 'STEPPED', 'SMOOTHSTEP', 'SMOOTHERSTEP'] = 'LINEAR')
Float.map_range_linear(self,
from_min: Float | Vector = None,
from_max: Float | Vector = None,
to_min: Float | Vector = None,
to_max: Float | Vector = None,
clamp = True)
Float.map_range_stepped(self,
from_min: Float | Vector = None,
from_max: Float | Vector = None,
to_min: Float | Vector = None,
to_max: Float | Vector = None,
steps: Float = None,
clamp = True)
Float.map_range_smooth_step(self,
from_min: Float | Vector = None,
from_max: Float | Vector = None,
to_min: Float | Vector = None,
to_max: Float | Vector = None,
clamp = True)
Float.map_range_smoother_step(self,
from_min: Float | Vector = None,
from_max: Float | Vector = None,
to_min: Float | Vector = None,
to_max: Float | Vector = None,
clamp = True)
class Vector
Vector.map_range(self,
from_min: Vector = None,
from_max: Vector = None,
to_min: Vector = None,
to_max: Vector = None,
clamp = True,
interpolation_type: Literal['LINEAR', 'STEPPED', 'SMOOTHSTEP', 'SMOOTHERSTEP'] = 'LINEAR')
nd
nd.map_range(cls,
value: Float = None,
from_min: Float = None,
from_max: Float = None,
to_min: Float = None,
to_max: Float = None,
steps: Float = None,
vector: Vector = None,
from_min_1: Vector = None,
from_max_1: Vector = None,
to_min_1: Vector = None,
to_max_1: Vector = None,
steps_1: Vector = None,
clamp = True,
data_type: Literal['FLOAT', 'FLOAT_VECTOR'] = 'FLOAT',
interpolation_type: Literal['LINEAR', 'STEPPED', 'SMOOTHSTEP', 'SMOOTHERSTEP'] = 'LINEAR')
snd
nd.map_range(cls,
value: Float = None,
from_min: Float = None,
from_max: Float = None,
to_min: Float = None,
to_max: Float = None,
steps: Float = None,
vector: Vector = None,
from_min_1: Vector = None,
from_max_1: Vector = None,
to_min_1: Vector = None,
to_max_1: Vector = None,
steps_1: Vector = None,
clamp = True,
data_type: Literal['FLOAT', 'FLOAT_VECTOR'] = 'FLOAT',
interpolation_type: Literal['LINEAR', 'STEPPED', 'SMOOTHSTEP', 'SMOOTHERSTEP'] = 'LINEAR')
Mapping
bl_idname : ShaderNodeMapping
class Vector
Vector.mapping(self,
location: Vector = None,
rotation: Vector = None,
scale: Vector = None,
vector_type: Literal['POINT', 'TEXTURE', 'VECTOR', 'NORMAL'] = 'POINT')
snd
nd.mapping(cls,
vector: Vector = None,
location: Vector = None,
rotation: Vector = None,
scale: Vector = None,
vector_type: Literal['POINT', 'TEXTURE', 'VECTOR', 'NORMAL'] = 'POINT')
Match String
bl_idname : FunctionNodeMatchString
class String
String.match_string(self,
operation: Literal['Starts With', 'Ends With', 'Contains'] = None,
key: String = None)
nd
nd.match_string(cls,
string: String = None,
operation: Literal['Starts With', 'Ends With', 'Contains'] = None,
key: String = None)
Material
bl_idname : GeometryNodeInputMaterial
nd
nd.material(cls, material = None)
Material Index
bl_idname : GeometryNodeInputMaterialIndex
class Geometry
prop = Geometry.material_index
class Face
prop = Mesh.faces.material_index
class Spline
prop = Spline.splines.material_index
nd
Material Output
bl_idname : ShaderNodeOutputMaterial
class Shader
Shader.material_output(self,
volume: VolumeShader = None,
displacement: Vector = None,
thickness: Float = None,
is_active_output = True,
target: Literal['ALL', 'EEVEE', 'CYCLES'] = 'ALL')
snd
nd.material_output(cls,
surface: Shader = None,
volume: VolumeShader = None,
displacement: Vector = None,
thickness: Float = None,
is_active_output = True,
target: Literal['ALL', 'EEVEE', 'CYCLES'] = 'ALL')
Material Selection
bl_idname : GeometryNodeMaterialSelection
class Mesh
Mesh.material_selection(cls, material: Material = None)
class Curve
Curve.material_selection(cls, material: Material = None)
nd
nd.material_selection(cls, material: Material = None)
Math
bl_idname : ShaderNodeMath
class Float
Float.add(self, value: Float = None, use_clamp = False)
Float.subtract(self, value: Float = None, use_clamp = False)
Float.multiply(self, value: Float = None, use_clamp = False)
Float.divide(self, value: Float = None, use_clamp = False)
Float.multiply_add(self, multiplier: Float = None, addend: Float = None, use_clamp = False)
Float.power(self, exponent: Float = None, use_clamp = False)
Float.log(self, base: Float = None, use_clamp = False)
Float.sqrt(self, use_clamp = False)
Float.inverse_sqrt(self, use_clamp = False)
Float.abs(self, use_clamp = False)
Float.exp(self, use_clamp = False)
Float.min(self, value: Float = None, use_clamp = False)
Float.max(self, value: Float = None, use_clamp = False)
Float.mless_than(self, threshold: Float = None, use_clamp = False)
Float.mgreater_than(self, threshold: Float = None, use_clamp = False)
Float.sign(self, use_clamp = False)
Float.compare(self, value: Float = None, epsilon: Float = None, use_clamp = False)
Float.smooth_min(self, value: Float = None, distance: Float = None, use_clamp = False)
Float.smooth_max(self, value: Float = None, distance: Float = None, use_clamp = False)
Float.round(self, use_clamp = False)
Float.floor(self, use_clamp = False)
Float.ceil(self, use_clamp = False)
Float.trunc(self, use_clamp = False)
Float.fract(self, use_clamp = False)
Float.modulo(self, value: Float = None, use_clamp = False)
Float.floored_modulo(self, value: Float = None, use_clamp = False)
Float.wrap(self, max: Float = None, min: Float = None, use_clamp = False)
Float.snap(self, increment: Float = None, use_clamp = False)
Float.pingpong(self, scale: Float = None, use_clamp = False)
Float.sin(self, use_clamp = False)
Float.cos(self, use_clamp = False)
Float.tan(self, use_clamp = False)
Float.asin(self, use_clamp = False)
Float.acos(self, use_clamp = False)
Float.arctangent(self, use_clamp = False)
Float.atan2(self, value: Float = None, use_clamp = False)
Float.sinh(self, use_clamp = False)
Float.cosh(self, use_clamp = False)
Float.tanh(self, use_clamp = False)
Float.radians(self, use_clamp = False)
Float.degrees(self, use_clamp = False)
class gnmath
gnmath.add(value: Float = None, value_1: Float = None, use_clamp = False)
gnmath.subtract(value: Float = None, value_1: Float = None, use_clamp = False)
gnmath.multiply(value: Float = None, value_1: Float = None, use_clamp = False)
gnmath.divide(value: Float = None, value_1: Float = None, use_clamp = False)
gnmath.multiply_add(value: Float = None,
multiplier: Float = None,
addend: Float = None,
use_clamp = False)
gnmath.power(base: Float = None, exponent: Float = None, use_clamp = False)
gnmath.log(value: Float = None, base: Float = None, use_clamp = False)
gnmath.sqrt(value: Float = None, use_clamp = False)
gnmath.inverse_sqrt(value: Float = None, use_clamp = False)
gnmath.abs(value: Float = None, use_clamp = False)
gnmath.exp(value: Float = None, use_clamp = False)
gnmath.min(value: Float = None, value_1: Float = None, use_clamp = False)
gnmath.max(value: Float = None, value_1: Float = None, use_clamp = False)
gnmath.mless_than(value: Float = None, threshold: Float = None, use_clamp = False)
gnmath.mgreater_than(value: Float = None, threshold: Float = None, use_clamp = False)
gnmath.sign(value: Float = None, use_clamp = False)
gnmath.compare(value: Float = None,
value_1: Float = None,
epsilon: Float = None,
use_clamp = False)
gnmath.smooth_min(value: Float = None,
value_1: Float = None,
distance: Float = None,
use_clamp = False)
gnmath.smooth_max(value: Float = None,
value_1: Float = None,
distance: Float = None,
use_clamp = False)
gnmath.round(value: Float = None, use_clamp = False)
gnmath.floor(value: Float = None, use_clamp = False)
gnmath.ceil(value: Float = None, use_clamp = False)
gnmath.trunc(value: Float = None, use_clamp = False)
gnmath.fract(value: Float = None, use_clamp = False)
gnmath.modulo(value: Float = None, value_1: Float = None, use_clamp = False)
gnmath.floored_modulo(value: Float = None, value_1: Float = None, use_clamp = False)
gnmath.wrap(value: Float = None, max: Float = None, min: Float = None, use_clamp = False)
gnmath.snap(value: Float = None, increment: Float = None, use_clamp = False)
gnmath.pingpong(value: Float = None, scale: Float = None, use_clamp = False)
gnmath.sin(value: Float = None, use_clamp = False)
gnmath.cos(value: Float = None, use_clamp = False)
gnmath.tan(value: Float = None, use_clamp = False)
gnmath.asin(value: Float = None, use_clamp = False)
gnmath.acos(value: Float = None, use_clamp = False)
gnmath.arctangent(value: Float = None, use_clamp = False)
gnmath.atan2(value: Float = None, value_1: Float = None, use_clamp = False)
gnmath.sinh(value: Float = None, use_clamp = False)
gnmath.cosh(value: Float = None, use_clamp = False)
gnmath.tanh(value: Float = None, use_clamp = False)
gnmath.radians(degrees: Float = None, use_clamp = False)
gnmath.degrees(radians: Float = None, use_clamp = False)
nd
nd.math(cls,
value: Float = None,
value_1: Float = None,
value_2: Float = None,
operation: Literal['ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'POWER', 'LOGARITHM', 'SQRT', 'INVERSE_SQRT', 'ABSOLUTE', 'EXPONENT', 'MINIMUM', 'MAXIMUM', 'LESS_THAN', 'GREATER_THAN', 'SIGN', 'COMPARE', 'SMOOTH_MIN', 'SMOOTH_MAX', 'ROUND', 'FLOOR', 'CEIL', 'TRUNC', 'FRACT', 'MODULO', 'FLOORED_MODULO', 'WRAP', 'SNAP', 'PINGPONG', 'SINE', 'COSINE', 'TANGENT', 'ARCSINE', 'ARCCOSINE', 'ARCTANGENT', 'ARCTAN2', 'SINH', 'COSH', 'TANH', 'RADIANS', 'DEGREES'] = 'ADD',
use_clamp = False)
snd
nd.math(cls,
value: Float = None,
value_1: Float = None,
value_2: Float = None,
operation: Literal['ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'POWER', 'LOGARITHM', 'SQRT', 'INVERSE_SQRT', 'ABSOLUTE', 'EXPONENT', 'MINIMUM', 'MAXIMUM', 'LESS_THAN', 'GREATER_THAN', 'SIGN', 'COMPARE', 'SMOOTH_MIN', 'SMOOTH_MAX', 'ROUND', 'FLOOR', 'CEIL', 'TRUNC', 'FRACT', 'MODULO', 'FLOORED_MODULO', 'WRAP', 'SNAP', 'PINGPONG', 'SINE', 'COSINE', 'TANGENT', 'ARCSINE', 'ARCCOSINE', 'ARCTANGENT', 'ARCTAN2', 'SINH', 'COSH', 'TANH', 'RADIANS', 'DEGREES'] = 'ADD',
use_clamp = False)
Matrix Determinant
bl_idname : FunctionNodeMatrixDeterminant
class Matrix
nd
nd.matrix_determinant(cls, matrix: Matrix = None)
Matrix SVD
bl_idname : FunctionNodeMatrixSVD
class Matrix
nd
nd.matrix_svd(cls, matrix: Matrix = None)
bl_idname : GeometryNodeMenuSwitch
class Socket
Socket.MenuSwitch(items={'A': None, 'B': None}, menu=0, name='Menu', tip=None, panel=None, hide_value=False, hide_in_modifier=False, single_value=False)
Socket.menu_switch(items={'A': None, 'B': None}, menu=0, name='Menu', tip=None, panel=None, hide_value=False, hide_in_modifier=False, single_value=False)
Merge Layers
bl_idname : GeometryNodeMergeLayers
class GreasePencil
GreasePencil.merge_layers_by_name(self)
GreasePencil.merge_layers_by_id(self, group_id: Integer = None)
GreasePencil.merge_layers(self, mode: Literal['MERGE_BY_NAME', 'MERGE_BY_ID'] = 'MERGE_BY_NAME')
nd
nd.merge_layers(cls,
grease_pencil: GreasePencil = None,
selection: Boolean = None,
group_id: Integer = None,
mode: Literal['MERGE_BY_NAME', 'MERGE_BY_ID'] = 'MERGE_BY_NAME')
Merge by Distance
bl_idname : GeometryNodeMergeByDistance
class Geometry
Geometry.merge_by_distance(self, mode: Literal['All', 'Connected'] = None, distance: Float = None)
Geometry.merge(self, mode: Literal['All', 'Connected'] = None, distance: Float = None)
nd
nd.merge_by_distance(cls,
geometry: Geometry = None,
selection: Boolean = None,
mode: Literal['All', 'Connected'] = None,
distance: Float = None)
Mesh Boolean
bl_idname : GeometryNodeMeshBoolean
class Mesh
Mesh.boolean(self,
*mesh_2: Mesh,
operation: Literal['INTERSECT', 'UNION', 'DIFFERENCE'] = 'DIFFERENCE',
solver: Literal['EXACT', 'FLOAT', 'MANIFOLD'] = 'FLOAT')
Mesh.Boolean(cls,
*mesh_2: Mesh,
mesh_1: Mesh = None,
operation: Literal['INTERSECT', 'UNION', 'DIFFERENCE'] = 'DIFFERENCE',
solver: Literal['EXACT', 'FLOAT', 'MANIFOLD'] = 'FLOAT')
Mesh.intersect(self, *mesh: Mesh, solver: Literal['EXACT', 'FLOAT', 'MANIFOLD'] = 'FLOAT')
Mesh.union(self, *mesh: Mesh, solver: Literal['EXACT', 'FLOAT', 'MANIFOLD'] = 'FLOAT')
Mesh.difference(self, *mesh_2: Mesh, solver: Literal['EXACT', 'FLOAT', 'MANIFOLD'] = 'FLOAT')
Mesh.Intersect(cls, *mesh: Mesh, solver: Literal['EXACT', 'FLOAT', 'MANIFOLD'] = 'FLOAT')
Mesh.Union(cls, *mesh: Mesh, solver: Literal['EXACT', 'FLOAT', 'MANIFOLD'] = 'FLOAT')
Mesh.Difference(cls,
*mesh_2: Mesh,
mesh_1: Mesh = None,
solver: Literal['EXACT', 'FLOAT', 'MANIFOLD'] = 'FLOAT')
nd
nd.mesh_boolean(cls,
*mesh_2: Mesh,
mesh_1: Mesh = None,
self_intersection: Boolean = None,
hole_tolerant: Boolean = None,
operation: Literal['INTERSECT', 'UNION', 'DIFFERENCE'] = 'DIFFERENCE',
solver: Literal['EXACT', 'FLOAT', 'MANIFOLD'] = 'FLOAT')
Mesh Circle
bl_idname : GeometryNodeMeshCircle
class Mesh
Mesh.Circle(cls,
vertices: Integer = None,
radius: Float = None,
fill_type: Literal['NONE', 'NGON', 'TRIANGLE_FAN'] = 'NONE')
nd
nd.mesh_circle(cls,
vertices: Integer = None,
radius: Float = None,
fill_type: Literal['NONE', 'NGON', 'TRIANGLE_FAN'] = 'NONE')
Mesh Island
bl_idname : GeometryNodeInputMeshIsland
class Mesh
nd
Mesh Line
bl_idname : GeometryNodeMeshLine
class Mesh
Mesh.LineOffset(cls,
count: Integer = None,
start_location: Vector = None,
offset: Vector = None,
count_mode: Literal['TOTAL', 'RESOLUTION'] = 'TOTAL')
Mesh.LineEndPoints(cls,
count: Integer = None,
start_location: Vector = None,
end_location: Vector = None,
count_mode: Literal['TOTAL', 'RESOLUTION'] = 'TOTAL')
Mesh.Line(cls,
count: Integer = None,
start_location: Vector = None,
offset: Vector = None,
count_mode: Literal['TOTAL', 'RESOLUTION'] = 'TOTAL',
mode: Literal['OFFSET', 'END_POINTS'] = 'OFFSET')
nd
nd.mesh_line(cls,
count: Integer = None,
resolution: Float = None,
start_location: Vector = None,
offset: Vector = None,
count_mode: Literal['TOTAL', 'RESOLUTION'] = 'TOTAL',
mode: Literal['OFFSET', 'END_POINTS'] = 'OFFSET')
Mesh to Curve
bl_idname : GeometryNodeMeshToCurve
class Mesh
Mesh.to_curve_edges(self)
Mesh.to_curve_faces(self)
Mesh.to_curve(self, mode: Literal['EDGES', 'FACES'] = 'EDGES')
nd
nd.mesh_to_curve(cls,
mesh: Mesh = None,
selection: Boolean = None,
mode: Literal['EDGES', 'FACES'] = 'EDGES')
Mesh to Density Grid
bl_idname : GeometryNodeMeshToDensityGrid
class Mesh
Mesh.to_density_grid(self,
density: Float = None,
voxel_size: Float = None,
gradient_width: Float = None)
nd
nd.mesh_to_density_grid(cls,
mesh: Mesh = None,
density: Float = None,
voxel_size: Float = None,
gradient_width: Float = None)
Mesh to Points
bl_idname : GeometryNodeMeshToPoints
class Mesh
Mesh.to_points(self,
position: Vector = None,
radius: Float = None,
mode: Literal['VERTICES', 'EDGES', 'FACES', 'CORNERS'] = 'VERTICES')
Mesh.vertices_to_points(self, position: Vector = None, radius: Float = None)
Mesh.edges_to_points(self, position: Vector = None, radius: Float = None)
Mesh.faces_to_points(self, position: Vector = None, radius: Float = None)
Mesh.corners_to_points(self, position: Vector = None, radius: Float = None)
class Vertex
Mesh.points.to_points(self, position: Vector = None, radius: Float = None)
class Face
Mesh.faces.to_points(self, position: Vector = None, radius: Float = None)
class Edge
Mesh.edges.to_points(self, position: Vector = None, radius: Float = None)
class Corner
Mesh.corners.to_points(self, position: Vector = None, radius: Float = None)
nd
nd.mesh_to_points(cls,
mesh: Mesh = None,
selection: Boolean = None,
position: Vector = None,
radius: Float = None,
mode: Literal['VERTICES', 'EDGES', 'FACES', 'CORNERS'] = 'VERTICES')
Mesh to SDF Grid
bl_idname : GeometryNodeMeshToSDFGrid
class Mesh
Mesh.to_sdf_grid(self, voxel_size: Float = None, band_width: Integer = None)
nd
nd.mesh_to_sdf_grid(cls, mesh: Mesh = None, voxel_size: Float = None, band_width: Integer = None)
Mesh to Volume
bl_idname : GeometryNodeMeshToVolume
class Mesh
Mesh.to_volume(self,
density: Float = None,
resolution_mode: Literal['Amount', 'Size'] = None,
voxel_size: Float = None,
voxel_amount: Float = None,
interior_band_width: Float = None)
nd
nd.mesh_to_volume(cls,
mesh: Mesh = None,
density: Float = None,
resolution_mode: Literal['Amount', 'Size'] = None,
voxel_size: Float = None,
voxel_amount: Float = None,
interior_band_width: Float = None)
bl_idname : ShaderNodeBsdfMetallic
class Shader
Shader.Metallic(cls,
base_color: Color = None,
edge_tint: Color = None,
roughness: Float = None,
anisotropy: Float = None,
rotation: Float = None,
normal: Vector = None,
tangent: Vector = None,
thin_film_thickness: Float = None,
thin_film_ior: Float = None,
distribution: Literal['BECKMANN', 'GGX', 'MULTI_GGX'] = 'MULTI_GGX',
fresnel_type: Literal['PHYSICAL_CONDUCTOR', 'F82'] = 'F82')
snd
nd.metallic_bsdf(cls,
base_color: Color = None,
edge_tint: Color = None,
ior: Vector = None,
extinction: Vector = None,
roughness: Float = None,
anisotropy: Float = None,
rotation: Float = None,
normal: Vector = None,
tangent: Vector = None,
weight: Float = None,
thin_film_thickness: Float = None,
thin_film_ior: Float = None,
distribution: Literal['BECKMANN', 'GGX', 'MULTI_GGX'] = 'MULTI_GGX',
fresnel_type: Literal['PHYSICAL_CONDUCTOR', 'F82'] = 'F82')
Mix
bl_idname : ShaderNodeMix
class Float
Float.mix(self, b: Float = None, factor: Float = None, clamp_factor = True)
class Rotation
Rotation.mix(self, b: Rotation = None, factor: Float = None, clamp_factor = True)
class Vector
Vector.mix_uniform(self, b: Vector = None, factor: Float = None, clamp_factor = True)
Vector.mix_non_uniform(self, b: Vector = None, factor: Vector = None, clamp_factor = True)
class Color
Color.mix_mix(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_darken(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_multiply(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_burn(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_lighten(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_screen(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_dodge(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_add(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_overlay(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_soft_light(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_linear_light(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_difference(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_exclusion(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_subtract(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_divide(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_hue(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_saturation(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_color(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix_value(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False)
Color.mix(self,
b: Color = None,
factor: Float = None,
clamp_factor = True,
clamp_result = False,
factor_mode: Literal['UNIFORM', 'NON_UNIFORM'] = 'UNIFORM')
nd
nd.mix(cls,
a: Float = None,
b: Float = None,
a_1: Vector = None,
b_1: Vector = None,
a_2: Color = None,
b_2: Color = None,
a_3: Rotation = None,
b_3: Rotation = None,
factor: Vector = None,
blend_type: Literal['MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'] = 'MIX',
clamp_factor = True,
clamp_result = False,
data_type: Literal['FLOAT', 'VECTOR', 'RGBA', 'ROTATION'] = 'FLOAT',
factor_mode: Literal['UNIFORM', 'NON_UNIFORM'] = 'UNIFORM')
snd
nd.mix(cls,
a: Float = None,
b: Float = None,
a_1: Vector = None,
b_1: Vector = None,
a_2: Color = None,
b_2: Color = None,
a_3: Rotation = None,
b_3: Rotation = None,
factor: Vector = None,
blend_type: Literal['MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'] = 'MIX',
clamp_factor = True,
clamp_result = False,
data_type: Literal['FLOAT', 'VECTOR', 'RGBA'] = 'FLOAT',
factor_mode: Literal['UNIFORM', 'NON_UNIFORM'] = 'UNIFORM')
Mix Shader
bl_idname : ShaderNodeMixShader
class Shader
Shader.mix(self, shader: Shader = None, factor: Float = None)
snd
nd.mix_shader(cls, shader: Shader = None, shader_1: Shader = None, factor: Float = None)
Mouse Position
bl_idname : GeometryNodeToolMousePosition
nd
Multiply Matrices
bl_idname : FunctionNodeMatrixMultiply
class Matrix
Matrix.multiply(self, matrix: Matrix = None)
nd
nd.multiply_matrices(cls, matrix: Matrix = None, matrix_1: Matrix = None)
Named Attribute
bl_idname : GeometryNodeInputNamedAttribute
class Float
Float.Named(cls, name: String = None)
Float.NamedAttribute(cls, name: String = None)
class Integer
Integer.Named(cls, name: String = None)
Integer.NamedAttribute(cls, name: String = None)
class Boolean
Boolean.Named(cls, name: String = None)
Boolean.NamedAttribute(cls, name: String = None)
class Vector
Vector.Named(cls, name: String = None)
Vector.NamedAttribute(cls, name: String = None)
class Color
Color.Named(cls, name: String = None)
Color.NamedAttribute(cls, name: String = None)
class Rotation
Rotation.Named(cls, name: String = None)
Rotation.NamedAttribute(cls, name: String = None)
class Matrix
Matrix.Named(cls, name: String = None)
Matrix.NamedAttribute(cls, name: String = None)
nd
nd.named_attribute(cls,
name: String = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT')
Named Layer Selection
bl_idname : GeometryNodeInputNamedLayerSelection
class GreasePencil
GreasePencil.named_layer_selection(cls, name: String = None)
class Layer
GreasePencil.layers.named_selection(cls, name: String = None)
nd
nd.named_layer_selection(cls, name: String = None)
Noise Texture
bl_idname : ShaderNodeTexNoise
class Float
Float.Noise(cls,
vector: Vector = None,
scale: Float = None,
detail: Float = None,
roughness: Float = None,
lacunarity: Float = None,
distortion: Float = None,
noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D',
noise_type: Literal['MULTIFRACTAL', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL', 'FBM', 'HETERO_TERRAIN'] = 'FBM',
normalize = True)
class Texture
Texture.Noise(cls,
vector: Vector = None,
scale: Float = None,
detail: Float = None,
roughness: Float = None,
lacunarity: Float = None,
distortion: Float = None,
noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D',
noise_type: Literal['MULTIFRACTAL', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL', 'FBM', 'HETERO_TERRAIN'] = 'FBM',
normalize = True)
nd
nd.noise_texture(cls,
vector: Vector = None,
w: Float = None,
scale: Float = None,
detail: Float = None,
roughness: Float = None,
lacunarity: Float = None,
offset: Float = None,
gain: Float = None,
distortion: Float = None,
noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D',
noise_type: Literal['MULTIFRACTAL', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL', 'FBM', 'HETERO_TERRAIN'] = 'FBM',
normalize = True)
snd
nd.noise_texture(cls,
vector: Vector = None,
w: Float = None,
scale: Float = None,
detail: Float = None,
roughness: Float = None,
lacunarity: Float = None,
offset: Float = None,
gain: Float = None,
distortion: Float = None,
noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D',
noise_type: Literal['MULTIFRACTAL', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL', 'FBM', 'HETERO_TERRAIN'] = 'FBM',
normalize = True)
Normal
bl_idname : ShaderNodeNormal
class Vector
snd
nd.normal(cls, normal: Vector = None)
Normal Map
bl_idname : ShaderNodeNormalMap
class Float
Float.normal_map(self,
color: Color = None,
base: Literal['ORIGINAL', 'DISPLACED'] = 'DISPLACED',
convention: Literal['OPENGL', 'DIRECTX'] = 'OPENGL',
space: Literal['TANGENT', 'OBJECT', 'WORLD', 'BLENDER_OBJECT', 'BLENDER_WORLD'] = 'TANGENT',
uv_map = '')
snd
nd.normal_map(cls,
strength: Float = None,
color: Color = None,
base: Literal['ORIGINAL', 'DISPLACED'] = 'DISPLACED',
convention: Literal['OPENGL', 'DIRECTX'] = 'OPENGL',
space: Literal['TANGENT', 'OBJECT', 'WORLD', 'BLENDER_OBJECT', 'BLENDER_WORLD'] = 'TANGENT',
uv_map = '')
Object
bl_idname : GeometryNodeInputObject
nd
nd.object(cls, object = None)
Object Info
bl_idname : ShaderNodeObjectInfo
snd
Offset Corner in Face
bl_idname : GeometryNodeOffsetCornerInFace
class Mesh
Mesh.offset_corner_in_face(cls, corner_index: Integer = None, offset: Integer = None)
class Corner
Mesh.corners.offset_in_face(cls, corner_index: Integer = None, offset: Integer = None)
nd
nd.offset_corner_in_face(cls, corner_index: Integer = None, offset: Integer = None)
Offset Point in Curve
bl_idname : GeometryNodeOffsetPointInCurve
class Curve
Curve.offset_point_in_curve(cls, point_index: Integer = None, offset: Integer = None)
class SplinePoint
Spline.points.offset_in_curve(cls, point_index: Integer = None, offset: Integer = None)
nd
nd.offset_point_in_curve(cls, point_index: Integer = None, offset: Integer = None)
Pack UV Islands
bl_idname : GeometryNodeUVPackIslands
class Vector
Vector.pack_uv_islands(self,
margin: Float = None,
rotate: Boolean = None,
method: Literal['Bounding Box', 'Convex Hull', 'Exact Shape'] = None,
bottom_left: Vector = None,
top_right: Vector = None)
class Corner
Mesh.corners.pack_uv_islands(cls,
uv: Vector = None,
margin: Float = None,
rotate: Boolean = None,
method: Literal['Bounding Box', 'Convex Hull', 'Exact Shape'] = None,
bottom_left: Vector = None,
top_right: Vector = None)
nd
nd.pack_uv_islands(cls,
uv: Vector = None,
selection: Boolean = None,
margin: Float = None,
rotate: Boolean = None,
method: Literal['Bounding Box', 'Convex Hull', 'Exact Shape'] = None,
bottom_left: Vector = None,
top_right: Vector = None)
Particle Info
bl_idname : ShaderNodeParticleInfo
snd
Point Info
bl_idname : ShaderNodePointInfo
snd
Points
bl_idname : GeometryNodePoints
class Cloud
Cloud.Points(cls, count: Integer = None, position: Vector = None, radius: Float = None)
nd
nd.points(cls, count: Integer = None, position: Vector = None, radius: Float = None)
Points of Curve
bl_idname : GeometryNodePointsOfCurve
class Curve
Curve.points_of_curve(cls,
curve_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
class Spline
Spline.splines.points_of_curve(cls,
curve_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
Spline.splines.point_index(cls,
curve_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
Spline.splines.points_total(cls,
curve_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
nd
nd.points_of_curve(cls,
curve_index: Integer = None,
weights: Float = None,
sort_index: Integer = None)
Points to Curves
bl_idname : GeometryNodePointsToCurves
class Cloud
Cloud.to_curves(self, curve_group_id: Integer = None, weight: Float = None)
nd
nd.points_to_curves(cls,
points: Cloud = None,
curve_group_id: Integer = None,
weight: Float = None)
Points to SDF Grid
bl_idname : GeometryNodePointsToSDFGrid
class Cloud
Cloud.to_sdf_grid(self, radius: Float = None, voxel_size: Float = None)
nd
nd.points_to_sdf_grid(cls, points: Cloud = None, radius: Float = None, voxel_size: Float = None)
Points to Vertices
bl_idname : GeometryNodePointsToVertices
class Cloud
nd
nd.points_to_vertices(cls, points: Cloud = None, selection: Boolean = None)
Points to Volume
bl_idname : GeometryNodePointsToVolume
class Cloud
Cloud.to_volume(self,
density: Float = None,
resolution_mode: Literal['Amount', 'Size'] = None,
voxel_size: Float = None,
voxel_amount: Float = None,
radius: Float = None)
nd
nd.points_to_volume(cls,
points: Cloud = None,
density: Float = None,
resolution_mode: Literal['Amount', 'Size'] = None,
voxel_size: Float = None,
voxel_amount: Float = None,
radius: Float = None)
Position
bl_idname : GeometryNodeInputPosition
class Geometry
class Point
prop = Mesh.points.position
nd
Principled BSDF
bl_idname : ShaderNodeBsdfPrincipled
class Shader
Shader.Principled(cls,
base_color: Color = None,
metallic: Float = None,
roughness: Float = None,
ior: Float = None,
alpha: Float = None,
normal: Vector = None,
diffuse_roughness: Float = None,
subsurface_weight: Float = None,
subsurface_radius: Vector = None,
subsurface_scale: Float = None,
subsurface_anisotropy: Float = None,
specular_ior_level: Float = None,
specular_tint: Color = None,
anisotropic: Float = None,
anisotropic_rotation: Float = None,
tangent: Vector = None,
transmission_weight: Float = None,
coat_weight: Float = None,
coat_roughness: Float = None,
coat_ior: Float = None,
coat_tint: Color = None,
coat_normal: Vector = None,
sheen_weight: Float = None,
sheen_roughness: Float = None,
sheen_tint: Color = None,
emission_color: Color = None,
emission_strength: Float = None,
thin_film_thickness: Float = None,
thin_film_ior: Float = None,
distribution: Literal['GGX', 'MULTI_GGX'] = 'MULTI_GGX',
subsurface_method: Literal['BURLEY', 'RANDOM_WALK', 'RANDOM_WALK_SKIN'] = 'RANDOM_WALK')
snd
nd.principled_bsdf(cls,
base_color: Color = None,
metallic: Float = None,
roughness: Float = None,
ior: Float = None,
alpha: Float = None,
normal: Vector = None,
weight: Float = None,
diffuse_roughness: Float = None,
subsurface_weight: Float = None,
subsurface_radius: Vector = None,
subsurface_scale: Float = None,
subsurface_ior: Float = None,
subsurface_anisotropy: Float = None,
specular_ior_level: Float = None,
specular_tint: Color = None,
anisotropic: Float = None,
anisotropic_rotation: Float = None,
tangent: Vector = None,
transmission_weight: Float = None,
coat_weight: Float = None,
coat_roughness: Float = None,
coat_ior: Float = None,
coat_tint: Color = None,
coat_normal: Vector = None,
sheen_weight: Float = None,
sheen_roughness: Float = None,
sheen_tint: Color = None,
emission_color: Color = None,
emission_strength: Float = None,
thin_film_thickness: Float = None,
thin_film_ior: Float = None,
distribution: Literal['GGX', 'MULTI_GGX'] = 'MULTI_GGX',
subsurface_method: Literal['BURLEY', 'RANDOM_WALK', 'RANDOM_WALK_SKIN'] = 'RANDOM_WALK')
Principled Hair BSDF
bl_idname : ShaderNodeBsdfHairPrincipled
class Shader
Shader.PrincipledHair(cls,
color: Color = None,
roughness: Float = None,
radial_roughness: Float = None,
coat: Float = None,
ior: Float = None,
offset: Float = None,
random_roughness: Float = None,
random: Float = None,
model: Literal['CHIANG', 'HUANG'] = 'CHIANG',
parametrization: Literal['ABSORPTION', 'MELANIN', 'COLOR'] = 'COLOR')
snd
nd.principled_hair_bsdf(cls,
color: Color = None,
melanin: Float = None,
melanin_redness: Float = None,
tint: Color = None,
absorption_coefficient: Vector = None,
aspect_ratio: Float = None,
roughness: Float = None,
radial_roughness: Float = None,
coat: Float = None,
ior: Float = None,
offset: Float = None,
random_color: Float = None,
random_roughness: Float = None,
random: Float = None,
weight: Float = None,
reflection: Float = None,
transmission: Float = None,
secondary_reflection: Float = None,
model: Literal['CHIANG', 'HUANG'] = 'CHIANG',
parametrization: Literal['ABSORPTION', 'MELANIN', 'COLOR'] = 'COLOR')
Principled Volume
bl_idname : ShaderNodeVolumePrincipled
class VolumeShader
VolumeShader.Principled(cls,
color: Color = None,
color_attribute: String = None,
density: Float = None,
density_attribute: String = None,
anisotropy: Float = None,
absorption_color: Color = None,
emission_strength: Float = None,
emission_color: Color = None,
blackbody_intensity: Float = None,
blackbody_tint: Color = None,
temperature: Float = None,
temperature_attribute: String = None)
snd
nd.principled_volume(cls,
color: Color = None,
color_attribute: String = None,
density: Float = None,
density_attribute: String = None,
anisotropy: Float = None,
absorption_color: Color = None,
emission_strength: Float = None,
emission_color: Color = None,
blackbody_intensity: Float = None,
blackbody_tint: Color = None,
temperature: Float = None,
temperature_attribute: String = None,
weight: Float = None)
Project Point
bl_idname : FunctionNodeProjectPoint
class Matrix
Matrix.project_point(self, vector: Vector = None)
nd
nd.project_point(cls, vector: Vector = None, transform: Matrix = None)
Prune Grid
bl_idname : GeometryNodeGridPrune
class Float
Float.prune_grid(self,
mode: Literal['Inactive', 'Threshold', 'SDF'] = None,
threshold: Float = None)
class Integer
Integer.prune_grid(self,
mode: Literal['Inactive', 'Threshold', 'SDF'] = None,
threshold: Integer = None)
class Boolean
Boolean.prune_grid(self, mode: Literal['Inactive', 'Threshold', 'SDF'] = None)
class Vector
Vector.prune_grid(self,
mode: Literal['Inactive', 'Threshold', 'SDF'] = None,
threshold: Vector = None)
nd
nd.prune_grid(cls,
grid: Float = None,
mode: Literal['Inactive', 'Threshold', 'SDF'] = None,
threshold: Float = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT')
Quadratic Bézier
bl_idname : GeometryNodeCurveQuadraticBezier
class Curve
Curve.QuadraticBezier(cls,
resolution: Integer = None,
start: Vector = None,
middle: Vector = None,
end: Vector = None)
nd
nd.quadratic_bezier(cls,
resolution: Integer = None,
start: Vector = None,
middle: Vector = None,
end: Vector = None)
Quadrilateral
bl_idname : GeometryNodeCurvePrimitiveQuadrilateral
class Curve
Curve.QuadrilateralRectangle(cls, width: Float = None, height: Float = None)
Curve.QuadrilateralParallelogram(cls, width: Float = None, height: Float = None, offset: Float = None)
Curve.QuadrilateralTrapezoid(cls,
height: Float = None,
bottom_width: Float = None,
top_width: Float = None,
offset: Float = None)
Curve.QuadrilateralKite(cls,
width: Float = None,
bottom_height: Float = None,
top_height: Float = None)
Curve.QuadrilateralPoints(cls,
point_1: Vector = None,
point_2: Vector = None,
point_3: Vector = None,
point_4: Vector = None)
Curve.Quadrilateral(cls,
width: Float = None,
height: Float = None,
mode: Literal['RECTANGLE', 'PARALLELOGRAM', 'TRAPEZOID', 'KITE', 'POINTS'] = 'RECTANGLE')
nd
nd.quadrilateral(cls,
width: Float = None,
height: Float = None,
bottom_width: Float = None,
top_width: Float = None,
offset: Float = None,
bottom_height: Float = None,
top_height: Float = None,
point_1: Vector = None,
point_2: Vector = None,
point_3: Vector = None,
point_4: Vector = None,
mode: Literal['RECTANGLE', 'PARALLELOGRAM', 'TRAPEZOID', 'KITE', 'POINTS'] = 'RECTANGLE')
Quaternion to Rotation
bl_idname : FunctionNodeQuaternionToRotation
class Rotation
Rotation.FromQuaternion(cls, w: Float = None, x: Float = None, y: Float = None, z: Float = None)
nd
nd.quaternion_to_rotation(cls, w: Float = None, x: Float = None, y: Float = None, z: Float = None)
RGB Curves
bl_idname : ShaderNodeRGBCurve
nd
nd.rgb_curves(cls, color: Color = None, factor: Float = None)
snd
nd.rgb_curves(cls, color: Color = None, factor: Float = None)
RGB to BW
bl_idname : ShaderNodeRGBToBW
class Color
snd
nd.rgb_to_bw(cls, color: Color = None)
Radial Tiling
bl_idname : ShaderNodeRadialTiling
class Vector
Vector.radial_tiling(self, sides: Float = None, roundness: Float = None, normalize = False)
nd
nd.radial_tiling(cls,
vector: Vector = None,
sides: Float = None,
roundness: Float = None,
normalize = False)
snd
nd.radial_tiling(cls,
vector: Vector = None,
sides: Float = None,
roundness: Float = None,
normalize = False)
Radius
bl_idname : GeometryNodeInputRadius
class Cloud
class CloudPoint
prop = Cloud.points.radius
class Curve
class SplinePoint
prop = Spline.points.radius
nd
Random Value
bl_idname : FunctionNodeRandomValue
class Float
Float.Random(cls,
min: Float = None,
max: Float = None,
id: Integer = None,
seed: Integer = None)
class Integer
Integer.Random(cls,
min: Integer = None,
max: Integer = None,
id: Integer = None,
seed: Integer = None)
class Boolean
Boolean.Random(cls, probability: Float = None, id: Integer = None, seed: Integer = None)
class Vector
Vector.Random(cls,
min: Vector = None,
max: Vector = None,
id: Integer = None,
seed: Integer = None)
nd
nd.random_value(cls,
min: Vector = None,
max: Vector = None,
min_1: Float = None,
max_1: Float = None,
min_2: Integer = None,
max_2: Integer = None,
probability: Float = None,
id: Integer = None,
seed: Integer = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR'] = 'FLOAT')
Ray Portal BSDF
bl_idname : ShaderNodeBsdfRayPortal
class Shader
Shader.RayPortal(cls, color: Color = None, position: Vector = None, direction: Vector = None)
snd
nd.ray_portal_bsdf(cls,
color: Color = None,
position: Vector = None,
direction: Vector = None,
weight: Float = None)
Raycast
bl_idname : ShaderNodeRaycast
class Vector
Vector.raycast(self, direction: Vector = None, length: Float = None, only_local = False)
snd
nd.raycast(cls,
position: Vector = None,
direction: Vector = None,
length: Float = None,
only_local = False)
Realize Instances
bl_idname : GeometryNodeRealizeInstances
class Geometry
Geometry.realize(self,
realize_all: Boolean = None,
depth: Integer = None,
realize_to_point_domain = False)
nd
nd.realize_instances(cls,
geometry: Geometry = None,
selection: Boolean = None,
realize_all: Boolean = None,
depth: Integer = None,
realize_to_point_domain = False)
Refraction BSDF
bl_idname : ShaderNodeBsdfRefraction
class Shader
Shader.Refraction(cls,
color: Color = None,
roughness: Float = None,
ior: Float = None,
normal: Vector = None,
distribution: Literal['BECKMANN', 'GGX'] = 'BECKMANN')
snd
nd.refraction_bsdf(cls,
color: Color = None,
roughness: Float = None,
ior: Float = None,
normal: Vector = None,
weight: Float = None,
distribution: Literal['BECKMANN', 'GGX'] = 'BECKMANN')
Remove Named Attribute
bl_idname : GeometryNodeRemoveAttribute
class Geometry
Geometry.remove_named_attribute(self, pattern_mode: Literal['Exact', 'Wildcard'] = None, name: String = None)
nd
nd.remove_named_attribute(cls,
geometry: Geometry = None,
pattern_mode: Literal['Exact', 'Wildcard'] = None,
name: String = None)
bl_idname : GeometryNodeRepeatInput
class Repeat
with GeoNodes("Repeat Example"):
geo = Geometry()
count = Integer(3, "Count")
move = Vector((0, 0, 2), "Move")
scale = Float(0.5, "Scale")
for rep in repeat(count, geo=Geometry(), move=move, scale=scale):
rep.geo += geo.transform(scale=rep.scale, translation=rep.move)
rep.move += move*rep.scale
rep.scale *= scale
rep.geo.out()
Repeat Output
bl_idname : GeometryNodeRepeatOutput
class Repeat
with GeoNodes("Repeat Example"):
geo = Geometry()
count = Integer(3, "Count")
move = Vector((0, 0, 2), "Move")
scale = Float(0.5, "Scale")
for rep in repeat(count, geo=Geometry(), move=move, scale=scale):
rep.geo += geo.transform(scale=rep.scale, translation=rep.move)
rep.move += move*rep.scale
rep.scale *= scale
rep.geo.out()
Replace Material
bl_idname : GeometryNodeReplaceMaterial
class Geometry
Geometry.replace_material(self, old: Material = None, new: Material = None)
nd
nd.replace_material(cls, geometry: Geometry = None, old: Material = None, new: Material = None)
Replace String
bl_idname : FunctionNodeReplaceString
class String
String.replace(self, find: String = None, replace: String = None)
nd
nd.replace_string(cls, string: String = None, find: String = None, replace: String = None)
Reroute
bl_idname : NodeReroute
nd
nd.reroute(cls, input: Color = None, socket_idname = 'NodeSocketColor')
snd
nd.reroute(cls, input: Color = None, socket_idname = 'NodeSocketColor')
Resample Curve
bl_idname : GeometryNodeResampleCurve
class Curve
Curve.resample(self,
mode: Literal['Evaluated', 'Count', 'Length'] = None,
count: Integer = None,
length: Float = None,
keep_last_segment = True)
nd
nd.resample_curve(cls,
curve: Curve = None,
selection: Boolean = None,
mode: Literal['Evaluated', 'Count', 'Length'] = None,
count: Integer = None,
length: Float = None,
keep_last_segment = True)
Reverse Curve
bl_idname : GeometryNodeReverseCurve
class Curve
nd
nd.reverse_curve(cls, curve: Curve = None, selection: Boolean = None)
Rotate Instances
bl_idname : GeometryNodeRotateInstances
class Instances
Instances.rotate(self,
rotation: Rotation = None,
pivot_point: Vector = None,
local_space: Boolean = None)
nd
nd.rotate_instances(cls,
instances: Instances = None,
selection: Boolean = None,
rotation: Rotation = None,
pivot_point: Vector = None,
local_space: Boolean = None)
Rotate Rotation
bl_idname : FunctionNodeRotateRotation
class Rotation
Rotation.rotate(self,
rotate_by: Rotation = None,
rotation_space: Literal['GLOBAL', 'LOCAL'] = 'GLOBAL')
Rotation.rotate_global(self, rotate_by: Rotation = None)
Rotation.rotate_local(self, rotate_by: Rotation = None)
nd
nd.rotate_rotation(cls,
rotation: Rotation = None,
rotate_by: Rotation = None,
rotation_space: Literal['GLOBAL', 'LOCAL'] = 'GLOBAL')
Rotate Vector
bl_idname : FunctionNodeRotateVector
class Rotation
Rotation.rotate_vector(self, vector: Vector = None)
nd
nd.rotate_vector(cls, vector: Vector = None, rotation: Rotation = None)
Rotation
bl_idname : FunctionNodeInputRotation
nd
Rotation to Axis Angle
bl_idname : FunctionNodeRotationToAxisAngle
class Rotation
Rotation.to_axis_angle(self)
prop = Rotation.axis_angle
nd
nd.rotation_to_axis_angle(cls, rotation: Rotation = None)
Rotation to Euler
bl_idname : FunctionNodeRotationToEuler
class Rotation
nd
nd.rotation_to_euler(cls, rotation: Rotation = None)
Rotation to Quaternion
bl_idname : FunctionNodeRotationToQuaternion
class Rotation
Rotation.to_quaternion(self)
nd
nd.rotation_to_quaternion(cls, rotation: Rotation = None)
SDF Grid Boolean
bl_idname : GeometryNodeSDFGridBoolean
class Float
Float.sdf_grid_boolean(self,
*grid_2: Float,
operation: Literal['INTERSECT', 'UNION', 'DIFFERENCE'] = 'DIFFERENCE')
Float.sdf_intersect(self, *grid: Float)
Float.sdf_union(self, *grid: Float)
Float.sdf_difference(self, *grid_2: Float)
nd
nd.sdf_grid_boolean(cls,
*grid_2: Float,
grid_1: Float = None,
operation: Literal['INTERSECT', 'UNION', 'DIFFERENCE'] = 'DIFFERENCE')
SDF Grid Fillet
bl_idname : GeometryNodeSDFGridFillet
class Float
Float.sdf_grid_fillet(self, iterations: Integer = None)
nd
nd.sdf_grid_fillet(cls, grid: Float = None, iterations: Integer = None)
SDF Grid Laplacian
bl_idname : GeometryNodeSDFGridLaplacian
class Float
Float.sdf_grid_laplacian(self, iterations: Integer = None)
nd
nd.sdf_grid_laplacian(cls, grid: Float = None, iterations: Integer = None)
SDF Grid Mean
bl_idname : GeometryNodeSDFGridMean
class Float
Float.sdf_grid_mean(self, width: Integer = None, iterations: Integer = None)
nd
nd.sdf_grid_mean(cls, grid: Float = None, width: Integer = None, iterations: Integer = None)
SDF Grid Mean Curvature
bl_idname : GeometryNodeSDFGridMeanCurvature
class Float
Float.sdf_grid_mean_curvature(self, iterations: Integer = None)
nd
nd.sdf_grid_mean_curvature(cls, grid: Float = None, iterations: Integer = None)
bl_idname : GeometryNodeSDFGridMedian
class Float
Float.sdf_grid_median(self, width: Integer = None, iterations: Integer = None)
nd
nd.sdf_grid_median(cls, grid: Float = None, width: Integer = None, iterations: Integer = None)
SDF Grid Offset
bl_idname : GeometryNodeSDFGridOffset
class Float
Float.sdf_grid_offset(self, distance: Float = None)
nd
nd.sdf_grid_offset(cls, grid: Float = None, distance: Float = None)
Sample Curve
bl_idname : GeometryNodeSampleCurve
class Curve
Curve.sample_factor(self,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
curve_index: Integer = None,
factor: Float = None,
use_all_curves = False)
Curve.sample_length(self,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
length: Float = None,
curve_index: Integer = None,
use_all_curves = False)
Curve.sample(self,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
curve_index: Integer = None,
factor: Float = None,
mode: Literal['FACTOR', 'LENGTH'] = 'FACTOR',
use_all_curves = False)
nd
nd.sample_curve(cls,
curves: Curve = None,
value: Float = None,
length: Float = None,
curve_index: Integer = None,
factor: Float = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT',
mode: Literal['FACTOR', 'LENGTH'] = 'FACTOR',
use_all_curves = False)
Sample Grid
bl_idname : GeometryNodeSampleGrid
class Float
Float.sample_grid(self,
position: Vector = None,
interpolation: Literal['Nearest Neighbor', 'Trilinear', 'Triquadratic'] = None)
class Integer
Integer.sample_grid(self,
position: Vector = None,
interpolation: Literal['Nearest Neighbor', 'Trilinear', 'Triquadratic'] = None)
class Boolean
Boolean.sample_grid(self,
position: Vector = None,
interpolation: Literal['Nearest Neighbor', 'Trilinear', 'Triquadratic'] = None)
class Vector
Vector.sample_grid(self,
position: Vector = None,
interpolation: Literal['Nearest Neighbor', 'Trilinear', 'Triquadratic'] = None)
nd
nd.sample_grid(cls,
grid: Float = None,
position: Vector = None,
interpolation: Literal['Nearest Neighbor', 'Trilinear', 'Triquadratic'] = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT')
Sample Grid Index
bl_idname : GeometryNodeSampleGridIndex
class Float
Float.sample_grid_index(self, x: Integer = None, y: Integer = None, z: Integer = None)
class Integer
Integer.sample_grid_index(self, x: Integer = None, y: Integer = None, z: Integer = None)
class Boolean
Boolean.sample_grid_index(self, x: Integer = None, y: Integer = None, z: Integer = None)
class Vector
Vector.sample_grid_index(self, x: Integer = None, y: Integer = None, z: Integer = None)
nd
nd.sample_grid_index(cls,
grid: Float = None,
x: Integer = None,
y: Integer = None,
z: Integer = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT')
Sample Index
bl_idname : GeometryNodeSampleIndex
class Point
Mesh.points.sample_index(self,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
index: Integer = None,
clamp = False)
class Edge
Mesh.edges.sample_index(self,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
index: Integer = None,
clamp = False)
class Face
Mesh.faces.sample_index(self,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
index: Integer = None,
clamp = False)
class Corner
Mesh.corners.sample_index(self,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
index: Integer = None,
clamp = False)
class Spline
Spline.splines.sample_index(self,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
index: Integer = None,
clamp = False)
class Instance
Instances.insts.sample_index(self,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
index: Integer = None,
clamp = False)
class Layer
GreasePencil.layers.sample_index(self,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
index: Integer = None,
clamp = False)
nd
nd.sample_index(cls,
geometry: Geometry = None,
value: Float = None,
index: Integer = None,
clamp = False,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT',
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
Sample Nearest
bl_idname : GeometryNodeSampleNearest
class Point
Mesh.points.sample_nearest(self, sample_position: Vector = None)
class Edge
Mesh.edges.sample_nearest(self, sample_position: Vector = None)
class Face
Mesh.faces.sample_nearest(self, sample_position: Vector = None)
class Corner
Mesh.corners.sample_nearest(self, sample_position: Vector = None)
nd
nd.sample_nearest(cls,
geometry: Geometry = None,
sample_position: Vector = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER'] = 'POINT')
Sample Nearest Surface
bl_idname : GeometryNodeSampleNearestSurface
class Mesh
Mesh.sample_nearest_surface(self,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
group_id: Integer = None,
sample_position: Vector = None,
sample_group_id: Integer = None)
nd
nd.sample_nearest_surface(cls,
mesh: Mesh = None,
value: Float = None,
group_id: Integer = None,
sample_position: Vector = None,
sample_group_id: Integer = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT')
Sample UV Surface
bl_idname : GeometryNodeSampleUVSurface
class Mesh
Mesh.sample_uv_surface(self,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix = None,
uv_map: Vector = None,
sample_uv: Vector = None)
nd
nd.sample_uv_surface(cls,
mesh: Mesh = None,
value: Float = None,
uv_map: Vector = None,
sample_uv: Vector = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT')
Scale Elements
bl_idname : GeometryNodeScaleElements
class Face
Mesh.faces.scale(self,
scale: Float = None,
center: Vector = None,
scale_mode: Literal['Uniform', 'Single Axis'] = None,
axis: Vector = None)
class Edge
Mesh.edges.scale(self,
scale: Float = None,
center: Vector = None,
scale_mode: Literal['Uniform', 'Single Axis'] = None,
axis: Vector = None)
nd
nd.scale_elements(cls,
geometry: Geometry = None,
selection: Boolean = None,
scale: Float = None,
center: Vector = None,
scale_mode: Literal['Uniform', 'Single Axis'] = None,
axis: Vector = None,
domain: Literal['FACE', 'EDGE'] = 'FACE')
Scale Instances
bl_idname : GeometryNodeScaleInstances
class Instances
Instances.scale(self, scale: Vector = None, center: Vector = None, local_space: Boolean = None)
nd
nd.scale_instances(cls,
instances: Instances = None,
selection: Boolean = None,
scale: Vector = None,
center: Vector = None,
local_space: Boolean = None)
Scene Time
bl_idname : GeometryNodeInputSceneTime
class Float
nd
Script
bl_idname : ShaderNodeScript
snd
nd.script(cls,
bytecode = '',
bytecode_hash = '',
filepath = '',
mode: Literal['INTERNAL', 'EXTERNAL'] = 'INTERNAL',
script = None,
use_auto_update = False)
Selection
bl_idname : GeometryNodeToolSelection
nd
Self Object
bl_idname : GeometryNodeSelfObject
class Object
nd
Separate Bundle
bl_idname : NodeSeparateBundle
class Bundle
Bundle.separate_bundle(self, named_sockets: dict = {}, define_signature = False, **sockets)
nd
nd.separate_bundle(cls,
named_sockets: dict = {},
bundle: Bundle = None,
define_signature = False,
**sockets)
snd
nd.separate_bundle(cls,
named_sockets: dict = {},
bundle: Bundle = None,
define_signature = False,
**sockets)
Separate Color
bl_idname : ShaderNodeSeparateColor
class Color
Color.separate_col_RGB(self)
Color.separate_col_HSV(self)
Color.separate_col_HSL(self)
Color.separate_col(self, mode: Literal['RGB', 'HSV', 'HSL'] = 'RGB')
snd
nd.separate_color(cls, color: Color = None, mode: Literal['RGB', 'HSV', 'HSL'] = 'RGB')
Separate Components
bl_idname : GeometryNodeSeparateComponents
class Geometry
Geometry.separate_components(self)
prop = Geometry.grease_pencil
prop = Geometry.point_cloud
prop = Geometry.instances
nd
nd.separate_components(cls, geometry: Geometry = None)
Separate Geometry
bl_idname : GeometryNodeSeparateGeometry
class Point
Mesh.points.separate(self)
class Edge
Mesh.edges.separate(self)
class Face
Mesh.faces.separate(self)
class Spline
Spline.splines.separate(self)
class Instance
Instances.insts.separate(self)
class Layer
GreasePencil.layers.separate(self)
nd
nd.separate_geometry(cls,
geometry: Geometry = None,
selection: Boolean = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
Separate Matrix
bl_idname : FunctionNodeSeparateMatrix
class Matrix
Matrix.separate_matrix(self)
prop = Matrix.column_1_row_1
prop = Matrix.column_1_row_2
prop = Matrix.column_1_row_3
prop = Matrix.column_1_row_4
prop = Matrix.column_2_row_1
prop = Matrix.column_2_row_2
prop = Matrix.column_2_row_3
prop = Matrix.column_2_row_4
prop = Matrix.column_3_row_1
prop = Matrix.column_3_row_2
prop = Matrix.column_3_row_3
prop = Matrix.column_3_row_4
prop = Matrix.column_4_row_1
prop = Matrix.column_4_row_2
prop = Matrix.column_4_row_3
prop = Matrix.column_4_row_4
nd
nd.separate_matrix(cls, matrix: Matrix = None)
bl_idname : FunctionNodeSeparateTransform
class Matrix
Matrix.separate_transform(self)
prop = Matrix.translation
nd
nd.separate_transform(cls, transform: Matrix = None)
Separate XYZ
bl_idname : ShaderNodeSeparateXYZ
class Vector
Vector.separate_xyz(self)
nd
nd.separate_xyz(cls, vector: Vector = None)
snd
nd.separate_xyz(cls, vector: Vector = None)
Set Curve Normal
bl_idname : GeometryNodeSetCurveNormal
class Curve
Curve.set_normal(self,
mode: Literal['Minimum Twist', 'Z Up', 'Free'] = None,
normal: Vector = None)
class Spline
Spline.splines.normal = value
nd
nd.set_curve_normal(cls,
curve: Curve = None,
selection: Boolean = None,
mode: Literal['Minimum Twist', 'Z Up', 'Free'] = None,
normal: Vector = None)
Set Curve Radius
bl_idname : GeometryNodeSetCurveRadius
class Curve
Curve.set_radius(self, radius: Float = None)
class SplinePoint
Spline.points.radius = value
nd
nd.set_curve_radius(cls, curve: Curve = None, selection: Boolean = None, radius: Float = None)
Set Curve Tilt
bl_idname : GeometryNodeSetCurveTilt
class Curve
Curve.set_tilt(self, tilt: Float = None)
class Spline
Spline.splines.tilt = value
nd
nd.set_curve_tilt(cls, curve: Curve = None, selection: Boolean = None, tilt: Float = None)
Set Face Set
bl_idname : GeometryNodeToolSetFaceSet
class Mesh
Mesh.set_face_set(self, face_set: Integer = None)
nd
nd.set_face_set(cls, mesh: Mesh = None, selection: Boolean = None, face_set: Integer = None)
Set Geometry Bundle
bl_idname : GeometryNodeSetGeometryBundle
nd
nd.set_geometry_bundle(cls, geometry: Geometry = None, bundle: Bundle = None)
Set Geometry Name
bl_idname : GeometryNodeSetGeometryName
class Geometry
Geometry.set_name(self, name: String = None)
nd
nd.set_geometry_name(cls, geometry: Geometry = None, name: String = None)
Set Grease Pencil Color
bl_idname : GeometryNodeSetGreasePencilColor
class GreasePencil
GreasePencil.set_color_stroke(self, color: Color = None, opacity: Float = None)
GreasePencil.set_color_fill(self, color: Color = None, opacity: Float = None)
GreasePencil.set_color(self,
color: Color = None,
opacity: Float = None,
mode: Literal['STROKE', 'FILL'] = 'STROKE')
GreasePencil.stroke_color = value
GreasePencil.fill_color = value
nd
nd.set_grease_pencil_color(cls,
grease_pencil: GreasePencil = None,
selection: Boolean = None,
color: Color = None,
opacity: Float = None,
mode: Literal['STROKE', 'FILL'] = 'STROKE')
Set Grease Pencil Depth
bl_idname : GeometryNodeSetGreasePencilDepth
class GreasePencil
GreasePencil.set_depth(self, depth_order: Literal['2D', '3D'] = '2D')
GreasePencil.depth = value
nd
nd.set_grease_pencil_depth(cls,
grease_pencil: GreasePencil = None,
depth_order: Literal['2D', '3D'] = '2D')
Set Grease Pencil Softness
bl_idname : GeometryNodeSetGreasePencilSoftness
class GreasePencil
GreasePencil.set_softness(self, softness: Float = None)
GreasePencil.softness = value
nd
nd.set_grease_pencil_softness(cls,
grease_pencil: GreasePencil = None,
selection: Boolean = None,
softness: Float = None)
Set Grid Background
bl_idname : GeometryNodeSetGridBackground
class Float
Float.set_grid_background(self, background: Float = None, update_inactive: Boolean = None)
class Integer
Integer.set_grid_background(self, background: Integer = None, update_inactive: Boolean = None)
class Boolean
Boolean.set_grid_background(self, background: Boolean = None, update_inactive: Boolean = None)
class Vector
Vector.set_grid_background(self, background: Vector = None, update_inactive: Boolean = None)
nd
nd.set_grid_background(cls,
grid: Float = None,
background: Float = None,
update_inactive: Boolean = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT')
bl_idname : GeometryNodeSetGridTransform
class Float
Float.set_grid_transform(self, transform: Matrix = None)
class Integer
Integer.set_grid_transform(self, transform: Matrix = None)
class Boolean
Boolean.set_grid_transform(self, transform: Matrix = None)
class Vector
Vector.set_grid_transform(self, transform: Matrix = None)
nd
nd.set_grid_transform(cls,
grid: Float = None,
transform: Matrix = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT')
Set Handle Positions
bl_idname : GeometryNodeSetCurveHandlePositions
class Curve
Curve.set_handle_positions(self,
position: Vector = None,
offset: Vector = None,
mode: Literal['LEFT', 'RIGHT'] = 'LEFT')
Curve.set_left_handle_positions(self, position: Vector = None, offset: Vector = None)
Curve.set_right_handle_positions(self, position: Vector = None, offset: Vector = None)
Curve.left_handle_position = value
Curve.right_handle_position = value
Curve.left_handle_offset = value
Curve.right_handle_offset = value
nd
nd.set_handle_positions(cls,
curve: Curve = None,
selection: Boolean = None,
position: Vector = None,
offset: Vector = None,
mode: Literal['LEFT', 'RIGHT'] = 'LEFT')
Set Handle Type
bl_idname : GeometryNodeCurveSetHandles
class Curve
Curve.set_handle_type(self,
handle_type: Literal['FREE', 'AUTO', 'VECTOR', 'ALIGN'] = 'AUTO',
mode = {'LEFT', 'RIGHT'})
Curve.set_left_handle_type(self, handle_type: Literal['FREE', 'AUTO', 'VECTOR', 'ALIGN'] = 'AUTO')
Curve.set_right_handle_type(self, handle_type: Literal['FREE', 'AUTO', 'VECTOR', 'ALIGN'] = 'AUTO')
Curve.set_both_handle_type(self, handle_type: Literal['FREE', 'AUTO', 'VECTOR', 'ALIGN'] = 'AUTO')
Curve.handle_type = value
Curve.left_handle_type = value
Curve.right_handle_type = value
nd
nd.set_handle_type(cls,
curve: Curve = None,
selection: Boolean = None,
handle_type: Literal['FREE', 'AUTO', 'VECTOR', 'ALIGN'] = 'AUTO',
mode = {'LEFT', 'RIGHT'})
Set ID
bl_idname : GeometryNodeSetID
class Geometry
Geometry.set_id(self, id: Integer = None)
nd
nd.set_id(cls, geometry: Geometry = None, selection: Boolean = None, id: Integer = None)
bl_idname : GeometryNodeSetInstanceTransform
class Instances
Instances.set_transform(self, transform: Matrix = None)
Instances.transform = value
nd
nd.set_instance_transform(cls,
instances: Instances = None,
selection: Boolean = None,
transform: Matrix = None)
Set Material
bl_idname : GeometryNodeSetMaterial
class Geometry
Geometry.set_material(self, material: Material = None)
Geometry.material = value
class Face
Mesh.faces.material = value
class Edge
Mesh.edges.material = value
nd
nd.set_material(cls,
geometry: Geometry = None,
selection: Boolean = None,
material: Material = None)
Set Material Index
bl_idname : GeometryNodeSetMaterialIndex
class Geometry
Geometry.set_material_index(self, material_index: Integer = None)
Geometry.material_index = value
class Face
Mesh.faces.material_index = value
class Spline
Spline.splines.material_index = value
nd
nd.set_material_index(cls,
geometry: Geometry = None,
selection: Boolean = None,
material_index: Integer = None)
Set Mesh Normal
bl_idname : GeometryNodeSetMeshNormal
class Mesh
Mesh.set_normal_sharpness(self,
remove_custom: Boolean = None,
edge_sharpness: Boolean = None,
face_sharpness: Boolean = None,
domain: Literal['POINT', 'FACE', 'CORNER'] = 'POINT')
Mesh.set_normal_free(self,
custom_normal: Vector = None,
domain: Literal['POINT', 'FACE', 'CORNER'] = 'POINT')
Mesh.set_normal_tangent_space(self,
custom_normal: Vector = None,
domain: Literal['POINT', 'FACE', 'CORNER'] = 'POINT')
Mesh.set_normal(self,
remove_custom: Boolean = None,
edge_sharpness: Boolean = None,
face_sharpness: Boolean = None,
domain: Literal['POINT', 'FACE', 'CORNER'] = 'POINT',
mode: Literal['SHARPNESS', 'FREE', 'TANGENT_SPACE'] = 'SHARPNESS')
class Point
Mesh.points.normal = value
class Face
Mesh.faces.normal = value
class Corner
Mesh.corners.normal = value
nd
nd.set_mesh_normal(cls,
mesh: Mesh = None,
remove_custom: Boolean = None,
edge_sharpness: Boolean = None,
face_sharpness: Boolean = None,
domain: Literal['POINT', 'FACE', 'CORNER'] = 'POINT',
mode: Literal['SHARPNESS', 'FREE', 'TANGENT_SPACE'] = 'SHARPNESS')
Set Point Radius
bl_idname : GeometryNodeSetPointRadius
class Point
Mesh.points.set_radius(self, radius: Float = None)
class Cloud
class CloudPoint
Cloud.points.radius = value
nd
nd.set_point_radius(cls, points: Cloud = None, selection: Boolean = None, radius: Float = None)
Set Position
bl_idname : GeometryNodeSetPosition
class Geometry
Geometry.set_position(self, position: Vector = None, offset: Vector = None)
Geometry.position = value
class Point
Mesh.points.position = value
Mesh.points.offset = value
nd
nd.set_position(cls,
geometry: Geometry = None,
selection: Boolean = None,
position: Vector = None,
offset: Vector = None)
Set Selection
bl_idname : GeometryNodeToolSetSelection
class Point
Mesh.points.set_selection(self)
class Edge
Mesh.edges.set_selection(self)
class Face
Mesh.faces.set_selection(self)
class Spline
Spline.splines.set_selection(self)
nd
nd.set_selection(cls,
geometry: Geometry = None,
selection: Boolean = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CURVE'] = 'POINT',
selection_type: Literal['BOOLEAN', 'FLOAT'] = 'BOOLEAN')
Set Shade Smooth
bl_idname : GeometryNodeSetShadeSmooth
class Edge
Mesh.edges.set_shade_smooth(self, shade_smooth: Boolean = None)
Mesh.edges.shade_smooth = value
Mesh.edges.smooth = value
class Face
Mesh.faces.set_shade_smooth(self, shade_smooth: Boolean = None)
Mesh.faces.shade_smooth = value
Mesh.faces.smooth = value
nd
nd.set_shade_smooth(cls,
mesh: Mesh = None,
selection: Boolean = None,
shade_smooth: Boolean = None,
domain: Literal['EDGE', 'FACE'] = 'FACE')
Set Spline Cyclic
bl_idname : GeometryNodeSetSplineCyclic
class Curve
Curve.set_spline_cyclic(self, cyclic: Boolean = None)
class Spline
Spline.splines.is_cyclic = value
nd
nd.set_spline_cyclic(cls, curve: Curve = None, selection: Boolean = None, cyclic: Boolean = None)
Set Spline Resolution
bl_idname : GeometryNodeSetSplineResolution
class Curve
Curve.set_spline_resolution(self, resolution: Integer = None)
class Spline
Spline.splines.resolution = value
nd
nd.set_spline_resolution(cls,
curve: Curve = None,
selection: Boolean = None,
resolution: Integer = None)
Set Spline Type
bl_idname : GeometryNodeCurveSplineType
class Curve
Curve.set_spline_type(self, spline_type: Literal['CATMULL_ROM', 'POLY', 'BEZIER', 'NURBS'] = 'POLY')
class Spline
Spline.splines.type = value
nd
nd.set_spline_type(cls,
curve: Curve = None,
selection: Boolean = None,
spline_type: Literal['CATMULL_ROM', 'POLY', 'BEZIER', 'NURBS'] = 'POLY')
Shader to RGB
bl_idname : ShaderNodeShaderToRGB
class Shader
snd
nd.shader_to_rgb(cls, shader: Shader = None)
Sheen BSDF
bl_idname : ShaderNodeBsdfSheen
class Shader
Shader.Sheen(cls,
color: Color = None,
roughness: Float = None,
normal: Vector = None,
distribution: Literal['ASHIKHMIN', 'MICROFIBER'] = 'MICROFIBER')
snd
nd.sheen_bsdf(cls,
color: Color = None,
roughness: Float = None,
normal: Vector = None,
weight: Float = None,
distribution: Literal['ASHIKHMIN', 'MICROFIBER'] = 'MICROFIBER')
Shortest Edge Paths
bl_idname : GeometryNodeInputShortestEdgePaths
class Mesh
Mesh.shortest_edge_paths(cls, end_vertex: Boolean = None, edge_cost: Float = None)
class Edge
Mesh.edges.shortest_paths(cls, end_vertex: Boolean = None, edge_cost: Float = None)
nd
nd.shortest_edge_paths(cls, end_vertex: Boolean = None, edge_cost: Float = None)
bl_idname : GeometryNodeSimulationInput
class Simulation
with GeoNodes("Simulation Example"):
for sim in simulation(geo=Geometry(), pos=(0, 0, 0), speed=(1, 0, 10)):
delta = sim.speed.scale(sim.delta_time)
sim.pos += delta
sim.geo.transform(translation=delta)
x, y, z = sim.pos.xyz
sim.speed -= (0, 0, 10*sim.delta_time)
bounce = z < 0
sim.speed.switch(bounce, -sim.speed)
sim.pos.switch(bounce, (x, y, -z))
sim.geo.out()
Simulation Output
bl_idname : GeometryNodeSimulationOutput
class Simulation
with GeoNodes("Simulation Example"):
for sim in simulation(geo=Geometry(), pos=(0, 0, 0), speed=(1, 0, 10)):
delta = sim.speed.scale(sim.delta_time)
sim.pos += delta
sim.geo.transform(translation=delta)
x, y, z = sim.pos.xyz
sim.speed -= (0, 0, 10*sim.delta_time)
bounce = z < 0
sim.speed.switch(bounce, -sim.speed)
sim.pos.switch(bounce, (x, y, -z))
sim.geo.out()
Sky Texture
bl_idname : ShaderNodeTexSky
class Color
Color.SkyTexture(cls,
aerosol_density = 1.0,
air_density = 1.0,
altitude = 100.0,
ground_albedo = 0.30000001192092896,
ozone_density = 1.0,
sky_type: Literal['SINGLE_SCATTERING', 'MULTIPLE_SCATTERING', 'PREETHAM', 'HOSEK_WILKIE'] = 'MULTIPLE_SCATTERING',
sun_disc = True,
sun_elevation = 0.2617993950843811,
sun_intensity = 1.0,
sun_rotation = 0.0,
sun_size = 0.009512044489383698,
turbidity = 2.200000047683716)
snd
nd.sky_texture(cls,
vector: Vector = None,
aerosol_density = 1.0,
air_density = 1.0,
altitude = 100.0,
ground_albedo = 0.30000001192092896,
ozone_density = 1.0,
sky_type: Literal['SINGLE_SCATTERING', 'MULTIPLE_SCATTERING', 'PREETHAM', 'HOSEK_WILKIE'] = 'MULTIPLE_SCATTERING',
sun_disc = True,
sun_elevation = 0.2617993950843811,
sun_intensity = 1.0,
sun_rotation = 0.0,
sun_size = 0.009512044489383698,
turbidity = 2.200000047683716)
Slice String
bl_idname : FunctionNodeSliceString
class String
String.slice(self, position: Integer = None, length: Integer = None)
nd
nd.slice_string(cls, string: String = None, position: Integer = None, length: Integer = None)
Sort Elements
bl_idname : GeometryNodeSortElements
class Point
Mesh.points.sort(self, group_id: Integer = None, sort_weight: Float = None)
class Edge
Mesh.edges.sort(self, group_id: Integer = None, sort_weight: Float = None)
class Face
Mesh.faces.sort(self, group_id: Integer = None, sort_weight: Float = None)
class Spline
Spline.splines.sort(self, group_id: Integer = None, sort_weight: Float = None)
class Instance
Instances.insts.sort(self, group_id: Integer = None, sort_weight: Float = None)
nd
nd.sort_elements(cls,
geometry: Geometry = None,
selection: Boolean = None,
group_id: Integer = None,
sort_weight: Float = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE'] = 'POINT')
Special Characters
bl_idname : FunctionNodeInputSpecialCharacters
class String
prop = String.special_characters
nd
nd.special_characters(cls)
Specular BSDF
bl_idname : ShaderNodeEeveeSpecular
class Shader
Shader.Specular(cls,
base_color: Color = None,
specular: Color = None,
roughness: Float = None,
emissive_color: Color = None,
transparency: Float = None,
normal: Vector = None,
clear_coat: Float = None,
clear_coat_roughness: Float = None,
clear_coat_normal: Vector = None)
snd
nd.specular_bsdf(cls,
base_color: Color = None,
specular: Color = None,
roughness: Float = None,
emissive_color: Color = None,
transparency: Float = None,
normal: Vector = None,
clear_coat: Float = None,
clear_coat_roughness: Float = None,
clear_coat_normal: Vector = None,
weight: Float = None)
Spiral
bl_idname : GeometryNodeCurveSpiral
class Curve
Curve.Spiral(cls,
resolution: Integer = None,
rotations: Float = None,
start_radius: Float = None,
end_radius: Float = None,
height: Float = None,
reverse: Boolean = None)
nd
nd.spiral(cls,
resolution: Integer = None,
rotations: Float = None,
start_radius: Float = None,
end_radius: Float = None,
height: Float = None,
reverse: Boolean = None)
Spline Length
bl_idname : GeometryNodeSplineLength
class Curve
class Spline
prop = Spline.splines.spline_length
prop = Spline.splines.length
prop = Spline.splines.point_count
nd
Spline Parameter
bl_idname : GeometryNodeSplineParameter
class Curve
Curve.spline_parameter(cls)
class Spline
prop = Spline.splines.parameter
prop = Spline.splines.parameter_factor
prop = Spline.splines.parameter_length
prop = Spline.splines.parameter_index
nd
Spline Resolution
bl_idname : GeometryNodeInputSplineResolution
class Curve
class Spline
prop = Spline.splines.resolution
nd
nd.spline_resolution(self)
Split Edges
bl_idname : GeometryNodeSplitEdges
class Mesh
class Edge
nd
nd.split_edges(cls, mesh: Mesh = None, selection: Boolean = None)
Split to Instances
bl_idname : GeometryNodeSplitToInstances
class Point
Mesh.points.split_to_instances(self, group_id: Integer = None)
class Edge
Mesh.edges.split_to_instances(self, group_id: Integer = None)
class Face
Mesh.faces.split_to_instances(self, group_id: Integer = None)
class Spline
Spline.splines.split_to_instances(self, group_id: Integer = None)
class Instance
Instances.insts.split_to_instances(self, group_id: Integer = None)
class Layer
GreasePencil.layers.split_to_instances(self, group_id: Integer = None)
nd
nd.split_to_instances(cls,
geometry: Geometry = None,
selection: Boolean = None,
group_id: Integer = None,
domain: Literal['POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
Star
bl_idname : GeometryNodeCurveStar
class Curve
Curve.Star(cls,
points: Integer = None,
inner_radius: Float = None,
outer_radius: Float = None,
twist: Float = None)
nd
nd.star(cls,
points: Integer = None,
inner_radius: Float = None,
outer_radius: Float = None,
twist: Float = None)
Store Bundle Item
bl_idname : NodeStoreBundleItem
class Bundle
Bundle.set_item(self,
path: String = None,
item: Float = None,
structure_type: Literal['AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'] = 'AUTO')
Bundle.store_item(self,
path: String = None,
item: Float = None,
structure_type: Literal['AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'] = 'AUTO')
nd
nd.store_bundle_item(cls,
bundle: Bundle = None,
path: String = None,
item: Float = None,
socket_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT',
structure_type: Literal['AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'] = 'AUTO')
Store Named Attribute
bl_idname : GeometryNodeStoreNamedAttribute
class Point
Mesh.points.store_named_attribute(self,
name: String = None,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix | Integer | Vector | Color = None)
Mesh.points.store(self,
name: String = None,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix | Integer | Vector | Color = None)
class Edge
Mesh.edges.store_named_attribute(self,
name: String = None,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix | Integer | Vector | Color = None)
Mesh.edges.store(self,
name: String = None,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix | Integer | Vector | Color = None)
class Face
Mesh.faces.store_named_attribute(self,
name: String = None,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix | Integer | Vector | Color = None)
Mesh.faces.store(self,
name: String = None,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix | Integer | Vector | Color = None)
class Corner
Mesh.corners.store_named_attribute(self,
name: String = None,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix | Integer | Vector | Color = None)
Mesh.corners.store(self,
name: String = None,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix | Integer | Vector | Color = None)
Mesh.corners.store_uv(self, name: String = None, value: Vector = None)
class Spline
Spline.splines.store_named_attribute(self,
name: String = None,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix | Integer | Vector | Color = None)
Spline.splines.store(self,
name: String = None,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix | Integer | Vector | Color = None)
class Instance
Instances.insts.store_named_attribute(self,
name: String = None,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix | Integer | Vector | Color = None)
Instances.insts.store(self,
name: String = None,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix | Integer | Vector | Color = None)
class Layer
GreasePencil.layers.store_named_attribute(self,
name: String = None,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix | Integer | Vector | Color = None)
GreasePencil.layers.store(self,
name: String = None,
value: Float | Integer | Boolean | Vector | Color | Rotation | Matrix | Integer | Vector | Color = None)
nd
nd.store_named_attribute(cls,
geometry: Geometry = None,
selection: Boolean = None,
name: String = None,
value: Float = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4', 'INT8', 'FLOAT2', 'BYTE_COLOR'] = 'FLOAT',
domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT')
Store Named Grid
bl_idname : GeometryNodeStoreNamedGrid
class Volume
Volume.store_named_grid(self, name: String = None, grid: Boolean | Float | Integer | Vector = None)
nd
nd.store_named_grid(cls,
volume: Volume = None,
name: String = None,
grid: Float = None,
data_type: Literal['BOOLEAN', 'FLOAT', 'INT', 'VECTOR_FLOAT'] = 'FLOAT')
String
bl_idname : FunctionNodeInputString
nd
nd.string(cls, string = '')
String Length
bl_idname : FunctionNodeStringLength
class String
nd
nd.string_length(cls, string: String = None)
String to Curves
bl_idname : GeometryNodeStringToCurves
class String
String.to_curves(self,
size: Float = None,
font: Font = None,
align_x: Literal['Left', 'Center', 'Right', 'Justify', 'Flush'] = None,
align_y: Literal['Top', 'Top Baseline', 'Middle', 'Bottom Baseline', 'Bottom'] = None,
pivot_point: Literal['Midpoint', 'Top Left', 'Top Center', 'Top Right', 'Bottom Left', 'Bottom Center', 'Bottom Right'] = None,
character_spacing: Float = None,
word_spacing: Float = None,
line_spacing: Float = None,
overflow: Literal['Overflow', 'Scale To Fit', 'Truncate'] = None,
text_box_width: Float = None,
text_box_height: Float = None)
nd
nd.string_to_curves(cls,
string: String = None,
size: Float = None,
font: Font = None,
align_x: Literal['Left', 'Center', 'Right', 'Justify', 'Flush'] = None,
align_y: Literal['Top', 'Top Baseline', 'Middle', 'Bottom Baseline', 'Bottom'] = None,
pivot_point: Literal['Midpoint', 'Top Left', 'Top Center', 'Top Right', 'Bottom Left', 'Bottom Center', 'Bottom Right'] = None,
character_spacing: Float = None,
word_spacing: Float = None,
line_spacing: Float = None,
overflow: Literal['Overflow', 'Scale To Fit', 'Truncate'] = None,
text_box_width: Float = None,
text_box_height: Float = None)
String to Value
bl_idname : FunctionNodeStringToValue
class String
String.to_value(self, data_type: Literal['FLOAT', 'INT'] = 'FLOAT')
nd
nd.string_to_value(cls, string: String = None, data_type: Literal['FLOAT', 'INT'] = 'FLOAT')
Subdivide Curve
bl_idname : GeometryNodeSubdivideCurve
class Curve
Curve.subdivide(self, cuts: Integer = None)
nd
nd.subdivide_curve(cls, curve: Curve = None, cuts: Integer = None)
Subdivide Mesh
bl_idname : GeometryNodeSubdivideMesh
class Mesh
Mesh.subdivide(self, level: Integer = None)
nd
nd.subdivide_mesh(cls, mesh: Mesh = None, level: Integer = None)
Subdivision Surface
bl_idname : GeometryNodeSubdivisionSurface
class Mesh
Mesh.subdivision_surface(self,
level: Integer = None,
edge_crease: Float = None,
vertex_crease: Float = None,
limit_surface: Boolean = None,
uv_smooth: Literal['None', 'Keep Corners', 'Keep Corners, Junctions', 'Keep Corners, Junctions, Concave', 'Keep Boundaries', 'All'] = None,
boundary_smooth: Literal['Keep Corners', 'All'] = None)
nd
nd.subdivision_surface(cls,
mesh: Mesh = None,
level: Integer = None,
edge_crease: Float = None,
vertex_crease: Float = None,
limit_surface: Boolean = None,
uv_smooth: Literal['None', 'Keep Corners', 'Keep Corners, Junctions', 'Keep Corners, Junctions, Concave', 'Keep Boundaries', 'All'] = None,
boundary_smooth: Literal['Keep Corners', 'All'] = None)
Subsurface Scattering
bl_idname : ShaderNodeSubsurfaceScattering
class Shader
Shader.SubsurfaceScattering(cls,
color: Color = None,
scale: Float = None,
radius: Vector = None,
ior: Float = None,
roughness: Float = None,
anisotropy: Float = None,
normal: Vector = None,
falloff: Literal['BURLEY', 'RANDOM_WALK', 'RANDOM_WALK_SKIN'] = 'RANDOM_WALK')
snd
nd.subsurface_scattering(cls,
color: Color = None,
scale: Float = None,
radius: Vector = None,
ior: Float = None,
roughness: Float = None,
anisotropy: Float = None,
normal: Vector = None,
weight: Float = None,
falloff: Literal['BURLEY', 'RANDOM_WALK', 'RANDOM_WALK_SKIN'] = 'RANDOM_WALK')
Switch
bl_idname : GeometryNodeSwitch
class Socket
Socket.Switch(condition=None, false=None, true=None)
Socket.switch(condition=None, true=None)
Tangent
bl_idname : ShaderNodeTangent
class Vector
Vector.Tangent(cls,
axis: Literal['X', 'Y', 'Z'] = 'Z',
direction_type: Literal['RADIAL', 'UV_MAP'] = 'RADIAL',
uv_map = '')
snd
nd.tangent(cls,
axis: Literal['X', 'Y', 'Z'] = 'Z',
direction_type: Literal['RADIAL', 'UV_MAP'] = 'RADIAL',
uv_map = '')
Texture Coordinate
bl_idname : ShaderNodeTexCoord
snd
nd.texture_coordinate(cls, from_instancer = False, object = None)
Toon BSDF
bl_idname : ShaderNodeBsdfToon
class Shader
Shader.Toon(cls,
color: Color = None,
size: Float = None,
smooth: Float = None,
normal: Vector = None,
component: Literal['DIFFUSE', 'GLOSSY'] = 'DIFFUSE')
snd
nd.toon_bsdf(cls,
color: Color = None,
size: Float = None,
smooth: Float = None,
normal: Vector = None,
weight: Float = None,
component: Literal['DIFFUSE', 'GLOSSY'] = 'DIFFUSE')
bl_idname : FunctionNodeTransformDirection
class Matrix
Matrix.transform_direction(self, direction: Vector = None)
nd
nd.transform_direction(cls, direction: Vector = None, transform: Matrix = None)
bl_idname : GeometryNodeTransform
class Geometry
Geometry.transform(self,
mode: Literal['Components', 'Matrix'] = None,
translation: Vector = None,
rotation: Rotation = None,
scale: Vector = None,
transform: Matrix = None)
nd
nd.transform_geometry(cls,
geometry: Geometry = None,
mode: Literal['Components', 'Matrix'] = None,
translation: Vector = None,
rotation: Rotation = None,
scale: Vector = None,
transform: Matrix = None)
bl_idname : GeometryNodeGizmoTransform
class Matrix
Matrix.transform_gizmo(self,
*value: Matrix,
position: Vector = None,
rotation: Rotation = None,
use_rotation_x = True,
use_rotation_y = True,
use_rotation_z = True,
use_scale_x = True,
use_scale_y = True,
use_scale_z = True,
use_translation_x = True,
use_translation_y = True,
use_translation_z = True)
nd
nd.transform_gizmo(cls,
*value: Matrix,
position: Vector = None,
rotation: Rotation = None,
use_rotation_x = True,
use_rotation_y = True,
use_rotation_z = True,
use_scale_x = True,
use_scale_y = True,
use_scale_z = True,
use_translation_x = True,
use_translation_y = True,
use_translation_z = True)
bl_idname : FunctionNodeTransformPoint
class Matrix
Matrix.transform_point(self, vector: Vector = None)
nd
nd.transform_point(cls, vector: Vector = None, transform: Matrix = None)
Translate Instances
bl_idname : GeometryNodeTranslateInstances
class Instances
Instances.translate(self, translation: Vector = None, local_space: Boolean = None)
nd
nd.translate_instances(cls,
instances: Instances = None,
selection: Boolean = None,
translation: Vector = None,
local_space: Boolean = None)
Translucent BSDF
bl_idname : ShaderNodeBsdfTranslucent
class Shader
Shader.Translucent(cls, color: Color = None, normal: Vector = None)
snd
nd.translucent_bsdf(cls, color: Color = None, normal: Vector = None, weight: Float = None)
Transparent BSDF
bl_idname : ShaderNodeBsdfTransparent
class Shader
Shader.Transparent(cls, color: Color = None)
snd
nd.transparent_bsdf(cls, color: Color = None, weight: Float = None)
Transpose Matrix
bl_idname : FunctionNodeTransposeMatrix
class Matrix
nd
nd.transpose_matrix(cls, matrix: Matrix = None)
Triangulate
bl_idname : GeometryNodeTriangulate
class Mesh
Mesh.triangulate(self,
quad_method: Literal['Beauty', 'Fixed', 'Fixed Alternate', 'Shortest Diagonal', 'Longest Diagonal'] = None,
n_gon_method: Literal['Beauty', 'Clip'] = None)
nd
nd.triangulate(cls,
mesh: Mesh = None,
selection: Boolean = None,
quad_method: Literal['Beauty', 'Fixed', 'Fixed Alternate', 'Shortest Diagonal', 'Longest Diagonal'] = None,
n_gon_method: Literal['Beauty', 'Clip'] = None)
Trim Curve
bl_idname : GeometryNodeTrimCurve
class Curve
Curve.trim_factor(self, start: Float = None, end: Float = None)
Curve.trim_length(self, start: Float = None, end: Float = None)
Curve.trim(self,
start: Float = None,
end: Float = None,
mode: Literal['FACTOR', 'LENGTH'] = 'FACTOR')
nd
nd.trim_curve(cls,
curve: Curve = None,
selection: Boolean = None,
start: Float = None,
end: Float = None,
start_1: Float = None,
end_1: Float = None,
mode: Literal['FACTOR', 'LENGTH'] = 'FACTOR')
UV Along Stroke
bl_idname : ShaderNodeUVAlongStroke
snd
nd.uv_along_stroke(cls, use_tips = False)
UV Map
bl_idname : ShaderNodeUVMap
class Vector
Vector.UvMap(cls, from_instancer = False, uv_map = '')
snd
nd.uv_map(cls, from_instancer = False, uv_map = '')
UV Sphere
bl_idname : GeometryNodeMeshUVSphere
class Mesh
Mesh.UVSphere(cls, segments: Integer = None, rings: Integer = None, radius: Float = None)
nd
nd.uv_sphere(cls, segments: Integer = None, rings: Integer = None, radius: Float = None)
UV Tangent
bl_idname : GeometryNodeUVTangent
class Vector
Vector.uv_tangent(self, method: Literal['Exact', 'Fast'] = None)
nd
nd.uv_tangent(cls, method: Literal['Exact', 'Fast'] = None, uv: Vector = None)
UV Unwrap
bl_idname : GeometryNodeUVUnwrap
class Boolean
Boolean.uv_unwrap(self,
seam: Boolean = None,
margin: Float = None,
fill_holes: Boolean = None,
method: Literal['Angle Based', 'Conformal', 'Minimum Stretch'] = None,
iterations: Integer = None,
no_flip: Boolean = None)
class Corner
Mesh.corners.uv_unwrap(cls,
seam: Boolean = None,
margin: Float = None,
fill_holes: Boolean = None,
method: Literal['Angle Based', 'Conformal', 'Minimum Stretch'] = None,
iterations: Integer = None,
no_flip: Boolean = None)
nd
nd.uv_unwrap(cls,
selection: Boolean = None,
seam: Boolean = None,
margin: Float = None,
fill_holes: Boolean = None,
method: Literal['Angle Based', 'Conformal', 'Minimum Stretch'] = None,
iterations: Integer = None,
no_flip: Boolean = None)
Value
bl_idname : ShaderNodeValue
nd
snd
Value to String
bl_idname : FunctionNodeValueToString
class Float
Float.to_string(self, decimals: Integer = None)
class Integer
nd
nd.value_to_string(cls,
value: Float = None,
decimals: Integer = None,
data_type: Literal['FLOAT', 'INT'] = 'FLOAT')
Vector
bl_idname : FunctionNodeInputVector
nd
Vector Curves
bl_idname : ShaderNodeVectorCurve
nd
nd.vector_curves(cls, vector: Vector = None, factor: Float = None)
snd
nd.vector_curves(cls, vector: Vector = None, factor: Float = None)
Vector Displacement
bl_idname : ShaderNodeVectorDisplacement
class Color
Color.vector_displacement(self,
midlevel: Float = None,
scale: Float = None,
space: Literal['TANGENT', 'OBJECT', 'WORLD'] = 'TANGENT')
snd
nd.vector_displacement(cls,
vector: Color = None,
midlevel: Float = None,
scale: Float = None,
space: Literal['TANGENT', 'OBJECT', 'WORLD'] = 'TANGENT')
Vector Math
bl_idname : ShaderNodeVectorMath
class Vector
Vector.add(self, vector: Vector = None)
Vector.subtract(self, vector: Vector = None)
Vector.multiply(self, vector: Vector = None)
Vector.divide(self, vector: Vector = None)
Vector.multiply_add(self, multiplier: Vector = None, addend: Vector = None)
Vector.cross(self, vector: Vector = None)
Vector.project(self, vector: Vector = None)
Vector.reflect(self, vector: Vector = None)
Vector.refract(self, vector: Vector = None, ior: Float = None)
Vector.faceforward(self, incident: Vector = None, reference: Vector = None)
Vector.dot(self, vector: Vector = None)
Vector.distance(self, vector: Vector = None)
Vector.scale(self, scale: Float = None)
Vector.power(self, exponent: Vector = None)
Vector.min(self, vector: Vector = None)
Vector.max(self, vector: Vector = None)
Vector.modulo(self, vector: Vector = None)
Vector.wrap(self, max: Vector = None, min: Vector = None)
Vector.snap(self, increment: Vector = None)
class gnmath
gnmath.vadd(vector: Vector = None, vector_1: Vector = None)
gnmath.vsubtract(vector: Vector = None, vector_1: Vector = None)
gnmath.vmultiply(vector: Vector = None, vector_1: Vector = None)
gnmath.vdivide(vector: Vector = None, vector_1: Vector = None)
gnmath.vmultiply_add(vector: Vector = None, multiplier: Vector = None, addend: Vector = None)
gnmath.cross(vector: Vector = None, vector_1: Vector = None)
gnmath.project(vector: Vector = None, vector_1: Vector = None)
gnmath.reflect(vector: Vector = None, vector_1: Vector = None)
gnmath.refract(vector: Vector = None, vector_1: Vector = None, ior: Float = None)
gnmath.faceforward(vector: Vector = None, incident: Vector = None, reference: Vector = None)
gnmath.dot(vector: Vector = None, vector_1: Vector = None)
gnmath.distance(vector: Vector = None, vector_1: Vector = None)
gnmath.length(vector: Vector = None)
gnmath.scale(vector: Vector = None, scale: Float = None)
gnmath.normalize(vector: Vector = None)
gnmath.vabs(vector: Vector = None)
gnmath.vpower(base: Vector = None, exponent: Vector = None)
gnmath.vsign(vector: Vector = None)
gnmath.vmin(vector: Vector = None, vector_1: Vector = None)
gnmath.vmax(vector: Vector = None, vector_1: Vector = None)
gnmath.vround(vector: Vector = None)
gnmath.vfloor(vector: Vector = None)
gnmath.vceil(vector: Vector = None)
gnmath.vfraction(vector: Vector = None)
gnmath.vmodulo(vector: Vector = None, vector_1: Vector = None)
gnmath.vwrap(vector: Vector = None, max: Vector = None, min: Vector = None)
gnmath.vsnap(vector: Vector = None, increment: Vector = None)
gnmath.vsin(vector: Vector = None)
gnmath.vcos(vector: Vector = None)
gnmath.vtan(vector: Vector = None)
nd
nd.vector_math(cls,
vector: Vector = None,
vector_1: Vector = None,
vector_2: Vector = None,
scale: Float = None,
operation: Literal['ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'CROSS_PRODUCT', 'PROJECT', 'REFLECT', 'REFRACT', 'FACEFORWARD', 'DOT_PRODUCT', 'DISTANCE', 'LENGTH', 'SCALE', 'NORMALIZE', 'ABSOLUTE', 'POWER', 'SIGN', 'MINIMUM', 'MAXIMUM', 'ROUND', 'FLOOR', 'CEIL', 'FRACTION', 'MODULO', 'WRAP', 'SNAP', 'SINE', 'COSINE', 'TANGENT'] = 'ADD')
snd
nd.vector_math(cls,
vector: Vector = None,
vector_1: Vector = None,
vector_2: Vector = None,
scale: Float = None,
operation: Literal['ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'CROSS_PRODUCT', 'PROJECT', 'REFLECT', 'REFRACT', 'FACEFORWARD', 'DOT_PRODUCT', 'DISTANCE', 'LENGTH', 'SCALE', 'NORMALIZE', 'ABSOLUTE', 'POWER', 'SIGN', 'MINIMUM', 'MAXIMUM', 'ROUND', 'FLOOR', 'CEIL', 'FRACTION', 'MODULO', 'WRAP', 'SNAP', 'SINE', 'COSINE', 'TANGENT'] = 'ADD')
Vector Rotate
bl_idname : ShaderNodeVectorRotate
class Vector
Vector.rotate(self,
center: Vector = None,
axis: Vector = None,
angle: Float = None,
invert = False,
rotation_type: Literal['AXIS_ANGLE', 'X_AXIS', 'Y_AXIS', 'Z_AXIS', 'EULER_XYZ'] = 'AXIS_ANGLE')
Vector.rotate_axis_angle(self,
center: Vector = None,
axis: Vector = None,
angle: Float = None,
invert = False)
Vector.rotate_x_axis(self, center: Vector = None, angle: Float = None, invert = False)
Vector.rotate_y_axis(self, center: Vector = None, angle: Float = None, invert = False)
Vector.rotate_z_axis(self, center: Vector = None, angle: Float = None, invert = False)
Vector.rotate_euler_xyz(self, center: Vector = None, rotation: Vector = None, invert = False)
nd
nd.vector_rotate(cls,
vector: Vector = None,
center: Vector = None,
axis: Vector = None,
angle: Float = None,
rotation: Vector = None,
invert = False,
rotation_type: Literal['AXIS_ANGLE', 'X_AXIS', 'Y_AXIS', 'Z_AXIS', 'EULER_XYZ'] = 'AXIS_ANGLE')
snd
nd.vector_rotate(cls,
vector: Vector = None,
center: Vector = None,
axis: Vector = None,
angle: Float = None,
rotation: Vector = None,
invert = False,
rotation_type: Literal['AXIS_ANGLE', 'X_AXIS', 'Y_AXIS', 'Z_AXIS', 'EULER_XYZ'] = 'AXIS_ANGLE')
bl_idname : ShaderNodeVectorTransform
class Vector
Vector.vector_transform(self,
convert_from: Literal['WORLD', 'OBJECT', 'CAMERA'] = 'WORLD',
convert_to: Literal['WORLD', 'OBJECT', 'CAMERA'] = 'OBJECT',
vector_type: Literal['POINT', 'VECTOR', 'NORMAL'] = 'VECTOR')
snd
nd.vector_transform(cls,
vector: Vector = None,
convert_from: Literal['WORLD', 'OBJECT', 'CAMERA'] = 'WORLD',
convert_to: Literal['WORLD', 'OBJECT', 'CAMERA'] = 'OBJECT',
vector_type: Literal['POINT', 'VECTOR', 'NORMAL'] = 'VECTOR')
Vertex Neighbors
bl_idname : GeometryNodeInputMeshVertexNeighbors
class Mesh
prop = Mesh.vertex_neighbors
class Vertex
prop = Mesh.points.neighbors
prop = Mesh.points.neighbors_vertex_count
prop = Mesh.points.neighbors_face_count
nd
Vertex of Corner
bl_idname : GeometryNodeVertexOfCorner
class Mesh
Mesh.vertex_of_corner(cls, corner_index: Integer = None)
class Corner
Mesh.corners.vertex_index(cls, corner_index: Integer = None)
nd
nd.vertex_of_corner(cls, corner_index: Integer = None)
Viewer
bl_idname : GeometryNodeViewer
class Geometry
Geometry.viewer(cls, named_sockets: dict = {}, ui_shortcut = 0, **sockets)
class Point
Mesh.points.viewer(cls, named_sockets: dict = {}, ui_shortcut = 0, **sockets)
class Edge
Mesh.edges.viewer(cls, named_sockets: dict = {}, ui_shortcut = 0, **sockets)
class Face
Mesh.faces.viewer(cls, named_sockets: dict = {}, ui_shortcut = 0, **sockets)
class Corner
Mesh.corners.viewer(cls, named_sockets: dict = {}, ui_shortcut = 0, **sockets)
class Spline
Spline.splines.viewer(cls, named_sockets: dict = {}, ui_shortcut = 0, **sockets)
class Instance
Instances.insts.viewer(cls, named_sockets: dict = {}, ui_shortcut = 0, **sockets)
class Layer
GreasePencil.layers.viewer(cls, named_sockets: dict = {}, ui_shortcut = 0, **sockets)
nd
nd.viewer(cls,
named_sockets: dict = {},
domain: Literal['AUTO', 'POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'AUTO',
ui_shortcut = 0,
**sockets)
bl_idname : GeometryNodeViewportTransform
nd
nd.viewport_transform(cls)
Volume Absorption
bl_idname : ShaderNodeVolumeAbsorption
class VolumeShader
VolumeShader.Absorption(cls, color: Color = None, density: Float = None)
snd
nd.volume_absorption(cls, color: Color = None, density: Float = None, weight: Float = None)
Volume Coefficients
bl_idname : ShaderNodeVolumeCoefficients
snd
nd.volume_coefficients(cls,
weight: Float = None,
absorption_coefficients: Vector = None,
scatter_coefficients: Vector = None,
anisotropy: Float = None,
ior: Float = None,
backscatter: Float = None,
alpha: Float = None,
diameter: Float = None,
emission_coefficients: Vector = None,
phase: Literal['HENYEY_GREENSTEIN', 'FOURNIER_FORAND', 'DRAINE', 'RAYLEIGH', 'MIE'] = 'HENYEY_GREENSTEIN')
Volume Cube
bl_idname : GeometryNodeVolumeCube
class Volume
Volume.Cube(cls,
density: Float = None,
background: Float = None,
min: Vector = None,
max: Vector = None,
resolution_x: Integer = None,
resolution_y: Integer = None,
resolution_z: Integer = None)
nd
nd.volume_cube(cls,
density: Float = None,
background: Float = None,
min: Vector = None,
max: Vector = None,
resolution_x: Integer = None,
resolution_y: Integer = None,
resolution_z: Integer = None)
Volume Info
bl_idname : ShaderNodeVolumeInfo
class VolumeShader
snd
Volume Scatter
bl_idname : ShaderNodeVolumeScatter
class VolumeShader
VolumeShader.Scatter(cls,
color: Color = None,
density: Float = None,
anisotropy: Float = None,
phase: Literal['HENYEY_GREENSTEIN', 'FOURNIER_FORAND', 'DRAINE', 'RAYLEIGH', 'MIE'] = 'HENYEY_GREENSTEIN')
snd
nd.volume_scatter(cls,
color: Color = None,
density: Float = None,
anisotropy: Float = None,
ior: Float = None,
backscatter: Float = None,
alpha: Float = None,
diameter: Float = None,
weight: Float = None,
phase: Literal['HENYEY_GREENSTEIN', 'FOURNIER_FORAND', 'DRAINE', 'RAYLEIGH', 'MIE'] = 'HENYEY_GREENSTEIN')
Volume to Mesh
bl_idname : GeometryNodeVolumeToMesh
class Volume
Volume.to_mesh(self,
resolution_mode: Literal['Grid', 'Amount', 'Size'] = None,
voxel_size: Float = None,
voxel_amount: Float = None,
threshold: Float = None,
adaptivity: Float = None)
nd
nd.volume_to_mesh(cls,
volume: Volume = None,
resolution_mode: Literal['Grid', 'Amount', 'Size'] = None,
voxel_size: Float = None,
voxel_amount: Float = None,
threshold: Float = None,
adaptivity: Float = None)
Voronoi Texture
bl_idname : ShaderNodeTexVoronoi
class Float
Float.Voronoi(cls,
vector: Vector = None,
scale: Float = None,
detail: Float = None,
roughness: Float = None,
lacunarity: Float = None,
randomness: Float = None,
distance: Literal['EUCLIDEAN', 'MANHATTAN', 'CHEBYCHEV', 'MINKOWSKI'] = 'EUCLIDEAN',
feature: Literal['F1', 'F2', 'SMOOTH_F1', 'DISTANCE_TO_EDGE', 'N_SPHERE_RADIUS'] = 'F1',
normalize = False,
voronoi_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D')
class Texture
Texture.Voronoi(cls,
vector: Vector = None,
scale: Float = None,
detail: Float = None,
roughness: Float = None,
lacunarity: Float = None,
randomness: Float = None,
distance: Literal['EUCLIDEAN', 'MANHATTAN', 'CHEBYCHEV', 'MINKOWSKI'] = 'EUCLIDEAN',
feature: Literal['F1', 'F2', 'SMOOTH_F1', 'DISTANCE_TO_EDGE', 'N_SPHERE_RADIUS'] = 'F1',
normalize = False,
voronoi_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D')
nd
nd.voronoi_texture(cls,
vector: Vector = None,
w: Float = None,
scale: Float = None,
detail: Float = None,
roughness: Float = None,
lacunarity: Float = None,
smoothness: Float = None,
exponent: Float = None,
randomness: Float = None,
distance: Literal['EUCLIDEAN', 'MANHATTAN', 'CHEBYCHEV', 'MINKOWSKI'] = 'EUCLIDEAN',
feature: Literal['F1', 'F2', 'SMOOTH_F1', 'DISTANCE_TO_EDGE', 'N_SPHERE_RADIUS'] = 'F1',
normalize = False,
voronoi_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D')
snd
nd.voronoi_texture(cls,
vector: Vector = None,
w: Float = None,
scale: Float = None,
detail: Float = None,
roughness: Float = None,
lacunarity: Float = None,
smoothness: Float = None,
exponent: Float = None,
randomness: Float = None,
distance: Literal['EUCLIDEAN', 'MANHATTAN', 'CHEBYCHEV', 'MINKOWSKI'] = 'EUCLIDEAN',
feature: Literal['F1', 'F2', 'SMOOTH_F1', 'DISTANCE_TO_EDGE', 'N_SPHERE_RADIUS'] = 'F1',
normalize = False,
voronoi_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D')
Voxel Index
bl_idname : GeometryNodeInputVoxelIndex
class Float
class Integer
class Boolean
class Vector
nd
Voxelize Grid
bl_idname : GeometryNodeGridVoxelize
class Float
Float.voxelize_grid(self)
class Integer
Integer.voxelize_grid(self)
class Boolean
Boolean.voxelize_grid(self)
class Vector
Vector.voxelize_grid(self)
nd
nd.voxelize_grid(cls,
grid: Float = None,
data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT')
Warning
bl_idname : GeometryNodeWarning
class Boolean
Boolean.error(self, message: String = None)
Boolean.warning(self, message: String = None)
Boolean.info(self, message: String = None)
nd
nd.warning(cls,
show: Boolean = None,
message: String = None,
warning_type: Literal['ERROR', 'WARNING', 'INFO'] = 'ERROR')
Wave Texture
bl_idname : ShaderNodeTexWave
class Color
Color.Wave(cls,
vector: Vector = None,
scale: Float = None,
distortion: Float = None,
detail: Float = None,
detail_scale: Float = None,
detail_roughness: Float = None,
phase_offset: Float = None,
bands_direction: Literal['X', 'Y', 'Z', 'DIAGONAL'] = 'X',
rings_direction: Literal['X', 'Y', 'Z', 'SPHERICAL'] = 'X',
wave_profile: Literal['SIN', 'SAW', 'TRI'] = 'SIN',
wave_type: Literal['BANDS', 'RINGS'] = 'BANDS')
class Texture
Texture.Wave(cls,
vector: Vector = None,
scale: Float = None,
distortion: Float = None,
detail: Float = None,
detail_scale: Float = None,
detail_roughness: Float = None,
phase_offset: Float = None,
bands_direction: Literal['X', 'Y', 'Z', 'DIAGONAL'] = 'X',
rings_direction: Literal['X', 'Y', 'Z', 'SPHERICAL'] = 'X',
wave_profile: Literal['SIN', 'SAW', 'TRI'] = 'SIN',
wave_type: Literal['BANDS', 'RINGS'] = 'BANDS')
nd
nd.wave_texture(cls,
vector: Vector = None,
scale: Float = None,
distortion: Float = None,
detail: Float = None,
detail_scale: Float = None,
detail_roughness: Float = None,
phase_offset: Float = None,
bands_direction: Literal['X', 'Y', 'Z', 'DIAGONAL'] = 'X',
rings_direction: Literal['X', 'Y', 'Z', 'SPHERICAL'] = 'X',
wave_profile: Literal['SIN', 'SAW', 'TRI'] = 'SIN',
wave_type: Literal['BANDS', 'RINGS'] = 'BANDS')
snd
nd.wave_texture(cls,
vector: Vector = None,
scale: Float = None,
distortion: Float = None,
detail: Float = None,
detail_scale: Float = None,
detail_roughness: Float = None,
phase_offset: Float = None,
bands_direction: Literal['X', 'Y', 'Z', 'DIAGONAL'] = 'X',
rings_direction: Literal['X', 'Y', 'Z', 'SPHERICAL'] = 'X',
wave_profile: Literal['SIN', 'SAW', 'TRI'] = 'SIN',
wave_type: Literal['BANDS', 'RINGS'] = 'BANDS')
Wavelength
bl_idname : ShaderNodeWavelength
class Float
snd
nd.wavelength(cls, wavelength: Float = None)
White Noise Texture
bl_idname : ShaderNodeTexWhiteNoise
class Float
Float.WhiteNoise(cls,
vector: Vector = None,
noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D')
class Texture
Texture.WhiteNoise(cls,
vector: Vector = None,
noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D')
nd
nd.white_noise_texture(cls,
vector: Vector = None,
w: Float = None,
noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D')
snd
nd.white_noise_texture(cls,
vector: Vector = None,
w: Float = None,
noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D')
Wireframe
bl_idname : ShaderNodeWireframe
class Float
Float.wireframe(self, use_pixel_size = False)
snd
nd.wireframe(cls, size: Float = None, use_pixel_size = False)
World Output
bl_idname : ShaderNodeOutputWorld
class Shader
Shader.world_output(self,
volume: VolumeShader = None,
is_active_output = True,
target: Literal['ALL', 'EEVEE', 'CYCLES'] = 'ALL')
snd
nd.world_output(cls,
surface: Shader = None,
volume: VolumeShader = None,
is_active_output = True,
target: Literal['ALL', 'EEVEE', 'CYCLES'] = 'ALL')