def process(self):
self.ensure_enums_have_no_space(enums=["current_op"])
if self.outputs[0].is_linked:
current_func = func_from_mode(self.current_op)
params = [
si.sv_get(default=[[]], deepcopy=False) for si in self.inputs
]
matching_f = list_match_func[self.list_match]
desired_levels = [2 for p in params]
if self.current_op in ['GCD', 'ROUND-N']:
result = recurse_fxy(params[0], params[1], current_func)
elif self.current_op == 'SINCOS':
ops = [np.sin, self.list_match, self.output_numpy]
result = recurse_f_level_control(params, ops, math_numpy,
matching_f, desired_levels)
ops2 = [np.cos, self.list_match, self.output_numpy]
result2 = recurse_f_level_control(params, ops2, math_numpy,
matching_f, desired_levels)
self.outputs[1].sv_set(result2)
else:
ops = [current_func, self.list_match, self.output_numpy]
result = recurse_f_level_control(params, ops, math_numpy,
matching_f, desired_levels)
self.outputs[0].sv_set(result)
def process(self):
inputs = self.inputs
outputs = self.outputs
curve_node_name = self._get_curve_node_name()
evaluate = get_evaluator(node_group_name, curve_node_name)
curve_node = get_valid_node(node_group_name, curve_node_name,
CURVE_NODE_TYPE)
if 'Curve' in self.outputs:
curve = SvScalarFunctionCurve(evaluate)
curve.u_bounds = (curve_node.mapping.clip_min_x,
curve_node.mapping.clip_max_x)
self.outputs['Curve'].sv_set([curve])
if 'Control Points' in self.outputs:
points = get_points_from_curve(node_group_name, curve_node_name)
self.outputs['Control Points'].sv_set(points)
# no outputs, end early.
if not outputs['Value'].is_linked:
return
result = []
floats_in = inputs[0].sv_get(default=[[]], deepcopy=False)
desired_levels = [2]
result = recurse_f_level_control([floats_in], evaluate, curve_mapper,
None, desired_levels)
self.outputs[0].sv_set(result)
def process(self):
inputs, outputs = self.inputs, self.outputs
if not outputs[0].is_linked:
return
result = []
params = [si.sv_get(default=[[]], deepcopy=False) for si in inputs[:4]]
params.append(inputs[4].sv_get(default=[Matrix()], deepcopy=False))
matching_f = list_match_func[self.list_match]
desired_levels = [3, 3, 2, 3, 2]
if self.noise_type in noise_numpy_types.keys():
main_func = noise_displace_numpy
noise_function = noise_func_numpy[self.out_mode]
else:
main_func = noise_displace
noise_function = noise_func[self.out_mode]
ops = [
noise_function, self.noise_type, self.smooth, self.interpolate,
self.list_match, self.output_numpy
]
result = recurse_f_level_control(params, ops, main_func, matching_f,
desired_levels)
self.outputs[0].sv_set(result)
def process(self):
outputs = self.outputs
if not any(s.is_linked for s in outputs):
return
data_in = [] # collect the inputs from the connected sockets
for s in filter(lambda s: s.is_linked, self.inputs):
data_in.append(s.sv_get(default=id_mat))
operation = self.get_operation()
if self.operation in {"MULTIPLY"}: # multiple input operations
desired_levels = [1 for i in data_in]
ops = [operation, self.prePost]
list_match_f = list_match_func[self.list_match]
result = recurse_f_level_control(data_in, ops, matrix_multiply,
list_match_f, desired_levels)
outputs['C'].sv_set(result)
else: # single input operations
mat_list = data_in[0]
if self.operation == "BASIS":
x_list, y_list, z_list = recursive_basis_op(mat_list)
wrap = isinstance(x_list[0][0], (list, tuple))
outputs['X'].sv_set(x_list if wrap else [x_list])
outputs['Y'].sv_set(y_list if wrap else [y_list])
outputs['Z'].sv_set(z_list if wrap else [z_list])
outputs['C'].sv_set(mat_list)
else: # INVERSE / FILTER
outputs['C'].sv_set(general_op(mat_list, operation))
def process(self):
inputs, outputs = self.inputs, self.outputs
if not outputs[0].is_linked:
return
matching_f = list_match_func[self.list_match]
ops = [self.list_match, self.output_numpy]
inputs_used = ['Vertices', 'Centers'] + modes_dict[self.mode][1]
rotate_func = modes_dict[self.mode][0]
if self.mode == 'EULER':
ops.append(self.order)
desired_levels = [
3 if inputs[s].bl_idname == 'SvVerticesSocket' else 2
for s in inputs_used
]
params = [
si.sv_get(default=[[]], deepcopy=False) for si in inputs
if si.name in inputs_used
]
result = recurse_f_level_control(params, ops, rotate_func, matching_f,
desired_levels)
self.outputs[0].sv_set(result)
def process(self):
inputs, outputs = self.inputs, self.outputs
if not outputs[0].is_linked:
return
result = []
params = []
params.append(inputs[0].sv_get(default=[[]], deepcopy=False))
if not inputs[1].is_linked:
if not self.texture_pointer:
params.append([[EmptyTexture()]])
else:
params.append([[self.texture_pointer]])
else:
params.append(inputs[1].sv_get(default=[[]], deepcopy=False))
matching_f = list_match_func[self.list_match]
desired_levels = [3, 2]
if self.color_channel == 'Color' and self.use_alpha:
channel = 'RGBA'
else:
channel = self.color_channel
ops = [channel, self.tex_coord_type, self.list_match]
result = recurse_f_level_control(params, ops, meshes_texture_evaluate,
matching_f, desired_levels)
self.outputs[0].sv_set(result)
def process(self):
if not self.outputs[0].is_linked:
return
# if the user specifies a variable, they must also link a value into that socket, this will prevent Exception
self.ui_message = ""
if not self.all_inputs_connected():
self.ui_message = "node not fully connected"
return
var_names = self.get_variables()
inputs = self.get_input()
results = []
if var_names:
input_values = [inputs.get(name) for name in var_names]
matching_f = list_match_func[self.list_match]
parameters = matching_f(input_values)
desired_levels = [s.depth for s in self.inputs]
ops = [
self.formulas(), self.separate, var_names,
[s.transform for s in self.inputs], self.as_list
]
results = recurse_f_level_control(parameters, ops, formula_func,
matching_f, desired_levels)
else:
def joined_formulas(f1, f2, f3, f4):
built_string = ""
if f1: built_string += f1
if f2: built_string += f",{f2}"
if f3: built_string += f",{f3}"
if f4: built_string += f",{f4}"
return list(ast.literal_eval(built_string))
if self.use_ast:
results = joined_formulas(*self.formulas())
else:
vector = []
for formula in self.formulas():
if formula:
value = safe_eval(formula, dict())
vector.append(value)
results.extend(vector)
if self.wrapping == "+1":
results = [results]
elif self.wrapping == "-1":
results = results[0] if len(results) else results
self.outputs['Result'].sv_set(results)
def process(self):
if self.outputs[0].is_linked:
params = [
si.sv_get(default=[[]], deepcopy=False) for si in self.inputs
]
matching_f = list_match_func[self.list_match]
desired_levels = [2, 2, 2]
ops = [self.cyclic, self.output_numpy]
result = recurse_f_level_control(params, ops, smooth_numbers,
matching_f, desired_levels)
self.outputs[0].sv_set(result)
def process(self):
if not self.outputs['Vectors'].is_linked:
return
params = [si.sv_get(default=[[]], deepcopy=False) for si in self.inputs]
matching_f = list_match_func[self.list_match]
desired_levels = [2, 2, 2]
ops = [self.output_numpy, self.list_match]
concatenate = 'APPEND' if self.correct_output == 'NONE' else "EXTEND"
pack_func = numpy_pack_vecs if self.implementation == 'NumPy' else python_pack_vecs
result = recurse_f_level_control(params, ops, pack_func, matching_f, desired_levels, concatenate=concatenate)
self.outputs[0].sv_set(result)
def process(self):
inputs = self.inputs
outputs = self.outputs
color_ramp_node_name = self._get_color_ramp_node_name()
evaluate = get_evaluator(node_group_name, color_ramp_node_name)
# no outputs, end early.
if not outputs['Color'].is_linked:
return
result = []
floats_in = inputs[0].sv_get(default=[[]], deepcopy=False)
desired_levels = [2]
result = recurse_f_level_control([floats_in], [evaluate, self.use_alpha], color_ramp_mapper, None, desired_levels)
self.outputs[0].sv_set(result)
def process(self):
if not self.outputs['Gate'].is_linked:
return
if self.items_ in self.constant:
result = [[self.constant[self.items_]]]
else:
current_func = func_from_mode(self.items_)
params = [si.sv_get(default=[[]], deepcopy=False) for si in self.inputs]
matching_f = list_match_func[self.list_match]
desired_levels = [2 for p in params]
ops = [current_func, self.list_match, self.output_numpy]
result = recurse_f_level_control(params, ops, logic_numpy, matching_f, desired_levels)
self.outputs[0].sv_set(result)
def process(self):
inputs, outputs = self.inputs, self.outputs
if not outputs[0].is_linked:
return
result = []
params = [si.sv_get(default=[[]], deepcopy=False) for si in inputs]
matching_f = list_match_func[self.list_match]
desired_levels = [3, 3, 2]
ops = [self.list_match, self.output_numpy]
result = recurse_f_level_control(params, ops, move_meshes, matching_f, desired_levels)
self.outputs[0].sv_set(result)
def process(self):
inputs, outputs = self.inputs, self.outputs
if not outputs[0].is_linked:
return
result = []
params = [si.sv_get(default=[[]], deepcopy=False) for si in inputs[:4]]
if not inputs[2].is_linked:
if not self.name_texture:
params[2] = [[EmptyTexture()]]
else:
params[2] = [[
self.get_bpy_data_from_name(self.name_texture,
bpy.data.textures)
]]
if not self.tex_coord_type == 'UV':
params.append(inputs[4].sv_get(default=[Matrix()], deepcopy=False))
mat_level = 2
else:
if inputs[4].is_linked:
params.append(inputs[4].sv_get(default=[[]], deepcopy=False))
else:
params.append(params[0])
mat_level = 3
params.append(inputs[5].sv_get(default=[[]], deepcopy=False))
params.append(inputs[6].sv_get(default=[[]], deepcopy=False))
params.append(inputs[7].sv_get(default=[[]], deepcopy=False))
matching_f = list_match_func[self.list_match]
desired_levels = [3, 3, 2, 3, mat_level, 2, 2, 3]
out_mode = self.out_mode.replace("_", " ")
ops = [
out_mode, displace_funcs[out_mode],
self.color_channel.replace("_", " "), self.list_match,
self.tex_coord_type.replace("_", " ")
]
result = recurse_f_level_control(params, ops, meshes_texture_diplace,
matching_f, desired_levels)
self.outputs[0].sv_set(result)
def process(self):
if self.outputs[0].is_linked:
params = [
si.sv_get(default=[[]], deepcopy=False) for si in self.inputs
]
matching_f = list_match_func[self.list_match]
desired_levels = [2, 3, 3]
ops = [
self.current_op, self.list_match, self.clamp_output,
self.output_numpy
]
result = recurse_f_level_control(params, ops, color_mix,
matching_f, desired_levels)
self.outputs[0].sv_set(result)
def process(self):
inputs, outputs = self.inputs, self.outputs
if not outputs[0].is_linked:
return
result = []
params = [si.sv_get(default=[[]], deepcopy=False) for si in inputs[:4]]
params.append(inputs[4].sv_get(default=[Matrix()], deepcopy=False))
matching_f = list_match_func[self.list_match]
desired_levels = [3, 3, 2, 3, 2]
ops = [noise_func[self.out_mode], self.noise_type, self.list_match]
result = recurse_f_level_control(params, ops, noise_displace,
matching_f, desired_levels)
self.outputs[0].sv_set(result)
def process(self):
inputs = self.inputs
outputs = self.outputs
# no outputs, end early.
if not outputs['Value'].is_linked:
return
params = [si.sv_get(default=[[]], deepcopy=False) for si in inputs]
matching_f = list_match_func[self.list_match]
desired_levels = [2 for p in params]
ops = [
self.clamp, self.auto_limits, self.list_match, self.output_numpy
]
result = recurse_f_level_control(params, ops, map_range, matching_f,
desired_levels)
self.outputs[0].sv_set(result)
def process(self):
if self.outputs[0].is_linked:
current_func = func_from_mode(self.current_op)
params = [
si.sv_get(default=[[]], deepcopy=False) for si in self.inputs
]
matching_f = list_match_func[self.list_match]
desired_levels = [2 if self.current_op == 'join_all' else 1
] * len(params)
inputs_signature = self.sockets_signature.split(' ')[0]
ops = [current_func, inputs_signature]
if self.current_op == 'to_string':
depth = levels_of_list_or_np(params[0])
desired_levels = [max(depth - self.level + 1, 1)]
result = recurse_f_level_control(params, ops, string_tools,
matching_f, desired_levels)
self.outputs[0].sv_set(result)
def process(self):
if self.outputs[0].is_linked:
if self.current_op == 'Custom' and not self.inputs[
"Wave"].is_linked:
return
params = [
si.sv_get(default=[[]], deepcopy=False)
for si in self.inputs[:6]
]
matching_f = list_match_func[self.list_match]
spline_func = CubicSpline if self.wave_interp_mode == 'SPL' else LinearSpline
desired_levels = [2, 2, 2, 2, 2, 3]
ops = [
self.current_op, spline_func, self.knot_mode, self.list_match,
self.output_numpy
]
result = recurse_f_level_control(params, ops, oscillator,
matching_f, desired_levels)
self.outputs[0].sv_set(result)
def process(self):
if not self.outputs['Random'].is_linked:
return
params = [
si.sv_get(default=[[]], deepcopy=False) for si in self.inputs
]
matching_f = list_match_func[self.list_match]
desired_levels = [1, 1, 1]
ops = self.output_numpy
concatenate = 'APPEND' if self.correct_output == 'NONE' else "EXTEND"
result = recurse_f_level_control(params,
ops,
random_vector,
matching_f,
desired_levels,
concatenate=concatenate)
self.outputs[0].sv_set(result)
