def execute(self, context):
inputs = bpy.data.node_groups[self.treename].nodes[self.nodename].inputs
# vertices socket
out_verts = "None \n"
if inputs["vertices"].links:
if type(inputs["vertices"].links[0].from_socket) == bpy.types.VerticesSocket:
evaverti = inputs["vertices"].sv_get()
deptl = levelsOflist(evaverti)
if deptl and deptl > 2:
a = self.readFORviewer_sockets_data(evaverti, deptl, len(evaverti))
elif deptl:
a = self.readFORviewer_sockets_data_small(evaverti, deptl, len(evaverti))
else:
a = "None \n"
out_verts = a
# edges/faces socket
out_edgpol = "None \n"
edpotype = "\n\ndata \n"
if inputs["edg_pol"].links:
if type(inputs["edg_pol"].links[0].from_socket) == bpy.types.StringsSocket:
evaline_str = inputs["edg_pol"].sv_get()
if evaline_str:
edpotype = self.edgDef(evaline_str)
deptl = levelsOflist(evaline_str)
if deptl and deptl > 2:
b = self.readFORviewer_sockets_data(evaline_str, deptl, len(evaline_str))
elif deptl:
b = self.readFORviewer_sockets_data_small(evaline_str, deptl, len(evaline_str))
else:
b = "None \n"
out_edgpol = str(b)
# matrix socket
out_matrix = "None \n"
if inputs["matrix"].links:
if type(inputs["matrix"].links[0].from_socket) == bpy.types.MatrixSocket:
eva = inputs["matrix"].sv_get()
deptl = levelsOflist(eva)
if deptl and deptl > 2:
c = self.readFORviewer_sockets_data(eva, deptl, len(eva))
elif deptl:
c = self.readFORviewer_sockets_data_small(eva, deptl, len(eva))
else:
c = "None \n"
out_matrix = str(c)
self.do_text(out_verts, out_edgpol, out_matrix, edpotype)
return {"FINISHED"}
def process(self):
if any(s.is_linked for s in self.outputs):
slots = []
for socket in self.inputs:
if socket.is_linked:
slots.append(socket.sv_get())
if len(slots) == 0:
return
lol = levelsOflist(slots)
if lol == 4:
result = self.connect(slots, self.dir_check, self.cicl_check_U, self.cicl_check_V, lol, self.polygons, self.slice_check, self.cup_U, self.cup_V)
elif lol == 5:
one = []
two = []
for slo in slots:
for s in slo:
result = self.connect([s], self.dir_check, self.cicl_check_U, self.cicl_check_V, lol, self.polygons, self.slice_check, self.cup_U, self.cup_V)
one.extend(result[0])
two.extend(result[1])
result = (one, two)
else: # give up
return
if self.outputs['vertices'].is_linked:
self.outputs['vertices'].sv_set(result[0])
if self.outputs['data'].is_linked:
self.outputs['data'].sv_set(result[1])
def recurse_fxy(l1, l2, func, level):
res = []
res_append = res.append
if levelsOflist(l1) < 2:
l1 = [l1]
if levelsOflist(l2) < 2:
l2 = [l2]
# will only be used if lists are of unequal length
fl = l2[-1] if len(l1) > len(l2) else l1[-1]
if level == 1:
for u, v in zip_longest(l1, l2, fillvalue=fl):
res_append(func(u, v))
else:
for u, v in zip_longest(l1, l2, fillvalue=fl):
res_append(recurse_fxy(u, v, func, level - 1))
return res
def process(self):
if self.inputs[0].is_linked:
slots = [
socket.sv_get() for socket in self.inputs if socket.is_linked
]
lol = levelsOflist(slots)
if lol == 4:
one, two = self.connect(slots, self.dir_check,
self.cicl_check_U, self.cicl_check_V,
lol, self.polygons, self.slice_check,
self.cup_U, self.cup_V)
elif lol == 5:
one = []
two = []
for slo in slots:
for s in slo:
result = self.connect([s], self.dir_check,
self.cicl_check_U,
self.cicl_check_V, lol,
self.polygons, self.slice_check,
self.cup_U, self.cup_V)
one.extend(result[0])
two.extend(result[1])
else:
return
if self.outputs['vertices'].is_linked:
self.outputs['vertices'].sv_set(one)
if self.outputs['data'].is_linked:
self.outputs['data'].sv_set(two)
def process(self):
if self.outputs['vertices'].is_linked or self.outputs['data'].is_linked:
slots = []
for socket in self.inputs:
if socket.is_linked:
slots.append(socket.sv_get())
if len(slots) == 0:
return
lol = levelsOflist(slots)
if lol == 4:
result = self.connect(slots, self.dir_check, self.cicl_check_U,
self.cicl_check_V, lol, self.polygons,
self.slice_check, self.cup_U, self.cup_V)
elif lol == 5:
one = []
two = []
for slo in slots:
for s in slo:
result = self.connect([s], self.dir_check,
self.cicl_check_U,
self.cicl_check_V, lol,
self.polygons, self.slice_check,
self.cup_U, self.cup_V)
one.extend(result[0])
two.extend(result[1])
result = (one, two)
if self.outputs['vertices'].is_linked:
SvSetSocketAnyType(self, 'vertices', result[0])
if self.outputs['data'].is_linked:
SvSetSocketAnyType(self, 'data', result[1])
def process(self):
if self.outputs['vertices'].is_linked or self.outputs['data'].is_linked:
slots = []
for socket in self.inputs:
if socket.is_linked:
slots.append(socket.sv_get())
if len(slots) == 0:
return
lol = levelsOflist(slots)
if lol == 4:
result = self.connect(slots, self.dir_check, self.cicl_check, lol, self.polygons, self.slice_check)
elif lol == 5:
one = []
two = []
for slo in slots:
for s in slo:
result = self.connect([s], self.dir_check, self.cicl_check, lol, self.polygons, self.slice_check)
one.extend(result[0])
two.extend(result[1])
result = (one,two)
if self.outputs['vertices'].is_linked:
SvSetSocketAnyType(self, 'vertices', result[0])
if self.outputs['data'].is_linked:
SvSetSocketAnyType(self, 'data', result[1])
def auto_count(self):
data = self.inputs['data'].sv_get(default=[])
leve = levelsOflist(data)
if leve+1 < self.level:
self.level = leve+1
result = self.beat(data, self.level)
self.count = min(len(result), 16)
def prep_text(node, num_lines):
""" main preparation function for text """
outs = ''
inputs = node.inputs
for socket in inputs:
if socket.is_linked and socket.other:
label = socket.other.node.label
if label:
label = '; node ' + label.upper()
name = socket.name.upper()
data_type = socket_types.get(socket.other.bl_idname, "DATA")
itype = f'\n\nSocket {name}{label}; type {data_type}: \n'
eva = socket.sv_get()
deptl = levelsOflist(eva)
if deptl and deptl > 2:
a = readFORviewer_sockets_data(eva, deptl, len(eva), num_lines)
elif deptl:
a = readFORviewer_sockets_data_small(eva, deptl, len(eva), num_lines)
else:
a = 'None'
outs += itype+str(a)+'\n'
do_text(node, outs)
def process(self):
if 'vers' in self.outputs and len(self.outputs['vers'].links) > 0:
# get any type socket from input:
vers = SvGetSocketAnyType(self, self.inputs['vers'])
# Process data
levs = levelsOflist(vers)
result = self.remdou(vers, levs)
SvSetSocketAnyType(self, 'vers', result)
def sv_recursive_transformations(*args):
''' main function takes 5 args
function, verts1, verts2, multiplyer, separate
resulting levels arg to recursion'''
# print('arguments recursive',len(args))
if len(args) == 5:
f,v1,v2,m,s = args
m,v1,v2 = match_long_repeat([m,v1,v2])
level1 = levelsOflist(v1)
level2 = levelsOflist(v2)
level3 = levelsOflist(m)
lev = max(level1,level2,level3)-1
#print('recursion-dataspoiled',m,level3)
v1 = dataSpoil(v1, lev)
v2 = dataSpoil(v2, lev)
m = dataSpoil(m, lev)
#print('recursion-dataspoiled',m,lev)
return sv_recursion(f,v1,v2,m,s,lev)
def sv_recursive_transformations(*args):
''' main function takes 5 args
function, verts1, verts2, multiplyer, separate
resulting levels arg to recursion'''
# print('arguments recursive',len(args))
if len(args) == 5:
f, v1, v2, m, s = args
m, v1, v2 = match_long_repeat([m, v1, v2])
level1 = levelsOflist(v1)
level2 = levelsOflist(v2)
level3 = levelsOflist(m)
lev = max(level1, level2, level3) - 1
#print('recursion-dataspoiled',m,level3)
v1 = dataSpoil(v1, lev)
v2 = dataSpoil(v2, lev)
m = dataSpoil(m, lev)
#print('recursion-dataspoiled',m,lev)
return sv_recursion(f, v1, v2, m, s, lev)
def process(self):
if self.inputs['X'].is_linked:
vecs = SvGetSocketAnyType(self, self.inputs['X'])
else:
vecs = [[0.0]]
# outputs
if not self.outputs['Result'].is_linked:
return
list_mult = []
if self.inputs['n[0]'].is_linked:
i = 0
for socket in self.inputs[1:]:
if socket.is_linked:
list_mult.append(SvGetSocketAnyType(self, socket))
#print(list_mult)
code_formula = parser.expr(self.formula).compile()
# finding nasty levels, make equal nastyness (canonical 0,1,2,3)
levels = [levelsOflist(vecs)]
for n in list_mult:
levels.append(levelsOflist(n))
maxlevel = max(max(levels), 3)
diflevel = maxlevel - levels[0]
if diflevel:
vecs_ = dataSpoil([vecs], diflevel-1)
vecs = dataCorrect(vecs_, nominal_dept=2)
for i, lev in enumerate(levels):
if i == 0:
continue
diflevel = maxlevel-lev
if diflevel:
list_temp = dataSpoil([list_mult[i-1]], diflevel-1)
list_mult[i-1] = dataCorrect(list_temp, nominal_dept=2)
#print(list_mult)
r = self.inte(vecs, code_formula, list_mult, 3)
result = dataCorrect(r, nominal_dept=min((levels[0]-1), 2))
SvSetSocketAnyType(self, 'Result', result)
def auto_count(self):
data = self.inputs['data'].sv_get(default="not found")
other = get_other_socket(self.inputs['data'])
if other and data == "not found":
update_system.process_to_node(other.node)
data = self.inputs['data'].sv_get()
leve = levelsOflist(data)
if leve + 1 < self.level:
self.level = leve + 1
result = self.beat(data, self.level)
self.count = min(len(result), 16)
def process(self):
# достаём два слота - вершины и полики
if self.outputs['Sum'].is_linked and self.inputs['Data'].is_linked:
data = self.inputs['Data'].sv_get()
lol = levelsOflist(data) - 1
level = min(lol, self.level)
out = self.summ(data, level, lol)
if self.level == 1:
out = [out]
self.outputs['Sum'].sv_set(out)
def auto_count(self):
data = self.inputs['data'].sv_get(default="not found")
other = get_other_socket(self.inputs['data'])
if other and data == "not found":
update_system.process_to_node(other.node)
data = self.inputs['data'].sv_get()
leve = levelsOflist(data)
if leve+1 < self.level:
self.level = leve+1
result = self.beat(data, self.level)
self.count = min(len(result), 16)
def process(self):
if self.inputs['X'].is_linked:
vecs = self.inputs['X'].sv_get()
else:
vecs = [[0.0]]
# outputs
if not self.outputs['Result'].is_linked:
return
list_mult = []
if self.inputs['n[0]'].is_linked:
i = 0
for socket in self.inputs[1:]:
if socket.is_linked:
list_mult.append(socket.sv_get())
code_formula = parser.expr(self.formula).compile()
# finding nested levels, make equal nastedness (canonical 0,1,2,3)
levels = [levelsOflist(vecs)]
for n in list_mult:
levels.append(levelsOflist(n))
maxlevel = max(max(levels), 3)
diflevel = maxlevel - levels[0]
if diflevel:
vecs_ = dataSpoil([vecs], diflevel - 1)
vecs = dataCorrect(vecs_, nominal_dept=2)
for i, lev in enumerate(levels):
if i == 0:
continue
diflevel = maxlevel - lev
if diflevel:
list_temp = dataSpoil([list_mult[i - 1]], diflevel - 1)
list_mult[i - 1] = dataCorrect(list_temp, nominal_dept=2)
r = self.inte(vecs, code_formula, list_mult, 3)
result = dataCorrect(r, nominal_dept=min((levels[0] - 1), 2))
self.outputs['Result'].sv_set(result)
def process(self):
# достаём два слота - вершины и полики
if 'Sum' in self.outputs and self.outputs['Sum'].is_linked:
if 'Data' in self.inputs and self.inputs['Data'].is_linked:
data = SvGetSocketAnyType(self, self.inputs['Data'])
lol = levelsOflist(data) - 1
level = min(lol, self.level)
out = self.summ(data, level, lol)
if self.level == 1:
out = [out]
SvSetSocketAnyType(self, 'Sum', out)
def process(self):
# достаём два слота - вершины и полики
if 'Sum' in self.outputs and self.outputs['Sum'].is_linked:
if 'Data' in self.inputs and self.inputs['Data'].is_linked:
data = self.inputs['Data'].sv_get()
lol = levelsOflist(data) - 1
level = min(lol, self.level)
out = self.summ(data, level, lol)
if self.level == 1:
out = [out]
self.outputs['Sum'].sv_set(out)
def process(self):
if not self.outputs['data'].is_linked and not self.newsock:
return
self.newsock = False
data_ = self.inputs['data'].sv_get()
out = []
input_level = levelsOflist(data_)
if not self.inputs['keys'].is_linked:
out = sv_sort(data_, min(self.level, input_level))
else:
keys_ = self.inputs['keys'].sv_get()
out = key_sort(data_, keys_, min(self.level, input_level), 0)
self.outputs['data'].sv_set(out)
def process(self):
if not self.outputs['data'].is_linked:
return
data_ = self.inputs['data'].sv_get()
levelinit = levelsOflist(data_)
data = dataCorrect(data_, nominal_dept=self.level).copy()
out_ = []
if not self.inputs['keys'].is_linked:
for obj in data:
out_.append(sorted(obj))
else:
keys_ = self.inputs['keys'].sv_get()
keys = dataCorrect(keys_, nominal_dept=1)
for d,k in zip(data,keys):
d.sort(key = lambda x: k.pop(0))
out_.append(d)
out = dataCorrect(out_,nominal_dept=levelinit-1)
self.outputs['data'].sv_set(out)
def process(self):
if not self.outputs['data'].is_linked:
return
data_ = self.inputs['data'].sv_get()
levelinit = levelsOflist(data_)
data = dataCorrect(data_, nominal_dept=self.level).copy()
out_ = []
if not self.inputs['keys'].is_linked:
for obj in data:
out_.append(sorted(obj))
else:
keys_ = self.inputs['keys'].sv_get()
keys = dataCorrect(keys_, nominal_dept=1)
for d, k in zip(data, keys):
d.sort(key=lambda x: k.pop(0))
out_.append(d)
out = dataCorrect(out_, nominal_dept=levelinit - 1)
self.outputs['data'].sv_set(out)
def process(self):
if self.inputs['Data'].is_linked:
data = self.inputs['Data'].sv_get(deepcopy=False)
# blocking too height values of levels, reduce
levels = levelsOflist(data) - 2
if levels >= self.level:
levels = self.level - 1
elif levels < 1:
levels = 1
# assign out
if self.outputs['First'].is_linked:
out = self.count(data, levels, 0)
self.outputs['First'].sv_set(out)
if self.outputs['Middl'].is_linked:
out = self.count(data, levels, 1)
self.outputs['Middl'].sv_set(out)
if self.outputs['Last'].is_linked:
out = self.count(data, levels, 2)
self.outputs['Last'].sv_set(out)
def process(self):
if self.inputs[0].is_linked:
slots = [socket.sv_get() for socket in self.inputs if socket.is_linked]
lol = levelsOflist(slots)
if lol == 4:
one, two = self.connect(slots, self.dir_check, self.cicl_check_U, self.cicl_check_V, lol, self.polygons, self.slice_check, self.cup_U, self.cup_V)
elif lol == 5:
one = []
two = []
for slo in slots:
for s in slo:
result = self.connect([s], self.dir_check, self.cicl_check_U, self.cicl_check_V, lol, self.polygons, self.slice_check, self.cup_U, self.cup_V)
one.extend(result[0])
two.extend(result[1])
else:
return
if self.outputs['vertices'].is_linked:
self.outputs['vertices'].sv_set(one)
if self.outputs['data'].is_linked:
self.outputs['data'].sv_set(two)
def process(self):
inputs, outputs = self.inputs, self.outputs
if not outputs[0].is_linked:
return
func = func_dict.get(self.current_op)[1]
num_inputs = len(inputs)
# get either input data, or socket default
input_one = inputs[0].sv_get(deepcopy=False)
level = levelsOflist(input_one) - 1
if num_inputs == 1:
result = recurse_fx(input_one, func, level)
else:
input_two = inputs[1].sv_get(deepcopy=False)
result = recurse_fxy(input_one, input_two, func, level)
outputs[0].sv_set(result)
def process(self):
inputs, outputs = self.inputs, self.outputs
if not outputs[0].is_linked:
return
func = func_dict.get(self.current_op)[1]
num_inputs = len(inputs)
# get either input data, or socket default
input_one = inputs[0].sv_get(deepcopy=False)
level = levelsOflist(input_one) - 1
if num_inputs == 1:
result = recurse_fx(input_one, func, level)
else:
input_two = inputs[1].sv_get(deepcopy=False)
result = recurse_fxy(input_one, input_two, func, level)
outputs[0].sv_set(result)
def prep_text(self, context, node, inputs):
'main preparation function for text'
# outputs
outs = ''
for insert in inputs:
if insert.is_linked:
label = insert.other.node.label
if label:
label = '; node ' + label.upper()
name = insert.name.upper()
# vertices socket
if insert.other.bl_idname == 'VerticesSocket':
itype = '\n\nSocket ' + name + label + '; type VERTICES: \n'
# edges/faces socket
elif insert.other.bl_idname == 'StringsSocket':
itype = '\n\nSocket ' + name + label + '; type EDGES/POLYGONS/OTHERS: \n'
# matrix socket
elif insert.other.bl_idname == 'MatrixSocket':
itype = '\n\nSocket ' + name + label + '; type MATRICES: \n'
# object socket
elif insert.other.bl_idname == 'SvObjectSocket':
itype = '\n\nSocket ' + name + label + '; type OBJECTS: \n'
# else
else:
itype = '\n\nSocket ' + name + label + '; type DATA: \n'
eva = insert.sv_get()
deptl = levelsOflist(eva)
if deptl and deptl > 2:
a = self.readFORviewer_sockets_data(eva, deptl, len(eva))
elif deptl:
a = self.readFORviewer_sockets_data_small(
eva, deptl, len(eva))
else:
a = 'None'
outs += itype + str(a) + '\n'
self.do_text(outs, node)
def process(self):
if 'First' in self.outputs and self.outputs['First'].is_linked or \
'Last' in self.outputs and self.outputs['Last'].is_linked or \
'Middl' in self.outputs and self.outputs['Middl'].is_linked:
data = SvGetSocketAnyType(self, self.inputs['Data'])
# blocking too height values of levels, reduce
levels = levelsOflist(data)-2
if levels >= self.level:
levels = self.level-1
elif levels < 1:
levels = 1
# assign out
if self.outputs['First'].is_linked:
out = self.count(data, levels, 0)
SvSetSocketAnyType(self, 'First', out)
if self.outputs['Middl'].is_linked:
out = self.count(data, levels, 1)
SvSetSocketAnyType(self, 'Middl', out)
if self.outputs['Last'].is_linked:
out = self.count(data, levels, 2)
SvSetSocketAnyType(self, 'Last', out)
def process(self):
if 'First' in self.outputs and self.outputs['First'].is_linked or \
'Last' in self.outputs and self.outputs['Last'].is_linked or \
'Middl' in self.outputs and self.outputs['Middl'].is_linked:
data = SvGetSocketAnyType(self, self.inputs['Data'])
# blocking too height values of levels, reduce
levels = levelsOflist(data) - 2
if levels >= self.level:
levels = self.level - 1
elif levels < 1:
levels = 1
# assign out
if self.outputs['First'].is_linked:
out = self.count(data, levels, 0)
SvSetSocketAnyType(self, 'First', out)
if self.outputs['Middl'].is_linked:
out = self.count(data, levels, 1)
SvSetSocketAnyType(self, 'Middl', out)
if self.outputs['Last'].is_linked:
out = self.count(data, levels, 2)
SvSetSocketAnyType(self, 'Last', out)
def process(self):
if 'First' in self.outputs and self.outputs['First'].is_linked or \
'Last' in self.outputs and self.outputs['Last'].is_linked or \
'Middl' in self.outputs and self.outputs['Middl'].is_linked:
data = self.inputs['Data'].sv_get(deepcopy=False)
# blocking too height values of levels, reduce
levels = levelsOflist(data)-2
if levels >= self.level:
levels = self.level-1
elif levels < 1:
levels = 1
# assign out
if self.outputs['First'].is_linked:
out = self.count(data, levels, 0)
self.outputs['First'].sv_set(out)
if self.outputs['Middl'].is_linked:
out = self.count(data, levels, 1)
self.outputs['Middl'].sv_set(out)
if self.outputs['Last'].is_linked:
out = self.count(data, levels, 2)
self.ouputs['Last'].sv_set(out)
def execute(self, context):
inputs = bpy.data.node_groups[self.treename].nodes[self.nodename].inputs
# vertices socket
out_verts = 'None \n'
if inputs['vertices'].is_linked:
if inputs['vertices'].other.bl_idname == 'VerticesSocket':
evaverti = inputs['vertices'].sv_get()
deptl = levelsOflist(evaverti)
if deptl and deptl > 2:
a = self.readFORviewer_sockets_data(evaverti, deptl, len(evaverti))
elif deptl:
a = self.readFORviewer_sockets_data_small(evaverti, deptl, len(evaverti))
else:
a = 'None \n'
out_verts = a
# edges/faces socket
out_edgpol = 'None \n'
edpotype = '\n\ndata \n'
if inputs['edg_pol'].is_linked:
if inputs['edg_pol'].other.bl_idname == 'StringsSocket':
evaline_str = inputs['edg_pol'].sv_get()
if evaline_str:
edpotype = self.edgDef(evaline_str)
deptl = levelsOflist(evaline_str)
if deptl and deptl > 2:
b = self.readFORviewer_sockets_data(evaline_str, deptl, len(evaline_str))
elif deptl:
b = self.readFORviewer_sockets_data_small(evaline_str, deptl, len(evaline_str))
else:
b = 'None \n'
out_edgpol = str(b)
# matrix socket
out_matrix = 'None \n'
if inputs['matrix'].is_linked:
if inputs['matrix'].other.bl_idname == 'MatrixSocket':
eva = inputs['matrix'].sv_get()
deptl = levelsOflist(eva)
if deptl and deptl > 2:
c = self.readFORviewer_sockets_data(eva, deptl, len(eva))
elif deptl:
c = self.readFORviewer_sockets_data_small(eva, deptl, len(eva))
else:
c = 'None \n'
out_matrix = str(c)
# object socket
out_object = 'None \n'
if inputs['object'].is_linked:
if inputs['object'].other.bl_idname == 'SvObjectSocket':
eva = inputs['object'].sv_get()
deptl = levelsOflist(eva)
if deptl and deptl > 2:
d = self.readFORviewer_sockets_data(eva, deptl, len(eva))
elif deptl:
d = self.readFORviewer_sockets_data_small(eva, deptl, len(eva))
else:
d = 'None \n'
out_object = str(d)
self.do_text(out_verts, out_edgpol, out_matrix, edpotype, out_object)
return {'FINISHED'}
def execute(self, context):
inputs = bpy.data.node_groups[self.treename].nodes[
self.nodename].inputs
# vertices socket
out_verts = 'None \n'
if inputs['vertices'].links:
if type(inputs['vertices'].links[0].from_socket
) == bpy.types.VerticesSocket:
evaverti = inputs['vertices'].sv_get()
deptl = levelsOflist(evaverti)
if deptl and deptl > 2:
a = self.readFORviewer_sockets_data(
evaverti, deptl, len(evaverti))
elif deptl:
a = self.readFORviewer_sockets_data_small(
evaverti, deptl, len(evaverti))
else:
a = 'None \n'
out_verts = a
# edges/faces socket
out_edgpol = 'None \n'
edpotype = '\n\ndata \n'
if inputs['edg_pol'].links:
if type(inputs['edg_pol'].links[0].from_socket
) == bpy.types.StringsSocket:
evaline_str = inputs['edg_pol'].sv_get()
if evaline_str:
edpotype = self.edgDef(evaline_str)
deptl = levelsOflist(evaline_str)
if deptl and deptl > 2:
b = self.readFORviewer_sockets_data(
evaline_str, deptl, len(evaline_str))
elif deptl:
b = self.readFORviewer_sockets_data_small(
evaline_str, deptl, len(evaline_str))
else:
b = 'None \n'
out_edgpol = str(b)
# matrix socket
out_matrix = 'None \n'
if inputs['matrix'].links:
if type(inputs['matrix'].links[0].from_socket
) == bpy.types.MatrixSocket:
eva = inputs['matrix'].sv_get()
deptl = levelsOflist(eva)
if deptl and deptl > 2:
c = self.readFORviewer_sockets_data(eva, deptl, len(eva))
elif deptl:
c = self.readFORviewer_sockets_data_small(
eva, deptl, len(eva))
else:
c = 'None \n'
out_matrix = str(c)
# object socket
out_object = 'None \n'
if inputs['object'].links:
if type(inputs['object'].links[0].from_socket
) == bpy.types.SvObjectSocket:
eva = inputs['object'].sv_get()
deptl = levelsOflist(eva)
if deptl and deptl > 2:
d = self.readFORviewer_sockets_data(eva, deptl, len(eva))
elif deptl:
d = self.readFORviewer_sockets_data_small(
eva, deptl, len(eva))
else:
d = 'None \n'
out_object = str(d)
self.do_text(out_verts, out_edgpol, out_matrix, edpotype, out_object)
return {'FINISHED'}
def process(self):
vers = self.inputs['vers'].sv_get()
# Process data
levs = levelsOflist(vers)
result = self.remdou(vers, levs)
self.outputs[0].sv_set(result)
def process(self):
inputs = self.inputs
outputs = self.outputs
operation = self.items_
self.label = self.items_
if not outputs[0].is_linked:
return
# this input is shared over both.
vector1 = []
if inputs['U'].is_linked:
if isinstance(inputs['U'].links[0].from_socket, VerticesSocket):
vector1 = SvGetSocketAnyType(self, inputs['U'], deepcopy=False)
if not vector1:
return
# reaches here only if we have vector1
u = vector1
leve = levelsOflist(u)
scalars = ["SCALAR", "1/SCALAR", "ROUND"]
result = []
# vector-output
if 'W' in outputs and outputs['W'].is_linked:
func = vector_out[operation][0]
if len(inputs) == 1:
try:
result = self.recurse_fx(u, func, leve - 1)
except:
print('one input only, failed')
return
elif len(inputs) == 2:
'''
get second input sockets content, depending on mode
'''
b = []
if operation in scalars:
socket = ['S', StringsSocket]
msg = "two inputs, 1 scalar, "
else:
socket = ['V', VerticesSocket]
msg = "two inputs, both vector, "
name, _type = socket
if name in inputs and inputs[name].links:
if isinstance(inputs[name].links[0].from_socket, _type):
b = SvGetSocketAnyType(self,
inputs[name],
deepcopy=False)
# this means one of the necessary sockets is not connected
if not b:
return
try:
result = self.recurse_fxy(u, b, func, leve - 1)
except:
print(self.name, msg, 'failed')
return
else:
return # fail!
SvSetSocketAnyType(self, 'W', result)
# scalar-output
if 'out' in outputs and outputs['out'].is_linked:
vector2, result = [], []
func = scalar_out[operation][0]
num_inputs = len(inputs)
try:
if num_inputs == 1:
result = self.recurse_fx(u, func, leve - 1)
elif all(
[num_inputs == 2, ('V' in inputs), (inputs['V'].links)]):
if isinstance(inputs['V'].links[0].from_socket,
VerticesSocket):
vector2 = SvGetSocketAnyType(self,
inputs['V'],
deepcopy=False)
result = self.recurse_fxy(u, vector2, func, leve - 1)
else:
print('socket connected to V is not a vertices socket')
else:
return
except:
print('failed scalar out, {} inputs'.format(num_inputs))
return
if result:
SvSetSocketAnyType(self, 'out', result)
def process(self):
inputs = self.inputs
outputs = self.outputs
operation = self.items_
self.label = self.items_
if not outputs[0].is_linked:
return
# this input is shared over both.
vector1 = []
if inputs['U'].is_linked:
if isinstance(inputs['U'].links[0].from_socket, VerticesSocket):
vector1 = SvGetSocketAnyType(self, inputs['U'], deepcopy=False)
if not vector1:
return
# reaches here only if we have vector1
u = vector1
leve = levelsOflist(u)
scalars = ["SCALAR", "1/SCALAR", "ROUND"]
result = []
# vector-output
if 'W' in outputs and outputs['W'].is_linked:
func = vector_out[operation][0]
if len(inputs) == 1:
try:
result = self.recurse_fx(u, func, leve - 1)
except:
print('one input only, failed')
return
elif len(inputs) == 2:
'''
get second input sockets content, depending on mode
'''
b = []
if operation in scalars:
socket = ['S', StringsSocket]
msg = "two inputs, 1 scalar, "
else:
socket = ['V', VerticesSocket]
msg = "two inputs, both vector, "
name, _type = socket
if name in inputs and inputs[name].links:
if isinstance(inputs[name].links[0].from_socket, _type):
b = SvGetSocketAnyType(self, inputs[name], deepcopy=False)
# this means one of the necessary sockets is not connected
if not b:
return
try:
result = self.recurse_fxy(u, b, func, leve - 1)
except:
print(self.name, msg, 'failed')
return
else:
return # fail!
SvSetSocketAnyType(self, 'W', result)
# scalar-output
if 'out' in outputs and outputs['out'].is_linked:
vector2, result = [], []
func = scalar_out[operation][0]
num_inputs = len(inputs)
try:
if num_inputs == 1:
result = self.recurse_fx(u, func, leve - 1)
elif all([num_inputs == 2, ('V' in inputs), (inputs['V'].links)]):
if isinstance(inputs['V'].links[0].from_socket, VerticesSocket):
vector2 = SvGetSocketAnyType(self, inputs['V'], deepcopy=False)
result = self.recurse_fxy(u, vector2, func, leve - 1)
else:
print('socket connected to V is not a vertices socket')
else:
return
except:
print('failed scalar out, {} inputs'.format(num_inputs))
return
if result:
SvSetSocketAnyType(self, 'out', result)
