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)