def process(self): if not (self.id_data.sv_show and self.activate): callback_disable(node_id(self)) return n_id = node_id(self) global cache_viewer_baker vertex_ref = n_id + 'v' poledg_ref = n_id + 'ep' matrix_ref = n_id + 'm' cache_viewer_baker[vertex_ref] = [] cache_viewer_baker[poledg_ref] = [] cache_viewer_baker[matrix_ref] = [] callback_disable(n_id) # every time you hit a dot, you pay a price, so alias and benefit inputs = self.inputs # this should catch accidental connections which otherwise will cause # an unrecoverable crash. It might even be an idea to have step in between # new connections and processing, it could auto rewire s->s v->v m->m. def check_origin(to_socket, socket_type): sock_string = sock_dict.get(socket_type) return inputs[to_socket].links[0].from_socket.bl_idname == sock_string vertex_links = inputs['vertices'].is_linked and check_origin('vertices', 'v') matrix_links = inputs['matrix'].is_linked and check_origin('matrix', 'm') edgepol_links = inputs['edg_pol'].is_linked and check_origin('edg_pol', 's') if (vertex_links or matrix_links): if vertex_links: propv = inputs['vertices'].sv_get(deepcopy=False, default=[]) if propv: verts = dataCorrect(propv) for v in verts: if any(l != 3 for l in map(len, v)): raise ValueError cache_viewer_baker[vertex_ref] = verts if edgepol_links: prope = inputs['edg_pol'].sv_get(deepcopy=False, default=[]) if prope: cache_viewer_baker[poledg_ref] = dataCorrect(prope) if matrix_links: propm = inputs['matrix'].sv_get(deepcopy=False, default=[]) if propm: cache_viewer_baker[matrix_ref] = dataCorrect(propm) if cache_viewer_baker[vertex_ref] or cache_viewer_baker[matrix_ref]: config_options = self.get_options() callback_enable(n_id, cache_viewer_baker, config_options)
def free(self): global cache_viewer_baker n_id = node_id(self) callback_disable(n_id) cache_viewer_baker.pop(n_id + "v", None) cache_viewer_baker.pop(n_id + "ep", None) cache_viewer_baker.pop(n_id + "m", None)
def sv_init(self, context): n_id = node_id(self) self.width = 400 self.color = (0.5, 0.5, 1) self.use_custom_color = True self.inputs.new('StringsSocket', "Text In", "Text In") self.outputs.new('StringsSocket', "Text Out", "Text Out")
def update_csv(self): n_id = node_id(self) if self.reload_on_update: self.reload_csv() if self.current_text and n_id not in self.csv_data: self.reload_csv() if n_id not in self.csv_data: print("CSV auto reload failed, press update") self.use_custom_color = True self.color = FAIL_COLOR return self.use_custom_color = True self.color = READY_COLOR csv_data = self.csv_data[n_id] if not self.one_sock: for name in csv_data.keys(): if name in self.outputs and self.outputs[name].links: SvSetSocketAnyType(self, name, [csv_data[name]]) else: name = 'one_sock' SvSetSocketAnyType(self, 'one_sock', list(csv_data.values()))
def load_json(self): n_id = node_id(self) self.load_json_data() json_data = self.json_data.get(n_id, []) if not json_data: self.current_text = '' return socket_order = json_data.get('socket_order') if socket_order: # avoid arbitrary socket assignment order def iterate_socket_order(): for named_socket in socket_order: data = json_data.get(named_socket) yield named_socket, data socket_iterator = iterate_socket_order() else: socket_iterator = sorted(json_data.items()) for named_socket, data in socket_iterator: if len(data) == 2 and data[0] in {'v', 's', 'm'}: new_output_socket(self, named_socket, data[0]) else: self.use_custom_color = True self.color = FAIL_COLOR return
def reload_json(self): n_id = node_id(self) self.load_json_data() if n_id in self.json_data: self.use_custom_color = True self.color = READY_COLOR
def update_csv(self): n_id = node_id(self) if self.autoreload: self.reload_csv() if self.current_text and n_id not in self.csv_data: self.reload_csv() if n_id not in self.csv_data: print("CSV auto reload failed, press update") self.use_custom_color = True self.color = FAIL_COLOR return self.use_custom_color = True self.color = READY_COLOR csv_data = self.csv_data[n_id] if not self.one_sock: for name in csv_data.keys(): if name in self.outputs and self.outputs[name].is_linked: self.outputs[name].sv_set([csv_data[name]]) else: name = 'one_sock' self.outputs['one_sock'].sv_set(list(csv_data.values()))
def free(self): global cache_viewer_baker n_id = node_id(self) callback_disable(n_id) cache_viewer_baker.pop(n_id + 'v', None) cache_viewer_baker.pop(n_id + 'ep', None) cache_viewer_baker.pop(n_id + 'm', None)
def process(self): p = self.inputs['Float'].sv_get() n_id = node_id(self) # end early nvBGL2.callback_disable(n_id) float_out = self.outputs['Float'] easing_func = easing_dict.get(int(self.selected_mode)) if float_out.is_linked: out = [] for obj in p: r = [] for i in obj: r.append(easing_func(i)) out.append(r) float_out.sv_set(out) else: float_out.sv_set([[None]]) if self.activate: palette = palette_dict.get(self.selected_theme_mode)[:] x, y = [int(j) for j in (self.location + Vector((self.width + 20, 0)))[:]] draw_data = { 'tree_name': self.id_data.name[:], 'mode': 'custom_function', 'custom_function': simple_grid_xy, 'loc': (x, y), 'args': (easing_func, palette) } nvBGL2.callback_enable(n_id, draw_data)
def reset(self): n_id = node_id(self) self.outputs.clear() self.current_text = "" self.csv_data.pop(n_id, None) self.list_data.pop(n_id, None) self.json_data.pop(n_id, None)
def process(self): inputs = self.inputs n_id = node_id(self) # end early nvBGL.callback_disable(n_id) if self.activate and inputs[0].is_linked: try: with sv_preferences() as prefs: scale = prefs.stethoscope_view_scale location_theta = prefs.render_location_xy_multiplier except: # print('did not find preferences - you need to save user preferences') scale = 1.0 location_theta = 1.0 # gather vertices from input data = inputs[0].sv_get(deepcopy=False) self.num_elements = len(data) if self.selected_mode == 'text-based': props = lambda: None props.line_width = self.line_width props.compact = self.compact props.depth = self.depth or None processed_data = nvBGL.parse_socket( inputs[0], self.rounding, self.element_index, self.view_by_element, props ) else: # # implement another nvBGL parses for gfx processed_data = data node_width = (self.width_hidden + 30.0) if self.hide else self.width # adjust proposed text location in case node is framed. # take into consideration the hidden state _x, _y = recursive_framed_location_finder(self, self.location[:]) _x, _y = Vector((_x, _y)) + Vector((node_width + 20, 0)) # this alters location based on DPI/Scale settings. location = adjust_location(_x, _y, location_theta) draw_data = { 'tree_name': self.id_data.name[:], 'content': processed_data, 'location': location, 'color': self.text_color[:], 'scale' : float(scale), 'mode': self.selected_mode[:], 'font_id': int(self.font_id) } nvBGL.callback_enable(n_id, draw_data)
def update(self): if not ("Data" in self.inputs): return try: if not self.inputs[0].other: nvBGL.callback_disable(node_id(self)) except: print('stethoscope update holdout (not a problem)')
def update(self): if not ("matrix" in self.inputs): return try: if not (self.inputs[0].other or self.inputs[2].other): callback_disable(node_id(self)) except: print('vdmk2 update holdout')
def load_csv(self): n_id = node_id(self) self.load_csv_data() if not n_id in self.csv_data: print("Error, no data loaded") else: for name in self.csv_data[n_id]: self.outputs.new("StringsSocket", name, name)
def load_sv(self): n_id = node_id(self) self.load_sv_data() if n_id in self.list_data: name_dict = {'m': 'Matrix', 's': 'Data', 'v': 'Vertices'} typ = self.socket_type new_output_socket(self, name_dict[typ], typ)
def load_sv(self): n_id = node_id(self) self.load_sv_data() if n_id in self.list_data: name_dict = {"m": "Matrix", "s": "Data", "v": "Vertices"} typ = self.socket_type new_output_socket(self, name_dict[typ], typ)
def process(self): if not (self.id_data.sv_show and self.activate): callback_disable(node_id(self)) return n_id = node_id(self) global cache_viewer_baker vertex_ref = n_id + 'v' poledg_ref = n_id + 'ep' matrix_ref = n_id + 'm' cache_viewer_baker[vertex_ref] = [] cache_viewer_baker[poledg_ref] = [] cache_viewer_baker[matrix_ref] = [] callback_disable(n_id) # every time you hit a dot, you pay a price, so alias and benefit inputs = self.inputs vertex_links = inputs['vertices'].is_linked matrix_links = inputs['matrix'].is_linked edgepol_links = inputs['edg_pol'].is_linked if vertex_links or matrix_links: if vertex_links: propv = inputs['vertices'].sv_get(deepcopy=False, default=[]) if propv: cache_viewer_baker[vertex_ref] = dataCorrect(propv) if edgepol_links: prope = inputs['edg_pol'].sv_get(deepcopy=False, default=[]) if prope: cache_viewer_baker[poledg_ref] = dataCorrect(prope) if matrix_links: propm = inputs['matrix'].sv_get(deepcopy=False, default=[]) if propm: cache_viewer_baker[matrix_ref] = dataCorrect(propm) if cache_viewer_baker[vertex_ref] or cache_viewer_baker[matrix_ref]: config_options = self.get_options() callback_enable(n_id, cache_viewer_baker, config_options)
def process(self): global cache_viewer_baker # node id, used as ref n_id = node_id(self) if 'matrix' not in self.inputs: return cache_viewer_baker[n_id+'v'] = [] cache_viewer_baker[n_id+'ep'] = [] cache_viewer_baker[n_id+'m'] = [] if not self.id_data.sv_show: callback_disable(n_id) return if self.activate and (self.inputs['vertices'].links or self.inputs['matrix'].links): callback_disable(n_id) if self.inputs['vertices'].links and \ type(self.inputs['vertices'].links[0].from_socket) == VerticesSocket: propv = SvGetSocketAnyType(self, self.inputs['vertices']) cache_viewer_baker[n_id+'v'] = dataCorrect(propv) else: cache_viewer_baker[n_id+'v'] = [] if self.inputs['edg_pol'].links and \ type(self.inputs['edg_pol'].links[0].from_socket) == StringsSocket: prope = SvGetSocketAnyType(self, self.inputs['edg_pol']) cache_viewer_baker[n_id+'ep'] = dataCorrect(prope) #print (prope) else: cache_viewer_baker[n_id+'ep'] = [] if self.inputs['matrix'].links and \ type(self.inputs['matrix'].links[0].from_socket) == MatrixSocket: propm = SvGetSocketAnyType(self, self.inputs['matrix']) cache_viewer_baker[n_id+'m'] = dataCorrect(propm) else: cache_viewer_baker[n_id+'m'] = [] else: callback_disable(n_id) if cache_viewer_baker[n_id+'v'] or cache_viewer_baker[n_id+'m']: callback_enable(n_id, cache_viewer_baker[n_id+'v'], cache_viewer_baker[n_id+'ep'], \ cache_viewer_baker[n_id+'m'], self.Vertex_show, self.color_view.copy(), self.transparant, self.shading) self.use_custom_color = True self.color = (1, 0.3, 0) else: self.use_custom_color = True self.color = (0.1, 0.05, 0) #print ('отражения вершин ',len(cache_viewer_baker['v']), " рёбёры ", len(cache_viewer_baker['ep']), "матрицы",len(cache_viewer_baker['m'])) if not self.inputs['vertices'].links and not self.inputs['matrix'].links: callback_disable(n_id)
def create_empty(self): n_id = node_id(self) scene = bpy.context.scene objects = bpy.data.objects empty = objects.new(self.empty_name, None) scene.objects.link(empty) scene.update() empty["SVERCHOK_REF"] = n_id self.empty_ref_name = empty.name return empty
def load_csv(self): n_id = node_id(self) self.load_csv_data() if not n_id in self.csv_data: print("Error, no data loaded") else: if not self.one_sock: for name in self.csv_data[n_id]: self.outputs.new('StringsSocket', name, name) else: name = 'one_sock' self.outputs.new('StringsSocket', name, name)
def process(self): n_id = node_id(self) data = self.node_dict.get(n_id) if not data: self.node_dict[n_id] = {} data = self.node_dict.get(n_id) frame_current = bpy.context.scene.frame_current out_frame = frame_current - self.cache_offset data[frame_current] = self.inputs[0].sv_get() out_data = data.get(out_frame, []) self.outputs[0].sv_set(out_data)
def process(self): if not self.inputs['Float'].is_linked: return n_id = node_id(self) self.delete_texture() nvBGL2.callback_disable(n_id) size_tex = 0 width = 0 height = 0 if self.to_image_viewer: mode = self.color_mode pixels = np.array(self.inputs['Float'].sv_get(deepcopy=False)).flatten() width, height = self.texture_width_height resized_np_array = np.resize(pixels, self.calculate_total_size()) transfer_to_image(resized_np_array, self.texture_name, width, height, mode) if self.activate: texture = self.get_buffer() width, height = self.texture_width_height x, y = self.xy_offset gl_color_constant = gl_color_dict.get(self.color_mode) name = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, name) self.texture[n_id] = name[0] init_texture(width, height, name[0], texture, gl_color_constant) # adjust render location based on preference multiplier setting try: with sv_preferences() as prefs: multiplier = prefs.render_location_xy_multiplier scale = prefs.render_scale except: # print('did not find preferences - you need to save user preferences') multiplier = 1.0 scale = 1.0 x, y = [x * multiplier, y * multiplier] width, height =[width * scale, height * scale] draw_data = { 'tree_name': self.id_data.name[:], 'mode': 'custom_function', 'custom_function': simple_screen, 'loc': (x, y), 'args': (texture, self.texture[n_id], width, height) } nvBGL2.callback_enable(n_id, draw_data)
def create_metaball(self): n_id = node_id(self) scene = bpy.context.scene objects = bpy.data.objects metaball_data = bpy.data.metaballs.new("MetaBall") metaball_object = bpy.data.objects.new(self.meta_name, metaball_data) scene.objects.link(metaball_object) scene.update() metaball_object["SVERCHOK_REF"] = n_id self.metaball_ref_name = metaball_object.name return metaball_object
def execute(self, context): global cache_viewer_baker nid = node_id(bpy.data.node_groups[self.idtree].nodes[self.idname]) if cache_viewer_baker[nid + "m"] and not cache_viewer_baker[nid + "v"]: return {"CANCELLED"} vers = dataCorrect(cache_viewer_baker[nid + "v"]) edg_pol = dataCorrect(cache_viewer_baker[nid + "ep"]) if cache_viewer_baker[nid + "m"]: matrixes = dataCorrect(cache_viewer_baker[nid + "m"]) else: matrixes = [] for i in range((len(vers))): matrixes.append(Matrix()) self.makeobjects(vers, edg_pol, matrixes) return {"FINISHED"}
def process(self): if 'Text In' in self.inputs and self.inputs['Text In'].is_linked: self.text = str(SvGetSocketAnyType(self,self.inputs['Text In'])) n_id = node_id(self) if not n_id in self.text_cache: self.format_text() if 'Text Out' in self.outputs and self.outputs['Text Out'].is_linked: # I'm not sure that this makes sense, but keeping it like # old note right now. Would expect one value, and optional # split, or split via a text processing node, # but keeping this for now text = [[a] for a in self.text.split()] SvSetSocketAnyType(self, 'Text Out', [text])
def process(self): inputs = self.inputs n_id = node_id(self) IV.callback_disable(n_id) # end if tree status is set to not show if not self.id_data.sv_show: return self.use_custom_color = True if not (self.activate and inputs['vertices'].is_linked): return self.generate_callback(n_id, IV)
def load_json(self): n_id = node_id(self) self.load_json_data() json_data = self.json_data.get(n_id, []) if not json_data: self.current_text = "" return for item, data in json_data.items(): if len(data) == 2 and data[0] in {"v", "s", "m"}: new_output_socket(self, item, data[0]) else: self.use_custom_color = True self.color = FAIL_COLOR return
def process(self): if self.inputs and self.inputs['Text In'].is_linked: self.text = str(self.inputs['Text In'].sv_get(deepcopy=False)) n_id = node_id(self) if not n_id in self.text_cache: self.format_text() if self.outputs and self.outputs['Text Out'].is_linked: # I'm not sure that this makes sense, but keeping it like # old note right now. Would expect one value, and optional # split, or split via a text processing node, # but keeping this for now text = [[a] for a in self.text.split()] self.outputs['Text Out'].sv_set([text])
def update_sv(self): n_id = node_id(self) if self.reload_on_update: self.reload_sv() # nothing loaded, try to load and if it doesn't work fail if n_id not in self.list_data and self.current_text: self.reload_sv() if n_id not in self.list_data: self.use_custom_color = True self.color = FAIL_COLOR return # load data into selected socket for item in ["Vertices", "Data", "Matrix"]: if item in self.outputs and self.outputs[item].links: SvSetSocketAnyType(self, item, self.list_data[n_id])
def update_sv(self): n_id = node_id(self) if self.autoreload: self.reload_sv() # nothing loaded, try to load and if it doesn't *work* -- then fail it. if n_id not in self.list_data and self.current_text: self.reload_sv() if n_id not in self.list_data: self.use_custom_color = True self.color = FAIL_COLOR return # load data into selected socket for item in ['Vertices', 'Data', 'Matrix']: if item in self.outputs and self.outputs[item].links: self.outputs[item].sv_set(self.list_data[n_id])
def free(self): v3dBGL.callback_disable(node_id(self)) v3dBGL.callback_disable(node_id(self) + '__2D')
def sv_free(self): callback_disable(node_id(self))
def process(self): n_id = node_id(self) nvBGL.callback_disable(n_id) inputs = self.inputs # end early if not self.activate: return if self.mode == 'Number': if not inputs['Number'].is_linked: return numbers = inputs['Number'].sv_get(default=[[]]) elif self.mode == 'Curve': if not inputs['Curve'].is_linked: return curves = inputs['Curve'].sv_get(default=[[]]) else: if not inputs['Vecs'].is_linked: return vecs = inputs['Vecs'].sv_get(default=[[]]) edges = inputs['Edges'].sv_get(default=[[]]) polygons = inputs['Polygons'].sv_get(default=[[]]) vector_color = inputs['Vector Color'].sv_get(default=[[self.vector_color]]) edge_color = inputs['Edge Color'].sv_get(default=[[self.edge_color]]) poly_color = inputs['Polygon Color'].sv_get(default=[[self.polygon_color]]) seed_set(self.random_seed) config = self.create_config() config.vector_color = vector_color config.edge_color = edge_color config.poly_color = poly_color config.edges = edges if self.mode == 'Number': config.size = self.drawing_size geom = generate_number_geom(config, numbers) elif self.mode == 'Path': geom = generate_graph_geom(config, vecs) elif self.mode == 'Curve': paths = [] for curve in curves: t_min, t_max = curve.get_u_bounds() ts = np_linspace(t_min, t_max, num=self.curve_samples, dtype=np_float64) paths.append(curve.evaluate_array(ts).tolist()) geom = generate_graph_geom(config, paths) else: config.polygons = polygons if not inputs['Edges'].is_linked and self.edge_toggle: config.edges = polygons_to_edges(polygons, unique_edges=True) geom = generate_mesh_geom(config, vecs) draw_data = { 'mode': 'custom_function', 'tree_name': self.id_data.name[:], 'node_name': self.name[:], 'loc': get_drawing_location, 'custom_function': view_2d_geom, 'args': (geom, config) } nvBGL.callback_enable(n_id, draw_data)
def _set_script(self, value): n_id = node_id(self) value.node = self self.script_objects[n_id] = value
def copy(self, node): self.n_id = "" node_id(self)
def free(self): IV.callback_disable(node_id(self))
def _get_script(self): n_id = node_id(self) script = self.script_objects.get(n_id) if script: script.node = self # paranoid update often safety setting return script
def process(self): self.handle_attr_socket() if not (self.id_data.sv_show and self.activate): callback_disable(node_id(self)) return n_id = node_id(self) callback_disable(n_id) if not any([self.display_verts, self.display_edges, self.display_faces]): return verts_socket, edges_socket, faces_socket, matrix_socket = self.inputs[:4] if verts_socket.is_linked: display_faces = self.display_faces and faces_socket.is_linked display_edges = self.display_edges and (edges_socket.is_linked or faces_socket.is_linked) config = self.fill_config() data = self.get_data() if len(data[0]) > 1: coords, edge_indices, face_indices = mesh_join(data[0], data[1], data[2]) else: coords, edge_indices, face_indices = [d[0].tolist() if type(d[0]) == ndarray else d[0] for d in data[:3]] geom = lambda: None geom.verts = coords if self.display_verts and not any([display_edges, display_faces]): gl_instructions = self.format_draw_data(func=draw_verts, args=(geom, config)) callback_enable(n_id, gl_instructions) return if edges_socket.is_linked and not faces_socket.is_linked: if self.use_dashed: self.add_gl_stuff_to_config(config) geom.edges = edge_indices gl_instructions = self.format_draw_data(func=draw_edges, args=(geom, config)) callback_enable(n_id, gl_instructions) return if faces_socket.is_linked: # expecting mixed bag of tris/quads/ngons if self.display_faces: geom.faces = ensure_triangles(coords, face_indices, self.handle_concave_quads) if self.display_edges: if self.use_dashed: self.add_gl_stuff_to_config(config) # we don't want to draw the inner edges of triangulated faces; use original face_indices. # pass edges from socket if we can, else we manually compute them from faces geom.edges = edge_indices if edges_socket.is_linked else edges_from_faces(face_indices) if self.display_faces: self.faces_diplay(geom, config) gl_instructions = self.format_draw_data(func=draw_complex, args=(geom, config)) callback_enable(n_id, gl_instructions) return return elif matrix_socket.is_linked: matrices = matrix_socket.sv_get(deepcopy=False, default=[Matrix()]) gl_instructions = self.format_draw_data(func=draw_matrix, args=(matrices, )) callback_enable(n_id, gl_instructions)
def process(self): if bpy.app.background: return self.handle_attr_socket() if not (self.id_data.sv_show and self.activate): callback_disable(node_id(self)) return n_id = node_id(self) callback_disable(n_id) inputs = self.inputs # end early if not self.activate: return if not any([inputs['Vertices'].is_linked, inputs['Matrix'].is_linked]): return if inputs['Vertices'].is_linked: vecs = inputs['Vertices'].sv_get(deepcopy=False, default=[[]]) total_verts = sum(map(len, vecs)) if not total_verts: raise LookupError("Empty vertices list") edges = inputs['Edges'].sv_get(deepcopy=False, default=[[]]) polygons = inputs['Polygons'].sv_get(deepcopy=False, default=[[]]) matrix = inputs['Matrix'].sv_get(deepcopy=False, default=[[]]) vector_color = inputs['Vector Color'].sv_get( deepcopy=False, default=[[self.vector_color]]) edge_color = inputs['Edge Color'].sv_get( deepcopy=False, default=[[self.edge_color]]) poly_color = inputs['Polygon Color'].sv_get( deepcopy=False, default=[[self.polygon_color]]) seed_set(self.random_seed) config = self.create_config() config.vector_color = vector_color config.edge_color = edge_color config.poly_color = poly_color config.edges = edges if self.use_dashed: add_dashed_shader(config) config.polygons = polygons config.matrix = matrix if not inputs['Edges'].is_linked and self.display_edges: config.edges = polygons_to_edges_np(polygons, unique_edges=True) geom = generate_mesh_geom(config, vecs) draw_data = { 'tree_name': self.id_data.name[:], 'custom_function': view_3d_geom, 'args': (geom, config) } callback_enable(n_id, draw_data) elif inputs['Matrix'].is_linked: matrices = inputs['Matrix'].sv_get(deepcopy=False, default=[Matrix()]) gl_instructions = { 'tree_name': self.id_data.name[:], 'custom_function': draw_matrix, 'args': (matrices, self.matrix_draw_scale) } callback_enable(n_id, gl_instructions)
def update(self): # used because this node should disable itself if no inputs. n_id = node_id(self) callback_disable(n_id)
def load_sv(self): n_id = node_id(self) self.load_sv_data() if n_id in self.list_data: new_output_socket(self, name_dict[self.socket_type], self.socket_type)
def sv_free(self): # free potentially lots of data n_id = node_id(self) pop_all_data(self, n_id)
def reset(self): n_id = node_id(self) self.outputs.clear() self.current_text = '' pop_all_data(self, n_id)
def free(self): nvBGL.callback_disable(node_id(self))
def process(self): n_id = node_id(self) nvBGL.callback_disable(n_id) if self.activate: # parameter containers config = lambda: None geom = lambda: None palette = lambda: None palette.high_colour = (0.13, 0.13, 0.13, 1.0) palette.low_colour = (0.1, 0.1, 0.1, 1.0) x, y, scale, multiplier = self.get_drawing_attributes() # some aliases w = self.graph_width h = self.graph_height dims = (w, h) loc = (x, y) config.loc = loc config.scale = scale grid_data = gridshader(dims, loc, palette, self.num_channels) # this is for drawing only. wave_data = self.get_wavedata(raw=False) wave_params = self.get_waveparams() wave_data_processed = self.generate_2d_drawing_data(wave_data, wave_params, dims, loc) scope_tick_data = self.generate_tick_data(wave_data, dims, loc) # GRAPH PART - Background config.background_shader = get_2d_smooth_color_shader() config.background_batch = batch_for_shader( config.background_shader, 'TRIS', { "pos": grid_data.background_coords, "color": grid_data.background_colors}, indices=grid_data.background_indices ) if scope_tick_data.verts: params, kw_params = (('LINES', {"pos": scope_tick_data.verts}), {"indices": scope_tick_data.indices}) config.tick_shader = get_2d_uniform_color_shader() config.tick_batch = batch_for_shader(config.tick_shader, *params, **kw_params) # LINE PART coords = wave_data_processed.verts indices = wave_data_processed.indices config.line_shader = get_2d_uniform_color_shader() params, kw_params = (('LINES', {"pos": coords}), {"indices": indices}) if indices else (('LINE_STRIP', {"pos": coords}), {}) config.line_batch = batch_for_shader(config.line_shader, *params, **kw_params) # -------------- final draw data accumulation and pass to callback ------------------ draw_data = { 'mode': 'custom_function_context', 'tree_name': self.id_data.name[:], 'custom_function': advanced_grid_xy, 'args': (geom, config) } nvBGL.callback_enable(self.n_id, draw_data)
""" in in_data v d=[] n=1 in in_colors v d=[] n=1 out float_out s """ import bgl import bpy from sverchok.data_structure import node_id from sverchok.ui import bgl_callback_3dview as v3dBGL self.n_id = node_id(self) v3dBGL.callback_disable(self.n_id) def screen_v3dBGL(context, args): region = context.region region3d = context.space_data.region_3d points = args[0] colors = args[1] size= 5.0 bgl.glEnable(bgl.GL_POINT_SMOOTH) # for round vertex bgl.glPointSize(size) bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) if colors: bgl.glBegin(bgl.GL_POINTS)
def load_text(self): n_id = node_id(self) self.load_text_data() if n_id in self.list_data: new_output_socket(self, 'Text', 'SvTextSocket')
def delete_texture(self): n_id = node_id(self) if n_id in self.texture: names = bgl.Buffer(bgl.GL_INT, 1, [self.texture[n_id]]) bgl.glDeleteTextures(1, names)
def update(self): # used because this node should disable itself in certain scenarios # : namely , no inputs. n_id = node_id(self) IV.callback_disable(n_id)
def free(self): callback_disable(node_id(self)) callback_disable(node_id(self) + '__2D')
def _del_script(self): n_id = node_id(self) if n_id in self.script_objects: del self.script_objects[n_id]
def load_csv_data(self): n_id = node_id(self) csv_data = collections.OrderedDict() if n_id in self.csv_data: del self.csv_data[n_id] f = io.StringIO(bpy.data.texts[self.text].as_string()) # setup CSV options if self.csv_dialect == 'user': if self.csv_delimiter == 'CUSTOM': d = self.csv_custom_delimiter else: d = self.csv_delimiter reader = csv.reader(f, delimiter=d) elif self.csv_dialect == 'semicolon': self.csv_decimalmark = ',' reader = csv.reader(f, delimiter=';') else: reader = csv.reader(f, dialect=self.csv_dialect) self.csv_decimalmark = '.' # setup parse decimalmark if self.csv_decimalmark == ',': get_number = lambda s: float(s.replace(',', '.')) elif self.csv_decimalmark == 'LOCALE': get_number = locale.atof elif self.csv_decimalmark == 'CUSTOM': if self.csv_custom_decimalmark: get_number = lambda s: float( s.replace(self.csv_custom_decimalmark, '.')) else: # . default get_number = float # some csv contain a number of must-skip lines, these csv break the csv standard. but we still # want to be able to read them :) if self.csv_skip_header_lines: for _ in range(self.csv_skip_header_lines): next(reader) # load data for i, row in enumerate(reader): if i == 0: # setup names if self.csv_header: for name in row: tmp = name c = 1 while tmp in csv_data: tmp = name + str(c) c += 1 csv_data[str(tmp)] = [] continue # first row is names else: for j in range(len(row)): csv_data["Col " + str(j)] = [] for j, name in enumerate(csv_data): if not self.csv_extended_mode: try: n = get_number(row[j]) csv_data[name].append(n) except Exception as err: error = str(err) if "could not convert string to float" in error: if self.force_input: csv_data[name].append(row[j]) else: print('unhandled error:', error) else: csv_data[name].append(row[j]) if csv_data: if not csv_data[list(csv_data.keys())[0]]: return self.current_text = self.text self.csv_data[n_id] = csv_data
def sv_init(self, context): node_id(self) self.color = FAIL_COLOR
def copy(self, node): self.n_id = '' node_id(self)
def update(self): if not ("matrix" in self.inputs): return if self.inputs[0].links or self.inputs[2].links: callback_disable(node_id(self))
def update(self): if not ("matrix" in self.inputs): return if not (self.inputs[0].other or self.inputs[2].other): callback_disable(node_id(self))
def process(self): if not (self.id_data.sv_show and self.activate): callback_disable(node_id(self)) return n_id = node_id(self) callback_disable(n_id) if not any([self.display_verts, self.display_edges, self.display_faces]): return verts_socket, edges_socket, faces_socket, matrix_socket = self.inputs[:4] if verts_socket.is_linked: geom = lambda: None config = lambda: None config.vector_light = self.vector_light[:] config.vcol = self.vert_color[:] config.line4f = self.edge_color[:] config.face4f = self.face_color[:] config.display_verts = self.display_verts config.display_edges = self.display_edges config.display_faces = self.display_faces config.shade = self.selected_draw_mode config.draw_gl_wireframe = self.draw_gl_wireframe # config.point_size = self.point_size config.line_width = self.line_width edge_indices = None face_indices = None propv = verts_socket.sv_get(deepcopy=False, default=[]) coords = propv[0] if edges_socket.is_linked: prope = edges_socket.sv_get(deepcopy=False, default=[]) edge_indices = prope[0] if faces_socket.is_linked: propf = faces_socket.sv_get(deepcopy=False, default=[]) face_indices = propf[0] if matrix_socket.is_linked: # for now just deal with first m = matrix_socket.sv_get(deepcopy=False, default=[Matrix()])[0] coords = multiply_vectors_deep(m, coords) geom.verts = coords if self.display_verts and not any([self.display_edges, self.display_faces]): draw_data = { 'tree_name': self.id_data.name[:], 'custom_function': draw_verts, 'args': (geom, config) } callback_enable(n_id, draw_data) return if edges_socket.is_linked and not faces_socket.is_linked: geom.edges = edge_indices draw_data = { 'tree_name': self.id_data.name[:], 'custom_function': draw_edges, 'args': (geom, config) } callback_enable(n_id, draw_data) return if faces_socket.is_linked: # we could offer different optimizations, like # -expecting only tris as input, then no processing # -expecting only quads, then minimal processing needed # -expecting mixed bag, then ensure_triangles (current default) if self.display_faces: geom.faces = ensure_triangles(coords, face_indices) if self.display_edges: # we don't want to draw the inner edges of triangulated faces; use original face_indices. # pass edges from socket if we can, else we manually compute them from faces geom.edges = edge_indices if edges_socket.is_linked else edges_from_faces(face_indices) if self.selected_draw_mode == 'facet' and self.display_faces: facet_verts, facet_verts_vcols = generate_facet_data(geom.verts, geom.faces, config.face4f, config.vector_light) geom.facet_verts = facet_verts geom.facet_verts_vcols = facet_verts_vcols elif self.selected_draw_mode == 'smooth' and self.display_faces: geom.smooth_vcols = generate_smooth_data(geom.verts, geom.faces, config.face4f, config.vector_light) elif self.selected_draw_mode == 'fragment' and self.display_faces: config.draw_fragment_function = None # double reload, for testing. ND = self.node_dict.get(hash(self)) if not ND: if self.custom_shader_location in bpy.data.texts: self.populate_node_with_custom_shader_from_text() ND = self.node_dict.get(hash(self)) if ND and ND.get('draw_fragment'): config.draw_fragment_function = ND.get('draw_fragment') config.shader = gpu.types.GPUShader(self.custom_vertex_shader, self.custom_fragment_shader) else: config.shader = gpu.types.GPUShader(default_vertex_shader, default_fragment_shader) config.batch = batch_for_shader(config.shader, 'TRIS', {"position": geom.verts}, indices=geom.faces) draw_data = { 'tree_name': self.id_data.name[:], 'custom_function': draw_faces, 'args': (geom, config) } callback_enable(n_id, draw_data) return else: # draw verts only pass return elif matrix_socket.is_linked: matrices = matrix_socket.sv_get(deepcopy=False, default=[Matrix()]) draw_data = { 'tree_name': self.id_data.name[:], 'custom_function': draw_matrix, 'args': (matrices,) } callback_enable(n_id, draw_data)
def format_text(self): n_id = node_id(self) tl = format_text(self.text, self.width) self.text_cache[n_id] = (self.width, tl)
def free(self): nvBGL2.callback_disable(node_id(self)) self.delete_texture()
def reload_csv(self): n_id = node_id(self) self.load_csv_data()