Class Group#
main - nodes - nodes menus
Node group
Node groups are dynamically built by reading the input and output sockets of the group.
Input sockets are initialized in the keyword arguments.
They can later on be initialized by the snake_case names
Constructor#
Group(self, node_name, **kwargs)
Content#
Properties
bl_idname | chain_label | fed_nodes | input_geometry_bsocket | label | node_color
Class and static methods
Boolean | Collection | Color | Curve | Curves | DataClass | Float | Geometry | Image | Instances | Integer | Material | Mesh | Object | Points | String | Texture | Vector | Volume | build_unames_dict | unitize
Methods
as_attribute | attribute_is_solved | connected_geometries | get_datasocket | get_label | get_output_socket | plug | plug_node | plugged | switch_input_sockets
Properties#
bl_idname#
Shortcut for self.bnode.bl_idname
Go to top - main - nodes - nodes menus
chain_label#
Label to use when building chain labels
Go to top - main - nodes - nodes menus
fed_nodes#
List of the node with input sockets connected with this socket
Go to top - main - nodes - nodes menus
input_geometry_bsocket#
The input geometry blender socket
Go to top - main - nodes - nodes menus
label#
Node label
Go to top - main - nodes - nodes menus
node_color#
Noe color
Go to top - main - nodes - nodes menus
Class and static methods#
Boolean#
@staticmethod
def Boolean(socket)
Initialize a Boolean with a DataSocket
Go to top - main - nodes - nodes menus
Collection#
@staticmethod
def Collection(socket)
Initialize a Collection with a DataSocket
Go to top - main - nodes - nodes menus
Color#
@staticmethod
def Color(socket)
Initialize a Color with a DataSocket
Go to top - main - nodes - nodes menus
Curve#
@staticmethod
def Curve(socket)
Initialize a Curve with a DataSocket
Go to top - main - nodes - nodes menus
Curves#
@staticmethod
def Curves(socket)
Initialize a Curves with a DataSocket
Go to top - main - nodes - nodes menus
DataClass#
@staticmethod
def DataClass(socket)
Initialize a DataClass of the property class from from the bl_idname of the socket
Go to top - main - nodes - nodes menus
Float#
@staticmethod
def Float(socket)
Initialize a Float with a DataSocket
Go to top - main - nodes - nodes menus
Geometry#
@staticmethod
def Geometry(socket)
Initialize a Geometry with a DataSocket
Go to top - main - nodes - nodes menus
Image#
@staticmethod
def Image(socket)
Initialize a Image with a DataSocket
Go to top - main - nodes - nodes menus
Instances#
@staticmethod
def Instances(socket)
Initialize a Instances with a DataSocket
Go to top - main - nodes - nodes menus
Integer#
@staticmethod
def Integer(socket)
Initialize a Integer with a DataSocket
Go to top - main - nodes - nodes menus
Material#
@staticmethod
def Material(socket)
Initialize a Material with a DataSocket
Go to top - main - nodes - nodes menus
Mesh#
@staticmethod
def Mesh(socket)
Initialize a Mesh with a DataSocket
Go to top - main - nodes - nodes menus
Object#
@staticmethod
def Object(socket)
Initialize a Object with a DataSocket
Go to top - main - nodes - nodes menus
Points#
@staticmethod
def Points(socket)
Initialize a Points with a DataSocket
Go to top - main - nodes - nodes menus
String#
@staticmethod
def String(socket)
Initialize a String with a DataSocket
Go to top - main - nodes - nodes menus
Texture#
@staticmethod
def Texture(socket)
Initialize a Texture with a DataSocket
Go to top - main - nodes - nodes menus
Vector#
@staticmethod
def Vector(socket)
Initialize a Vector with a DataSocket
Go to top - main - nodes - nodes menus
Volume#
@staticmethod
def Volume(socket)
Initialize a Volume with a DataSocket
Go to top - main - nodes - nodes menus
build_unames_dict#
@staticmethod
def build_unames_dict(bsockets)
snake_case version of the sockets names
Go to top - main - nodes - nodes menus
unitize#
@staticmethod
def unitize(names)
Utility to build unique names from a list with homonyms
:param names: The list of names to unitize :type names: list of strs :return: list with the same number of names where homonyms are suffixed by their rank :rtype: list of strs
Go to top - main - nodes - nodes menus
Methods#
as_attribute#
def as_attribute(self, owning_socket, domain='POINT')
Indicates that the node is an attribute.
:param owning_socket: The owning socket it is an atribute of :param domain: The domain if ‘Capture Attribute’ is necessary :type owning_socket: DataSocket :type domain: str
Set the property :attr:is_atribute
to True
to indicate that the socket
is the attribute of a Geometry.
The domain is stored in the property domain
see :func:Tree.check_attributes
Go to top - main - nodes - nodes menus
attribute_is_solved#
def attribute_is_solved(self)
Check if the attribute is already solved.
No need to insert a Capture Attribute Node when the socket is already connected to nodes Capture Attribute or Transfer Attribute.
see :func:Tree.check_attributes
Go to top - main - nodes - nodes menus
connected_geometries#
def connected_geometries(self)
List of the connected geometries
Explore the fowards links until finding a node with an input geometry. The resulting list will allow to determine if a ‘Capture Attribute’ is necessary.
Go to top - main - nodes - nodes menus
get_datasocket#
def get_datasocket(self, index)
Get the data socket by its index.
:param index: Index of the output socket to get :type index: int :return: The data socket at the given socket :rtype: DataSocket
.. Note:: The index is the user index. It can differ from the geometry node index of the socket when
several sockets share the same name. For instance the node Random value has several output sockets
named Value. Only one is enabled at the same time. All these sockets share the same index, which is 0.
The socket returned by get_datasocket
is the one which is enabled.
.. code-block:: python
import geonodes as gn
with gn.Tree("Geometry Nodes") as tree:
# Node 'Random Value' initialized for FLOAT
v = gn.Float.Random()
# Let's explore the node
random_node = v.node
# The actual output sockets of the geometry node
# Note that we loop on bnode which is the wrapped node
print("Actual sockets:")
for i, bsocket in enumerate(random_node.bnode.outputs):
print(i, bsocket.name, bsocket.enabled)
print()
# All the socket share the same name and user index
# The one whih is return is the enabled one
print("User sockets:")
for key in random_node.outsockets:
socket = getattr(v.node, key)
print(key, socket.socket_index, socket.bl_idname)
.. code-block:: console
Actual sockets:
0 Value False
1 Value True
2 Value False
3 Value False
User sockets:
value 1 NodeSocketFloat
Go to top - main - nodes - nodes menus
get_label#
def get_label(self)
Build the node label
If the label provided at initialization time is None, the node is labeled by concatening its unique id with its standard name.
Go to top - main - nodes - nodes menus
get_output_socket#
def get_output_socket(self, name)
ock_ind = self.outsockets.get(name.lower())
Go to top - main - nodes - nodes menus
plug#
def plug(self, index, *values)
Plug the values to the input socket whose index is provided.
:param index: The index of the input sockets (a valid index for Node.inputs) :param values: Each value can be an acceptable default value for the socket or an output socket :type index: int :type values: list of values
Since an input socket can be multi input, the values argument is a list.
If the socket is multi input, the plug method is called once per provide value. If a value is None, nothing happens.
A not None value can be:
either a valid valud for the socket (eg: 123 for Integer socket)
or an output socket of another Node
When it is a socket, it can be a Blender socket or a DataSocket
—– Index can be a string
Go to top - main - nodes - nodes menus
plug_node#
def plug_node(self, node)
Plug all the sockets of a node.
:param node: The node whose output sockets will be plugged :type node: Node
Plug the output sockets of node whose name match an input socket of self.
Go to top - main - nodes - nodes menus
plugged#
def plugged(self, index)
The liste of plugged sockets
:param index: the index of the socket to consider :type index: int :return: The list of connected sockets :rtype: list of DataSockets
Go to top - main - nodes - nodes menus
switch_input_sockets#
def switch_input_sockets(self, index0, index1)
Utility method which switchs the links of two sockets.
- param index0:
The first index
- param index1:
The second index
- type index0:
int
- typ index1:
int
Used when implementing operators rxxx_
Go to top - main - nodes - nodes menus