def process(self):
if self.inputs['vertices1'].is_linked and self.inputs['vertices2'].is_linked:
prop1_ = self.inputs['vertices1'].sv_get()
prop1 = Vector_generate(prop1_)
prop2_ = self.inputs['vertices2'].sv_get()
prop2 = Vector_generate(prop2_)
elif self.inputs['matrix1'].is_linked and self.inputs['matrix2'].is_linked:
propa = self.inputs['matrix1'].sv_get()
prop1 = Matrix_location(Matrix_generate(propa))
propb = self.inputs['matrix2'].sv_get()
prop2 = Matrix_location(Matrix_generate(propb))
else:
prop1, prop2 = [], []
if prop1 and prop2:
if self.outputs['distances'].is_linked:
# print ('distances input', str(prop1), str(prop2))
if self.Cross_dist:
output = self.calcM(prop1, prop2)
else:
output = self.calcV(prop1, prop2)
self.outputs['distances'].sv_set(output)
# print ('distances out' , str(output))
else:
self.outputs['distances'].sv_set([])
def process(self):
if self.inputs['vertices1'].is_linked and self.inputs[
'vertices2'].is_linked:
prop1_ = SvGetSocketAnyType(self, self.inputs['vertices1'])
prop1 = Vector_generate(prop1_)
prop2_ = SvGetSocketAnyType(self, self.inputs['vertices2'])
prop2 = Vector_generate(prop2_)
elif self.inputs['matrix1'].is_linked and self.inputs[
'matrix2'].is_linked:
propa = SvGetSocketAnyType(self, self.inputs['matrix1'])
prop1 = Matrix_location(Matrix_generate(propa))
propb = SvGetSocketAnyType(self, self.inputs['matrix2'])
prop2 = Matrix_location(Matrix_generate(propb))
else:
prop1, prop2 = [], []
if prop1 and prop2:
if self.outputs['distances'].is_linked:
#print ('distances input', str(prop1), str(prop2))
if self.Cross_dist:
output = self.calcM(prop1, prop2)
else:
output = self.calcV(prop1, prop2)
SvSetSocketAnyType(self, 'distances', output)
#print ('distances out' , str(output))
else:
SvSetSocketAnyType(self, 'distances', [])
def process(self):
outputs = self.outputs
if not outputs['C'].is_linked:
return
inputs = self.inputs
id_mat = Matrix_listing([Matrix.Identity(4)])
A = Matrix_generate(inputs['A'].sv_get(default=id_mat))
if self.operation in {"MULTIPLY"}:
# two matrix inputs available
B = Matrix_generate(inputs['B'].sv_get(default=id_mat))
if self.prePost == "PRE":
parameters = match_long_repeat([A, B])
else:
parameters = match_long_repeat([B, A])
else:
# one matrix input available
parameters = [A]
operation = self.get_operation()
matrixList = []
for params in zip(*parameters):
c = operation(*params)
matrixList.append(c)
matrices = Matrix_listing(matrixList)
outputs['C'].sv_set(matrices)
def process(self):
if not self.outputs['Vertices'].is_linked:
return
vertices = self.inputs['Vertices'].sv_get()
vertices = Vector_generate(vertices)
edges = self.inputs['Edges'].sv_get(default=[[]])
faces = self.inputs['Faces'].sv_get(default=[[]])
matrices = self.inputs['Matrices'].sv_get()
matrices = Matrix_generate(matrices)
n = len(matrices)
result_vertices = self.apply(vertices, matrices)
result_vertices = Vector_degenerate(result_vertices)
self.outputs['Vertices'].sv_set(result_vertices)
if self.outputs['Edges'].is_linked or self.outputs['Faces'].is_linked:
result_edges = edges * n
result_faces = faces * n
if self.do_join:
result_vertices, result_edges, result_faces = mesh_join(
result_vertices, result_edges, result_faces)
if self.outputs['Edges'].is_linked:
self.outputs['Edges'].sv_set(result_edges)
if self.outputs['Faces'].is_linked:
self.outputs['Faces'].sv_set(result_faces)
def process(self):
if not all([s.is_linked for s in self.inputs]):
return
if not self.outputs['vertices'].is_linked:
return
verts_ob = Vector_generate(self.inputs['vertices'].sv_get())
edg_pols = self.inputs['edg_pol'].sv_get()
cut_mats_ = self.inputs['cut_matrix'].sv_get()
cut_mats = Matrix_generate(cut_mats_)
verts_out = []
edges_out = []
polys_out = []
for cut_mat in cut_mats:
pp = cut_mat.to_translation()
pno = Vector((0.0, 0.0, 1.0)) * cut_mat.to_3x3().transposed()
for obj in zip(verts_ob, edg_pols):
res = bisect(obj[0], obj[1], pp, pno, self.outer, self.inner,
self.fill)
if not res:
return
verts_out.append(res[0])
edges_out.append(res[1])
polys_out.append(res[2])
self.outputs['vertices'].sv_set(verts_out)
self.outputs['edges'].sv_set(edges_out)
self.outputs['polygons'].sv_set(polys_out)
def process(self):
if 'Matrix' in self.inputs and self.inputs['Matrix'].is_linked:
matrixes_ = SvGetSocketAnyType(self, self.inputs['Matrix'])
matrixes = Matrix_generate(matrixes_)
if 'Location' in self.outputs and self.outputs[
'Location'].is_linked:
locs = Matrix_location(matrixes, list=True)
SvSetSocketAnyType(self, 'Location', locs)
if 'Scale' in self.outputs and self.outputs['Scale'].is_linked:
locs = Matrix_scale(matrixes, list=True)
SvSetSocketAnyType(self, 'Scale', locs)
if ('Rotation' in self.outputs and self.outputs['Rotation'].is_linked) \
or ('Angle' in self.outputs and self.outputs['Angle'].is_linked):
locs = Matrix_rotation(matrixes, list=True)
rots = []
angles = []
for lists in locs:
rots.append([pair[0] for pair in lists])
for pair in lists:
angles.append(degrees(pair[1]))
SvSetSocketAnyType(self, 'Rotation', rots)
SvSetSocketAnyType(self, 'Angle', [angles])
else:
matrixes = [[]]
def process(self):
O, L, S, R, A = self.inputs
Om = self.outputs[0]
if Om.is_linked:
if O.is_linked:
orig = Matrix_generate(O.sv_get())
else:
return
if L.is_linked:
loc = Vector_generate(L.sv_get())
else:
loc = [[]]
if S.is_linked:
scale = Vector_generate(S.sv_get())
else:
scale = [[]]
if R.is_linked:
rot = Vector_generate(R.sv_get())
else:
rot = [[]]
rotA, angle = [[]], [[0.0]]
# ability to add vector & vector difference instead of only rotation values
if A.is_linked:
if A.links[0].from_socket.bl_idname == 'VerticesSocket':
rotA = Vector_generate(A.sv_get())
angle = [[]]
else:
angle = A.sv_get()
rotA = [[]]
matrixes_ = matrixdef(orig, loc, scale, rot, angle, rotA)
matrixes = Matrix_listing(matrixes_)
Om.sv_set(matrixes)
def process(self):
if not self.outputs['Vertices'].is_linked:
return
vertices = Vector_generate(self.inputs['Vertices'].sv_get())
matrices = Matrix_generate(self.inputs['Matrices'].sv_get())
verts_out, edges_out, faces_out = self.make_tube(matrices, vertices)
self.outputs['Vertices'].sv_set([verts_out])
self.outputs['Edges'].sv_set([edges_out])
self.outputs['Faces'].sv_set([faces_out])
def makeobjects(self, vers, edg_pol, mats):
# inception
# fht = предохранитель от перебора рёбер и полигонов.
fht = []
if len(edg_pol[0][0]) == 2:
pols = []
for edgs in edg_pol:
maxi = max(max(a) for a in edgs)
fht.append(maxi)
#print (maxi)
elif len(edg_pol[0][0]) > 2:
edgs = []
for pols in edg_pol:
maxi = max(max(a) for a in pols)
fht.append(maxi)
#print (maxi)
#print (fht)
vertices = Vector_generate(vers)
matrixes = Matrix_generate(mats)
#print('mats' + str(matrixes))
objects = {}
fhtagn = []
for u, f in enumerate(fht):
fhtagn.append(min(len(vertices[u]), fht[u]))
#lenmesh = len(vertices) - 1
#print ('запекание вершин ', vertices, " матрицы запекашка ", matrixes, " полиглоты ", edg_pol)
#print (matrixes)
for i, m in enumerate(matrixes):
k = i
lenver = len(vertices) - 1
if i > lenver:
v = vertices[-1]
k = lenver
else:
v = vertices[k]
#print (fhtagn, len(v)-1)
if (len(v) - 1) < fhtagn[k]:
continue
# возможно такая сложность не нужна, но пусть лежит тут. Удалять лишние точки не обязательно.
elif fhtagn[k] < (len(v) - 1):
nonneed = (len(v) - 1) - fhtagn[k]
for q in range(nonneed):
v.pop((fhtagn[k] + 1))
#print (fhtagn[k], (len(v)-1))
e = edg_pol[k] if edgs else []
p = edg_pol[k] if pols else []
objects[str(i)] = self.makemesh(i, v, e, p, m)
for ite in objects.values():
me = ite[1]
ob = ite[0]
calcedg = True
if edgs:
calcedg = False
me.update(calc_edges=calcedg)
bpy.context.scene.objects.link(ob)
def get_data(name, fallback=[]):
TypeSocket = get_socket_type(name)
if has_good_link(name, TypeSocket):
d = dataCorrect(inputs[name].sv_get())
if name == 'matrix':
d = Matrix_generate(d) if d else []
elif name == 'vertices':
d = Vector_generate(d) if d else []
return d
return fallback
def process(self):
# inputs
if 'Matrix' in self.outputs and self.outputs['Matrix'].links:
if self.inputs['Original'].links and \
type(self.inputs['Original'].links[0].from_socket) == MatrixSocket:
orig_ = SvGetSocketAnyType(self, self.inputs['Original'])
orig = Matrix_generate(orig_)
else:
return
if 'Location' in self.inputs and self.inputs['Location'].links and \
type(self.inputs['Location'].links[0].from_socket) == VerticesSocket:
loc_ = SvGetSocketAnyType(self, self.inputs['Location'])
loc = Vector_generate(loc_)
else:
loc = [[]]
if 'Scale' in self.inputs and self.inputs['Scale'].links and \
type(self.inputs['Scale'].links[0].from_socket) == VerticesSocket:
scale_ = SvGetSocketAnyType(self, self.inputs['Scale'])
scale = Vector_generate(scale_)
else:
scale = [[]]
if 'Rotation' in self.inputs and self.inputs['Rotation'].links and \
type(self.inputs['Rotation'].links[0].from_socket) == VerticesSocket:
rot_ = SvGetSocketAnyType(self, self.inputs['Rotation'])
rot = Vector_generate(rot_)
#print ('matrix_def', str(rot_))
else:
rot = [[]]
rotA = [[]]
angle = [[0.0]]
if 'Angle' in self.inputs and self.inputs['Angle'].links:
if type(self.inputs['Angle'].links[0].from_socket
) == StringsSocket:
angle = SvGetSocketAnyType(self, self.inputs['Angle'])
elif type(self.inputs['Angle'].links[0].from_socket
) == VerticesSocket:
rotA_ = SvGetSocketAnyType(self, self.inputs['Angle'])
rotA = Vector_generate(rotA_)
# outputs
#print(loc)
matrixes_ = matrixdef(orig, loc, scale, rot, angle, rotA)
matrixes = Matrix_listing(matrixes_)
SvSetSocketAnyType(self, 'Matrix', matrixes)
def process(self):
if self.outputs['Vectors'].is_linked:
vecs_ = self.inputs['Vectors'].sv_get(deepcopy=False)
vecs = Vector_generate(vecs_)
mats_ = self.inputs['Matrixes'].sv_get(deepcopy=False)
mats = Matrix_generate(mats_)
vectors_ = self.vecscorrect(vecs, mats)
vectors = Vector_degenerate(vectors_)
self.outputs['Vectors'].sv_set(vectors)
def process(self):
# inputs
if not self.inputs['Matrix'].is_linked:
return
matrices = self.inputs['Matrix'].sv_get()
matrices = Matrix_generate(matrices)
counts = self.inputs['Iterations'].sv_get()[0]
vertices_s = self.inputs['Vertices'].sv_get()
vertices_s = Vector_generate(vertices_s)
edges_s = self.inputs['Edges'].sv_get(default=[[]])
faces_s = self.inputs['Polygons'].sv_get(default=[[]])
if self.outputs['Vertices'].is_linked:
result_vertices = []
result_edges = []
result_faces = []
if edges_s[0]:
if len(edges_s) != len(vertices_s):
raise Exception("Invalid number of edges: {} != {}".format(
len(edges_s), len(vertices_s)))
if faces_s[0]:
if len(faces_s) != len(vertices_s):
raise Exception(
"Invalid number of polygons: {} != {}".format(
len(faces_s), len(vertices_s)))
meshes = match_long_repeat([vertices_s, edges_s, faces_s, counts])
offset = 0
for vertices, edges, faces, count in zip(*meshes):
result_vertices.extend(vertices)
result_edges.extend(shift_edges(edges, offset))
result_faces.extend(shift_faces(faces, offset))
offset += len(vertices)
new_vertices, new_edges, new_faces = iterate_matrices(
matrices, vertices, edges, faces, count, offset)
offset += len(new_vertices)
result_vertices.extend(new_vertices)
result_edges.extend(new_edges)
result_faces.extend(new_faces)
result_vertices = Vector_degenerate([result_vertices])
self.outputs['Vertices'].sv_set(result_vertices)
if self.outputs['Edges'].is_linked:
self.outputs['Edges'].sv_set([result_edges])
if self.outputs['Polygons'].is_linked:
self.outputs['Polygons'].sv_set([result_faces])
def makeobjects(self, vers, edg_pol, mats):
try:
num_keys = len(edg_pol[0][0])
except:
num_keys = 0
vertices = Vector_generate(vers)
matrixes = Matrix_generate(mats)
edgs, pols, max_vert_index, fht = [], [], [], []
if num_keys >= 2:
for k in edg_pol:
maxi = max(max(a) for a in k)
fht.append(maxi)
for u, f in enumerate(fht):
max_vert_index.append(min(len(vertices[u]), fht[u]))
objects = {}
for i, m in enumerate(matrixes):
k = i
lenver = len(vertices) - 1
if i > lenver:
v = vertices[-1]
k = lenver
else:
v = vertices[k]
if max_vert_index:
if (len(v) - 1) < max_vert_index[k]:
print('skipped object ', i, 'index out of bounds')
print('largest available vertex index:',
len(v) - 1, 'first larger reference:',
max_vert_index[k])
continue
elif max_vert_index[k] < (len(v) - 1):
nonneed = (len(v) - 1) - max_vert_index[k]
for q in range(nonneed):
v.pop((max_vert_index[k] + 1))
e, p = [], []
if num_keys == 2:
e = edg_pol[k]
elif num_keys > 2:
p = edg_pol[k]
objects[str(i)] = self.makemesh(i, v, e, p, m)
for ob, me in objects.values():
calcedg = False if (num_keys == 2) else True
me.update(calc_edges=calcedg)
bpy.context.scene.objects.link(ob)
def process(self):
# inputs
if self.outputs['Vectors'].is_linked:
vecs_ = SvGetSocketAnyType(self, self.inputs['Vectors'])
vecs = Vector_generate(vecs_)
mats_ = SvGetSocketAnyType(self, self.inputs['Matrixes'])
mats = Matrix_generate(mats_)
vectors_ = self.vecscorrect(vecs, mats)
vectors = Vector_degenerate(vectors_)
SvSetSocketAnyType(self, 'Vectors', vectors)
def process(self):
# inputs
if not self.outputs['Vectors'].is_linked:
return
vecs_ = self.inputs['Vectors'].sv_get()
vecs = Vector_generate(vecs_)
mats_ = dataCorrect(self.inputs['Matrixes'].sv_get())
mats = Matrix_generate(mats_)
vectors = self.vecscorrect(vecs, mats)
self.outputs['Vectors'].sv_set(vectors)
def process(self):
empty = self.find_empty()
if not empty:
empty = self.create_empty()
print("created new empty")
if self.inputs['Matrix'].is_linked:
mats = SvGetSocketAnyType(self, self.inputs['Matrix'])
mat = Matrix_generate(mats)[0]
else:
mat = Matrix()
self.label = empty.name
empty.matrix_world = mat
def sv_main(verts=[], polygons=[], matrix=[], ver=3, hor=3):
in_sockets = [['v', 'verts', verts], ['s', 'polygons', polygons],
['m', 'matrix', matrix], ['s', 'vertical', ver],
['s', 'horisontal', hor]]
verts_out = []
matrixes = []
ver = max(3, ver)
hor = max(3, hor)
def out_sockets():
return [['v', 'verts_out', verts_out], ['m', 'matrixes', matrixes]]
if not all([verts, polygons]):
return in_sockets, out_sockets()
def make_centers(v, p, m):
out = []
matrixes = []
vlh = v[pol[1]] - v[pol[0]]
vlv = v[pol[3]] - v[pol[0]]
for i in range(hor - 1):
per_h = (1 / hor) * (i + 1)
for k in range(ver - 1):
per_v = (1 / ver) * (k + 1)
v_loc = v[pol[0]] + vlh * per_h + vlv * per_v
m.translation = v_loc
matrixes.append(m.copy())
out.append(v_loc)
return out, matrixes
# paradigm change
verts = Vector_generate(verts)
matrix = Matrix_generate(matrix)
centers = []
for p, v in zip(polygons, verts):
centers_ = []
for pol, m in zip(p, matrix):
cout, mout = make_centers(v, pol, m)
centers_.extend(cout)
matrixes.extend(mout)
centers.append(centers_)
#print(centers,matrixes)
#bpy.data.shape_keys['Key'].key_blocks['Key 1'].value
verts_out = Vector_degenerate(centers)
matrixes = Matrix_listing(matrixes)
return in_sockets, out_sockets()
def process(self):
# inputs
if not self.outputs['C'].is_linked:
return
id_mat = Matrix_listing([Matrix.Identity(4)])
A = Matrix_generate(self.inputs['A'].sv_get(default=id_mat))
B = Matrix_generate(self.inputs['B'].sv_get(default=id_mat))
factor = self.inputs['Factor'].sv_get()
matrixes_ = []
# match inputs, first matrix A and B using fullList
# then extend the factor list if necessary,
# A and B should control length of list, not interpolation lists
max_l = max(len(A), len(B))
fullList(A, max_l)
fullList(B, max_l)
if len(factor) < max_l:
fullList(factor, max_l)
for i in range(max_l):
for k in range(len(factor[i])):
matrixes_.append(A[i].lerp(B[i], factor[i][k]))
matrixes = Matrix_listing(matrixes_)
self.outputs['C'].sv_set(matrixes)
def process(self):
empty = self.find_empty()
if not empty:
empty = self.create_empty()
print("created new empty")
if self.inputs['Matrix'].is_linked:
mats = self.inputs['Matrix'].sv_get()
mat = Matrix_generate(mats)[0]
else:
mat = Matrix()
self.label = empty.name
empty.matrix_world = mat
if 'Objects' in self.outputs:
self.outputs['Objects'].sv_set([empty])
def input_mode(self):
inputs = self.inputs
if (len(inputs) == 0) or (not inputs[0].links):
print('has no link!')
return
# then morph default socket type to whatever we plug into it.
from_socket = inputs[0].links[0].from_socket
incoming_socket_type = type(from_socket)
stype = {
VerticesSocket: 'VerticesSocket',
MatrixSocket: 'MatrixSocket',
StringsSocket: 'StringsSocket'
}.get(incoming_socket_type, None)
# print(incoming_socket_type, from_socket, stype)
if not stype:
print('unidentified flying input')
return
# if the current self.input socket is different to incoming
if not (stype == self.inputs[0].bl_idname):
self.morph_input_socket_type(stype)
# only one nesting level supported, for types other than matrix.
# else x gets complicated. x is complex already, this forces
# simplicity
tvar = None
if stype == 'MatrixSocket':
prop = SvGetSocketAnyType(self, inputs[0])
tvar = Matrix_generate(prop)[0]
# print('---repr-\n', repr(tvar))
else:
tvar = SvGetSocketAnyType(self, inputs[0])[0][0]
# input can still be empty or []
if not tvar:
return
if self.eval_str.endswith("with x"):
process_input_dofunction(self, tvar)
else:
process_input_to_bpy(self, tvar, stype)
def process(self):
if not self.inputs['Matrices'].is_linked:
return
vertices = self.inputs['Vertices'].sv_get()
matrices = self.inputs['Matrices'].sv_get()
matrices = Matrix_generate(matrices)
n = len(matrices)
result_vertices = (vertices*n)[:n]
outV = []
for i, i2 in zip(matrices, result_vertices):
outV.append([(i*Vector(v))[:] for v in i2])
edges = self.inputs['Edges'].sv_get(default=[[]])
faces = self.inputs['Faces'].sv_get(default=[[]])
result_edges = (edges * n)[:n]
result_faces = (faces * n)[:n]
if self.do_join:
outV, result_edges, result_faces = mesh_join(outV, result_edges, result_faces)
outV, result_edges, result_faces = [outV], [result_edges], [result_faces]
self.outputs['Edges'].sv_set(result_edges)
self.outputs['Faces'].sv_set(result_faces)
self.outputs['Vertices'].sv_set(outV)
def process(self):
L, S, R, A = self.outputs
M = self.inputs[0]
if M.is_linked:
matrixes_ = M.sv_get()
matrixes = Matrix_generate(matrixes_)
if L.is_linked:
locs = Matrix_location(matrixes, list=True)
L.sv_set(locs)
if S.is_linked:
locs = Matrix_scale(matrixes, list=True)
S.sv_set(locs)
if R.is_linked or A.is_linked:
locs = Matrix_rotation(matrixes, list=True)
rots, angles = [], []
for lists in locs:
rots.append([pair[0] for pair in lists])
for pair in lists:
angles.append(degrees(pair[1]))
R.sv_set(rots)
A.sv_set([angles])
def assign_data(obj, data):
'''
assigns data to the object
'''
if isinstance(obj, (int, float)):
# doesn't work
obj = data[0][0]
elif isinstance(obj, (Vector, Color)):
obj[:] = data[0][0]
elif isinstance(obj, (Matrix, Euler, Quaternion)):
mats = Matrix_generate(data)
mat = mats[0]
if isinstance(obj, Euler):
eul = mat.to_euler(obj.order)
obj[:] = eul
elif isinstance(obj, Quaternion):
quat = mat.to_quaternion()
obj[:] = quat
else: #isinstance(obj, Matrix)
obj[:] = mat
else: # super optimistic guess
obj[:] = type(obj)(data[0][0])
def process(self):
if not ('vertices' in self.outputs and self.outputs['vertices'].links
or 'edges' in self.outputs and self.outputs['edges'].links and
'polygons' in self.outputs and self.outputs['polygons'].links):
return
if 'vertices' in self.inputs and self.inputs['vertices'].links and \
'edg_pol' in self.inputs and self.inputs['edg_pol'].links and\
'cut_matrix' in self.inputs and self.inputs['cut_matrix'].links:
verts_ob = Vector_generate(
SvGetSocketAnyType(self, self.inputs['vertices']))
edg_pols = SvGetSocketAnyType(self, self.inputs['edg_pol'])
cut_mats_ = SvGetSocketAnyType(self, self.inputs['cut_matrix'])
cut_mats = Matrix_generate(cut_mats_)
verts_out = []
edges_out = []
polys_out = []
for cut_mat in cut_mats:
pp = cut_mat.to_translation()
pno = Vector((0.0, 0.0, 1.0)) * cut_mat.to_3x3().transposed()
for obj in zip(verts_ob, edg_pols):
res = bisect(obj[0], obj[1], pp, pno, self.outer,
self.inner, self.fill)
if not res:
return
verts_out.append(res[0])
edges_out.append(res[1])
polys_out.append(res[2])
if 'vertices' in self.outputs and self.outputs['vertices'].links:
SvSetSocketAnyType(self, 'vertices', verts_out)
if 'edges' in self.outputs and self.outputs['edges'].links:
SvSetSocketAnyType(self, 'edges', edges_out)
if 'polygons' in self.outputs and self.outputs['polygons'].links:
SvSetSocketAnyType(self, 'polygons', polys_out)
def process(self):
verts = self.inputs['Vertices'].sv_get()
if self.inputs['PolyEdge'].is_linked:
poly_edge = self.inputs['PolyEdge'].sv_get()
poly_in = True
else:
poly_in = False
poly_edge = repeat_last([[]])
verts_out = []
poly_edge_out = []
item_order = []
poly_output = poly_in and self.outputs['PolyEdge'].is_linked
order_output = self.outputs['Item order'].is_linked
vert_output = self.outputs['Vertices'].is_linked
if not any((vert_output, order_output, poly_output)):
return
if self.mode == 'XYZ':
# should be user settable
op_order = [(0, False),
(1, False),
(2, False)]
for v, p in zip(verts, poly_edge):
s_v = ((e[0], e[1], e[2], i) for i, e in enumerate(v))
for item_index, rev in op_order:
s_v = sorted(s_v, key=itemgetter(item_index), reverse=rev)
verts_out.append([v[:3] for v in s_v])
if poly_output:
v_index = {item[-1]: j for j, item in enumerate(s_v)}
poly_edge_out.append([list(map(lambda n:v_index[n], pe)) for pe in p])
if order_output:
item_order.append([i[-1] for i in s_v])
if self.mode == 'DIST':
if self.inputs['Base Point'].is_linked:
base_points = self.inputs['Base Point'].sv_get()
bp_iter = repeat_last(base_points[0])
else:
bp = [(0, 0, 0)]
bp_iter = repeat_last(bp)
for v, p, v_base in zip(verts, poly_edge, bp_iter):
s_v = sorted(((v_c, i) for i, v_c in enumerate(v)), key=lambda v: distK(v[0], v_base))
verts_out.append([vert[0] for vert in s_v])
if poly_output:
v_index = {item[-1]: j for j, item in enumerate(s_v)}
poly_edge_out.append([list(map(lambda n:v_index[n], pe)) for pe in p])
if order_output:
item_order.append([i[-1] for i in s_v])
if self.mode == 'AXIS':
if self.inputs['Mat'].is_linked:
mat = Matrix_generate(self.inputs['Mat'].sv_get())
else:
mat = [Matrix. Identity(4)]
mat_iter = repeat_last(mat)
def f(axis, q):
if axis.dot(q.axis) > 0:
return q.angle
else:
return -q.angle
for v, p, m in zip(Vector_generate(verts), poly_edge, mat_iter):
axis = m @ Vector((0, 0, 1))
axis_norm = m @ Vector((1, 0, 0))
base_point = m @ Vector((0, 0, 0))
intersect_d = [intersect_point_line(v_c, base_point, axis) for v_c in v]
rotate_d = [f(axis, (axis_norm + v_l[0]).rotation_difference(v_c)) for v_c, v_l in zip(v, intersect_d)]
s_v = ((data[0][1], data[1], i) for i, data in enumerate(zip(intersect_d, rotate_d)))
s_v = sorted(s_v, key=itemgetter(0, 1))
verts_out.append([v[i[-1]].to_tuple() for i in s_v])
if poly_output:
v_index = {item[-1]: j for j, item in enumerate(s_v)}
poly_edge_out.append([list(map(lambda n:v_index[n], pe)) for pe in p])
if order_output:
item_order.append([i[-1] for i in s_v])
if self.mode == 'USER':
if self.inputs['Index Data'].is_linked:
index = self.inputs['Index Data'].sv_get()
else:
return
for v, p, i in zip(verts, poly_edge, index):
s_v = sorted([(data[0], data[1], i) for i, data in enumerate(zip(i, v))], key=itemgetter(0))
verts_out.append([obj[1] for obj in s_v])
if poly_output:
v_index = {item[-1]: j for j, item in enumerate(s_v)}
poly_edge_out.append([[v_index[k] for k in pe] for pe in p])
if order_output:
item_order.append([i[-1] for i in s_v])
if self.mode == 'CONNEX':
if self.inputs['PolyEdge'].is_linked:
edges = self.inputs['PolyEdge'].sv_get()
for v, p in zip(verts, edges):
pols = []
if len(p[0]) > 2:
pols = [p[:]]
p = pols_edges([p], True)[0]
vect_new, pol_edge_new, index_new = sort_vertices_by_connexions(v, p, self.limit_mode)
if len(pols) > 0:
new_pols = []
for pol in pols[0]:
new_pol = []
for i in pol:
new_pol.append(index_new.index(i))
new_pols.append(new_pol)
pol_edge_new = [new_pols]
verts_out.append(vect_new)
poly_edge_out.append(pol_edge_new)
item_order.append(index_new)
if vert_output:
self.outputs['Vertices'].sv_set(verts_out)
if poly_output:
self.outputs['PolyEdge'].sv_set(poly_edge_out)
if order_output:
self.outputs['Item order'].sv_set(item_order)
def process(self):
# inputs
if not (self.inputs['Vertices'].is_linked):
return
vertices_s = self.inputs['Vertices'].sv_get()
edges_s = self.inputs['Edg_Pol'].sv_get(default=[[]])
#faces_s = self.inputs['Polygons'].sv_get(default=[[]])
matrices_s = self.inputs['Matrices'].sv_get(default=[[]])
if is_matrix(matrices_s[0]):
matrices_s = [Matrix_generate(matrices_s)]
else:
matrices_s = [Matrix_generate(matrices) for matrices in matrices_s]
#extrude_edges_s = self.inputs['ExtrudeEdges'].sv_get(default=[[]])
result_vertices = []
result_edges = []
result_faces = []
result_ext_vertices = []
result_ext_edges = []
result_ext_faces = []
meshes = match_long_repeat([vertices_s, edges_s,
matrices_s]) #, extrude_edges_s])
for vertices, edges, matrices in zip(*meshes):
if len(edges[0]) == 2:
faces = []
else:
faces = edges.copy()
edges = []
if not matrices:
matrices = [Matrix()]
bm = bmesh_from_pydata(vertices, edges, faces)
# better to do it in separate node, not integrate by default.
#if extrude_edges:
# b_edges = []
# for edge in extrude_edges:
# b_edge = [e for e in bm.edges if set([v.index for v in e.verts]) == set(edge)]
# b_edges.append(b_edge[0])
#else:
b_edges = bm.edges
new_geom = bmesh.ops.extrude_edge_only(
bm, edges=b_edges, use_select_history=False)['geom']
extruded_verts = [
v for v in new_geom if isinstance(v, bmesh.types.BMVert)
]
for vertex, matrix in zip(
*match_long_repeat([extruded_verts, matrices])):
bmesh.ops.transform(bm,
verts=[vertex],
matrix=matrix,
space=Matrix())
extruded_verts = [tuple(v.co) for v in extruded_verts]
extruded_edges = [
e for e in new_geom if isinstance(e, bmesh.types.BMEdge)
]
extruded_edges = [
tuple(v.index for v in edge.verts) for edge in extruded_edges
]
extruded_faces = [
f for f in new_geom if isinstance(f, bmesh.types.BMFace)
]
extruded_faces = [[v.index for v in edge.verts]
for edge in extruded_faces]
new_vertices, new_edges, new_faces = pydata_from_bmesh(bm)
bm.free()
result_vertices.append(new_vertices)
result_edges.append(new_edges)
result_faces.append(new_faces)
result_ext_vertices.append(extruded_verts)
result_ext_edges.append(extruded_edges)
result_ext_faces.append(extruded_faces)
if self.outputs['Vertices'].is_linked:
self.outputs['Vertices'].sv_set(result_vertices)
if self.outputs['Edges'].is_linked:
self.outputs['Edges'].sv_set(result_edges)
if self.outputs['Polygons'].is_linked:
self.outputs['Polygons'].sv_set(result_faces)
if self.outputs['NewVertices'].is_linked:
self.outputs['NewVertices'].sv_set(result_ext_vertices)
if self.outputs['NewEdges'].is_linked:
self.outputs['NewEdges'].sv_set(result_ext_edges)
if self.outputs['NewFaces'].is_linked:
self.outputs['NewFaces'].sv_set(result_ext_faces)
def draw_callback_view(n_id, cached_view, options):
def Vector_generate2(prop):
# try:
# return [[Vector(v[:3]) for v in obj] for obj in prop]
# except ValueEror:
# return []
return [[Vector(v) for v in obj] for obj in prop]
# context = bpy.context
if options["timings"]:
start = time.perf_counter()
if options['draw_list'] == 0:
sl1 = cached_view[n_id + 'v']
sl2 = cached_view[n_id + 'ep']
sl3 = cached_view[n_id + 'm']
if sl1:
data_vector = Vector_generate2(sl1)
verlen = len(data_vector) - 1
else:
if not sl3:
# end early: no matrix and no vertices
callback_disable(n_id)
return
# display matrix repr only.
data_vector = []
verlen = 0
options['verlen'] = verlen
data_polygons = []
data_edges = []
if sl2 and sl2[0]:
if isinstance(sl2[0], int):
#callback_disable(n_id)
return
len_sl2 = len(sl2[0][0])
if len_sl2 == 2:
data_edges = sl2
elif len_sl2 > 2:
data_polygons = sl2
if sl3:
data_matrix = Matrix_generate(sl3)
else:
data_matrix = [Matrix() for i in range(verlen + 1)]
if (data_vector, data_polygons, data_matrix, data_edges) == (0, 0, 0,
0):
#callback_disable(n_id)
return
try:
the_display_list = glGenLists(1)
glNewList(the_display_list, GL_COMPILE)
draw_geometry(n_id, options, data_vector, data_polygons,
data_matrix, data_edges)
except Exception as err:
print("Error in callback!:")
traceback.print_exc()
options['error'] = True
finally:
glEndList()
options['genlist'] = the_display_list
elif options['draw_list'] == 1:
the_display_list = options['genlist']
if not 'error' in options:
glCallList(the_display_list)
glFlush()
# restore to system state
glLineWidth(1)
if options["timings"]:
stop = time.perf_counter()
print("callback drawn in {:4f}".format(stop - start))
# has drawn once with success.
options['draw_list'] = 1
def process(self):
# return if no outputs are connected
if not any(s.is_linked for s in self.outputs):
return
inputs = self.inputs
outputs = self.outputs
identityMatrix = [[tuple(v) for v in Matrix()]]
input_verts = inputs['Vertices'].sv_get()[0]
input_polys = inputs['PolyEdge'].sv_get()[0]
input_matrixT = inputs['Matrix T'].sv_get(default=identityMatrix)
input_matrixF = inputs['Matrix F'].sv_get(default=identityMatrix)
n = len(input_verts)
if inputs['Mask'].is_linked:
input_mask = inputs['Mask'].sv_get()[0][:n]
input_mask = list(map(lambda x: int(x) % 2, input_mask))
else: # if no mask input, generate a 0,1,0,1 mask
input_mask = ([1, 0] * (int((n + 1) / 2)))[:n]
matrixF = (Matrix_generate(input_matrixF))[:n]
matrixT = (Matrix_generate(input_matrixT))[:n]
params = match_long_repeat([input_mask, input_verts, matrixT, matrixF])
# process vertices
vertListA, vertListT, vertListF = [[], [], []]
for ma, v, mt, mf in zip(*params):
if ma == 1: # do some processing using Matrix T here
v = (mt * Vector(v))[:]
vertListT.append(v)
else: # do some processing using Matrix F here
v = (mf * Vector(v))[:]
vertListF.append(v)
vertListA.append(v)
# process polyEdges
vert_indexT = [i for i, m in enumerate(input_mask) if m]
vert_indexF = [i for i, m in enumerate(input_mask) if not m]
vt = {j: i for i, j in enumerate(vert_indexT)}
vf = {j: i for i, j in enumerate(vert_indexF)}
vext = set(vert_indexT)
vexf = set(vert_indexF)
polyEdgeListA = input_polys
polyEdgeListT, polyEdgeListF, polyEdgeListO = [[], [], []]
inSetT, inSetF = vext.issuperset, vexf.issuperset
addPET, addPEF, addPEO = polyEdgeListT.append, polyEdgeListF.append, polyEdgeListO.append
for pe in input_polys:
pex = set(pe)
if inSetT(pex):
addPET([vt[i] for i in pe])
elif inSetF(pex):
addPEF([vf[i] for i in pe])
else:
addPEO(pe)
outputs['Vertices'].sv_set([vertListA])
outputs['PolyEdge'].sv_set([polyEdgeListA])
outputs['PolyEdge O'].sv_set([polyEdgeListO])
outputs['Vertices T'].sv_set([vertListT])
outputs['PolyEdge T'].sv_set([polyEdgeListT])
outputs['Vertices F'].sv_set([vertListF])
outputs['PolyEdge F'].sv_set([polyEdgeListF])
def makeobjects(self, vers, edg_pol, mats):
fht = []
if len(edg_pol[0][0]) == 2:
pols = []
for edgs in edg_pol:
maxi = max(max(a) for a in edgs)
fht.append(maxi)
elif len(edg_pol[0][0]) > 2:
edgs = []
for pols in edg_pol:
maxi = max(max(a) for a in pols)
fht.append(maxi)
vertices = Vector_generate(vers)
matrixes = Matrix_generate(mats)
objects = {}
fhtagn = []
for u, f in enumerate(fht):
fhtagn.append(min(len(vertices[u]), fht[u]))
#lenmesh = len(vertices) - 1
# name space for particular bakery node
# defined only by matrices count (without .001 etc)
global sverchok_bakery_cache
try:
cache = sverchok_bakery_cache[self.name]
except:
cache = []
names = ['Sv_' + self.name + str(i) for i, t in enumerate(mats)]
#print('bakery'+str(names)+str(cache))
bpy.ops.object.select_all(action='DESELECT')
for i, obj in enumerate(bpy.context.scene.objects):
nam = 'Sv_' + self.name
if nam in obj.name:
if obj.name not in names:
bpy.context.scene.objects[obj.name].select = True
bpy.ops.object.delete(use_global=False)
for i, m in enumerate(matrixes):
# solution to reduce number of vertices respect to edges/pols
########
k = i
lenver = len(vertices) - 1
if i > lenver:
v = vertices[-1]
k = lenver
else:
v = vertices[k]
if (len(v) - 1) < fhtagn[k]:
continue
elif fhtagn[k] < (len(v) - 1):
nonneed = (len(v) - 1) - fhtagn[k]
for q in range(nonneed):
v.pop((fhtagn[k] + 1))
#########
# end of solution to reduce vertices
e = edg_pol[k] if edgs else []
p = edg_pol[k] if pols else []
# to change old, create new separately
if names[i] not in cache:
objects[str(i)] = self.makemesh(names[i], v, e, p, m)
elif bpy.context.scene.objects.find(names[i]) >= 0:
objects[str(i)] = self.makemesh_exist(names[i], v, e, p, m)
else:
objects[str(i)] = self.makemesh(names[i], v, e, p, m)
for i, ite in enumerate(objects.values()):
me = ite[1]
ob = ite[0]
calcedg = True
if edgs:
calcedg = False
me.update(calc_edges=calcedg)
if ob.name not in cache:
bpy.context.scene.objects.link(ob)
# save cache
sverchok_bakery_cache[self.name] = names