def process(self):
if not self.inputs['Vectors'].is_linked:
return
vertices = self.inputs['Vectors'].sv_get(deepcopy=False)
matrices = self.inputs['Matrixes'].sv_get(deepcopy=False, default=[])
out_vertices = []
if matrices:
if isinstance(matrices[0][0][0],
(int, float)): # one level nesting
for v, m in zip(cycle(vertices), matrices):
v = copy(v)
mesh = me.to_mesh(
v) if not self.output_numpy else me.NpMesh(v)
mesh.apply_matrix(m)
out_vertices.append(mesh.vertices.data)
else: # otherwise it expects two levels nesting
for v, ms in zip(cycle(vertices), matrices):
meshes = []
for m in ms:
v = copy(v)
mesh = me.to_mesh(
v) if not self.output_numpy else me.NpMesh(v)
mesh.apply_matrix(m)
meshes.append(mesh)
mesh = reduce(lambda m1, m2: m1.add_mesh(m2), meshes)
out_vertices.append(mesh.vertices.data)
self.outputs['Vectors'].sv_set(out_vertices or vertices)
def process(self):
if not self.inputs['Vertices'].is_linked:
return
vertices = self.inputs['Vertices'].sv_get(default=[])
edges = []
polygons = []
poly_edges = self.inputs['PolyEdge'].sv_get(default=[])
first_elements = [obj[0] for obj in poly_edges]
if first_elements:
if all([len(el) == 2 for el in first_elements]):
edges = poly_edges
elif all([len(el) != 2 for el in first_elements]):
polygons = poly_edges
else:
raise TypeError('PoyEdge socket should consist either all edges or all faces') # Sv architecture law
meshes = [me.to_mesh(*m) for m in zip(vertices, chain(edges, cycle([[]])), chain(polygons, cycle([[]])))]
joined_mesh = reduce(lambda m1, m2: m1.add_mesh(m2), meshes)
self.outputs['Vertices'].sv_set([joined_mesh.vertices.data])
if joined_mesh.edges:
self.outputs['PolyEdge'].sv_set([joined_mesh.edges.data])
if joined_mesh.polygons:
self.outputs['PolyEdge'].sv_set([joined_mesh.polygons.data])
def process(self):
vertices = self.inputs['Vertices'].sv_get(default=[], deepcopy=False)
edges = self.inputs['Edges'].sv_get(default=[], deepcopy=False)
faces = self.inputs['Faces'].sv_get(default=[], deepcopy=False)
matrices = self.inputs['Matrices'].sv_get(default=[], deepcopy=False)
object_number = max([len(vertices), len(matrices)]) if vertices else 0
meshes = []
for i, *elements, matrix in zip(range(object_number),
repeat_last(vertices),
repeat_last(edges or [[]]),
repeat_last(faces or [[]]),
repeat_last(matrices or [[]])):
if matrix:
if not isinstance(matrix, (list, tuple)):
# most likely it is Matrix or np.ndarray
# but the node expects list of list of matrices as input
matrix = [matrix]
sub_meshes = []
for mat in matrix:
mesh = me.to_mesh(
*elements
) if self.implementation != 'NumPy' else me.NpMesh(
*elements)
mesh.apply_matrix(mat)
sub_meshes.append(mesh)
sub_mesh = reduce(lambda m1, m2: m1.add_mesh(m2), sub_meshes)
else:
sub_mesh = me.to_mesh(
*elements
) if self.implementation != 'NumPy' else me.NpMesh(*elements)
meshes.append(sub_mesh)
if self.do_join and meshes:
meshes = [reduce(lambda m1, m2: m1.add_mesh(m2), meshes)]
self.outputs['Vertices'].sv_set([m.vertices.data for m in meshes])
self.outputs['Edges'].sv_set([m.edges.data for m in meshes])
self.outputs['Faces'].sv_set([m.polygons.data for m in meshes])
def process(self):
if not self.is_active:
return
vertices = self.inputs['vertices'].sv_get(deepcopy=False, default=[])
matrices = self.inputs['matrix'].sv_get(deepcopy=False, default=[])
radius = self.inputs['radius'].sv_get(deepcopy=False)
tilt = self.inputs['tilt'].sv_get(deepcopy=False)
bevel_objects = self.inputs['bevel object'].sv_get(default=[])
if 'Cyclic' in self.inputs:
cyclic = self.inputs['Cyclic'].sv_get(deepcopy=False)[0]
else:
cyclic = [self.close]
# first step is merge everything if the option
if self.is_merge:
objects_number = max([len(vertices), len(matrices)])
meshes = []
for i, verts, matrix in zip(
range(objects_number), repeat_last(vertices),
repeat_last(matrices if matrices else [[]])):
mesh = me.to_mesh(verts)
if matrix:
mesh.apply_matrix(matrix)
meshes.append(mesh)
vertices = [m.vertices.data for m in meshes]
matrices = []
objects_number = max([len(vertices), len(matrices)
]) if len(vertices) else 0
# extract mesh matrices
if self.apply_matrices_to == 'mesh':
if matrices:
mesh_matrices = matrices
else:
mesh_matrices = [None]
else:
mesh_matrices = [None]
# extract object matrices
if self.apply_matrices_to == 'object':
if matrices:
obj_matrices = matrices
else:
if self.is_lock_origin:
obj_matrices = [Matrix.Identity(4)]
else:
obj_matrices = []
else:
if self.is_lock_origin:
obj_matrices = [Matrix.Identity(4)]
else:
obj_matrices = []
# regenerate curve data blocks
if self.is_merge:
correct_collection_length(self.curve_data, 1)
self.curve_data[0].regenerate_curve(self.base_data_name, vertices,
self.curve_type, radius,
cyclic, self.use_smooth, tilt)
else:
correct_collection_length(self.curve_data, objects_number)
for cu_data, verts, matrix, r, t, close in zip(
self.curve_data, repeat_last(vertices),
repeat_last(mesh_matrices), repeat_last(radius),
repeat_last(tilt), repeat_last(cyclic)):
if matrix:
mesh = me.to_mesh(verts)
mesh.apply_matrix(matrix)
verts = mesh.vertices.data
cu_data.regenerate_curve(self.base_data_name, [verts],
self.curve_type, [r], [close],
self.use_smooth, [t])
# assign curve properties
for cu_data, bevel_object in zip(self.curve_data,
repeat_last(bevel_objects or [None])):
cu_data.curve.dimensions = self.curve_dimensions
cu_data.curve.bevel_depth = self.bevel_depth
cu_data.curve.bevel_resolution = self.resolution
cu_data.curve.resolution_u = self.preview_resolution_u
cu_data.curve.bevel_object = bevel_object
cu_data.curve.use_fill_caps = self.caps
print(type(cu_data.curve), )
for spline in cu_data.curve.splines:
spline.use_endpoint_u = self.last_point
if self.material:
cu_data.curve.materials.clear()
cu_data.curve.materials.append(self.material)
# regenerate object data blocks
self.regenerate_objects([self.base_data_name],
[d.curve for d in self.curve_data],
[self.collection])
[
setattr(prop.obj, 'matrix_local', m)
for prop, m in zip(self.object_data, repeat_last(obj_matrices))
]
[
setattr(prop.obj, 'show_wire', self.show_wire)
for prop in self.object_data
]
self.outputs['Objects'].sv_set(
[obj_data.obj for obj_data in self.object_data])
def process(self):
if not self.is_active:
return
verts = self.inputs['vertices'].sv_get(deepcopy=False, default=[])
edges = self.inputs['edges'].sv_get(deepcopy=False, default=[[]])
faces = self.inputs['faces'].sv_get(deepcopy=False, default=[[]])
mat_indexes = self.inputs['material_idx'].sv_get(deepcopy=False, default=[[]])
matrices = self.inputs['matrix'].sv_get(deepcopy=False, default=[])
# first step is merge everything if the option
if self.is_merge:
objects_number = max([len(verts), len(matrices)])
meshes = []
for i, *elements, materials, matrix in zip(
range(objects_number),
repeat_last(verts),
repeat_last(edges),
repeat_last(faces),
repeat_last(mat_indexes),
repeat_last(matrices if matrices else [[]])):
mesh = me.to_mesh(*elements)
if materials:
mesh.polygons['material'] = materials
if matrix:
mesh.apply_matrix(matrix)
meshes.append(mesh)
base_mesh = reduce(lambda m1, m2: m1.add_mesh(m2), meshes)
verts, edges, faces = [base_mesh.vertices.data], [base_mesh.edges.data], [base_mesh.polygons.data]
mat_indexes = [base_mesh.polygons.get_attribute('material', [])]
matrices = []
objects_number = max([len(verts), len(matrices)]) if verts else 0
# extract mesh matrices
if self.apply_matrices_to == 'mesh':
if matrices:
mesh_matrices = matrices
else:
mesh_matrices = cycle([None])
else:
mesh_matrices = cycle([None])
# extract object matrices
if self.apply_matrices_to == 'object':
if matrices:
obj_matrices = matrices
else:
if self.is_lock_origin:
obj_matrices = cycle([Matrix.Identity(4)])
else:
obj_matrices = []
else:
if self.is_lock_origin:
obj_matrices = cycle([Matrix.Identity(4)])
else:
obj_matrices = []
# regenerate mesh data blocks
correct_collection_length(self.mesh_data, objects_number)
create_mesh_data = zip(self.mesh_data, cycle(verts), cycle(edges), cycle(faces), cycle(mesh_matrices),
cycle(mat_indexes))
for me_data, v, e, f, m, mat_i in create_mesh_data:
me_data.regenerate_mesh(self.base_data_name, v, e, f, m, self.fast_mesh_update)
if self.material:
me_data.mesh.materials.clear()
me_data.mesh.materials.append(self.material)
if mat_indexes:
mat_i = [mi for _, mi in zip(me_data.mesh.polygons, cycle(mat_i))]
me_data.mesh.polygons.foreach_set('material_index', mat_i)
me_data.set_smooth(self.is_smooth_mesh)
# regenerate object data blocks
self.regenerate_objects([self.base_data_name], [d.mesh for d in self.mesh_data], [self.collection])
[setattr(prop.obj, 'matrix_local', m) for prop, m in zip(self.object_data, cycle(obj_matrices))]
[setattr(prop.obj, 'show_wire', self.show_wireframe) for prop in self.object_data]
self.outputs['Objects'].sv_set([obj_data.obj for obj_data in self.object_data])
