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])