def draw_line(self, context, vertexloc, vertexnorm, colour, thick): obj = context.active_object #get obj rotation rot = obj.rotation_euler.to_matrix().inverted() scale = obj.scale vertex = vertexloc * rot normal = vertexnorm * rot x1 = vertex[0] * scale[0] + obj.location[0] y1 = vertex[1] * scale[1] + obj.location[1] z1 = vertex[2] * scale[2] + obj.location[2] x2 = normal[0]*context.scene.tool_settings.normal_size* scale[0] + x1 y2 = normal[1]*context.scene.tool_settings.normal_size* scale[1] + y1 z2 = normal[2]*context.scene.tool_settings.normal_size* scale[2] + z1 bgl.glEnable(bgl.GL_BLEND) bgl.glLineWidth(thick) # set colour bgl.glColor4f(*colour) # draw line bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex3f(x1,y1,z1) bgl.glVertex3f(x2,y2,z2) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND)
def draw_circle_select(m_coords, radius = 16, p_col = (0.7,0.8,1.0,0.6), enabled = False, sub = False): if(enabled): f_col = p_col if sub: f_col = (1.0, 0.5, 0.4, 0.6) bgl.glEnable(bgl.GL_BLEND) bgl.glBegin(bgl.GL_POLYGON) bgl.glColor4f(f_col[0], f_col[1], f_col[2], f_col[3]/3) point_x = m_coords[0] point_y = m_coords[1] radius = int(radius) for x in range(0, radius*2): bgl.glVertex2f(point_x + radius * math.cos(x * (360/(radius*2)) / 180 * 3.14159), point_y + radius * math.sin(x * (360/(radius*2)) / 180 * 3.14159)) bgl.glEnd() bgl.glBegin(bgl.GL_LINES) bgl.glColor4f(f_col[0], f_col[1], f_col[2], f_col[3]) for x in range(0, radius*2): bgl.glVertex2f(point_x + radius * math.cos(x * (360 / (radius * 2)) / 180 * 3.14159), point_y + radius * math.sin(x * (360 / (radius * 2)) / 180 * 3.14159)) bgl.glEnd() # restore opengl defaults bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback_px(self, context): if init_functions(self, context) == None: return region = context.region rv3d = context.space_data.region_3d points, guide_verts = init_functions(self, context) arc_verts = get_arc_from_state(points, guide_verts, context) # draw bevel, followed by symmetry line, then fillet edge loop draw_polyline_from_coordinates(context, points, "GL_LINE_STIPPLE") draw_polyline_from_coordinates(context, guide_verts, "GL_LINE_STIPPLE") draw_polyline_from_coordinates(context, arc_verts, "GL_BLEND") # draw arc verts, then radial centre if DRAW_POINTS: draw_points(context, arc_verts, 4.2, gl_col1) draw_points(context, [guide_verts[1]], 5.2, gl_col2) # draw bottom left, above object name the number of vertices in the fillet draw_text(context, (65, 30), context.scene.NumVerts) # restore opengl defaults bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0) return
def draw_callback_px(self, context): print("mouse points", len(self.mouse_path)) font_id = 0 # XXX, need to find out how best to get this. # draw some text blf.position(font_id, 15, 30, 0) blf.size(font_id, 20, 72) blf.draw(font_id, "Hello Word " + str(len(self.mouse_path))) # 50% alpha, 2 pixel width line bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 0.5) bgl.glLineWidth(2) bgl.glBegin(bgl.GL_LINE_STRIP) for x, y in self.mouse_path: bgl.glVertex2i(x, y) bgl.glEnd() # restore opengl defaults bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_one(u): c = PCVCache.cache[u] # update matrix, every frame for now, it should be done better.. but it works well.. m = c['object'].matrix_world matrix = [] for v in m.transposed(): matrix.extend(list(v.to_tuple())) matrix_buffer = bgl.Buffer(bgl.GL_FLOAT, len(matrix), matrix) c['matrix'] = m c['matrix_buffer'] = matrix_buffer bgl.glPushMatrix() bgl.glMultMatrixf(c['matrix_buffer']) bgl.glEnable(bgl.GL_DEPTH_TEST) bgl.glEnableClientState(bgl.GL_VERTEX_ARRAY) bgl.glVertexPointer(3, bgl.GL_FLOAT, 0, c['vertex_buffer']) bgl.glEnableClientState(bgl.GL_COLOR_ARRAY) bgl.glColorPointer(3, bgl.GL_FLOAT, 0, c['color_buffer']) if(PCVCache.cache[u]['smooth']): bgl.glEnable(bgl.GL_POINT_SMOOTH) l = int((c['length'] / 100) * c['display_percent']) bgl.glDrawArrays(bgl.GL_POINTS, 0, l) bgl.glDisableClientState(bgl.GL_VERTEX_ARRAY) bgl.glDisableClientState(bgl.GL_COLOR_ARRAY) if(c['smooth']): bgl.glDisable(bgl.GL_POINT_SMOOTH) bgl.glDisable(bgl.GL_DEPTH_TEST) bgl.glPopMatrix()
def draw(self, context, render=False): if self.image is None: return bgl.glPushAttrib(bgl.GL_ENABLE_BIT) p0 = self.pts[0] p1 = self.pts[1] bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(*self.colour) bgl.glRectf(p0.x, p0.y, p1.x, p1.y) self.image.gl_load() bgl.glEnable(bgl.GL_BLEND) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.image.bindcode[0]) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_NEAREST) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST) bgl.glEnable(bgl.GL_TEXTURE_2D) bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) # bgl.glColor4f(1, 1, 1, 1) bgl.glBegin(bgl.GL_QUADS) bgl.glTexCoord2d(0, 0) bgl.glVertex2d(p0.x, p0.y) bgl.glTexCoord2d(0, 1) bgl.glVertex2d(p0.x, p1.y) bgl.glTexCoord2d(1, 1) bgl.glVertex2d(p1.x, p1.y) bgl.glTexCoord2d(1, 0) bgl.glVertex2d(p1.x, p0.y) bgl.glEnd() self.image.gl_free() bgl.glDisable(bgl.GL_TEXTURE_2D)
def draw3d_closed_polylines(context, lpoints, color, thickness, LINE_TYPE, mirror): #if type(lpoints) is types.GeneratorType: # lpoints = list(lpoints) lpoints = [[mirror(pt) for pt in points] for points in lpoints] if len(lpoints) == 0: return if LINE_TYPE == "GL_LINE_STIPPLE": bgl.glLineStipple(4, 0x5555) #play with this later bgl.glEnable(bgl.GL_LINE_STIPPLE) bgl.glEnable(bgl.GL_BLEND) bgl.glLineWidth(thickness) bgl.glColor4f(*color) for points in lpoints: set_depthrange(0.0, 0.997, points) bgl.glBegin(bgl.GL_LINE_STRIP) for coord in chain(points,points[:1]): bgl.glVertex3f(*coord) bgl.glEnd() # if settings.symmetry_plane == 'x': # bgl.glColor4f(*color_mirror) # for points in lpoints: # bgl.glBegin(bgl.GL_LINE_STRIP) # for coord in points: # bgl.glVertex3f(-coord.x, coord.y, coord.z) # bgl.glVertex3f(-points[0].x, points[0].y, points[0].z) # bgl.glEnd() bgl.glLineWidth(1) if LINE_TYPE == "GL_LINE_STIPPLE": bgl.glDisable(bgl.GL_LINE_STIPPLE) bgl.glEnable(bgl.GL_BLEND) # back to uninterrupted lines
def mi_draw_3d_polyline(points, p_size, p_col, x_ray): bgl.glEnable(bgl.GL_BLEND) bgl.glLineWidth(1) if x_ray is True: bgl.glDisable(bgl.GL_DEPTH_TEST) bgl.glPointSize(p_size) # bgl.glBegin(bgl.GL_LINE_LOOP) bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glColor4f(p_col[0], p_col[1], p_col[2], p_col[3]) # bgl.glBegin(bgl.GL_POLYGON) for point in points: bgl.glVertex3f(point[0], point[1], point[2]) if x_ray is True: bgl.glEnable(bgl.GL_DEPTH_TEST) bgl.glEnd() # restore opengl defaults bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback_px(self, context): if context.region.id != self.region_id: return posx = 70 posy1 = 30 posy2 = 50 text_interval = 5 font_id = 0 blf.size(font_id, 11, context.user_preferences.system.dpi) bgl.glEnable(bgl.GL_BLEND) if self.changing_mgtype: bgl.glColor4f(1.0, 1.0, 0.0, 1.0) else: bgl.glColor4f(1.0, 1.0, 1.0, 1.0) # draw origin bgl.glLineWidth(2) radius = path_threthold radius2 = radius + 5 x, y, z = self.path[0] bgl.glBegin(bgl.GL_LINES) for i in range(4): r = math.pi / 2 * i + math.pi / 4 bgl.glVertex2f(x + radius * math.cos(r), y + radius * math.sin(r)) bgl.glVertex2f(x + radius2 * math.cos(r), y + radius2 * math.sin(r)) bgl.glEnd() bgl.glLineWidth(1) # draw lines bgl.glEnable(bgl.GL_LINE_STIPPLE) bgl.glLineStipple(1, int(0b101010101010101)) # (factor, pattern) bgl.glBegin(bgl.GL_LINE_STRIP) for v in self.path: bgl.glVertex2f(v[0], v[1]) bgl.glEnd() bgl.glLineStipple(1, 1) bgl.glDisable(bgl.GL_LINE_STIPPLE) # draw txt if self.action or self.mgitem: x = posx for txt in self.action: blf.position(font_id, x, posy1, 0) blf.draw(font_id, txt) text_width, text_height = blf.dimensions(font_id, txt) x += text_width + text_interval if self.mgitem: blf.position(font_id, posx, posy2, 0) blf.draw(font_id, self.mgitem.name) else: #blf.position(font_id, posx, posy2, 0) #blf.draw(font_id, '[Mouse Gesture]') pass # restore opengl defaults bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0) blf.size(0, 11, context.user_preferences.system.dpi)
def draw_texture(x, y, w, h, texture, mode=None): mode_bak = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_DRAW_BUFFER, mode_bak) if mode is not None: bgl.glDrawBuffer(mode) bgl.glEnable(bgl.GL_TEXTURE_2D) bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture) bgl.glColor4d(1.0, 1.0, 1.0, 1.0) bgl.glBegin(bgl.GL_TRIANGLE_FAN) bgl.glTexCoord2d(0.0, 0.0) bgl.glVertex2i(x, y) bgl.glTexCoord2d(1.0, 0.0) bgl.glVertex2i(x + w, y) bgl.glTexCoord2d(1.0, 1.0) bgl.glVertex2i(x + w, y + h) bgl.glTexCoord2d(0.0, 1.0) bgl.glVertex2i(x, y + h) bgl.glEnd() bgl.glDisable(bgl.GL_TEXTURE_2D) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) if mode is not None: bgl.glDrawBuffer(mode_bak[0])
def draw_channel_color(scroller_width, channel_coords, curx, color): from bgl import glColor4f, glRectf, glEnable, glDisable, glBlendFunc, GL_BLEND, GL_ONE, GL_SRC_ALPHA context = bpy.context # Strip coords s_x1, s_y1, s_x2, s_y2 = channel_coords # Drawing coords x = 0 d_y1 = s_y1 d_y2 = s_y2 d_x1 = s_x1 d_x2 = s_x2 # be careful not to override the current frame line cf_x = context.scene.frame_current_final y = 0 r, g, b, a = color glColor4f(r, g, b, a) glEnable(GL_BLEND) # glBlendFunc(GL_SRC_ALPHA, GL_ONE); if d_x1 < cf_x and cf_x < d_x2: # current frame line over strip glRectf(d_x1, d_y1, cf_x - curx, d_y2) glRectf(cf_x + curx, d_y1, d_x2, d_y2) else: # Normal, full rectangle draw glRectf(d_x1, d_y1, d_x2, d_y2) glDisable(GL_BLEND)
def draw_polyline_from_points(context, points, color, thickness, LINE_TYPE): ''' a simple way to draw a line args: points: a list of tuples representing x,y SCREEN coordinate eg [(10,30),(11,31),...] color: tuple (r,g,b,a) thickness: integer? maybe a float LINE_TYPE: eg...bgl.GL_LINE_STIPPLE or ''' if LINE_TYPE == "GL_LINE_STIPPLE": bgl.glLineStipple(4, 0x5555) #play with this later bgl.glEnable(bgl.GL_LINE_STIPPLE) bgl.glEnable(bgl.GL_BLEND) current_width = bgl.GL_LINE_WIDTH bgl.glColor4f(*color) bgl.glLineWidth(thickness) bgl.glBegin(bgl.GL_LINE_STRIP) for coord in points: bgl.glVertex2f(*coord) bgl.glEnd() bgl.glLineWidth(1) if LINE_TYPE == "GL_LINE_STIPPLE": bgl.glDisable(bgl.GL_LINE_STIPPLE) bgl.glEnable(bgl.GL_BLEND) # back to uninterupted lines return
def draw_polyline_from_3dpoints(context, points_3d, color, thickness, LINE_TYPE): ''' a simple way to draw a line slow...becuase it must convert to screen every time but allows you to pan and zoom around args: points_3d: a list of tuples representing x,y SCREEN coordinate eg [(10,30),(11,31),...] color: tuple (r,g,b,a) thickness: integer? maybe a float LINE_TYPE: eg...bgl.GL_LINE_STIPPLE or ''' points = [location_3d_to_region_2d(context.region, context.space_data.region_3d, loc) for loc in points_3d] if LINE_TYPE == "GL_LINE_STIPPLE": bgl.glLineStipple(4, 0x5555) #play with this later bgl.glEnable(bgl.GL_LINE_STIPPLE) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(*color) bgl.glLineWidth(thickness) bgl.glBegin(bgl.GL_LINE_STRIP) for coord in points: bgl.glVertex2f(*coord) bgl.glEnd() if LINE_TYPE == "GL_LINE_STIPPLE": bgl.glDisable(bgl.GL_LINE_STIPPLE) bgl.glEnable(bgl.GL_BLEND) # back to uninterupted lines bgl.glLineWidth(1) return
def display_line_between_two_points(region, rv3d, p1_3d, p2_3d): bgl.glEnable(bgl.GL_BLEND) p1_2d = view3d_utils.location_3d_to_region_2d(region, rv3d, p1_3d) p2_2d = view3d_utils.location_3d_to_region_2d(region, rv3d, p2_3d) if p1_2d is None: p1_2d = (0.0, 0.0) p2_2d = (0.0, 0.0) col_line_main = addon_settings_graph()['col_line_main'] col_line_shadow = addon_settings_graph()['col_line_shadow'] bgl.glColor4f(*col_line_shadow) bgl.glLineWidth(1.4) bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f((p1_2d[0]-1),(p1_2d[1]-1)) bgl.glVertex2f((p2_2d[0]-1),(p2_2d[1]-1)) bgl.glEnd() bgl.glColor4f(*col_line_main) bgl.glLineWidth(1.4) bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(*p1_2d) bgl.glVertex2f(*p2_2d) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND)
def draw_callback(self, context): mid = int(360 * self.recv / self.fsize) cx = 200 cy = 30 blf.position(0, 230, 23, 0) blf.size(0, 20, 72) blf.draw(0, "{0:2d}% of {1}".format(100 * self.recv // self.fsize, self.hfsize)) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(0.7, 0.7, 0.7, 0.8) bgl.glBegin(bgl.GL_TRIANGLE_FAN) bgl.glVertex2i(cx, cy) for i in range(mid): x = cx + 20 * math.sin(math.radians(float(i))) y = cy + 20 * math.cos(math.radians(float(i))) bgl.glVertex2f(x, y) bgl.glEnd() bgl.glColor4f(0.0, 0.0, 0.0, 0.6) bgl.glBegin(bgl.GL_TRIANGLE_FAN) bgl.glVertex2i(cx, cy) for i in range(mid, 360): x = cx + 20 * math.sin(math.radians(float(i))) y = cy + 20 * math.cos(math.radians(float(i))) bgl.glVertex2f(x, y) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def __exit__(self, type, value, traceback): bgl.glEnd() # restore opengl defaults bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glEnable(bgl.GL_DEPTH_TEST) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_normal(context, vertexloc, vertexnorm, objscale, is_selected = True): # draw normals in object mode obj = context.active_object color1, thick1 = (0.5, 1.0, 1.0, 1.0), 3 # input in localspace vertexloc = copy.copy(vertexloc) vertexloc.resize_4d() obmat = obj.matrix_world r1 = obmat*vertexloc r1.resize_3d() del vertexloc r2 = obj.rotation_euler.to_matrix() * mathutils.Vector(vertexnorm) r2 = r2* objscale r2 = r2* context.scene.tool_settings.normal_size + r1 bgl.glEnable(bgl.GL_BLEND) bgl.glLineWidth(thick1) # set colour bgl.glColor4f(*color1) # draw line bgl.glBegin(bgl.GL_LINES) bgl.glVertex3f(r1.x,r1.y,r1.z) bgl.glVertex3f(r2.x,r2.y,r2.z) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND)
def draw_callback_px(self, context): kha_SystemImpl.frame() bgl.glUseProgram(0) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) bgl.glBindBuffer(bgl.GL_ELEMENT_ARRAY_BUFFER, 0) bgl.glDisable(bgl.GL_DEPTH_TEST) bgl.glDepthFunc(bgl.GL_ALWAYS)
def visualise(self, context): area = context.area speaker = context.scene.speaker action = getAction(speaker) scene = context.scene frame = scene.frame_current """ print("MHHM") action = context.screen.sound_driver_areas["VIEW_3D_4"].action print("THIS WORKING", action) #action = context.area.sound_action # NEW IDEA REFACTO """ if action is None: return None area_settings = self.area_settings(context) if area_settings is None: return None (x, y) = area_settings.loc fw = context.area.regions[-1].width - (x + 20) fh = context.area.regions[-1].height - 50 area_settings = self.area_settings(context) AMP = area_settings.height * fh / 100 if action.get("MIDI"): bgl.glEnable(bgl.GL_BLEND) self.draw_box(x, y + AMP, 3 * fw, 20, color=self.gridcol) bgl.glDisable(bgl.GL_BLEND) self.draw_action_header_text(x, y + AMP, speaker, action) self.draw_midi_keyboard(x, y, fw, AMP, action=action, frame=frame) else: self.draw_spectrum(context, x, y, speaker, action)
def viconutil_draw_lineloop_smooth(pts): linesmooth = vagl.Buffer('bool', 0, bgl.GL_LINE_SMOOTH) if not linesmooth: bgl.glEnable(bgl.GL_LINE_SMOOTH) viconutil_draw_lineloop(pts) if not linesmooth: bgl.glDisable(bgl.GL_LINE_SMOOTH)
def h_draw_gradient_rect(bounds, gradient, border_width=1, border_radius=0, border_color=(0, 0, 0, 1), wire=False): if len(gradient.colors) != len(gradient.offsets): return bgl.glEnable(bgl.GL_BLEND) bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) h_mask_begin(bounds, border_radius) mode = bgl.GL_LINE_STRIP if wire else bgl.GL_TRIANGLE_STRIP bgl.glBegin(mode) if gradient.orientation == 0: # HOR for i in range(len(gradient.colors)): bgl.glColor4f(*gradient.colors[i]) x = (bounds[2] * clamp(gradient.offsets[i], 0.0, 1.0)) + bounds[0] bgl.glVertex2f(x, bounds[1]) bgl.glVertex2f(x, bounds[1]+bounds[3]) elif gradient.orientation == 1: # VER for i in range(len(gradient.colors)): bgl.glColor4f(*gradient.colors[i]) y = (bounds[3] * clamp(gradient.offsets[i], 0.0, 1.0)) + bounds[1] bgl.glVertex2f(bounds[0], y) bgl.glVertex2f(bounds[0]+bounds[2], y) bgl.glEnd() h_mask_end() if border_width > 0: h_round_rect_wire(bounds, border_radius, color=border_color, width=border_width) bgl.glDisable(bgl.GL_BLEND)
def draw3d_closed_polylines(context, lpoints, color, thickness, LINE_TYPE): lpoints = list(lpoints) if LINE_TYPE == "GL_LINE_STIPPLE": bgl.glLineStipple(4, 0x5555) #play with this later bgl.glEnable(bgl.GL_LINE_STIPPLE) bgl.glEnable(bgl.GL_BLEND) bgl.glLineWidth(thickness) bgl.glDepthRange(0.0, 0.997) bgl.glColor4f(*color) for points in lpoints: bgl.glBegin(bgl.GL_LINE_STRIP) for coord in points: bgl.glVertex3f(*coord) bgl.glVertex3f(*points[0]) bgl.glEnd() if settings.symmetry_plane == 'x': bgl.glColor4f(*color_mirror) for points in lpoints: bgl.glBegin(bgl.GL_LINE_STRIP) for coord in points: bgl.glVertex3f(-coord.x, coord.y, coord.z) bgl.glVertex3f(-points[0].x, points[0].y, points[0].z) bgl.glEnd() bgl.glLineWidth(1) if LINE_TYPE == "GL_LINE_STIPPLE": bgl.glDisable(bgl.GL_LINE_STIPPLE) bgl.glEnable(bgl.GL_BLEND) # back to uninterrupted lines
def DRAW_RunResize(self, context): # Restore opengl defaults bgl.glDisable(bgl.GL_POINTS) bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_Cartesian(self):#vertices): ob = bpy.context.scene.objects.active.location rgn = bpy.context.region rv3d = bpy.context.space_data.region_3d #bgl.glClear() bgl.glEnable(bgl.GL_BLEND) bgl.glLineWidth(4) bgl.glBegin(bgl.GL_LINE_STRIP) v3d = Vector((0, 0, 0)) v2d = location_3d_to_region_2d(rgn, rv3d, v3d) bgl.glVertex2f(*v2d) bgl.glColor4f(100, 0.0, 0.0, 1) v3d = mathutils.Vector((ob.x,0,0)) v2d = location_3d_to_region_2d(rgn, rv3d, v3d) bgl.glVertex2f(*v2d) bgl.glColor4f(0, 100.0, 0.0, 1) v3d = mathutils.Vector((ob.x,ob.y,0)) v2d = location_3d_to_region_2d(rgn, rv3d, v3d) bgl.glVertex2f(*v2d) bgl.glColor4f(0, 0.0, 100.0, 1) v3d = mathutils.Vector((ob.x,ob.y,ob.z)) v2d = location_3d_to_region_2d(rgn, rv3d, v3d) bgl.glVertex2f(*v2d) bgl.glEnd() bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(1, 1, 1, 1) self.draw_value(Vector((ob.x/2,0,0)), str(round(ob.x, 2))) self.draw_value(Vector((ob.x, ob.y/2, 0)), str(round(ob.y, 2))) self.draw_value(Vector((ob.x, ob.y, ob.z/2)), str(round(ob.z, 2)))
def draw_texture(x=0, y=0, w=30, h=10, texname=texname): # function to draw a texture bgl.glDisable(bgl.GL_DEPTH_TEST) act_tex = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_TEXTURE_2D, act_tex) bgl.glEnable(bgl.GL_TEXTURE_2D) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glTexEnvf(bgl.GL_TEXTURE_ENV, bgl.GL_TEXTURE_ENV_MODE, bgl.GL_REPLACE) bgl.glBindTexture(bgl.GL_TEXTURE_2D, texname) texco = [(0, 1), (1, 1), (1, 0), (0, 0)] verco = [(x, y), (x + w, y), (x + w, y - h), (x, y - h)] bgl.glPolygonMode(bgl.GL_FRONT_AND_BACK, bgl.GL_FILL) bgl.glBegin(bgl.GL_QUADS) for i in range(4): bgl.glTexCoord3f(texco[i][0], texco[i][1], 0.0) bgl.glVertex2f(verco[i][0], verco[i][1]) bgl.glEnd() # restoring settings bgl.glBindTexture(bgl.GL_TEXTURE_2D, act_tex[0]) bgl.glDisable(bgl.GL_TEXTURE_2D)
def draw_ephestos(self,context): global show_world bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 0.5) bgl.glLineWidth(1.5) """ #set colour to use bgl.glColor4f(0.5,0.0,0.5,0.3) x_region = round((bpy.context.area.regions[4].width-5)/2) y_region = round((bpy.context.area.regions[4].height-5)/2) print("x_region : ",x_region) print("y_region : ",y_region) bgl.glRecti(5,5,x_region, y_region) """ # if show_world: world.draw() ''' good_rounded_box.draw_new(ephestos) world.draw_new(ephestos) # show_world = False red_morph.draw_new(ephestos) green_morph.draw_new(ephestos) blue_morph.draw_new(ephestos) multiline_text.draw_new(ephestos) rounded_box.draw_new(ephestos) one_String.draw_new(ephestos) #PKHG.stringfieldTest.??? test_stringfield.draw_new( ephestos) ''' # restore opengl defaults bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_preview(self): bgl.glPushAttrib(bgl.GL_ALL_ATTRIB_BITS) bgl.glMatrixMode(bgl.GL_MODELVIEW) bgl.glPushMatrix() bgl.glLoadIdentity() bgl.glMatrixMode(bgl.GL_PROJECTION) bgl.glPushMatrix() bgl.glLoadIdentity() bgl.glEnable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_DEPTH_TEST) bgl.glBegin(bgl.GL_QUADS) # TODO: not use immediate mode bgl.glColor4f(0,0,0.2,0.5) bgl.glVertex2f(-1, -1) bgl.glVertex2f( 1, -1) bgl.glColor4f(0,0,0.2,0) bgl.glVertex2f( 1, 1) bgl.glVertex2f(-1, 1) bgl.glEnd() bgl.glPopMatrix() bgl.glMatrixMode(bgl.GL_MODELVIEW) bgl.glPopMatrix() bgl.glMatrixMode(bgl.GL_PROJECTION) bgl.glPopAttrib()
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) for coord, color in zip(points, colors): bgl.glColor4f(*color) bgl.glVertex3f(*coord) bgl.glEnd() else: gl_col = (0.9, 0.9, 0.8, 1.0) bgl.glColor4f(*gl_col) bgl.glBegin(bgl.GL_POINTS) for coord in points: bgl.glVertex3f(*coord) bgl.glEnd() bgl.glDisable(bgl.GL_POINT_SMOOTH) bgl.glDisable(bgl.GL_POINTS)
def draw_callback(self, context): scene = context.scene x = int(round(context.region.width * 0.01 + (self._t_target - scene.frame_start) * self._ppf)) string = str(self._t_target) string = string[0 : string.index(".") + 3] font_id = 0 # XXX, need to find out how best to get this. # draw marker bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(1, 0, 0, 1) bgl.glLineWidth(2) bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2i(x, 17) bgl.glVertex2i(x, context.region.height) bgl.glEnd() bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0) # draw frame number if self._show_frame_indicator: blf.position(font_id, x + 5, 21, 0) blf.size(font_id, 12, 72) blf.draw(font_id, string)
def draw_postpixel(self): bgl.glPushAttrib(bgl.GL_ALL_ATTRIB_BITS) bgl.glEnable(bgl.GL_BLEND) bgl.glMatrixMode(bgl.GL_MODELVIEW) bgl.glPushMatrix() bgl.glLoadIdentity() bgl.glMatrixMode(bgl.GL_PROJECTION) bgl.glPushMatrix() bgl.glLoadIdentity() bgl.glColor4f(1,0,0,0.2) # TODO: use window background color?? bgl.glEnable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_DEPTH_TEST) bgl.glBegin(bgl.GL_QUADS) # TODO: not use immediate mode bgl.glVertex2f(-1, -1) bgl.glVertex2f( 1, -1) bgl.glVertex2f( 1, 1) bgl.glVertex2f(-1, 1) bgl.glEnd() bgl.glPopMatrix() bgl.glMatrixMode(bgl.GL_MODELVIEW) bgl.glPopMatrix() bgl.glMatrixMode(bgl.GL_PROJECTION) bgl.glPopAttrib()
def draw_callback_px(self, context): if context.mode == "EDIT_MESH": en0 = context.scene.dt_custom_props.en0 font_id = 0 font_size = context.scene.dt_custom_props.fs ob_act = context.active_object bme = bmesh.from_edit_mesh(ob_act.data) mtrx = ob_act.matrix_world list_0 = [v.index for v in bme.verts if v.select] if len(list_0) != 0: p = bme.verts[list_0[0]].co.copy() p_loc_2d = location_3d_to_region_2d(context.region, context.space_data.region_3d, p) q = mtrx * bme.verts[list_0[0]].co.copy() q_loc_2d = location_3d_to_region_2d(context.region, context.space_data.region_3d, q) # -- -- -- -- distance to adjacent vertices if context.scene.dt_custom_props.b0 == True: list_ = [[v.index for v in e.verts] for e in bme.verts[list_0[0]].link_edges] for ek in list_: vi = [i for i in ek if i != list_0[0]][0] p1 = bme.verts[vi].co.copy() loc_0_3d = mtrx * ((p + p1) * 0.5) loc_0_2d = location_3d_to_region_2d( context.region, context.space_data.region_3d, loc_0_3d) bgl.glColor4f(1.0, 1.0, 0.0, context.scene.dt_custom_props.a) blf.position(font_id, loc_0_2d[0] + 4, loc_0_2d[1] + 4, 0) blf.size(font_id, font_size, context.user_preferences.system.dpi) blf.draw(font_id, str(round((p - p1).length, 4))) bgl.glLineStipple(4, 0xAAAA) bgl.glEnable(bgl.GL_LINE_STIPPLE) # -- -- -- -- distance to axis local global if context.scene.dt_custom_props.b1 == True: # -- -- -- -- local if en0 == 'opt0': # -- -- -- -- x axis px = mtrx * Vector((0.0, p[1], p[2])) px_loc_2d = location_3d_to_region_2d( context.region, context.space_data.region_3d, px) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(1.0, 0.0, 0.0, context.scene.dt_custom_props.a) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(q_loc_2d[0], q_loc_2d[1]) bgl.glVertex2f(px_loc_2d[0], px_loc_2d[1]) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) if context.scene.dt_custom_props.b2 == False: lx = (q_loc_2d + px_loc_2d) * 0.5 bgl.glColor4f(1.0, 0.0, 0.0, context.scene.dt_custom_props.a) blf.position(font_id, lx[0] + 4, lx[1] + 4, 0) blf.size(font_id, font_size, context.user_preferences.system.dpi) blf.draw(font_id, str(round(p[0], 4))) # -- -- -- -- y axis py = mtrx * Vector((p[0], 0.0, p[2])) py_loc_2d = location_3d_to_region_2d( context.region, context.space_data.region_3d, py) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(0.0, 1.0, 0.0, context.scene.dt_custom_props.a) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(q_loc_2d[0], q_loc_2d[1]) bgl.glVertex2f(py_loc_2d[0], py_loc_2d[1]) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) if context.scene.dt_custom_props.b2 == False: ly = (q_loc_2d + py_loc_2d) * 0.5 bgl.glColor4f(0.0, 1.0, 0.0, context.scene.dt_custom_props.a) blf.position(font_id, ly[0] + 4, ly[1] + 4, 0) blf.size(font_id, font_size, context.user_preferences.system.dpi) blf.draw(font_id, str(round(p[1], 4))) # -- -- -- -- z axis pz = mtrx * Vector((p[0], p[1], 0.0)) pz_loc_2d = location_3d_to_region_2d( context.region, context.space_data.region_3d, pz) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 1.0, context.scene.dt_custom_props.a) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(q_loc_2d[0], q_loc_2d[1]) bgl.glVertex2f(pz_loc_2d[0], pz_loc_2d[1]) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) if context.scene.dt_custom_props.b2 == False: lz = (q_loc_2d + pz_loc_2d) * 0.5 bgl.glColor4f(0.0, 0.0, 1.0, context.scene.dt_custom_props.a) blf.position(font_id, lz[0] + 4, lz[1] + 4, 0) blf.size(font_id, font_size, context.user_preferences.system.dpi) blf.draw(font_id, str(round(p[2], 4))) # -- -- -- -- if context.scene.dt_custom_props.b2 == True and context.scene.dt_custom_props.b1 == True: blf.size(font_id, font_size, context.user_preferences.system.dpi) bgl.glColor4f(1.0, 0.0, 0.0, context.scene.dt_custom_props.a) blf.position( font_id, q_loc_2d[0] + 4, q_loc_2d[1] + 4 + font_size + 4 + font_size + 4, 0) blf.draw(font_id, 'x ' + str(round(p[0], 4))) bgl.glColor4f(0.0, 1.0, 0.0, context.scene.dt_custom_props.a) blf.position(font_id, q_loc_2d[0] + 4, q_loc_2d[1] + 4 + font_size + 4, 0) blf.draw(font_id, 'y ' + str(round(p[1], 4))) bgl.glColor4f(0.0, 0.0, 1.0, context.scene.dt_custom_props.a) blf.position(font_id, q_loc_2d[0] + 4, q_loc_2d[1] + 4, 0) blf.draw(font_id, 'z ' + str(round(p[2], 4))) # -- -- -- -- global elif en0 == 'opt1': # -- -- -- -- x axis ip_x = intersect_line_plane( q, q + (Vector((1.0, 0.0, 0.0)) * 0.1), Vector((0.0, 1.0, 0.0)), Vector((1.0, 0.0, 0.0))) ip_x_loc_2d = location_3d_to_region_2d( context.region, context.space_data.region_3d, ip_x) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(1.0, 0.0, 0.0, context.scene.dt_custom_props.a) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(q_loc_2d[0], q_loc_2d[1]) bgl.glVertex2f(ip_x_loc_2d[0], ip_x_loc_2d[1]) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) if context.scene.dt_custom_props.b2 == False: loc_1_2d = (q_loc_2d + ip_x_loc_2d) * 0.5 bgl.glColor4f(1.0, 0.0, 0.0, context.scene.dt_custom_props.a) blf.position(font_id, loc_1_2d[0] + 4, loc_1_2d[1] + 4, 0) blf.size(font_id, font_size, context.user_preferences.system.dpi) blf.draw(font_id, str(round((q - ip_x).length, 4))) # -- -- -- -- y axis ip_y = intersect_line_plane( q, q + (Vector((0.0, 1.0, 0.0)) * 0.1), Vector((1.0, 0.0, 0.0)), Vector((0.0, 1.0, 0.0))) ip_y_loc_2d = location_3d_to_region_2d( context.region, context.space_data.region_3d, ip_y) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(0.0, 1.0, 0.0, context.scene.dt_custom_props.a) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(q_loc_2d[0], q_loc_2d[1]) bgl.glVertex2f(ip_y_loc_2d[0], ip_y_loc_2d[1]) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) if context.scene.dt_custom_props.b2 == False: loc_2_2d = (q_loc_2d + ip_y_loc_2d) * 0.5 bgl.glColor4f(0.0, 1.0, 0.0, context.scene.dt_custom_props.a) blf.position(font_id, loc_2_2d[0] + 4, loc_2_2d[1] + 4, 0) blf.size(font_id, font_size, context.user_preferences.system.dpi) blf.draw(font_id, str(round((q - ip_y).length, 4))) # -- -- -- -- z axis ip_z = intersect_line_plane( q, q + (Vector((0.0, 0.0, 1.0)) * 0.1), Vector((1.0, 0.0, 0.0)), Vector((0.0, 0.0, 1.0))) ip_z_loc_2d = location_3d_to_region_2d( context.region, context.space_data.region_3d, ip_z) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 1.0, context.scene.dt_custom_props.a) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(q_loc_2d[0], q_loc_2d[1]) bgl.glVertex2f(ip_z_loc_2d[0], ip_z_loc_2d[1]) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) if context.scene.dt_custom_props.b2 == False: loc_3_2d = (q_loc_2d + ip_z_loc_2d) * 0.5 bgl.glColor4f(0.0, 0.0, 1.0, context.scene.dt_custom_props.a) blf.position(font_id, loc_3_2d[0] + 4, loc_3_2d[1] + 4, 0) blf.size(font_id, font_size, context.user_preferences.system.dpi) blf.draw(font_id, str(round((q - ip_z).length, 4))) # -- -- -- -- if context.scene.dt_custom_props.b2 == True and context.scene.dt_custom_props.b1 == True: blf.size(font_id, font_size, context.user_preferences.system.dpi) bgl.glColor4f(1.0, 0.0, 0.0, context.scene.dt_custom_props.a) blf.position( font_id, q_loc_2d[0] + 4, q_loc_2d[1] + 4 + font_size + 4 + font_size + 4, 0) blf.draw(font_id, 'x ' + str(round((q - ip_x).length, 4))) bgl.glColor4f(0.0, 1.0, 0.0, context.scene.dt_custom_props.a) blf.position(font_id, q_loc_2d[0] + 4, q_loc_2d[1] + 4 + font_size + 4, 0) blf.draw(font_id, 'y ' + str(round((q - ip_y).length, 4))) bgl.glColor4f(0.0, 0.0, 1.0, context.scene.dt_custom_props.a) blf.position(font_id, q_loc_2d[0] + 4, q_loc_2d[1] + 4, 0) blf.draw(font_id, 'z ' + str(round((q - ip_z).length, 4))) # -- -- -- -- mouse location if context.scene.dt_custom_props.b4 == True: rgn = context.region # region rgn_3d = context.space_data.region_3d # region 3d bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(1.0, 1.0, 1.0, context.scene.dt_custom_props.a) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(0, dt_buf.y) bgl.glVertex2f(dt_buf.x - 15, dt_buf.y) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(1.0, 1.0, 1.0, context.scene.dt_custom_props.a) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(rgn.width, dt_buf.y) bgl.glVertex2f(dt_buf.x + 15, dt_buf.y) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(1.0, 1.0, 1.0, context.scene.dt_custom_props.a) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(dt_buf.x, 0) bgl.glVertex2f(dt_buf.x, dt_buf.y - 15) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(1.0, 1.0, 1.0, context.scene.dt_custom_props.a) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(dt_buf.x, rgn.height) bgl.glVertex2f(dt_buf.x, dt_buf.y + 15) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_LINE_STIPPLE) t = str(dt_buf.x) + ', ' + str(dt_buf.y) lo = region_2d_to_location_3d(context.region, context.space_data.region_3d, Vector((dt_buf.x, dt_buf.y)), Vector((0.0, 0.0, 0.0))) t1 = '( ' + str(round(lo[0], 4)) + ', ' + str(round( lo[1], 4)) + ', ' + str(round(lo[2], 4)) + ' )' bgl.glColor4f(1.0, 1.0, 1.0, context.scene.dt_custom_props.a) blf.position(font_id, dt_buf.x + 15, dt_buf.y + 15, 0) blf.size(font_id, 14, context.user_preferences.system.dpi) blf.draw(font_id, t1 if context.scene.dt_custom_props.b5 == True else t) bgl.glDisable(bgl.GL_LINE_STIPPLE) # -- -- -- -- angles if context.scene.dt_custom_props.b3 == True: list_ek = [[v.index for v in e.verts] for e in bme.verts[list_0[0]].link_edges] n1 = len(list_ek) for j in range(n1): vec1 = p - bme.verts[[ i for i in list_ek[j] if i != list_0[0] ][0]].co.copy() vec2 = p - bme.verts[[ i for i in list_ek[(j + 1) % n1] if i != list_0[0] ][0]].co.copy() ang = vec1.angle(vec2) a_loc_2d = location_3d_to_region_2d( context.region, context.space_data.region_3d, mtrx * (((p - (vec1.normalized() * 0.1)) + (p - (vec2.normalized() * 0.1))) * 0.5)) bgl.glColor4f(0.0, 0.757, 1.0, context.scene.dt_custom_props.a) blf.position(font_id, a_loc_2d[0], a_loc_2d[1], 0) blf.size(font_id, font_size, context.user_preferences.system.dpi) blf.draw( font_id, str( round(ang, 4) if context.scene.dt_custom_props. b6 == True else round(degrees(ang), 2))) # -- -- -- -- tool on/off bgl.glColor4f(1.0, 1.0, 1.0, 1.0) blf.position(font_id, 150, 10, 0) blf.size(font_id, 20, context.user_preferences.system.dpi) blf.draw(font_id, 'Ruler On')
def check_draw_bgl(self, context): objs = context.selected_objects if len(objs) > 0: props = context.preferences.addons[__package__].preferences theme = context.preferences.themes['Default'] vertex_size = theme.view_3d.vertex_size bgl.glEnable(bgl.GL_BLEND) bgl.glLineWidth(props.edge_width + 1) bgl.glPointSize(vertex_size + 5) bgl.glCullFace(bgl.GL_BACK) if props.xray_che == False: bgl.glEnable(bgl.GL_DEPTH_TEST) bgl.glEnable(bgl.GL_CULL_FACE) if props.line_smooth: bgl.glEnable(bgl.GL_LINE_SMOOTH) bgl.glDepthRange(0, 0.9999) #bgl.glDepthFunc(600) bgl.glDepthMask(False) shader.bind() # COLOR #opacity_second = props.opacity + 0.1 ngone_col = props.ngone_col[0], props.ngone_col[1], props.ngone_col[ 2], props.ngone_col[3] tris_col = props.tris_col[0], props.tris_col[1], props.tris_col[ 2], props.tris_col[3] e_non_col = props.non_manifold_color[0], props.non_manifold_color[ 1], props.non_manifold_color[2], props.non_manifold_color[3] e_pole_col = props.e_pole_col[0], props.e_pole_col[ 1], props.e_pole_col[2], props.e_pole_col[3] n_pole_col = props.n_pole_col[0], props.n_pole_col[ 1], props.n_pole_col[2], props.n_pole_col[3] f_pole_col = props.f_pole_col[0], props.f_pole_col[ 1], props.f_pole_col[2], props.f_pole_col[3] v_bound_col = props.bound_col[0], props.bound_col[1], props.bound_col[ 2], props.bound_col[3] v_alone_col = props.v_alone_color[0], props.v_alone_color[ 1], props.v_alone_color[2], props.v_alone_color[3] custom_col = props.custom_col[0], props.custom_col[ 1], props.custom_col[2], props.custom_col[3] if props.use_mod_che: depsgraph = context.evaluated_depsgraph_get() for obj in objs: if obj.type == 'MESH': me = obj.data if len(me.polygons) < 50000: if context.mode == 'EDIT_MESH' and props.use_mod_che == False: bm = bmesh.from_edit_mesh(obj.data) else: if props.use_mod_che: if len(obj.modifiers) > 0: depsgraph.update() ob_eval = obj.evaluated_get(depsgraph) me = ob_eval.to_mesh() bm = bmesh.new() bm.from_mesh(me, face_normals=True, use_shape_key=False) bm.verts.ensure_lookup_table() bm.edges.ensure_lookup_table() bm.faces.ensure_lookup_table() # --- N-Gone if props.ngone: ngone = [] for n in bm.faces: if len(n.verts) > 4: ngone.append(n.index) #print("ngone",ngone) copy = bm.copy() copy.faces.ensure_lookup_table() edge_n = [ e for i in ngone for e in copy.faces[i].edges ] for e in copy.edges: if not e in edge_n: e.hide_set(True) bmesh.ops.triangulate(copy, faces=copy.faces[:]) v_index = [] ngone_co = [] for f in copy.faces: v_index.extend( [v.index for v in f.verts if not f.hide]) ngone_co.extend([ obj.matrix_world @ v.co for v in f.verts if not f.hide ]) copy.free() # TODO может быть удалить ? ngons_indices = [] ngons_indices.extend( list(range(0, len(v_index)))[v_i:v_i + 3] for v_i in range(0, len(v_index), 3)) NGONE = batch_for_shader(shader, 'TRIS', {"pos": ngone_co}, indices=ngons_indices) shader.uniform_float("color", ngone_col) NGONE.draw(shader) # --- Custom if props.custom_count: custom_faces = [] for n in bm.faces: if len(n.verts) == props.custom_count_verts: custom_faces.append(n.index) copy = bm.copy() copy.faces.ensure_lookup_table() edge_n = [ e for i in custom_faces for e in copy.faces[i].edges ] for e in copy.edges: if not e in edge_n: e.hide_set(True) bmesh.ops.triangulate(copy, faces=copy.faces[:]) v_index = [] custom_co = [] for f in copy.faces: v_index.extend( [v.index for v in f.verts if not f.hide]) custom_co.extend([ obj.matrix_world @ v.co for v in f.verts if not f.hide ]) copy.free() # TODO может быть удалить ? custom_faces_indices = [] custom_faces_indices.extend( list(range(0, len(v_index)))[v_i:v_i + 3] for v_i in range(0, len(v_index), 3)) CUSTOM = batch_for_shader(shader, 'TRIS', {"pos": custom_co}, indices=custom_faces_indices) shader.uniform_float("color", custom_col) CUSTOM.draw(shader) if props.tris: tris_co = [ obj.matrix_world @ v.co for f in bm.faces for v in f.verts if len(f.verts) == 3 ] TRIS = batch_for_shader(shader, 'TRIS', {"pos": tris_co}) shader.uniform_float("color", tris_col) TRIS.draw(shader) if props.non_manifold_check: e_non_i = [ e.index for e in bm.edges if not e.is_manifold ] e_non_co = [ obj.matrix_world @ v.co for i in e_non_i for v in bm.edges[i].verts ] EDGES_NON = batch_for_shader(shader, 'LINES', {"pos": e_non_co}) shader.uniform_float("color", e_non_col) EDGES_NON.draw(shader) if props.e_pole: e_pole_co = [ obj.matrix_world @ v.co for v in bm.verts if len(v.link_edges) == 5 ] E_POLE = batch_for_shader(shader, 'POINTS', {"pos": e_pole_co}) shader.uniform_float("color", e_pole_col) E_POLE.draw(shader) if props.n_pole: n_pole_co = [ obj.matrix_world @ v.co for v in bm.verts if len(v.link_edges) == 3 ] N_POLE = batch_for_shader(shader, 'POINTS', {"pos": n_pole_co}) shader.uniform_float("color", n_pole_col) N_POLE.draw(shader) if props.f_pole: f_pole_co = [ obj.matrix_world @ v.co for v in bm.verts if len(v.link_edges) > 5 ] F_POLE = batch_for_shader(shader, 'POINTS', {"pos": f_pole_co}) shader.uniform_float("color", f_pole_col) F_POLE.draw(shader) if props.v_bound: v_bound_co = [ obj.matrix_world @ v.co for v in bm.verts if v.is_boundary or not v.is_manifold ] V_BOUND = batch_for_shader(shader, 'POINTS', { "pos": v_bound_co, }) shader.uniform_float("color", v_bound_col) V_BOUND.draw(shader) if props.v_alone: v_alone_co = [ obj.matrix_world @ v.co for v in bm.verts if len(v.link_edges) < 1 ] V_ALONE = batch_for_shader(shader, 'POINTS', {"pos": v_alone_co}) shader.uniform_float("color", v_alone_col) V_ALONE.draw(shader) if props.use_mod_che: bm.free() if props.line_smooth: bgl.glDisable(bgl.GL_LINE_SMOOTH) bgl.glDisable(bgl.GL_DEPTH_TEST) bgl.glDisable(bgl.GL_CULL_FACE) bgl.glLineWidth(2) bgl.glPointSize(vertex_size) bgl.glDisable(bgl.GL_BLEND)
def _draw(self, context): if ( not context.window_manager.jewelcraft.widget_toggle or not context.space_data.overlay.show_overlays ): return global _font_loc prefs = context.preferences.addons[var.ADDON_ID].preferences props = context.scene.jewelcraft show_all = props.widget_show_all use_ovrd = props.widget_use_overrides default_spacing = props.widget_spacing default_color = prefs.widget_color default_linewidth = prefs.widget_linewidth is_df = context.mode == "EDIT_MESH" and context.edit_object.is_instancer diplay_thold = default_spacing + 0.5 depsgraph = context.evaluated_depsgraph_get() if is_df: df = context.edit_object for ob_act in df.children: if "gem" in ob_act: is_gem = True break else: is_gem = False else: ob_act = context.object if ob_act: is_gem = "gem" in ob_act if not (show_all or is_gem): return if is_gem: if use_ovrd and "jewelcraft_widget" in ob_act: ob_act_spacing = ob_act["jewelcraft_widget"].get("spacing", default_spacing) else: ob_act_spacing = default_spacing from_scene_scale = unit.Scale(context).from_scene if is_df: df_pass = False df.update_from_editmode() if df.modifiers and df.is_deform_modified(context.scene, "PREVIEW"): df_eval = df.evaluated_get(depsgraph) polys = df_eval.to_mesh().polygons poly = polys[polys.active] ob_act_loc = df.matrix_world @ poly.center mat_rot = poly.normal.to_track_quat("Z", "Y").to_matrix().to_4x4() df_eval.to_mesh_clear() else: polys = df.data.polygons poly = polys[polys.active] ob_act_loc = df.matrix_world @ poly.center mat_rot = poly.normal.to_track_quat("Z", "Y").to_matrix().to_4x4() else: ob_act_loc = ob_act.matrix_world.to_translation() mat_rot = ob_act.matrix_world.to_quaternion().to_matrix().to_4x4() ob_act_loc.freeze() ob_act_rad = max(ob_act.dimensions[:2]) / 2 mat_loc = Matrix.Translation(ob_act_loc) mat = mat_loc @ mat_rot mat.freeze() girdle_act = girdle_coords(ob_act_rad, mat) shader.bind() bgl.glEnable(bgl.GL_BLEND) bgl.glEnable(bgl.GL_LINE_SMOOTH) bgl.glDepthMask(bgl.GL_FALSE) if props.widget_show_in_front: bgl.glDisable(bgl.GL_DEPTH_TEST) for dup in depsgraph.object_instances: if dup.is_instance: ob = dup.instance_object.original else: ob = dup.object.original if "gem" not in ob: continue ob_rad = max(ob.dimensions[:2]) / 2 ob_loc = dup.matrix_world.translation spacing_thold = False if is_gem: dis_ob = (ob_act_loc - ob_loc).length dis_gap = from_scene_scale(dis_ob - (ob_act_rad + ob_rad)) dis_thold = dis_gap < diplay_thold if not (show_all or dis_thold): continue if is_df: if df_pass: is_act = False else: df_pass = is_act = dup.matrix_world.translation == ob_act_loc else: if dup.is_instance: is_act = False else: is_act = ob is ob_act use_diplay_dis = not is_act and dis_thold else: use_diplay_dis = False if show_all or use_diplay_dis: if use_ovrd and "jewelcraft_widget" in ob: _color = ob["jewelcraft_widget"].get("color", default_color) _linewidth = ob["jewelcraft_widget"].get("linewidth", default_linewidth) _spacing = ob["jewelcraft_widget"].get("spacing", default_spacing) else: _color = default_color _linewidth = default_linewidth _spacing = default_spacing bgl.glLineWidth(_linewidth) shader.uniform_float("color", _color) if dup.is_instance: mat = dup.matrix_world.copy() else: mat_loc = Matrix.Translation(ob_loc) mat_rot = dup.matrix_world.to_quaternion().to_matrix().to_4x4() mat = mat_loc @ mat_rot mat.freeze() if use_diplay_dis: if dis_ob: girdle_ob = girdle_coords(ob_rad, mat) dis_gap, start, end = find_nearest(ob_act_loc, ob_act_rad, girdle_act, girdle_ob) dis_gap = from_scene_scale(dis_gap) dis_thold = dis_gap < diplay_thold spacing_thold = dis_gap < (_spacing + 0.3) if not (show_all or dis_thold): continue mid = start.lerp(end, 0.5) else: start = end = mid = ob_loc.copy() if dis_thold: if dis_gap < 0.1: shader.uniform_float("color", (1.0, 0.0, 0.0, 1.0)) elif dis_gap < _spacing: shader.uniform_float("color", (1.0, 0.9, 0.0, 1.0)) _font_loc.append((dis_gap, mid, from_scene_scale(max(ob_act_spacing, _spacing)))) batch = batch_for_shader(shader, "LINES", {"pos": (start, end)}) batch.draw(shader) if show_all or spacing_thold: radius = ob_rad + _spacing coords = girdle_coords(radius, mat) batch = batch_for_shader(shader, "LINE_LOOP", {"pos": coords}) batch.draw(shader) # Restore OpenGL defaults # ---------------------------- bgl.glDisable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_LINE_SMOOTH) bgl.glDepthMask(bgl.GL_TRUE) bgl.glEnable(bgl.GL_DEPTH_TEST) bgl.glLineWidth(1.0)
def h_mask_end(): bgl.glDisable(bgl.GL_STENCIL_TEST)
def draw_callback_px(self, context): # draw 3d point OpenGL in the 3D View bgl.glEnable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_DEPTH_TEST) # bgl.glPushMatrix() # bgl.glMultMatrixf(self.obj_glmatrix) ## if DEBUG: ## mesh_drawing._store_current_shader_state(mesh_drawing.PreviousGLState) ## self.screen.Draw(self.sctx._texture) ## mesh_drawing._restore_shader_state(mesh_drawing.PreviousGLState) if self.vector_constrain: vc = self.vector_constrain if hasattr(self, 'preloc') and self.type in {'VERT', 'FACE'}: bgl.glColor4f(1.0, 1.0, 1.0, 0.5) bgl.glPointSize(5) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex3f(*self.preloc) bgl.glEnd() if vc[2] == 'X': Color4f = (self.axis_x_color + (1.0,)) elif vc[2] == 'Y': Color4f = (self.axis_y_color + (1.0,)) elif vc[2] == 'Z': Color4f = (self.axis_z_color + (1.0,)) else: Color4f = self.constrain_shift_color else: if self.type == 'OUT': Color4f = self.out_color elif self.type == 'FACE': Color4f = self.face_color elif self.type == 'EDGE': Color4f = self.edge_color elif self.type == 'VERT': Color4f = self.vert_color elif self.type == 'CENTER': Color4f = self.center_color elif self.type == 'PERPENDICULAR': Color4f = self.perpendicular_color else: # self.type == None Color4f = self.out_color bgl.glColor4f(*Color4f) bgl.glPointSize(10) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex3f(*self.location) bgl.glEnd() # draw 3d line OpenGL in the 3D View bgl.glEnable(bgl.GL_DEPTH_TEST) bgl.glDepthRange(0, 0.9999) bgl.glColor4f(1.0, 0.8, 0.0, 1.0) bgl.glLineWidth(2) bgl.glEnable(bgl.GL_LINE_STIPPLE) bgl.glBegin(bgl.GL_LINE_STRIP) for vert_co in self.list_verts_co: bgl.glVertex3f(*vert_co) bgl.glVertex3f(*self.location) bgl.glEnd() # restore opengl defaults # bgl.glPopMatrix() bgl.glDepthRange(0, 1) bgl.glPointSize(1) bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_LINE_STIPPLE) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def DRAW_Overlay(self, context): np_print('DRAW_Overlay_START',';','NP020PL.flag = ', NP020PL.flag) flag = NP020PL.flag helper = NP020PL.helper region = bpy.context.region rv3d = bpy.context.region_data rw = region.width rh = region.height co2d = view3d_utils.location_3d_to_region_2d(region, rv3d, helper.location) frompoints = NP020PL.frompoints topoints = NP020PL.topoints col_line_main = (1.0, 1.0, 1.0, 1.0) col_line_shadow = (0.1, 0.1, 0.1, 0.25) #greys: mark_col_A = (0.25, 0.25, 0.25, 1.0) mark_col_B = (0.5, 0.5, 0.5, 1.0) mark_col_C = (0.75, 0.75, 0.75, 1.0) #marins mark_col_A = (0.25, 0.35, 0.4, 1.0) mark_col_B = (0.5, 0.6, 0.65, 1.0) mark_col_C = (0.67, 0.77, 0.82, 1.0) # writing the dots for recwidget widget at center of scene: r = 12 angstep = 20 psize = 25 pofsetx = 15 pofsety = 15 fsize = 20 fofsetx = -8 fofsety = -7 widget_circle = construct_circle_2d(r, angstep) if flag == 'RUNTRANSF0': instruct = 'place start for point a' keys_aff = 'LMB - select, CTRL - snap, ENT - change snap' keys_neg = 'RMB, ESC - quit' frompoints[0] = helper.location elif flag == 'RUNTRANST0': instruct = 'place target for point a' keys_aff = 'LMB - select, CTRL - snap, ENT - change snap, MMB - lock axis, NUMPAD - value' keys_neg = 'RMB, ESC - quit' topoints[0] = helper.location elif flag == 'RUNTRANSF1': instruct = 'place start for point b' keys_aff = 'LMB - select, CTRL - snap, ENT - change snap, MMB - lock axis, NUMPAD - value, RMB - align A (translate)' keys_neg = 'ESC - quit' frompoints[1] = helper.location elif flag == 'RUNTRANST1': instruct = 'place target for point b' keys_aff = 'LMB - select, CTRL - snap, ENT - change snap, MMB - lock axis, NUMPAD - value, RMB - align A (translate)' keys_neg = 'ESC - quit' topoints[1] = helper.location elif flag == 'RUNTRANSF2': instruct = 'place start for point c' keys_aff = 'LMB - select, CTRL - snap, ENT - change snap, MMB - lock axis, NUMPAD - value, RMB - align AB (translate, rotate)' keys_neg = 'ESC - quit' frompoints[2] = helper.location elif flag == 'RUNTRANST2': instruct = 'place target for point c' keys_aff = 'LMB - select, CTRL - snap, ENT - change snap, MMB - lock axis, NUMPAD - value, RMB - align AB (translate, rotate)' keys_neg = 'ESC - quit' topoints[2] = helper.location # ON-SCREEN INSTRUCTIONS: keys_nav = '' display_instructions(region, rv3d, instruct, keys_aff, keys_nav, keys_neg) # LINE: for i, frompoint in enumerate(frompoints): topoint = topoints[i] if frompoint != None and topoint != None: bgl.glColor4f(*col_line_shadow) bgl.glLineWidth(1.4) bgl.glBegin(bgl.GL_LINE_STRIP) frompoint = view3d_utils.location_3d_to_region_2d(region, rv3d, frompoint) topoint = view3d_utils.location_3d_to_region_2d(region, rv3d, topoint) bgl.glVertex2f((frompoint[0] - 1), (frompoint[1] - 1)) bgl.glVertex2f((topoint[0] - 1), (topoint[1] - 1)) bgl.glEnd() bgl.glColor4f(*col_line_main) bgl.glLineWidth(1.4) bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(*frompoint) bgl.glVertex2f(*topoint) bgl.glEnd() # drawing of markers: i = 0 for point in frompoints: if point != None: point = view3d_utils.location_3d_to_region_2d(region, rv3d, point) point[0] = point[0] + pofsetx point[1] = point[1] + pofsety widget = [] for co in widget_circle: c = [0.0, 0.0] c[0] = co[0] + point[0] + pofsetx c[1] = co[1] + point[1] + pofsety widget.append(c) bgl.glEnable(bgl.GL_BLEND) if i == 0: bgl.glColor4f(*mark_col_A) mark = "A" elif i == 1: bgl.glColor4f(*mark_col_B) mark = "B" elif i == 2: bgl.glColor4f(*mark_col_C) mark = "C" ''' bgl.glLineWidth(1) bgl.glBegin(bgl.GL_LINE_STRIP) for co in widget: bgl.glVertex2f(*co) bgl.glVertex2f(*widget[len(widget) - 1]) bgl.glEnd() bgl.glBegin(bgl.GL_TRIANGLE_FAN) for co in widget: bgl.glVertex2f(*co) bgl.glEnd() ''' font_id = 0 bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glPointSize(psize) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex2f(*point) bgl.glEnd() bgl.glDisable(bgl.GL_POINT_SMOOTH) bgl.glColor4f(1.0, 1.0, 1.0, 0.75) blf.size(font_id, fsize, 72) blf.position(font_id, point[0] + fofsetx, point[1] + fofsety, 0) blf.draw(font_id, mark) i = i + 1 i = 0 for point in topoints: if point != None: point = view3d_utils.location_3d_to_region_2d(region, rv3d, point) point[0] = point[0] + pofsetx point[1] = point[1] + pofsety widget = [] for co in widget_circle: c = [0.0, 0.0] c[0] = co[0] + point[0] + pofsetx c[1] = co[1] + point[1] + pofsety widget.append(c) bgl.glEnable(bgl.GL_BLEND) if i == 0: bgl.glColor4f(*mark_col_A) mark = "A'" elif i == 1: bgl.glColor4f(*mark_col_B) mark = "B'" elif i == 2: bgl.glColor4f(*mark_col_C) mark = "C'" ''' bgl.glLineWidth(1) bgl.glBegin(bgl.GL_LINE_STRIP) for co in widget: bgl.glVertex2f(*co) bgl.glVertex2f(*widget[len(widget) - 1]) bgl.glEnd() bgl.glBegin(bgl.GL_TRIANGLE_FAN) for co in widget: bgl.glVertex2f(*co) bgl.glEnd() ''' font_id = 0 bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glPointSize(psize) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex2f(*point) bgl.glEnd() bgl.glDisable(bgl.GL_POINT_SMOOTH) bgl.glColor4f(1.0, 1.0, 1.0, 0.75) blf.size(font_id, fsize, 72) blf.position(font_id, point[0] + fofsetx, point[1] + fofsety, 0) blf.draw(font_id, mark) i = i + 1 #ENDING: bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_geometry(n_id, options, data_vector, data_polygons, data_matrix, data_edges): show_verts = options['show_verts'] show_edges = options['show_edges'] show_faces = options['show_faces'] vertex_colors = options['vertex_colors'] edge_colors = options['edge_colors'] edge_width = options['edge_width'] tran = options['transparent'] shade = options['shading'] verlen = options['verlen'] max_verts_ = [len(d) for d in data_vector] if tran: polyholy = GL_POLYGON_STIPPLE edgeholy = GL_LINE_STIPPLE edgeline = GL_LINE_STRIP else: polyholy = GL_POLYGON edgeholy = GL_LINE edgeline = GL_LINES def get_max_k(i, verlen): k = i if i > verlen: k = verlen return k ''' vertices ''' glEnable(GL_POINT_SIZE) glEnable(GL_POINT_SMOOTH) glHint(GL_POINT_SMOOTH_HINT, GL_NICEST) # glHint(GL_POINT_SMOOTH_HINT, GL_FASTEST) vsize = options['vertex_size'] if show_verts and data_vector: glPointSize(vsize) glColor3f(*vertex_colors) glBegin(GL_POINTS) for i, matrix in enumerate(data_matrix): k = get_max_k(i, verlen) for vert in data_vector[k]: vec = data_matrix[i] * vert glVertex3f(*vec) glEnd() glDisable(GL_POINT_SIZE) glDisable(GL_POINT_SMOOTH) ''' polygons ''' if data_polygons and data_vector: num_datapolygon_lists = len(data_polygons) glEnable(polyholy) for i, matrix in enumerate(data_matrix): k = get_max_k(i, verlen) mesh_edges = set() if k >= num_datapolygon_lists: k = (num_datapolygon_lists - 1) #break for j, pol in enumerate(data_polygons[k]): if max(pol) >= max_verts_[k]: continue if show_faces: display_face(options, pol, data_vector, data_matrix, k, i) # collect raw edges, sort by index, use set to prevent dupes. if show_edges: er = list(pol) + [pol[0]] kb = { tuple(sorted((e, er[i + 1]))) for i, e in enumerate(er[:-1]) } mesh_edges.update(kb) if show_edges and mesh_edges: # glHint(GL_LINE_SMOOTH_HINT, GL_NICEST) glEnable(edgeholy) glLineWidth(edge_width) glColor3f(*edge_colors) glBegin(GL_LINES) for edge in mesh_edges: for p in edge: vec = data_matrix[i] * data_vector[k][p] glVertex3f(*vec) glEnd() glDisable(edgeholy) glDisable(polyholy) ''' edges ''' if data_edges and data_vector and show_edges: glColor3f(*edge_colors) glLineWidth(edge_width) glEnable(edgeholy) for i, matrix in enumerate(data_matrix): k = get_max_k(i, verlen) if k >= len(data_edges): continue for line in data_edges[k]: # i think this catches edges which refer to indices not present in # the accompanying vertex list. if max(line) >= max_verts_[k]: continue glBegin(edgeline) for p in line: vec = data_matrix[i] * data_vector[k][p] glVertex3f(*vec) glEnd() glDisable(edgeholy) ''' matrix ''' if data_matrix and not data_vector: md = MatrixDraw() for mat in data_matrix: md.draw_matrix(mat)
def draw_callback_px(self, context): """Draws Code Editors Minimap and indentation marks""" def draw_line(origin, length, thickness, vertical=False): """Drawing lines with polys, its faster""" x = (origin[0] + thickness) if vertical else (origin[0] + length) y = (origin[1] + length) if vertical else (origin[1] + thickness) bgl.glBegin(bgl.GL_QUADS) for v1, v2 in [origin, (x, origin[1]), (x, y), (origin[0], y)]: bgl.glVertex2i(v1, v2) bgl.glEnd() return # abort if another text editor try: if self.window == context.window and self.area == context.area: bgl.glEnable(bgl.GL_BLEND) else: return except: return start = time.clock() # init params font_id = 0 self.width = next(region.width for region in context.area.regions if region.type == 'WINDOW') self.height = next(region.height for region in context.area.regions if region.type == 'WINDOW') dpi_r = context.user_preferences.system.dpi / 72.0 self.left_edge = self.width - round( dpi_r * (self.width + 5 * self.minimap_width) / 10.0) self.right_edge = self.width - round(dpi_r * 15) self.opacity = min(max(0, (self.width - self.min_width) / 100.0), 1) # compute character dimensions mcw = dpi_r * self.minimap_symbol_width # minimap char width mlh = round(dpi_r * self.minimap_line_height) # minimap line height fs = context.space_data.font_size cw = round(dpi_r * round(2 + 0.6 * (fs - 4))) # char width ch = round(dpi_r * round(2 + 1.3 * (fs - 2) + ((fs % 10) == 0))) # char height #chfx = round(dpi_r * (2 + 1.3 * (fs - 2) + ((fs % 10) == 0))) # char height fixed # panel background box #self.tab_width = round(dpi_r * 25) if (self.tabs and len(bpy.data.texts) > 1) else 0 bgl.glColor4f(self.background.r, self.background.g, self.background.b, (1 - self.bg_opacity) * self.opacity) bgl.glBegin(bgl.GL_QUADS) #bgl.glVertex2i(self.left_edge-self.tab_width, self.height) bgl.glVertex2i(self.left_edge, self.height) bgl.glVertex2i(self.right_edge, self.height) bgl.glVertex2i(self.right_edge, 0) #bgl.glVertex2i(self.left_edge-self.tab_width, 0) bgl.glVertex2i(self.left_edge, 0) bgl.glEnd() # space = context.space_data # if space.text: # lines = len(space.text.lines) # lines_digits = len(str(lines)) if space.show_line_numbers else 0 #### AQUI Y AHORA #line numbers background space = context.space_data if space.text: lines = len(space.text.lines) lines_digits = len(str(lines)) if space.show_line_numbers else 0 self.line_bar_width = int(dpi_r * 5) + cw * (lines_digits) # bgl.glColor4f(1, 0, 0, 0.3) # for id in range(space.top, min(space.top+space.visible_lines+1, lines+1)): # if id in [2, 1, 4, 8, 24, 55]: # bgl.glBegin(bgl.GL_QUADS) # bgl.glVertex2i(0, self.height-chfx*(id-space.top)) # bgl.glVertex2i(self.line_bar_width, self.height-chfx*(id-space.top)) # bgl.glVertex2i(self.line_bar_width, self.height-chfx*(id-1-space.top)) # bgl.glVertex2i(0, self.height-chfx*(id-1-space.top)) # bgl.glEnd() # #bgl.glColor4f(1, 0, 0, 0.5) #blf.size(font_id, fs, int(dpi_r)*72) #blf.position(font_id, 2+int(0.5*cw*(len(str(lines))-len(str(id)))), self.height-ch*(id-space.top)+3, 0) #blf.draw(font_id, '*') # blf.position(font_id, # 2+int(0.5*cw*(len(str(lines))-len(str(id)))), # self.height-ch*(id-space.top)+3, 0) # blf.draw(font_id, u'▓▓') # minimap shadow for id, intensity in enumerate([0.2, 0.1, 0.07, 0.05, 0.03, 0.02, 0.01]): bgl.glColor4f(0.0, 0.0, 0.0, intensity * self.opacity) bgl.glBegin(bgl.GL_LINE_STRIP) #bgl.glVertex2i(self.left_edge-id-self.tab_width, 0) #bgl.glVertex2i(self.left_edge-id-self.tab_width, self.height) bgl.glVertex2i(self.left_edge - id, 0) bgl.glVertex2i(self.left_edge - id, self.height) bgl.glEnd() # divider # if self.tab_width: # bgl.glColor4f(0.0, 0.0, 0.0, 0.2*self.opacity) # bgl.glBegin(bgl.GL_LINE_STRIP) # bgl.glVertex2i(self.left_edge, 0) # bgl.glVertex2i(self.left_edge, self.height) # bgl.glEnd() # if there is text in window if space.text and self.opacity: # minimap horizontal sliding based on text block length max_slide = max(0, mlh * (lines + self.height / ch) - self.height) self.slide = int(max_slide * space.top / lines) minimap_top_line = int(self.slide / mlh) minimap_bot_line = int((self.height + self.slide) / mlh) # draw minimap visible box if self.in_minimap: bgl.glColor4f(1.0, 1.0, 1.0, 0.1 * self.opacity) else: bgl.glColor4f(1.0, 1.0, 1.0, 0.07 * self.opacity) bgl.glBegin(bgl.GL_QUADS) bgl.glVertex2i(self.left_edge, self.height - mlh * space.top + self.slide) bgl.glVertex2i(self.right_edge, self.height - mlh * space.top + self.slide) bgl.glVertex2i( self.right_edge, self.height - mlh * (space.top + space.visible_lines) + self.slide) bgl.glVertex2i( self.left_edge, self.height - mlh * (space.top + space.visible_lines) + self.slide) bgl.glEnd() # draw minimap code for segment in self.segments[:-1]: bgl.glColor4f(segment['col'][0], segment['col'][1], segment['col'][2], 0.4 * self.opacity) for id, element in enumerate( segment['elements'][minimap_top_line:minimap_bot_line]): loc_y = mlh * (id + minimap_top_line + 3) - self.slide for sub_element in element: draw_line( (self.left_edge + int(mcw * (sub_element[0] + 4)), self.height - loc_y), int(mcw * (sub_element[1] - sub_element[0])), int(0.5 * mlh)) # minimap code marks bgl.glColor4f(self.segments[-2]['col'][0], self.segments[-2]['col'][1], self.segments[-2]['col'][2], 0.3 * self.block_trans * self.opacity) for id, element in enumerate(self.segments[-2]['elements']): for sub_element in element: if sub_element[ 2] >= space.top or id < space.top + space.visible_lines: draw_line( (self.left_edge + int(mcw * (sub_element[0] + 4)), self.height - mlh * (id + 3) + self.slide), -int(mlh * (sub_element[2] - id - 1)), int(0.5 * mlh), True) # draw dotted indentation marks bgl.glLineWidth(1.0 * dpi_r) if space.text: bgl.glColor4f(self.segments[0]['col'][0], self.segments[0]['col'][1], self.segments[0]['col'][2], self.indent_trans) for id, element in enumerate( self.segments[-1]['elements'][space.top:space.top + space.visible_lines]): loc_y = id for sub_element in element: draw_line( (int(dpi_r * 10) + cw * (lines_digits + sub_element[0] + 4), self.height - ch * (loc_y)), -ch, int(1 * dpi_r), True) # draw code block marks bgl.glColor4f(self.segments[-2]['col'][0], self.segments[-2]['col'][1], self.segments[-2]['col'][2], self.block_trans) for id, element in enumerate(self.segments[-2]['elements']): for sub_element in element: if sub_element[ 2] >= space.top or id < space.top + space.visible_lines: bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2i( int(dpi_r * 10 + cw * (lines_digits + sub_element[0])), self.height - ch * (id + 1 - space.top)) bgl.glVertex2i( int(dpi_r * 10 + cw * (lines_digits + sub_element[0])), self.height - int(ch * (sub_element[2] - space.top))) bgl.glVertex2i( int(dpi_r * 10 + cw * (lines_digits + sub_element[0] + 1)), self.height - int(ch * (sub_element[2] - space.top))) bgl.glEnd() # tab dividers # if self.tab_width and self.opacity: # self.tab_height = min(200, int(self.height/len(bpy.data.texts))) # y_loc = self.height-5 # for text in bpy.data.texts: # # tab selection # if text.name == self.in_tab: # bgl.glColor4f(1.0, 1.0, 1.0, 0.05*self.opacity) # bgl.glBegin(bgl.GL_QUADS) # bgl.glVertex2i(self.left_edge-self.tab_width, y_loc) # bgl.glVertex2i(self.left_edge, y_loc) # bgl.glVertex2i(self.left_edge, y_loc-self.tab_height) # bgl.glVertex2i(self.left_edge-self.tab_width, y_loc-self.tab_height) # bgl.glEnd() # # tab active # if context.space_data.text and text.name == context.space_data.text.name: # bgl.glColor4f(1.0, 1.0, 1.0, 0.05*self.opacity) # bgl.glBegin(bgl.GL_QUADS) # bgl.glVertex2i(self.left_edge-self.tab_width, y_loc) # bgl.glVertex2i(self.left_edge, y_loc) # bgl.glVertex2i(self.left_edge, y_loc-self.tab_height) # bgl.glVertex2i(self.left_edge-self.tab_width, y_loc-self.tab_height) # bgl.glEnd() # bgl.glColor4f(0.0, 0.0, 0.0, 0.2*self.opacity) # y_loc -= self.tab_height # bgl.glBegin(bgl.GL_LINE_STRIP) # bgl.glVertex2i(self.left_edge-self.tab_width, y_loc) # bgl.glVertex2i(self.left_edge, y_loc) # bgl.glEnd() # draw fps # bgl.glColor4f(1, 1, 1, 0.2) # blf.size(font_id, fs, int(dpi_r*72)) # blf.position(font_id, self.left_edge-50, 5, 0) # blf.draw(font_id, str(round(1/(time.clock() - start),3))) # draw line numbers # if space.text: # bgl.glColor4f(1, 0, 0, 0.5) # for id in range(space.top, min(space.top+space.visible_lines+1, lines+1)): # blf.size(font_id, fs, int(dpi_r*72)) # blf.position(font_id, 2+int(0.5*cw*(len(str(lines))-len(str(id)))), self.height-ch*(id-space.top)+3, 0) # blf.draw(font_id, '*') # # # bgl.glColor4f(self.segments[0]['col'][0], # # self.segments[0]['col'][1], # # self.segments[0]['col'][2], # # 0.5) # for id in range(space.top, min(space.top+space.visible_lines+1, lines+1)): # blf.position(font_id, 2+int(0.5*cw*(len(str(lines))-len(str(id)))), self.height-ch*(id-space.top)+3, 0) # blf.draw(font_id, u'▓▓') # draw file names # if self.tab_width: # blf.enable(font_id, blf.ROTATION) # blf.rotation(font_id, 1.570796) # y_loc = self.height # for text in bpy.data.texts: # text_max_length = max(2,int((self.tab_height - 40)/cw)) # name = text.name[:text_max_length] # if text_max_length < len(text.name): # name += '...' # bgl.glColor4f(self.segments[0]['col'][0], # self.segments[0]['col'][1], # self.segments[0]['col'][2], # (0.7 if text.name == self.in_tab else 0.4)*self.opacity) # blf.position(font_id, # self.left_edge-round((self.tab_width-ch)/2.0)-5, # round(y_loc-(self.tab_height/2)-cw*len(name)/2), # 0) # blf.draw(font_id, name) # y_loc -= self.tab_height # restore opengl defaults bgl.glColor4f(0, 0, 0, 1) bgl.glLineWidth(1.0) bgl.glDisable(bgl.GL_BLEND) blf.disable(font_id, blf.ROTATION) return
def DRAW_Overlay(self, context): np_print('DRAW_Overlay_START', ';', 'NP020RM.flag = ', NP020RM.flag) flag = NP020RM.flag helper = NP020RM.helper angstep = NP020RM.angstep region = bpy.context.region rv3d = bpy.context.region_data rw = region.width rh = region.height if NP020RM.centerloc == None: centerloc = helper.location else: centerloc = NP020RM.centerloc qdef = NP020RM.qdef ndef = NP020RM.ndef alpha_0 = NP020RM.alpha_0 alpha_1 = NP020RM.alpha_1 np_print('rw, rh', rw, rh) rmin = int(min(rw, rh) / 10) if rmin == 0: rmin = 1 co2d = self.co2d if flag in ('RUNTRANSCENTER', 'RUNTRANSSTART'): co2d = view3d_utils.location_3d_to_region_2d(region, rv3d, helper.location) if qdef == None: q = get_ro_normal_from_vertical(region, rv3d, co2d)[1] n = get_ro_normal_from_vertical(region, rv3d, co2d)[0] else: q = qdef n = ndef NP020RM.q = q NP020RM.n = n #co2d_exp = (event.mouse_region_x, event.mouse_region_y) #n_exp = get_ro_normal_from_vertical(region, rv3d, co2d_exp)[0] #np_print('co2d, n, q, n_exp', co2d, n, q) # writing the dots for circle at center of scene: radius = 1 ang = 0.0 circle = [(0.0, 0.0, 0.0)] while ang < 360.0: circle.append(((cos(radians(ang)) * radius), (sin(radians(ang)) * radius), (0.0))) ang += 10 circle.append( ((cos(radians(0.0)) * radius), (sin(radians(0.0)) * radius), (0.0))) # rotating and translating the circle to user picked angle and place: circle = rotate_graphic(circle, q) circle = translate_graphic(circle, centerloc) rmax = 1 for i, co in enumerate(circle): co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) circle[i] = co for i in range(1, 18): r = (circle[0] - circle[i]).length r1 = (circle[0] - circle[i + 18]).length #if (r + r1) > rmax and abs(r - r1) < min(r, r1)/5: rmax = (r+r1)/2 #if (r + r1) > rmax and abs(r - r1) < min(r, r1)/10: rmax = r + r1 if (r + r1) > rmax and (r + r1) / 2 < rmin: rmax = (r + r1) elif (r + r1) > rmax and (r + r1) / 2 >= rmin: rmax = (r + r1) * rmin / (((r + r1) / 2) - ((r + r1) / 2) - rmin) rmax = abs(rmax) circle[i] = co np_print('rmin', rmin) np_print('rmax', rmax) if flag not in ('RUNTRANSSTART', 'RUNROTEND'): fac = (rmin * 2) / rmax NP020RM.fac = fac else: fac = NP020RM.fac radius = 1 * fac ang = 0.0 circle = [(0.0, 0.0, 0.0)] while ang < 360.0: circle.append(((cos(radians(ang)) * radius), (sin(radians(ang)) * radius), (0.0))) ang += 10 circle.append( ((cos(radians(0.0)) * radius), (sin(radians(0.0)) * radius), (0.0))) if flag == 'RUNTRANSCENTER': instruct = 'place center point' keys_aff = 'LMB / ENT / NUMPAD ENT - confirm, CTRL - snap' keys_nav = '' keys_neg = 'ESC - quit' r1 = 1 r2 = 1.5 walpha = construct_roto_widget(alpha_0, alpha_1, fac, r1, r2, angstep) r1 = 1.5 r2 = 2 wbeta_L = construct_roto_widget(90, 0, fac, r1, r2, angstep) r1 = 1.5 r2 = 2 wbeta_D = construct_roto_widget(0, 90, fac, r1, r2, angstep) elif flag == 'BGLPLANE': instruct = 'choose rotation plane' keys_aff = 'LMB / ENT / NUMPAD ENT - confirm' keys_nav = 'MMB / SCROLL - navigate' keys_neg = 'ESC - quit' ro_hor, isohipse = get_ro_x_from_iso(region, rv3d, co2d, centerloc) NP020RM.ro_hor = copy.deepcopy(ro_hor) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(1.0, 0.0, 0.0, 1.0) bgl.glLineWidth(2) bgl.glBegin(bgl.GL_LINE_STRIP) for co in isohipse: co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) bgl.glVertex2f(*co) bgl.glEnd() bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glPointSize(4) bgl.glBegin(bgl.GL_POINTS) for co in isohipse: co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) bgl.glVertex2f(*co) bgl.glEnd() r1 = 1 r2 = 1.5 walpha = construct_roto_widget(alpha_0, alpha_1, fac, r1, r2, angstep) r1 = 1.5 r2 = 2 wbeta_L = construct_roto_widget(90, 0, fac, r1, r2, angstep) r1 = 1.5 r2 = 2 wbeta_D = construct_roto_widget(0, 90, fac, r1, r2, angstep) circle = rotate_graphic(circle, ro_hor) walpha = rotate_graphic(walpha, ro_hor) wbeta_L = rotate_graphic(wbeta_L, ro_hor) wbeta_D = rotate_graphic(wbeta_D, ro_hor) circle = rotate_graphic(circle, q) walpha = rotate_graphic(walpha, q) wbeta_L = rotate_graphic(wbeta_L, q) wbeta_D = rotate_graphic(wbeta_D, q) elif flag == 'RUNTRANSSTART': instruct = 'place start point' keys_aff = 'LMB / ENT / NUMPAD ENT - confirm, CTRL - snap' keys_nav = '' keys_neg = 'ESC - quit' hloc = helper.location #np_print('hloc', hloc) hlocb = hloc + n #np_print('hlocb', hlocb) #np_print('centerloc, n', centerloc, n) proj_start = mathutils.geometry.intersect_line_plane( helper.location, (helper.location + n), centerloc, n) NP020RM.proj_start = proj_start if proj_start == centerloc: proj = centerloc + Vector((0.0, 0.0, 0.001)) #np_print('proj_start' , proj_start) alpha_0, isohipse = get_angle_from_iso_planar(centerloc, n, proj_start) alpha_1 = alpha_0 NP020RM.alpha_0 = alpha_0 NP020RM.alpha_1 = alpha_1 np_print('alpha_0', alpha_0) ro_hor = NP020RM.ro_hor bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(1.0, 0.0, 0.0, 1.0) bgl.glLineWidth(2) bgl.glBegin(bgl.GL_LINE_STRIP) for co in isohipse: co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) bgl.glVertex2f(*co) bgl.glEnd() bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glPointSize(4) bgl.glBegin(bgl.GL_POINTS) for co in isohipse: co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) bgl.glVertex2f(*co) bgl.glEnd() r1 = 1 r2 = 1.5 walpha = construct_roto_widget(alpha_0, alpha_1, fac, r1, r2, angstep) r1 = 1.5 r2 = 2 wbeta_L = construct_roto_widget(alpha_1, 0, fac, r1, r2, angstep) r1 = 1.5 r2 = 2 wbeta_D = construct_roto_widget(0, alpha_0, fac, r1, r2, angstep) circle = rotate_graphic(circle, ro_hor) walpha = rotate_graphic(walpha, ro_hor) wbeta_L = rotate_graphic(wbeta_L, ro_hor) wbeta_D = rotate_graphic(wbeta_D, ro_hor) circle = rotate_graphic(circle, q) walpha = rotate_graphic(walpha, q) wbeta_L = rotate_graphic(wbeta_L, q) wbeta_D = rotate_graphic(wbeta_D, q) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(0.5, 0.5, 1.0, 1.0) bgl.glLineWidth(1) bgl.glBegin(bgl.GL_LINE_STRIP) points = (helper.location, proj_start, centerloc) for co in points: co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) bgl.glVertex2f(*co) bgl.glEnd() co = view3d_utils.location_3d_to_region_2d(region, rv3d, proj_start) bgl.glColor4f(1.0, 1.0, 1.0, 1.0) bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glPointSize(14) bgl.glEnable(bgl.GL_BLEND) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex2f(*co) bgl.glEnd() elif flag == 'RUNROTEND': instruct = 'place end point' keys_aff = 'LMB / ENT / NUMPAD ENT - confirm, CTRL - snap' keys_nav = '' keys_neg = 'ESC - quit' for k, v in bpy.context.active_operator.properties.items(): np_print(k, v) alpha_0 = NP020RM.alpha_0_def hloc = helper.location startloc = NP020RM.startloc endloc = helper.location proj_start = NP020RM.proj_start #np_print('hloc', hloc) hlocb = hloc + n #np_print('hlocb', hlocb) #np_print('centerloc, n', centerloc, n) proj_end = mathutils.geometry.intersect_line_plane( helper.location, (helper.location + n), centerloc, n) if proj_end == centerloc: proj_end = centerloc + Vector((0.0, 0.0, 0.001)) #np_print('proj_end' , proj_end) alpha = get_angle_vector_from_vector(centerloc, proj_start, proj_end) alpha_1 = alpha_0 + alpha np_print('alpha_0', alpha_0) ro_hor = NP020RM.ro_hor rot_helper_0 = NP020RM.rot_helper_0 np_print('rot_helper_0 =', rot_helper_0) rot_helper_1 = helper.rotation_euler np_print('rot_helper_1 =', rot_helper_1) alpha_real = get_eul_z_angle_diffffff_in_rotated_system( rot_helper_0, rot_helper_1, ndef) np_print('alpha_real =', alpha_real) delta = (abs(alpha_real) - (360 * int(abs(alpha_real) / 360))) if alpha_real >= 0: if alpha_0 + delta < 360: alpha_1 = alpha_0 + delta else: alpha_1 = delta - (360 - alpha_0) else: if delta < alpha_0: alpha_1 = alpha_0 alpha_0 = alpha_1 - delta else: alpha_1 = alpha_0 alpha_0 = 360 - (delta - alpha_0) if alpha_1 == alpha_0: alpha_1 = alpha_0 + 0.001 r1 = 1 r2 = 1.5 walpha = construct_roto_widget(alpha_0, alpha_1, fac, r1, r2, angstep) r1 = 1.5 r2 = 2 wbeta_L = construct_roto_widget(alpha_1, alpha_0, fac, r1, r2, angstep) ''' r1 = 1.5 r2 = 2 wbeta_D = construct_roto_widget(0, alpha_0, fac, r1, r2, angstep) ''' circle = rotate_graphic(circle, ro_hor) walpha = rotate_graphic(walpha, ro_hor) wbeta_L = rotate_graphic(wbeta_L, ro_hor) #wbeta_D = rotate_graphic(wbeta_D, ro_hor) circle = rotate_graphic(circle, q) walpha = rotate_graphic(walpha, q) wbeta_L = rotate_graphic(wbeta_L, q) #wbeta_D = rotate_graphic(wbeta_D, q) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(0.5, 0.5, 1.0, 1.0) bgl.glLineWidth(1) bgl.glBegin(bgl.GL_LINE_STRIP) points = (helper.location, proj_end, centerloc, proj_start) for co in points: co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) bgl.glVertex2f(*co) bgl.glEnd() co = view3d_utils.location_3d_to_region_2d(region, rv3d, proj_end) bgl.glColor4f(1.0, 1.0, 1.0, 1.0) bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glPointSize(14) bgl.glEnable(bgl.GL_BLEND) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex2f(*co) bgl.glEnd() # NUMERICAL ANGLE: bgl.glColor4f(0.0, 0.0, 0.0, 1.0) font_id = 0 blf.size(font_id, 20, 72) ang_pos = view3d_utils.location_3d_to_region_2d( region, rv3d, centerloc) blf.position(font_id, ang_pos[0] + 2, ang_pos[1] - 2, 0) blf.draw(font_id, str(round(alpha_real, 2))) bgl.glColor4f(1.0, 1.0, 1.0, 1.0) blf.position(font_id, ang_pos[0], ang_pos[1], 0) blf.draw(font_id, str(round(alpha_real, 2))) # DRAWING START: bgl.glEnable(bgl.GL_BLEND) # ON-SCREEN INSTRUCTIONS: display_instructions(region, rv3d, instruct, keys_aff, keys_nav, keys_neg) np_print('centerloc', centerloc) circle = translate_graphic(circle, centerloc) walpha = translate_graphic(walpha, centerloc) wbeta_L = translate_graphic(wbeta_L, centerloc) if flag is not 'RUNROTEND': wbeta_D = translate_graphic(wbeta_D, centerloc) np_print('rv3d', rv3d) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(1.0, 1.0, 1.0, 0.6) bgl.glLineWidth(1) bgl.glBegin(bgl.GL_LINE_STRIP) for i, co in enumerate(circle): co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) bgl.glVertex2f(*co) circle[i] = co bgl.glEnd() np_print('centerloc', centerloc) # drawing of walpha contours: bgl.glColor4f(1.0, 1.0, 1.0, 0.6) bgl.glLineWidth(1) bgl.glBegin(bgl.GL_LINE_STRIP) for i, co in enumerate(walpha): co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) bgl.glVertex2f(*co) walpha[i] = co bgl.glEnd() #np_print('walpha', walpha) bgl.glColor4f(0.0, 0.0, 0.0, 0.5) # drawing of walpha fields: np_print('alpha_0, alpha_1 =', alpha_0, alpha_1) if alpha_1 >= alpha_0: alpha = alpha_1 - alpha_0 else: alpha = alpha_1 + (360 - alpha_0) sides = int(alpha / NP020RM.angstep) + 1 bgl.glBegin(bgl.GL_TRIANGLE_FAN) bgl.glVertex2f(*walpha[0]) bgl.glVertex2f(*walpha[1]) bgl.glVertex2f(*walpha[2]) bgl.glVertex2f(*walpha[(sides * 2) + 1]) bgl.glEnd() for i in range(1, sides): bgl.glBegin(bgl.GL_TRIANGLE_FAN) bgl.glVertex2f(*walpha[((sides * 2) + 2) - i]) bgl.glVertex2f(*walpha[i + 1]) bgl.glVertex2f(*walpha[2 + i]) bgl.glVertex2f(*walpha[((sides * 2) + 2) - (i + 1)]) bgl.glEnd() # drawing of wbeta_L contours: bgl.glColor4f(1.0, 1.0, 1.0, 0.6) bgl.glLineWidth(1) bgl.glBegin(bgl.GL_LINE_STRIP) for i, co in enumerate(wbeta_L): co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) bgl.glVertex2f(*co) wbeta_L[i] = co bgl.glEnd() #np_print('wbeta_L', wbeta_L) bgl.glColor4f(0.65, 0.85, 1.0, 0.35) # drawing of wbeta_L fields: if flag == 'RUNROTEND': if alpha_0 >= alpha_1: alpha = alpha_0 - alpha_1 else: alpha = alpha_0 + (360 - alpha_1) else: alpha = 360 - alpha_1 sides = int(alpha / NP020RM.angstep) + 1 bgl.glBegin(bgl.GL_TRIANGLE_FAN) bgl.glVertex2f(*wbeta_L[0]) bgl.glVertex2f(*wbeta_L[1]) bgl.glVertex2f(*wbeta_L[2]) bgl.glVertex2f(*wbeta_L[(sides * 2) + 1]) bgl.glEnd() for i in range(1, sides): bgl.glBegin(bgl.GL_TRIANGLE_FAN) bgl.glVertex2f(*wbeta_L[((sides * 2) + 2) - i]) bgl.glVertex2f(*wbeta_L[i + 1]) bgl.glVertex2f(*wbeta_L[2 + i]) bgl.glVertex2f(*wbeta_L[((sides * 2) + 2) - (i + 1)]) bgl.glEnd() if flag is not 'RUNROTEND': # drawing of wbeta_D contours: bgl.glColor4f(1.0, 1.0, 1.0, 0.6) bgl.glLineWidth(1) bgl.glBegin(bgl.GL_LINE_STRIP) for i, co in enumerate(wbeta_D): co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) bgl.glVertex2f(*co) wbeta_D[i] = co bgl.glEnd() #np_print('wbeta_D', wbeta_D) bgl.glColor4f(0.35, 0.6, 0.75, 0.35) # drawing of wbeta_D fields: alpha = alpha_0 sides = int(alpha / NP020RM.angstep) + 1 bgl.glBegin(bgl.GL_TRIANGLE_FAN) bgl.glVertex2f(*wbeta_D[0]) bgl.glVertex2f(*wbeta_D[1]) bgl.glVertex2f(*wbeta_D[2]) bgl.glVertex2f(*wbeta_D[(sides * 2) + 1]) bgl.glEnd() for i in range(1, sides): bgl.glBegin(bgl.GL_TRIANGLE_FAN) bgl.glVertex2f(*wbeta_D[((sides * 2) + 2) - i]) bgl.glVertex2f(*wbeta_D[i + 1]) bgl.glVertex2f(*wbeta_D[2 + i]) bgl.glVertex2f(*wbeta_D[((sides * 2) + 2) - (i + 1)]) bgl.glEnd() #ENDING bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def h_clip_end(): bgl.glDisable(bgl.GL_SCISSOR_TEST)
def snap_get(self, mval, main_snap_obj=None): ret = None, None, None self.mval[:] = mval snap_vert = self._snap_mode & VERT != 0 snap_edge = self._snap_mode & EDGE != 0 snap_face = self._snap_mode & FACE != 0 _Internal.gpu_Indices_enable_state() self._offscreen.bind() #bgl.glDisable(bgl.GL_DITHER) # dithering and AA break color coding, so disable # #multisample_enabled = bgl.glIsEnabled(bgl.GL_MULTISAMPLE) #bgl.glDisable(bgl.GL_MULTISAMPLE) bgl.glEnable(bgl.GL_DEPTH_TEST) proj_mat = self.rv3d.perspective_matrix.copy() if self.proj_mat != proj_mat: self.proj_mat = proj_mat _Internal.gpu_Indices_set_ProjectionMatrix(self.proj_mat) self.update_drawing() ray_dir, ray_orig = self.get_ray(mval) for i, snap_obj in enumerate(self.snap_objects[self.drawn_count:], self.drawn_count): obj = snap_obj.data[0] try: bbmin = Vector(obj.bound_box[0]) bbmax = Vector(obj.bound_box[6]) except ReferenceError: self.snap_objects.remove(snap_obj) continue if bbmin != bbmax: MVP = proj_mat @ snap_obj.mat mat_inv = snap_obj.mat.inverted() ray_orig_local = mat_inv @ ray_orig ray_dir_local = mat_inv.to_3x3() @ ray_dir in_threshold = _Internal.intersect_boundbox_threshold( self, MVP, ray_orig_local, ray_dir_local, bbmin, bbmax) else: proj_co = _Internal.project_co_v3(self, snap_obj.mat.translation) dist = self.mval - proj_co in_threshold = abs(dist.x) < self._dist_px and abs( dist.y) < self._dist_px #snap_obj.data[1] = primitive_point if in_threshold: if len(snap_obj.data) == 1: from .mesh_drawing import GPU_Indices_Mesh is_bound = obj.display_type == 'BOUNDS' draw_face = snap_face and not is_bound and obj.display_type != 'WIRE' draw_edge = snap_edge and not is_bound draw_vert = snap_vert and not is_bound snap_obj.data.append( GPU_Indices_Mesh(obj, draw_face, draw_edge, draw_vert)) snap_obj.data[1].set_draw_mode(snap_face, snap_edge, snap_vert) snap_obj.data[1].set_ModelViewMatrix(snap_obj.mat) if snap_obj == main_snap_obj: snap_obj.data[1].Draw(self._offset_cur, -0.0001) else: snap_obj.data[1].Draw(self._offset_cur) self._offset_cur += snap_obj.data[1].get_tot_elems() tmp = self.snap_objects[self.drawn_count] self.snap_objects[self.drawn_count] = self.snap_objects[i] self.snap_objects[i] = tmp self.drawn_count += 1 bgl.glReadBuffer(bgl.GL_COLOR_ATTACHMENT0) bgl.glReadPixels( int(self.mval[0]) - self._dist_px, int(self.mval[1]) - self._dist_px, self.threshold, self.threshold, bgl.GL_RED_INTEGER, bgl.GL_UNSIGNED_INT, self._snap_buffer) #bgl.glReadBuffer(bgl.GL_BACK) #import numpy as np #a = np.array(self._snap_buffer) #print(a) snap_obj, index = self._get_nearest_index() #print("index:", index) if snap_obj: ret = self._get_loc(snap_obj, index) bgl.glDisable(bgl.GL_DEPTH_TEST) self._offscreen.unbind() _Internal.gpu_Indices_restore_state() return (snap_obj, *ret)
def draw_to_viewport(view_min, view_max, show_extra, label_counter, tilegrid, sprytile_data, cursor_loc, region, rv3d, middle_btn, context): """Draw the offscreen texture into the viewport""" # Prepare some data that will be used for drawing grid_size = SprytileGui.loaded_grid.grid tile_sel = SprytileGui.loaded_grid.tile_selection padding = SprytileGui.loaded_grid.padding margin = SprytileGui.loaded_grid.margin is_pixel = sprytile_utils.grid_is_single_pixel(SprytileGui.loaded_grid) # Draw work plane SprytileGui.draw_work_plane(grid_size, sprytile_data, cursor_loc, region, rv3d, middle_btn) # Setup GL for drawing the offscreen texture bgl.glColor4f(1.0, 1.0, 1.0, 1.0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, SprytileGui.texture) # Backup texture filter old_mag_filter = Buffer(bgl.GL_INT, [1]) bgl.glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, old_mag_filter) # Set texture filter bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST) bgl.glEnable(bgl.GL_TEXTURE_2D) bgl.glEnable(bgl.GL_BLEND) # Draw the preview tile if middle_btn is False: SprytileGui.draw_preview_tile(context, region, rv3d) # Calculate actual view size view_size = int(view_max.x - view_min.x), int(view_max.y - view_min.y) # Save the original scissor box, and then set new scissor setting scissor_box = bgl.Buffer(bgl.GL_INT, [4]) bgl.glGetIntegerv(bgl.GL_SCISSOR_BOX, scissor_box) bgl.glScissor( int(view_min.x) + scissor_box[0], int(view_min.y) + scissor_box[1], view_size[0], view_size[1]) # Draw the tile select UI SprytileGui.draw_tile_select_ui(view_min, view_max, view_size, SprytileGui.tex_size, grid_size, tile_sel, padding, margin, show_extra, is_pixel) # restore opengl defaults bgl.glScissor(scissor_box[0], scissor_box[1], scissor_box[2], scissor_box[3]) bgl.glLineWidth(1) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, old_mag_filter[0]) # Draw label if label_counter > 0: import math def ease_out_circ(t, b, c, d): t /= d t -= 1 return c * math.sqrt(1 - t * t) + b font_id = 0 font_size = 16 pad = 5 box_pad = font_size + (pad * 2) fade = label_counter fade = ease_out_circ(fade, 0, SprytileGui.label_frames, SprytileGui.label_frames) fade /= SprytileGui.label_frames bgl.glColor4f(0.0, 0.0, 0.0, 0.75 * fade) bgl.glBegin(bgl.GL_QUADS) uv = [(0, 0), (0, 1), (1, 1), (1, 0)] vtx = [(view_min.x, view_max.y), (view_min.x, view_max.y + box_pad), (view_max.x, view_max.y + +box_pad), (view_max.x, view_max.y)] for i in range(4): glTexCoord2f(uv[i][0], uv[i][1]) glVertex2f(vtx[i][0], vtx[i][1]) bgl.glEnd() bgl.glColor4f(1.0, 1.0, 1.0, 1.0 * fade) blf.size(font_id, font_size, 72) x_pos = view_min.x + pad y_pos = view_max.y + pad label_string = "%dx%d" % (tilegrid.grid[0], tilegrid.grid[1]) if tilegrid.name != "": label_string = "%s - %s" % (label_string, tilegrid.name) blf.position(font_id, x_pos, y_pos, 0) blf.draw(font_id, label_string) bgl.glDisable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_TEXTURE_2D) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback_px(self, context): # circle graphic, text, and slider unify_settings = bpy.context.tool_settings.unified_paint_settings strength = unify_settings.strength if self.uni_str else self.brush.strength size = unify_settings.size if self.uni_size else self.brush.size if self.graphic: bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(self.brushcolor.r, self.brushcolor.g, self.brushcolor.b, strength * 0.25) bgl.glBegin(bgl.GL_POLYGON) for x, y in self.circlepoints: bgl.glVertex2i( int(size * x) + self.cur[0], int(size * y) + self.cur[1]) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0) if self.text != 'NONE' and self.doingstr: if self.text == 'MEDIUM': fontsize = 11 elif self.text == 'LARGE': fontsize = 22 else: fontsize = 8 font_id = 0 blf.size(font_id, fontsize, 72) blf.shadow(font_id, 0, 0.0, 0.0, 0.0, 1.0) blf.enable(font_id, blf.SHADOW) if strength < 0.001: text = "0.001" else: text = str(strength)[0:5] textsize = blf.dimensions(font_id, text) xpos = self.start[0] + self.offset[0] ypos = self.start[1] + self.offset[1] bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(self.backcolor.r, self.backcolor.g, self.backcolor.b, 0.5) bgl.glBegin(bgl.GL_POLYGON) for x, y in self.rectpoints: bgl.glVertex2i( int(textsize[0] * x) + xpos, int(textsize[1] * y) + ypos) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0) blf.position(font_id, xpos, ypos, 0) blf.draw(font_id, text) blf.disable(font_id, blf.SHADOW) if self.slider != 'NONE' and self.doingstr: bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(self.backcolor.r, self.backcolor.g, self.backcolor.b, 0.5) xpos = self.start[0] + self.offset[0] - self.sliderwidth + ( 32 if self.text == 'MEDIUM' else 64 if self.text == 'LARGE' else 23) ypos = self.start[1] + self.offset[ 1] - self.sliderheight # + (1 if self.slider != 'SMALL' else 0) if strength < 1.0: sliderscale = strength elif strength > 5.0: sliderscale = strength / 10 elif strength > 2.0: sliderscale = strength / 5 else: sliderscale = strength / 2 bgl.glBegin(bgl.GL_POLYGON) for x, y in self.rectpoints: bgl.glVertex2i( int(self.sliderwidth * x) + xpos, int(self.sliderheight * y) + ypos - 1) bgl.glEnd() bgl.glColor4f(self.frontcolor.r, self.frontcolor.g, self.frontcolor.b, 0.8) bgl.glBegin(bgl.GL_POLYGON) for x, y in self.rectpoints: bgl.glVertex2i( int(self.sliderwidth * x * sliderscale) + xpos, int(self.sliderheight * y * 0.75) + ypos) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def view_3d_geom(context, args): """ draws the batches """ geom, config = args bgl.glEnable(bgl.GL_BLEND) if config.draw_polys: if config.draw_gl_wireframe: bgl.glPolygonMode(bgl.GL_FRONT_AND_BACK, bgl.GL_LINE) if config.draw_gl_polygonoffset: bgl.glEnable(bgl.GL_POLYGON_OFFSET_FILL) bgl.glPolygonOffset(1.0, 1.0) if config.shade_mode == 'fragment': p_batch = batch_for_shader(config.p_shader, 'TRIS', {"position": geom.p_vertices}, indices=geom.p_indices) config.p_shader.bind() matrix = context.region_data.perspective_matrix config.p_shader.uniform_float("viewProjectionMatrix", matrix) config.p_shader.uniform_float("brightness", 0.5) else: if config.uniform_pols: p_batch = batch_for_shader(config.p_shader, 'TRIS', {"pos": geom.p_vertices}, indices=geom.p_indices) config.p_shader.bind() config.p_shader.uniform_float("color", config.poly_color[0][0]) else: p_batch = batch_for_shader(config.p_shader, 'TRIS', { "pos": geom.p_vertices, "color": geom.p_vertex_colors }, indices=geom.p_indices) config.p_shader.bind() p_batch.draw(config.p_shader) if config.draw_gl_polygonoffset: bgl.glDisable(bgl.GL_POLYGON_OFFSET_FILL) if config.draw_gl_wireframe: bgl.glPolygonMode(bgl.GL_FRONT_AND_BACK, bgl.GL_FILL) if config.draw_edges: bgl.glLineWidth(config.line_width) if config.draw_dashed: shader = config.dashed_shader batch = batch_for_shader(shader, 'LINES', {"inPos": geom.e_vertices}, indices=geom.e_indices) shader.bind() matrix = context.region_data.perspective_matrix shader.uniform_float("u_mvp", matrix) shader.uniform_float("u_resolution", config.u_resolution) shader.uniform_float("u_dashSize", config.u_dash_size) shader.uniform_float("u_gapSize", config.u_gap_size) shader.uniform_float("m_color", geom.e_vertex_colors[0]) batch.draw(shader) else: if config.uniform_edges: e_batch = batch_for_shader(config.e_shader, 'LINES', {"pos": geom.e_vertices}, indices=geom.e_indices) config.e_shader.bind() config.e_shader.uniform_float("color", config.edge_color[0][0]) e_batch.draw(config.e_shader) else: e_batch = batch_for_shader(config.e_shader, 'LINES', { "pos": geom.e_vertices, "color": geom.e_vertex_colors }, indices=geom.e_indices) config.e_shader.bind() e_batch.draw(config.e_shader) bgl.glLineWidth(1) if config.draw_verts: bgl.glPointSize(config.point_size) if config.uniform_verts: v_batch = batch_for_shader(config.v_shader, 'POINTS', {"pos": geom.v_vertices}) config.v_shader.bind() config.v_shader.uniform_float("color", config.vector_color[0][0]) else: v_batch = batch_for_shader(config.v_shader, 'POINTS', { "pos": geom.v_vertices, "color": geom.points_color }) config.v_shader.bind() v_batch.draw(config.v_shader) bgl.glPointSize(1) bgl.glEnable(bgl.GL_BLEND)
def Draw_hdr_callback(self, context): if context.area != Hdr.view3d_area: return elif context.area.type == 'PROPERTIES' and \ context.space_data.context != 'WORLD': return # Check if window area has changed for sticky zoom theHdr = Hdr.object[0] if Hdr.region.width < Hdr.saved_region_width: diff = Hdr.saved_region_width - Hdr.region.width if theHdr.origin.x + theHdr.width > Hdr.saved_region_width: if theHdr.origin.x > 0: theHdr.origin.x -= diff else: theHdr.width -= diff else: if Hdr.toolProps is not None: if Hdr.toolProps.width > Hdr.toolProps_width: theHdr.origin.x -= diff Hdr.toolProps_width = Hdr.toolProps.width if theHdr.origin.x < 0: theHdr.origin.x += diff else: diff = Hdr.region.width - Hdr.saved_region_width if theHdr.width > Hdr.saved_region_width: theHdr.width += diff else: if Hdr.toolProps is not None: if Hdr.toolProps.width < Hdr.toolProps_width: theHdr.origin.x += diff Hdr.toolProps_width = Hdr.toolProps.width theHdr.set_dimensions(theHdr.width) Hdr.saved_region_width = Hdr.region.width zAzim = theHdr.width / 2 azimFac = zAzim / 180 zElev = theHdr.height / 2 elevFac = zElev / 90 crossChange = True if not Hdr.action == 'PAN': x = Hdr.mouse.x y = Hdr.mouse.y if x < theHdr.origin.x or x > theHdr.origin.x + theHdr.width: crossChange = False x = 0 else: testBoundary = theHdr.origin.x + theHdr.width if testBoundary < Hdr.region.width: rightBoundary = testBoundary else: rightBoundary = Hdr.region.width if x > rightBoundary: crossChange = False x = rightBoundary cX = x - zAzim - theHdr.origin.x if azimFac: newAzimuth = cX / azimFac else: newAzimuth = 0.0 if y < theHdr.origin.y or y < 0: crossChange = False y = 0 elif y > theHdr.origin.y + theHdr.height: crossChange = False y = theHdr.origin.y + theHdr.height cY = y - zElev - theHdr.origin.y if elevFac: newElevation = cY / elevFac else: newElevation = 0.0 if newElevation == Hdr.elevation and newAzimuth == Hdr.azimuth: crossChange = False else: Hdr.elevation = newElevation Hdr.azimuth = newAzimuth else: if Hdr.grab.offset.x < Hdr.grab.spot.x: off = Hdr.grab.spot.x - Hdr.grab.offset.x theHdr.origin.x -= off else: off = Hdr.grab.offset.x - Hdr.grab.spot.x theHdr.origin.x += off if Hdr.grab.offset.y < Hdr.grab.spot.y: off = Hdr.grab.spot.y - Hdr.grab.offset.y theHdr.origin.y -= off else: off = Hdr.grab.offset.y - Hdr.grab.spot.y theHdr.origin.y += off Hdr.grab.spot.x = Hdr.mouse.x Hdr.grab.spot.y = Hdr.mouse.y Lx = theHdr.origin.x Ly = theHdr.origin.y # --------------------- # Draw a textured quad # --------------------- bgl.glEnable(bgl.GL_BLEND) if Hdr.glImage.bindcode == 0: Hdr.load_gl_image() bgl.glBindTexture(bgl.GL_TEXTURE_2D, Hdr.glImage.bindcode) bgl.glEnable(bgl.GL_TEXTURE_2D) bgl.glColor4f(1.0, 1.0, 1.0, Hdr.object[0].opacity) bgl.glBegin(bgl.GL_QUADS) bgl.glTexCoord2f(0.0, 0.0) bgl.glVertex2f(Lx, Ly) bgl.glTexCoord2f(1.0, 0.0) bgl.glVertex2f(Lx + theHdr.width, Ly) bgl.glTexCoord2f(1.0, 1.0) bgl.glVertex2f(Lx + theHdr.width, Ly + theHdr.height) bgl.glTexCoord2f(0.0, 1.0) bgl.glVertex2f(Lx, theHdr.height + Ly) bgl.glEnd() bgl.glDisable(bgl.GL_TEXTURE_2D) # --------------------- # draw the crosshair # --------------------- x = theHdr.width / 2.0 if crossChange and not Hdr.lockCrosshair: Sun.SP.HDR_azimuth = degToRad(newAzimuth + 180) azimuth = ((radToDeg(Sun.SP.HDR_azimuth) - 180) * x / 180.0) + x bgl.glEnable(bgl.GL_BLEND) bgl.glEnable(bgl.GL_LINES) bgl.glLineWidth(1.0) alpha = 0.8 color = (0.4, 0.4, 0.4, alpha) bgl.glColor4f(color[0], color[1], color[2], color[3]) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(Lx + azimuth, Ly) bgl.glVertex2f(Lx + azimuth, Ly + theHdr.height) bgl.glEnd() y = theHdr.height / 2.0 if crossChange and not Hdr.lockCrosshair: Sun.SP.HDR_elevation = newElevation elevation = (Sun.SP.HDR_elevation * y / 90.0) + y bgl.glColor4f(color[0], color[1], color[2], color[3]) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(Lx, Ly + elevation) bgl.glVertex2f(Lx + theHdr.width, Ly + elevation) bgl.glEnd() # --------------------- # draw the border # --------------------- bgl.glDisable(bgl.GL_BLEND) color = (0.6, 0.6, .6, 1.0) bgl.glColor4f(color[0], color[1], color[2], color[3]) bgl.glBegin(bgl.GL_LINE_LOOP) bgl.glVertex2f(Lx, Ly) bgl.glVertex2f(Lx + theHdr.width, Ly) bgl.glVertex2f(Lx + theHdr.width, Ly + theHdr.height) bgl.glVertex2f(Lx, theHdr.height + Ly) bgl.glVertex2f(Lx, Ly) bgl.glEnd() bgl.glLineWidth(1.0) bgl.glDisable(bgl.GL_LINES) bgl.glFlush()
def restore_opengl_defaults(): bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND)
def draw_callback_2d(self, context): """Callback function for 2d drawing. Args: context: Returns: """ active = context.object selected = context.selected_objects if active and selected: objects = set(selected + [active]) else: objects = [] wm = context.window_manager # code that can be used to draw on 2d surface in 3d mode, not used any more # due to separate handlers for 2d and 3d # bgl.glMatrixMode(bgl.GL_PROJECTION) # bgl.glLoadIdentity() # bgl.gluOrtho2D(0, bpy.context.region.width, 0, bpy.context.region.height) # bgl.glMatrixMode(bgl.GL_MODELVIEW) # bgl.glLoadIdentity() bgl.glEnable(bgl.GL_BLEND) # submechanisms if objects and wm.draw_submechanisms: submechanism_roots = [ obj for obj in bpy.data.objects if 'submechanism/name' in obj ] # draw spanning trees for root in submechanism_roots: if 'submechanism/spanningtree' in root: if set(root['submechanism/spanningtree']).intersection( set(bpy.context.selected_objects)): linecolor = colors['submechanism'] linewidth = 5 else: linecolor = (*colors['submechanism'][:3], 0.4) linewidth = 3 draw_path(root['submechanism/spanningtree'], color=linecolor, width=linewidth) # joint['submechanism/independent'], # joint['submechanism/active']) avgpos = Vector() for obj in root['submechanism/spanningtree']: avgpos += obj.matrix_world.translation origin = to2d(avgpos / len(root['submechanism/spanningtree'])) draw_textbox( root['submechanism/name'], origin, textsize=8, textcolor=linecolor, backgroundcolor=colors['background'], offset=Vector((-30, 0)), ) # joints if objects and wm.draw_jointnames: for obj in [obj for obj in objects if obj.phobostype == 'link']: origin = to2d(obj.matrix_world.translation) draw_textbox( nUtils.getObjectName(obj, 'joint'), origin, textsize=6, textcolor=colors['dark_grey'], backgroundcolor=colors['bright_background'], rightalign=True, offset=Vector((-16, 0)), ) if wm.draw_submechanisms and 'submechanism/jointname' in obj: draw_textbox( obj['submechanism/jointname'], origin, textsize=6, textcolor=colors['dark_grey'], backgroundcolor=(*colors['submechanism'][:3], 0.7), offset=Vector((16, 0)), ) # interfaces if selected: for interface in [ obj for obj in selected if obj.phobostype == 'interface' ]: color = interface.active_material.diffuse_color maxc = max(color) color = [0.6 + c / maxc * 0.4 for c in color] bgcolor = [ c * 0.4 for c in interface.active_material.diffuse_color ] draw_textbox( nUtils.getObjectName(interface), to2d(interface.matrix_world.translation), textsize=6, textcolor=(*color, 1.0 if interface.show_name else 0.4), backgroundcolor=(*bgcolor, 1.0) if interface.show_name else colors['background'], linewidth=3 if interface.show_name else 2, ) # progress bar if wm.draw_progress and context.window_manager.progress not in [0, 1]: draw_progressbar(wm.progress) # log messages if wm.draw_messages: for m in range(wm.phobos_msg_count): opacity = 1.0 if 1 >= m <= wm.phobos_msg_offset - 1 or m >= wm.phobos_msg_count - 2: opacity = 0.5 if wm.phobos_msg_offset > 1 > m or m >= wm.phobos_msg_count - 1: opacity = 0.1 try: msg = messages[m + wm.phobos_msg_offset] draw_message(msg['text'], msg['type'], m, opacity, offset=wm.phobos_msg_offset) except IndexError: pass # restore opengl defaults bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw(self, context): # only draw highlight if no transform are running (mouse moving is False then) and no animation playback # for performance reasons if self.current_mesh and not bpy.context.screen.is_animation_playing and self.is_mouse_moving == "True": if self.current_mesh.name in self.objects_data and self.current_vgroup: if self.current_vgroup[: 3] == 'fs_' or self.current_vgroup[: 3] == 'fs:': # start_time1 = time.time() mesh_evaluation_method = 1 if mesh_evaluation_method == 0: mesh_baked = self.current_mesh.to_mesh( preserve_all_data_layers=False, depsgraph=bpy.context.evaluated_depsgraph_get()) _verts = mesh_baked.vertices else: """ mesh_baked = bmesh.new() depsg = bpy.context.evaluated_depsgraph_get() mesh_baked.from_object(self.current_mesh, depsg, deform=True, face_normals=False) mesh_baked.verts.ensure_lookup_table() _verts = mesh_baked.verts """ deps = bpy.context.evaluated_depsgraph_get() object_eval = self.current_mesh.evaluated_get(deps) mesh_baked = object_eval.to_mesh( preserve_all_data_layers=False, depsgraph=bpy.context.evaluated_depsgraph_get()) _verts = mesh_baked.vertices # start_time1 = time.time() mw = self.current_mesh.matrix_world object_data = self.objects_data[self.current_mesh.name] verts_list = object_data["vertex_groups_dict"][ self.current_vgroup] # verts_co = [mw @ Vector((round(_verts[v].co[0], 2), round(_verts[v].co[1], 2), round(_verts[ # v].co[2], 2))) for v in verts_list] verts_co = [mw @ _verts[v].co for v in verts_list] vertex_colors = [ self.highlight_color for _ in range(len(verts_co)) ] if mesh_evaluation_method == 0: try: bpy.data.meshes.remove(mesh_baked) except: pass # print('Computed verts in', time.time() - start_time1) # batch and shader batch = batch_for_shader( self.shader, 'TRIS', { "pos": verts_co, "color": vertex_colors }, indices=object_data["indices_groups_dict"][ self.current_vgroup]) # Render if self.backface_cull: bgl.glEnable(bgl.GL_CULL_FACE) bgl.glEnable(bgl.GL_BLEND) bgl.glDepthMask(bgl.GL_TRUE) # bgl.glDepthFunc(bgl.GL_LEQUAL) # bgl.glDepthRange(0.1, 1.0) # bgl.glClearDepth(1.0) # bgl.glPolygonMode(bgl.GL_FRONT, bgl.GL_FILL) # bgl.glClear(bgl.GL_DEPTH_BUFFER_BIT) batch.draw(self.shader) bgl.glDisable(bgl.GL_BLEND)
def _draw_browser(self, context): """OpenGL drawing code for the BROWSING state.""" window_region = self._window_region(context) content_width = window_region.width - ITEM_MARGIN_X * 2 content_height = window_region.height - ITEM_MARGIN_Y * 2 content_x = ITEM_MARGIN_X content_y = context.area.height - ITEM_MARGIN_Y - TARGET_ITEM_HEIGHT col_count = content_width // TARGET_ITEM_WIDTH item_width = (content_width - (col_count * ITEM_PADDING_X)) / col_count item_height = TARGET_ITEM_HEIGHT block_width = item_width + ITEM_PADDING_X block_height = item_height + ITEM_MARGIN_Y bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 0.6) bgl.glRectf(0, 0, window_region.width, window_region.height) if self.current_display_content: bottom_y = float('inf') # The -1 / +2 are for extra rows that are drawn only half at the top/bottom. first_item_idx = max( 0, int(-self.scroll_offset // block_height - 1) * col_count) items_per_page = int(content_height // item_height + 2) * col_count last_item_idx = first_item_idx + items_per_page for item_idx, item in enumerate(self.current_display_content): x = content_x + (item_idx % col_count) * block_width y = content_y - (item_idx // col_count) * block_height - self.scroll_offset item.update_placement(x, y, item_width, item_height) if first_item_idx <= item_idx < last_item_idx: # Only draw if the item is actually on screen. item.draw( highlighted=item.hits(self.mouse_x, self.mouse_y)) bottom_y = min(y, bottom_y) self.scroll_offset_space_left = window_region.height - bottom_y self.scroll_offset_max = (self.scroll_offset - self.scroll_offset_space_left + 0.25 * block_height) else: font_id = 0 text = "Communicating with Blender Cloud" bgl.glColor4f(1.0, 1.0, 1.0, 1.0) blf.size(font_id, 20, 72) text_width, text_height = blf.dimensions(font_id, text) blf.position(font_id, content_x + content_width * 0.5 - text_width * 0.5, content_y - content_height * 0.3 + text_height * 0.5, 0) blf.draw(font_id, text) bgl.glDisable(bgl.GL_BLEND)
def DRAW_Overlay(self, context): np_print('DRAW_Overlay_START', ';', 'NP020FB.flag = ', NP020FB.flag) ''' addon_prefs = context.preferences.addons[__package__].preferences badge = addon_prefs.npfb_badge badge_size = addon_prefs.npfb_badge_size dist_scale = addon_prefs.npfb_dist_scale ''' flag = NP020FB.flag helper = NP020FB.helper matrix = helper.matrix_world.to_3x3() region = bpy.context.region rv3d = bpy.context.region_data rw = region.width rh = region.height qdef = NP020FB.qdef ndef = NP020FB.ndef ro_hor_def = NP020FB.ro_hor_def constrain = NP020FB.constrain np_print('rw, rh', rw, rh) rmin = int(min(rw, rh) / 50) if rmin == 0: rmin = 1 co2d = view3d_utils.location_3d_to_region_2d(region, rv3d, helper.location) if qdef != None and constrain == False: q = qdef n = ndef pointloc = helper.location ro_hor = ro_hor_def elif qdef != None and constrain == True: q = qdef n = ndef pointloc = get_ro_normal_from_vertical(region, rv3d, co2d)[2] ro_hor = ro_hor_def else: q = get_ro_normal_from_vertical(region, rv3d, co2d)[1] n = get_ro_normal_from_vertical(region, rv3d, co2d)[0] pointloc = get_ro_normal_from_vertical(region, rv3d, co2d)[2] ro_hor, isohipse = get_ro_x_from_iso(region, rv3d, co2d, helper.location) if pointloc == Vector((0.0, 0.0, 0.0)): pointloc = helper.location np_print('n / q', n, q) NP020FB.q = q NP020FB.n = n NP020FB.pointloc = pointloc NP020FB.ro_hor = ro_hor np_print('co2d, n, q', co2d, n, q) # Acquiring factor for graphics scaling in order to be space - independent fac = get_fac_from_view_loc_plane(region, rv3d, rmin, helper.location, q) NP020FB.fac = fac symbol = [[18, 37], [21, 37], [23, 33], [26, 33]] badge_mode = 'RUN' if qdef != None: matrix.rotate(ro_hor) matrix.rotate(qdef) NP020FB.matrix = matrix if flag == 'RUNTRANS0': instruct = 'choose plane / place corner point' keys_aff = 'LMB - select, CTRL - snap, ENT - lock plane' keys_nav = '' keys_neg = 'ESC, RMB - quit' box = [ helper.location, helper.location, helper.location, helper.location, helper.location, helper.location, helper.location, helper.location ] message_main = 'CTRL+SNAP' message_aux = None aux_num = None aux_str = None elif flag == 'RUNTRANS1': instruct = 'define the width of the box' keys_aff = 'LMB - select, CTRL - snap, NUMPAD - value' keys_nav = '' keys_neg = 'ESC, RMB - quit' p0 = NP020FB.p0 box = [ p0, helper.location, helper.location, p0, p0, helper.location, helper.location, p0 ] message_main = 'CTRL+SNAP' message_aux = None aux_num = None aux_str = None elif flag == 'RUNTRANS2': instruct = 'define the length of the box' keys_aff = 'LMB - select, CTRL - snap, NUMPAD - value' keys_nav = '' keys_neg = 'ESC, RMB - quit' p0 = NP020FB.p0 p1 = NP020FB.p1 box = [ p0, p1, helper.location, p0 + (helper.location - p1), p0, p1, helper.location, p0 + (helper.location - p1) ] message_main = 'CTRL+SNAP' message_aux = None aux_num = None aux_str = None elif flag == 'RUNTRANS3': instruct = 'define the height of the box' keys_aff = 'LMB - select, CTRL - snap, NUMPAD - value' keys_nav = '' keys_neg = 'ESC, RMB - quit' p0 = NP020FB.p0 p1 = NP020FB.p1 p2 = NP020FB.p2 p3 = p0 + (p2 - p1) h = helper.location - p2 box = [p0, p1, p2, p3, p0 + h, p1 + h, p2 + h, p3 + h] message_main = 'CTRL+SNAP' message_aux = None aux_num = None aux_str = None NP020FB.box = box # ON-SCREEN INSTRUCTIONS: display_instructions(region, rv3d, instruct, keys_aff, keys_nav, keys_neg) # drawing of box: box_2d = [] for co in box: co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) box_2d.append(co) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(1.0, 1.0, 1.0, 1.0) bgl.glLineWidth(1) bgl.glBegin(bgl.GL_LINE_STRIP) for i in range(0, 4): bgl.glVertex2f(*box_2d[i]) bgl.glVertex2f(*box_2d[0]) bgl.glVertex2f(*box_2d[4]) bgl.glVertex2f(*box_2d[7]) bgl.glVertex2f(*box_2d[3]) bgl.glVertex2f(*box_2d[7]) bgl.glVertex2f(*box_2d[6]) bgl.glVertex2f(*box_2d[2]) bgl.glVertex2f(*box_2d[6]) bgl.glVertex2f(*box_2d[5]) bgl.glVertex2f(*box_2d[1]) bgl.glVertex2f(*box_2d[5]) bgl.glVertex2f(*box_2d[4]) bgl.glEnd() bgl.glColor4f(1.0, 1.0, 1.0, 0.25) bgl.glBegin(bgl.GL_TRIANGLE_FAN) boxfaces = ((0, 1, 2, 3), (0, 1, 5, 4), (1, 2, 6, 5), (2, 3, 7, 6), (3, 0, 4, 7), (4, 5, 6, 7)) for face in boxfaces: bgl.glBegin(bgl.GL_TRIANGLE_FAN) bgl.glVertex2f(*box_2d[face[0]]) bgl.glVertex2f(*box_2d[face[1]]) bgl.glVertex2f(*box_2d[face[2]]) bgl.glVertex2f(*box_2d[face[3]]) bgl.glEnd() # Drawing the small badge near the cursor with the basic instructions: display_cursor_badge(co2d, symbol, badge_mode, message_main, message_aux, aux_num, aux_str) # writing the dots for boxwidget widget at center of scene: geowidget_base = [(0.0, 0.0, 0.0), (5.0, 0.0, 0.0), (5.0, -3.0, 0.0), (0.0, -3.0, 0.0)] geowidget_top = [(0.0, 0.0, 4.0), (5.0, 0.0, 4.0), (5.0, -3.0, 4.0), (0.0, -3.0, 4.0)] geowidget_rest = [(0.0, 0.0, 0.0), (0.0, 0.0, 4.0), (5.0, 0.0, 4.0), (5.0, 0.0, 0.0), (5.0, -3.0, 0.0), (5.0, -3.0, 4.0), (0.0, -3.0, 4.0), (0.0, -3.0, 0.0)] # ON-SCREEN DISPLAY OF GEOWIDGET: display_geowidget(region, rv3d, fac, ro_hor, q, helper.location, n, qdef, geowidget_base, geowidget_top, geowidget_rest) # ON-SCREEN DISTANCES AND OTHERS: ''' if addon_prefs.npfb_suffix == 'None': suffix = None elif addon_prefs.npfb_suffix == 'km': suffix = ' km' elif addon_prefs.npfb_suffix == 'm': suffix = ' m' elif addon_prefs.npfb_suffix == 'cm': suffix = ' cm' elif addon_prefs.npfb_suffix == 'mm': suffix = ' mm' elif addon_prefs.npfb_suffix == 'nm': suffix = ' nm' elif addon_prefs.npfb_suffix == "'": suffix = "'" elif addon_prefs.npfb_suffix == '"': suffix = '"' elif addon_prefs.npfb_suffix == 'thou': suffix = ' thou' ''' # ON-SCREEN DISTANCES: display_distance_between_two_points(region, rv3d, box[0], box[1]) display_distance_between_two_points(region, rv3d, box[1], box[2]) display_distance_between_two_points(region, rv3d, box[2], box[6]) #ENDING: bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_polygon_object(mat, vertices, faces, face_color, draw_faces, draw_wires, wire_lines=None, wire_color=(0, 0, 0), face_transforms=None, wire_transforms=None): """ Draw a collider polygon object. It takes matrix, vertices (coordinates), faces (vertex index references), face color (RGB), faces drawing state (bool), wires drawing state (bool) and optional values wire lines (list of lists of vertex positions resulting in closed lines), wire color (RGB), face transformations (list of vertex indices) and wire transformations (list of vertex indices). :param mat: :param vertices: :param faces: :param face_color: :param draw_faces: :param draw_wires: :param wire_lines: :param wire_color: :param face_transforms: :param wire_transforms: :return: """ if draw_faces: for face in faces: glBegin(GL_POLYGON) glColor3f(face_color[0], face_color[1], face_color[2]) for vert in face: if face_transforms: trans = mat for transformation in face_transforms: if vert in transformation[1]: trans = trans * transformation[0] glVertex3f(*(trans * Vector(vertices[vert]))) else: glVertex3f(*(mat * Vector(vertices[vert]))) glEnd() if draw_wires: if wire_lines: # DRAW CUSTOM LINES vert_i_global = 0 for line in wire_lines: # glLineWidth(2.0) glEnable(GL_LINE_STIPPLE) glBegin(GL_LINES) glColor3f(wire_color[0], wire_color[1], wire_color[2]) for vert_i, vert1 in enumerate(line): if vert_i + 1 < len(line): vert2 = line[vert_i + 1] else: continue # SEPARATE PART TRANSFORMATIONS if wire_transforms: trans1 = trans2 = mat for transformation in wire_transforms: if vert_i_global in transformation[1]: trans1 = trans1 * transformation[0] if vert_i_global + 1 in transformation[1]: trans2 = trans2 * transformation[0] glVertex3f(*(trans1 * Vector(vert1))) glVertex3f(*(trans2 * Vector(vert2))) else: glVertex3f(*(mat * Vector(vert1))) glVertex3f(*(mat * Vector(vert2))) vert_i_global += 1 vert_i_global += 1 glEnd() glDisable(GL_LINE_STIPPLE) # glLineWidth(1.0) else: for face in faces: # glLineWidth(2.0) glEnable(GL_LINE_STIPPLE) glBegin(GL_LINES) glColor3f(wire_color[0], wire_color[1], wire_color[2]) for vert_i, vert1 in enumerate(face): if vert_i + 1 == len(face): vert2 = face[0] else: vert2 = face[vert_i + 1] if face_transforms: trans1 = mat trans2 = mat vec1 = Vector(vertices[vert1]) vec2 = Vector(vertices[vert2]) for transformation in face_transforms: if vert1 in transformation[1]: trans1 = trans1 * transformation[0] if vert2 in transformation[1]: trans2 = trans2 * transformation[0] glVertex3f(*(trans1 * vec1)) glVertex3f(*(trans2 * vec2)) else: glVertex3f(*(mat * Vector(vertices[vert1]))) glVertex3f(*(mat * Vector(vertices[vert2]))) glEnd() glDisable(GL_LINE_STIPPLE) # glLineWidth(1.0) if 0: # DEBUG: draw points from faces geometry glPointSize(3.0) glBegin(GL_POINTS) glColor3f(0.5, 0.5, 1) for vertex_i, vertex in enumerate(vertices): vec = Vector(vertex) if face_transforms: trans = mat for transformation in face_transforms: if vertex_i in transformation[1]: trans = trans * transformation[0] glVertex3f(*(trans * vec)) else: glVertex3f(*(mat * vec.to_3d())) glEnd() glPointSize(1.0) if 0: # DEBUG: draw points from lines geometry if wire_lines: glPointSize(3.0) glBegin(GL_POINTS) glColor3f(1, 0, 0.5) vert_i_global = 0 for line in wire_lines: for vert_i, vertex in enumerate(line): if vert_i + 1 < len(line): vec = Vector(vertex) else: continue if wire_transforms: trans = mat for transformation in wire_transforms: if vert_i_global in transformation[1]: trans = trans * transformation[0] glVertex3f(*(trans * vec.to_3d())) else: glVertex3f(*(mat * vec.to_3d())) vert_i_global += 1 vert_i_global += 1 glEnd() glPointSize(1.0)
def mesh_check_draw_callback(): obj = bpy.context.object if obj and obj.type == 'MESH': if draw_enabled[0]: mesh = obj.data matrix_world = obj.matrix_world glLineWidth(edge_width[0]) if bpy.context.mode == 'EDIT_MESH': use_occlude = True if bm_old[0] is None or not bm_old[0].is_valid: bm = bm_old[0] = bmesh.from_edit_mesh(mesh) else: bm = bm_old[0] no_depth = not bpy.context.space_data.use_occlude_geometry if no_depth: glDisable(GL_DEPTH_TEST) use_occlude = False if finer_lines[0]: glLineWidth(edge_width[0] / 4.0) use_occlude = True for face in bm.faces: if len([verts for verts in face.verts]) == 3: faces = [ matrix_world * vert.co for vert in face.verts ] glColor4f(*faces_tri_color[0]) glEnable(GL_BLEND) glBegin(GL_POLYGON) draw_poly(faces) glEnd() for edge in face.edges: if edge.is_valid: edges = [ matrix_world * vert.co for vert in edge.verts ] glColor4f(*edges_tri_color[0]) glBegin(GL_LINES) draw_poly(edges) glEnd() elif len([verts for verts in face.verts]) > 4: new_faces = [] faces = [] coords = [v.co for v in face.verts] indices = [v.index for v in face.verts] for pol in tessellate([coords]): new_faces.append([indices[i] for i in pol]) for f in new_faces: faces.append([ ((matrix_world * bm.verts[i].co)[0] + face.normal.x * 0.001, (matrix_world * bm.verts[i].co)[1] + face.normal.y * 0.001, (matrix_world * bm.verts[i].co)[2] + face.normal.z * 0.001) for i in f ]) for f in faces: glColor4f(*faces_ngons_color[0]) glEnable(GL_BLEND) glBegin(GL_POLYGON) draw_poly(f) glEnd() for edge in face.edges: if edge.is_valid: edges = [ matrix_world * vert.co for vert in edge.verts ] glColor4f(*edges_ngons_color[0]) glBegin(GL_LINES) draw_poly(edges) glEnd() glDisable(GL_BLEND) glColor4f(0.0, 0.0, 0.0, 1.0) glLineWidth(edge_width[0]) glEnable(GL_DEPTH_TEST) if use_occlude: for face in bm.faces: if len([verts for verts in face.verts]) == 3: faces = [] for vert in face.verts: vert_face = matrix_world * vert.co faces.append( (vert_face[0] + face.normal.x * 0.001, vert_face[1] + face.normal.y * 0.001, vert_face[2] + face.normal.z * 0.001)) glColor4f(*faces_tri_color[0]) glEnable(GL_BLEND) glBegin(GL_POLYGON) draw_poly(faces) glEnd() for edge in face.edges: if edge.is_valid: edges = [] for vert in edge.verts: vert_edge = matrix_world * vert.co edges.append((vert_edge[0] + face.normal.x * 0.001, vert_edge[1] + face.normal.y * 0.001, vert_edge[2] + face.normal.z * 0.001)) glColor4f(*edges_tri_color[0]) glBegin(GL_LINES) draw_poly(edges) glEnd() elif len([verts for verts in face.verts]) > 4: new_faces = [] faces = [] coords = [v.co for v in face.verts] indices = [v.index for v in face.verts] for pol in tessellate([coords]): new_faces.append([indices[i] for i in pol]) for f in new_faces: faces.append([ ((matrix_world * bm.verts[i].co)[0] + face.normal.x * 0.001, (matrix_world * bm.verts[i].co)[1] + face.normal.y * 0.001, (matrix_world * bm.verts[i].co)[2] + face.normal.z * 0.001) for i in f ]) for f in faces: glColor4f(*faces_ngons_color[0]) glEnable(GL_BLEND) glBegin(GL_POLYGON) draw_poly(f) glEnd() for edge in face.edges: if edge.is_valid: edges = [] for vert in edge.verts: vert_edge = matrix_world * vert.co edges.append((vert_edge[0] + face.normal.x * 0.001, vert_edge[1] + face.normal.y * 0.001, vert_edge[2] + face.normal.z * 0.001)) glColor4f(*edges_ngons_color[0]) glBegin(GL_LINES) draw_poly(edges) glEnd() glDisable(GL_BLEND) glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback(self, context): """ :type context: bpy.types.Context """ prefs = QuickBooleanPreferences.get_instance() color = prefs.color snap_color = prefs.snap_color region = context.region glsettings = vagl.GLSettings(context) glsettings.push() bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(*color) show_reversed = False if self.reverse: if self.mode == 'POLYGON': if len(self.mouse_coords) >= 3: show_reversed = True else: if len(self.mouse_coords) >= 2: if self.mouse_coords[0] != self.mouse_coords[1]: show_reversed = True if show_reversed: bgl.glEnable(bgl.GL_DEPTH_TEST) bgl.glClearDepth(1.0) bgl.glClear(bgl.GL_DEPTH_BUFFER_BIT) bgl.glDepthMask(1) bgl.glColorMask(0, 0, 0, 0) lines = [] if self.mouse_coords: if self.mode == 'LINE': w = region.width h = region.height p1, p2 = self.mouse_coords line = (p2 - p1).normalized() normal = Vector([-line[1], line[0]]) corners = [ Vector([0, 0]), Vector([w, 0]), Vector([w, h]), Vector([0, h]) ] corners_ofs = [v - p1 for v in corners] dists = [v.project(line).dot(line) for v in corners_ofs] i = dists.index(min(dists)) line_min = corners_ofs[i].project(line) + p1 i = dists.index(max(dists)) line_max = corners_ofs[i].project(line) + p1 dists = [v.project(normal).dot(normal) for v in corners_ofs] i = dists.index(max(dists)) normal_max_f = corners_ofs[i].project(normal).dot(normal) vec = normal * normal_max_f coords = [line_min, line_max, line_max + vec, line_min + vec] bgl.glBegin(bgl.GL_QUADS) for co in coords: bgl.glVertex2f(*co) bgl.glEnd() lines = self.mouse_coords elif self.mode == 'BOX': p1, p2 = self.mouse_coords bgl.glRectf(p1[0], p1[1], p2[0], p2[1]) lines = [ p1, Vector((p2[0], p1[1])), Vector((p2[0], p2[1])), Vector((p1[0], p2[1])), p1 ] elif self.mode == 'CIRCLE': p1, p2 = self.mouse_coords bgl.glBegin(bgl.GL_TRIANGLE_FAN) bgl.glVertex2f(*p1) r = (p2 - p1).length coords = calc_circle_coords(p1, r, self.circle_segments, self.circle_direction) for co in coords: bgl.glVertex2f(*co) bgl.glVertex2f(*coords[0]) bgl.glEnd() lines = coords + [coords[0]] elif self.mode == 'POLYGON': if len(self.mouse_coords) >= 3: tris = mathutils.geometry.tessellate_polygon( [[co.to_3d() for co in self.mouse_coords]]) bgl.glBegin(bgl.GL_TRIANGLES) for tri in tris: for i in tri: bgl.glVertex2f(*self.mouse_coords[i]) bgl.glEnd() if len(self.mouse_coords) > 1: lines = self.mouse_coords + [self.mouse_coords[0]] if show_reversed: bgl.glColorMask(1, 1, 1, 1) bgl.glBegin(bgl.GL_QUADS) bgl.glVertex3f(0, 0, -1) bgl.glVertex3f(region.width, 0, -1) bgl.glVertex3f(region.width, region.height, -1) bgl.glVertex3f(0, region.height, -1) bgl.glEnd() bgl.glDisable(bgl.GL_DEPTH_TEST) bgl.glColor4f(*color[:3], 1.0) bgl.glPointSize(1) bgl.glLineWidth(1) if len(lines) > 1: bgl.glBegin(bgl.GL_LINE_STRIP) for co in lines: bgl.glVertex2f(*co) bgl.glEnd() if self.mode == 'POLYGON': if len(self.mouse_coords) == 1: bgl.glPointSize(5) bgl.glBegin(bgl.GL_POINTS) for co in self.mouse_coords: bgl.glVertex2f(*co) bgl.glEnd() bgl.glPointSize(1) bgl.glLineWidth(1) if self.mco_ctrl: SIZE = 12 bgl.glColor4f(*snap_color) bgl.glBegin(bgl.GL_LINE_LOOP) v = self.mco_mod x = v[0] - SIZE / 2 y = v[1] - SIZE / 2 bgl.glVertex2f(x, y) bgl.glVertex2f(x + SIZE, y) bgl.glVertex2f(x + SIZE, y + SIZE) bgl.glVertex2f(x, y + SIZE) bgl.glEnd() glsettings.pop() glsettings.font_size()
def glsl_draw(self): if GlslDrawObj.myinstance is None and GlslDrawObj.draw_func is None: glsl_draw_obj = GlslDrawObj() glsl_draw_obj.build_scene() else: glsl_draw_obj = GlslDrawObj.myinstance model_offset = Matrix.Translation((glsl_draw_obj.draw_x_offset, 0, 0)) light_pos = [ i + n for i, n in zip(glsl_draw_obj.light.location, [-glsl_draw_obj.draw_x_offset, 0, 0]) ] batches = glsl_draw_obj.batches depth_shader = glsl_draw_obj.depth_shader toon_shader = glsl_draw_obj.toon_shader offscreen = glsl_draw_obj.offscreen # need bone etc changed only update depth_matrix = None light = glsl_draw_obj.light light_lookat = light.rotation_euler.to_quaternion() @ Vector( (0, 0, -1)) # TODO このへん tar = light_lookat.normalized() up = light.rotation_euler.to_quaternion() @ Vector((0, 1, 0)) tmp_bound_len = Vector(glsl_draw_obj.bounding_center).length camera_bias = 0.2 loc = Vector([ glsl_draw_obj.bounding_center[i] + tar[i] * (tmp_bound_len + camera_bias) for i in range(3) ]) loc = model_offset @ loc v_matrix = lookat_cross(loc, tar, up) const_proj = 2 * max(glsl_draw_obj.bounding_size) / 2 p_matrix = ortho_proj_mat(-const_proj, const_proj, -const_proj, const_proj, -const_proj, const_proj) depth_matrix = v_matrix @ p_matrix # reuse in main shader depth_matrix.transpose() # region shader depth path with offscreen.bind(): bgl.glClearColor(10, 10, 10, 1) bgl.glClear(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_DEPTH_BUFFER_BIT) for bat in batches: mat = bat[0] mat.update() depth_bat = bat[2] depth_shader.bind() bgl.glEnable(bgl.GL_BLEND) if mat.alpha_method == "TRANSPARENT": bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) bgl.glDepthMask(bgl.GL_TRUE) bgl.glEnable(bgl.GL_DEPTH_TEST) elif mat.alpha_method == "OPAQUE": bgl.glBlendFunc(bgl.GL_ONE, bgl.GL_ZERO) bgl.glDepthMask(bgl.GL_TRUE) bgl.glEnable(bgl.GL_DEPTH_TEST) elif mat.alpha_method == "CLIP": bgl.glBlendFunc(bgl.GL_ONE, bgl.GL_ZERO) bgl.glDepthMask(bgl.GL_TRUE) bgl.glEnable(bgl.GL_DEPTH_TEST) if mat.cull_mode == "BACK": bgl.glEnable(bgl.GL_CULL_FACE) bgl.glCullFace(bgl.GL_BACK) else: bgl.glDisable(bgl.GL_CULL_FACE) bgl.glEnable(bgl.GL_CULL_FACE) # そも輪郭線がの影は落ちる? bgl.glCullFace(bgl.GL_BACK) depth_shader.uniform_float("obj_matrix", model_offset) # obj.matrix_world) depth_shader.uniform_float("depthMVP", depth_matrix) depth_bat.draw(depth_shader) # endregion shader depth path # region shader main vp_mat = bpy.context.region_data.perspective_matrix projection_mat = bpy.context.region_data.window_matrix view_dir = bpy.context.region_data.view_matrix[2][:3] view_up = bpy.context.region_data.view_matrix[1][:3] normal_world_to_view_matrix = ( bpy.context.region_data.view_matrix.inverted_safe().transposed()) aspect = bpy.context.area.width / bpy.context.area.height for is_outline in [0, 1]: for bat in batches: toon_bat = bat[1] toon_shader.bind() mat = bat[0] if is_outline == 1 and mat.float_dic["OutlineWidthMode"] == 0: continue # mat.update() #already in depth path bgl.glEnable(bgl.GL_BLEND) bgl.glDepthMask(bgl.GL_TRUE) bgl.glEnable(bgl.GL_DEPTH_TEST) if mat.alpha_method == "TRANSPARENT": bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) elif mat.alpha_method == "OPAQUE": bgl.glBlendFunc(bgl.GL_ONE, bgl.GL_ZERO) elif mat.alpha_method == "CLIP": bgl.glBlendFunc(bgl.GL_ONE, bgl.GL_ZERO) if is_outline == 0: if mat.cull_mode == "BACK": bgl.glEnable(bgl.GL_CULL_FACE) bgl.glCullFace(bgl.GL_BACK) else: bgl.glDisable(bgl.GL_CULL_FACE) else: bgl.glEnable(bgl.GL_CULL_FACE) bgl.glCullFace(bgl.GL_BACK) toon_shader.uniform_float("obj_matrix", model_offset) # obj.matrix_world) toon_shader.uniform_float("projectionMatrix", projection_mat) toon_shader.uniform_float("viewProjectionMatrix", vp_mat) toon_shader.uniform_float("viewDirection", view_dir) toon_shader.uniform_float("viewUpDirection", view_up) toon_shader.uniform_float("normalWorldToViewMatrix", normal_world_to_view_matrix) toon_shader.uniform_float("depthMVP", depth_matrix) toon_shader.uniform_float("lightpos", light_pos) toon_shader.uniform_float("aspect", aspect) toon_shader.uniform_float("is_outline", is_outline) toon_shader.uniform_float("isDebug", 0.0) toon_shader.uniform_float( "is_cutout", 1.0 if mat.alpha_method == "CLIP" else 0.0) float_keys = [ "CutoffRate", "BumpScale", "ReceiveShadowRate", "ShadeShift", "ShadeToony", "RimLightingMix", "RimFresnelPower", "RimLift", "ShadingGradeRate", "LightColorAttenuation", "IndirectLightIntensity", "OutlineWidth", "OutlineScaleMaxDistance", "OutlineLightingMix", "UV_Scroll_X", "UV_Scroll_Y", "UV_Scroll_Rotation", "OutlineWidthMode", "OutlineColorMode", ] for k in float_keys: toon_shader.uniform_float(k, mat.float_dic[k]) for k, v in mat.vector_dic.items(): toon_shader.uniform_float(k, v) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, offscreen.color_texture) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_S, bgl.GL_CLAMP_TO_EDGE) # TODO bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_T, bgl.GL_CLAMP_TO_EDGE) toon_shader.uniform_int("depth_image", 0) for i, k in enumerate(mat.texture_dic.keys()): bgl.glActiveTexture(bgl.GL_TEXTURE1 + i) texture = mat.texture_dic[k] bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture.bindcode) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_S, bgl.GL_CLAMP_TO_EDGE) # TODO bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_T, bgl.GL_CLAMP_TO_EDGE) toon_shader.uniform_int(k, 1 + i) toon_bat.draw(toon_shader)
def generate_icon(name, verts=None, faces=None, coll="shape_types"): pcoll = preview_collections[coll] if name in pcoll: thumb = pcoll.get(name) else: thumb = pcoll.new(name) thumb.image_size = (200, 200) if verts is not None: import bgl polygon_color = bpy.context.user_preferences.themes[ 0].view_3d.edge_facesel edge_color = bpy.context.user_preferences.themes[0].view_3d.edge_select vertex_color = bpy.context.user_preferences.themes[ 0].view_3d.vertex_select clear_color = bpy.context.user_preferences.themes[ 0].user_interface.wcol_menu.inner viewport_info = bgl.Buffer(bgl.GL_INT, 4) bgl.glGetIntegerv(bgl.GL_VIEWPORT, viewport_info) buffer = bgl.Buffer(bgl.GL_FLOAT, 200 * 200 * 4) bgl.glDisable(bgl.GL_SCISSOR_TEST) bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) bgl.glEnable(bgl.GL_LINE_SMOOTH) bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glViewport(0, 0, 200, 200) bgl.glMatrixMode(bgl.GL_MODELVIEW) bgl.glPushMatrix() bgl.glLoadIdentity() bgl.glMatrixMode(bgl.GL_PROJECTION) bgl.glPushMatrix() bgl.glLoadIdentity() bgl.gluOrtho2D(0, 0, 0, 0) bgl.glLineWidth(4.0) bgl.glPointSize(10.0) bgl.glClearColor(*clear_color) bgl.glClear(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_DEPTH_BUFFER_BIT) if faces is None: bgl.glBegin(bgl.GL_POLYGON) bgl.glColor3f(*polygon_color) for vert in verts: bgl.glVertex2f(*vert) bgl.glEnd() else: bgl.glBegin(bgl.GL_TRIANGLES) bgl.glColor3f(*polygon_color) for face in faces: bgl.glVertex2f(*verts[face[0]]) bgl.glVertex2f(*verts[face[1]]) bgl.glVertex2f(*verts[face[2]]) bgl.glEnd() bgl.glBegin(bgl.GL_LINE_LOOP) bgl.glColor3f(*edge_color) for vert in verts: bgl.glVertex2f(*vert) bgl.glEnd() bgl.glBegin(bgl.GL_POINTS) bgl.glColor3f(*vertex_color) for vert in verts: bgl.glVertex2f(*vert) bgl.glEnd() bgl.glReadPixels(0, 0, 200, 200, bgl.GL_RGBA, bgl.GL_FLOAT, buffer) bgl.glEnable(bgl.GL_SCISSOR_TEST) bgl.glLineWidth(1.0) bgl.glPointSize(1.0) buffer = buffer[:] for idx in range(0, 200 * 200 * 4, 4): if buffer[idx] == clear_color[0] and \ buffer[idx + 1] == clear_color[1] and buffer[idx + 2] == clear_color[2]: buffer[idx + 3] = 0.0 thumb.image_pixels_float = buffer
def disable_depth_test(): glDisable(GL_DEPTH_TEST)
def draw_callback(cls, context): prefs = compat.get_user_preferences(context).addons[__package__].preferences if context.window.as_pointer() != cls.origin["window"]: return # Not match target window. rect = cls.calc_draw_area_rect(context) if not rect: return # No draw target. draw_area_min_x, draw_area_min_y, draw_area_max_x, draw_area_max_y = rect _, _, _, origin_x, origin_y = cls.get_origin(context) width = draw_area_max_x - origin_x height = draw_area_max_y - origin_y if width == height == 0: return region = context.region area = context.area if region.type == 'WINDOW': region_min_x, region_min_y, region_max_x, region_max_y = get_window_region_rect(area) else: region_min_x = region.x region_min_y = region.y region_max_x = region.x + region.width - 1 region_max_y = region.y + region.height - 1 if not intersect_aabb( [region_min_x, region_min_y], [region_max_x, region_max_y], [draw_area_min_x + 1, draw_area_min_y + 1], [draw_area_max_x - 1, draw_area_max_x - 1]): # We don't need to draw if draw area is not overlapped with region. return current_time = time.time() region_drawn = False font_size = prefs.font_size font_id = 0 dpi = compat.get_user_preferences(context).system.dpi blf.size(font_id, font_size, dpi) scissor_box = bgl.Buffer(bgl.GL_INT, 4) bgl.glGetIntegerv(bgl.GL_SCISSOR_BOX, scissor_box) # Clip 'TOOLS' and 'UI' region from 'WINDOW' region if need. # This prevents from drawing multiple time when # user_preferences.system.use_region_overlap is True. if context.area.type == 'VIEW_3D' and region.type == 'WINDOW': x_min, y_min, x_max, y_max = get_region_rect_on_v3d(context) bgl.glScissor(x_min, y_min, x_max - x_min + 1, y_max - y_min + 1) # Get string height in draw area. sh = blf.dimensions(0, string.printable)[1] x = origin_x - region.x y = origin_y - region.y # Draw last operator. operator_history = cls.removed_old_operator_history() if prefs.show_last_operator and operator_history: time_, bl_label, idname_py, _ = operator_history[-1] if current_time - time_ <= prefs.display_time: compat.set_blf_font_color(font_id, *prefs.color, 1.0) # Draw operator text. text = bpy.app.translations.pgettext_iface(bl_label, "Operator") text += " ('{}')".format(idname_py) offset_x = cls.get_text_offset_for_alignment(font_id, text, context) blf.position(font_id, x + offset_x, y, 0) if prefs.background: draw_text_background(text, font_id, x + offset_x, y, prefs.color_background) draw_text(text, font_id, prefs.color, prefs.shadow, prefs.color_shadow) y += sh + sh * cls.HEIGHT_RATIO_FOR_SEPARATOR * 0.2 # Draw separator. sw = blf.dimensions(font_id, "Left Mouse")[0] offset_x = cls.get_offset_for_alignment(sw, context) draw_line([x + offset_x, y], [x + sw + offset_x, y], prefs.color, prefs.shadow, prefs.color_shadow) y += sh * cls.HEIGHT_RATIO_FOR_SEPARATOR * 0.8 region_drawn = True else: y += sh + sh * cls.HEIGHT_RATIO_FOR_SEPARATOR # Draw hold modifier keys. drawing = False # TODO: Need to check if drawing is now on progress. compat.set_blf_font_color(font_id, *prefs.color, 1.0) margin = sh * 0.2 if cls.hold_modifier_keys or drawing: mod_keys = cls.sorted_modifier_keys(cls.hold_modifier_keys) if drawing: text = "" else: text = " + ".join(mod_keys) offset_x = cls.get_text_offset_for_alignment(font_id, text, context) # Draw rounded box. box_height = sh + margin * 2 box_width = blf.dimensions(font_id, text)[0] + margin * 2 draw_rounded_box(x - margin + offset_x, y - margin, box_width, box_height, box_height * 0.2, prefs.background, prefs.color_background) # Draw key text. blf.position(font_id, x + offset_x, y + margin, 0) draw_text(text, font_id, prefs.color, prefs.shadow, prefs.color_shadow) bgl.glColor4f(*prefs.color, 1.0) region_drawn = True y += sh + margin * 2 # Draw event history. event_history = cls.removed_old_event_history() y += sh * cls.HEIGHT_RATIO_FOR_SEPARATOR for _, event_type, modifiers, repeat_count in event_history[::-1]: color = prefs.color compat.set_blf_font_color(font_id, *color, 1.0) text = get_display_event_text(event_type.name) if modifiers: mod_keys = cls.sorted_modifier_keys(modifiers) text = "{} + {}".format(" + ".join(mod_keys), text) if repeat_count > 1: text += " x{}".format(repeat_count) offset_x = cls.get_text_offset_for_alignment(font_id, text, context) blf.position(font_id, x + offset_x, y, 0) if prefs.background: draw_text_background(text, font_id, x + offset_x, y, prefs.color_background) draw_text(text, font_id, prefs.color, prefs.shadow, prefs.color_shadow) y += sh region_drawn = True bgl.glDisable(bgl.GL_BLEND) bgl.glScissor(*scissor_box) bgl.glLineWidth(1.0) if region_drawn: cls.draw_regions_prev.add(region.as_pointer())
def glSwitch(attr, value): if value: bgl.glEnable(attr) else: bgl.glDisable(attr)
def draw_lw(context, lw, cross_up_dir, draw_faloff): region = context.region rv3d = context.region_data start_2d = view3d_utils.location_3d_to_region_2d(region, rv3d, lw.start_point.position) end_2d = view3d_utils.location_3d_to_region_2d(region, rv3d, lw.end_point.position) middle_2d = view3d_utils.location_3d_to_region_2d(region, rv3d, lw.middle_point.position) dist_ends = ((lw.start_point.position - lw.end_point.position).length * 0.1) * cross_up_dir end_p1 = view3d_utils.location_3d_to_region_2d( region, rv3d, lw.end_point.position + dist_ends) end_p2 = view3d_utils.location_3d_to_region_2d( region, rv3d, lw.end_point.position - dist_ends) if start_2d and end_2d and end_p1 and end_p2: bgl.glEnable(bgl.GL_BLEND) bgl.glLineWidth(1) bgl.glPointSize(6) coords = ((start_2d[0], start_2d[1]), (end_2d[0], end_2d[1])) batch = batch_for_shader(shader2d, 'LINE_STRIP', {"pos": coords}) shader2d.bind() shader2d.uniform_float("color", (0.99, 0.5, 0.99, 1.0)) batch.draw(shader2d) # bgl.glBegin(bgl.GL_LINE_STRIP) # bgl.glColor4f(0.99, 0.5, 0.99, 1.0) # bgl.glVertex2f(start_2d[0], start_2d[1]) # bgl.glVertex2f(end_2d[0], end_2d[1]) # bgl.glEnd() if draw_faloff: coords = ((start_2d[0], start_2d[1]), (end_p1[0], end_p1[1]), (end_p2[0], end_p2[1])) batch = batch_for_shader(shader2d, 'LINE_LOOP', {"pos": coords}) shader2d.bind() shader2d.uniform_float("color", (0.99, 0.5, 0.99, 1.0)) batch.draw(shader2d) # bgl.glBegin(bgl.GL_LINE_LOOP) # bgl.glVertex2f(start_2d[0], start_2d[1]) # bgl.glVertex2f(end_p1[0], end_p1[1]) # bgl.glVertex2f(end_p2[0], end_p2[1]) # bgl.glEnd() coords = ((start_2d[0], start_2d[1]), (middle_2d[0], middle_2d[1]), (end_2d[0], end_2d[1])) batch = batch_for_shader(shader2d, 'POINTS', {"pos": coords}) shader2d.bind() shader2d.uniform_float("color", (0.99, 0.8, 0.5, 1.0)) batch.draw(shader2d) # bgl.glBegin(bgl.GL_POINTS) # bgl.glColor4f(0.99, 0.8, 0.5, 1.0) # bgl.glVertex2f(start_2d[0], start_2d[1]) # bgl.glVertex2f(middle_2d[0], middle_2d[1]) # bgl.glVertex2f(end_2d[0], end_2d[1]) # bgl.glEnd() # restore opengl defaults bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND)
def draw_object_axes(args): context, objs, draw_cursor = args if context.space_data.overlay.show_overlays: axes = [(Vector((1, 0, 0)), red), (Vector((0, 1, 0)), green), (Vector((0, 0, 1)), blue)] size = context.scene.M3.object_axes_size alpha = context.scene.M3.object_axes_alpha for axis, color in axes: coords = [] # draw object(s) for obj in objs: mx = obj.matrix_world origin = mx.decompose()[0] # coords.append(origin) coords.append(origin + mx.to_3x3() @ axis * size * 0.1) coords.append(origin + mx.to_3x3() @ axis * size) # cursor if draw_cursor and context.space_data.overlay.show_cursor: cmx = context.scene.cursor.matrix corigin = cmx.decompose()[0] coords.append(corigin + cmx.to_3x3() @ axis * size * 0.1 * 0.5) coords.append(corigin + cmx.to_3x3() @ axis * size * 0.5) """ # debuging stash + stashtargtmx for object origin changes for stash in obj.MM.stashes: if stash.obj: smx = stash.obj.MM.stashmx sorigin = smx.decompose()[0] coords.append(sorigin + smx.to_3x3() @ axis * size * 0.1) coords.append(sorigin + smx.to_3x3() @ axis * size) stmx = stash.obj.MM.stashtargetmx storigin = stmx.decompose()[0] coords.append(storigin + stmx.to_3x3() @ axis * size * 0.1) coords.append(storigin + stmx.to_3x3() @ axis * size) """ if coords: indices = [(i, i + 1) for i in range(0, len(coords), 2)] shader = gpu.shader.from_builtin('3D_UNIFORM_COLOR') shader.bind() shader.uniform_float("color", (*color, alpha)) bgl.glEnable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_DEPTH_TEST) bgl.glLineWidth(2) batch = batch_for_shader(shader, 'LINES', {"pos": coords}, indices=indices) batch.draw(shader)