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 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 text_line(fx, fy, reduce, c, str): bgl.glColor4f(c[0], c[1], c[2], c[3]) blf.position(0, fx, fy, 0) blf.draw(0, str) if reduce: fy -= 20 return fy
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 vicon_view3d_draw(x, y, w, h, alpha=1.0): cx = x + w / 2 cy = y + h / 2 d = max(2, h / 3) bgl.glColor4f(0.5, 0.5, 0.5, alpha) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(x, cy - d) bgl.glVertex2f(x + w, cy - d) bgl.glVertex2f(x, cy + d) bgl.glVertex2f(x + w, cy + d) bgl.glVertex2f(cx - d, y) bgl.glVertex2f(cx - d, y + h) bgl.glVertex2f(cx + d, y) bgl.glVertex2f(cx + d, y + h) bgl.glEnd() bgl.glColor4f(0.0, 0.0, 0.0, alpha) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(x, cy) bgl.glVertex2f(x + w, cy) bgl.glVertex2f(cx, y) bgl.glVertex2f(cx, y + h) bgl.glEnd()
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_callback_px(self, context): #print("callback_px") # Maybe print a nice red circle in some corner bgl.glPushAttrib(bgl.GL_CLIENT_ALL_ATTRIB_BITS) FONT_RGBA = (0.8, 0.1, 0.1, 0.5) bgl.glColor4f(*FONT_RGBA) font_size = 11 DPI = 72 blf.size(0, font_size, DPI) msg = "Logging..." msg_w,msg_h = blf.dimensions(0, msg) pos_x = context.region.width - msg_w pos_y = font_size / 2 blf.position(0, pos_x, pos_y, 0) #blf.position(0, 10, 10, 0) blf.draw(0, msg) bgl.glPopAttrib() pass
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_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_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 cursor_history_draw(cls,context): cc = context.scene.cursor_history draw = 0 if hasattr(cc, "historyDraw"): draw = cc.historyDraw if(draw): bgl.glEnable(bgl.GL_BLEND) bgl.glShadeModel(bgl.GL_FLAT) alpha = 1-PHI_INV # History Trace if cc.historyPosition[0]<0: return bgl.glBegin(bgl.GL_LINE_STRIP) ccc = 0 for iii in range(cc.historyWindow+1): ix_rel = iii - int(cc.historyWindow / 2) ix = cc.historyPosition[0] + ix_rel if(ix<0 or ix>=len(cc.historyLocation)): continue ppp = region3d_get_2d_coordinates(context, cc.historyLocation[ix]) if(ix_rel<=0): bgl.glColor4f(0, 0, 0, alpha) else: bgl.glColor4f(1, 0, 0, alpha) bgl.glVertex2f(ppp[0], ppp[1]) ccc = ccc + 1 bgl.glEnd()
def hud(dummy, self, context) : if 'type' in dir(self) : city = bpy.context.scene.city mdl = city.modal evt = self x_min,x,x_max = self._regions y_min,y_max = self._regionsy if x < self.mouse_x < x_max and y_min < self.mouse_y < y_max : mouse_x = self.mouse_x - x mouse_y = self.mouse_y - y_min else : mouse_x = False mouse_y = False # timer if mdl.timer : if evt.type == 'TIMER' : self.idx = (self.idx + 1)%4 blf.size(0, 11, 72) blf.position(0, 35, 50, 0) blf.draw(0, "timer %1.3f : %s"%( mdl.timer_refresh, ('|/-\\')[self.idx]) ) # is over ? overcrop = False bgl.glColor4f(1,1,1,1) #if mouse_x : blf.position(0, 35, 35, 0) blf.size(0, 11, 72) blf.draw(0, 'Mx: %s My: %s %s'%(mouse_x, mouse_y,self._regions)) blf.position(0, 35, 20, 0) blf.size(0, 11, 72) blf.draw(0, 'Mx: %s My: %s'%(self.mouse_x, self.mouse_y))
def draw_borders(x=0, y=0, w=30, h=10, color=(0.0, 0.0, 0.0, 1.0)): # function to draw a border color around the texture bgl.glColor4f(*color) bgl.glBegin(bgl.GL_LINE_LOOP) for coord in [(x, y), (x + w, y), (w + x, y - h), (x, y - h)]: bgl.glVertex2f(*coord) bgl.glEnd()
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_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 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_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(self, context, render=False): """ render flag when rendering """ # print("draw_line %s" % (type(self).__name__)) bgl.glPushAttrib(bgl.GL_ENABLE_BIT) if self.style == bgl.GL_LINE_STIPPLE: bgl.glLineStipple(1, 0x9999) bgl.glEnable(self.style) bgl.glEnable(bgl.GL_BLEND) if render: # enable anti-alias on lines bgl.glEnable(bgl.GL_LINE_SMOOTH) bgl.glColor4f(*self.colour) bgl.glLineWidth(self.width) if self.closed: bgl.glBegin(bgl.GL_LINE_LOOP) else: bgl.glBegin(bgl.GL_LINE_STRIP) for pt in self.pts: x, y = self.position_2d_from_coord(context, pt, render) bgl.glVertex2f(x, y) self._end()
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 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 draw_index(rgb, rgb2, index, vec, text=''): vec_4d = perspective_matrix * vec.to_4d() if vec_4d.w <= 0.0: return x = region_mid_width + region_mid_width * (vec_4d.x / vec_4d.w) y = region_mid_height + region_mid_height * (vec_4d.y / vec_4d.w) if text: index = str(text[0]) else: index = str(index) if draw_bg: polyline = get_points(index) ''' draw polygon ''' bgl.glColor4f(*rgb2) bgl.glBegin(bgl.GL_POLYGON) for pointx, pointy in polyline: bgl.glVertex2f(pointx+x, pointy+y) bgl.glEnd() ''' draw text ''' txt_width, txt_height = blf.dimensions(0, index) bgl.glColor4f(*rgb) blf.position(0, x - (txt_width / 2), y - (txt_height / 2), 0) blf.draw(0, index)
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 drawText2D(color, text): font_id = 0 # XXX, need to find out how best to get this. # draw some text bgl.glColor4f(*color) blf.position(font_id, 20, 70, 0) blf.size(font_id, 20, 72) blf.draw(font_id, text)
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_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 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 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 write(): """write on screen""" # retrieve timer global game_timer scene = logic.getCurrentScene() game_timer = int(active_camera["Timer"]) catched = bamboo_counter["catched"] total = bamboo_counter["total"] vortex = panda.power width = render.getWindowWidth() height = render.getWindowHeight() # OpenGL setup bgl.glMatrixMode(bgl.GL_PROJECTION) bgl.glLoadIdentity() bgl.gluOrtho2D(0, width, 0, height) bgl.glMatrixMode(bgl.GL_MODELVIEW) bgl.glLoadIdentity() bgl.glColor4f(1, 1, 1, 1) # BLF drawing routine font_id = logic.font_id blf.size(font_id, int(18 * (width/dpi) * 0.06), dpi) blf.position(font_id, width*0.02, height*0.95, 0) if game_timer < 60: blf.draw(font_id, "{0} : {1:02d}".format(l_timer,game_timer)) else: blf.draw(font_id, "{0} : {1}:{2:02d}".format(l_timer,game_timer//60,game_timer%60)) blf.position(font_id, width*0.02, height*0.90, 0) blf.draw(font_id, "{0} : {1}".format(l_level, level)) blf.position(font_id, width*0.02, height*0.85, 0) blf.draw(font_id, "{0} : {1} / {2}".format(l_score, catched, total)) blf.position(font_id, width*0.02, height*0.80, 0) blf.draw(font_id, "{0} : {1}".format(l_vortex, vortex))
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_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_polyline_from_coordinates(context, points, width, LINE_TYPE='GL_LINE_STRIP', color=(1, 1, 1, 1)): region = context.region rv3d = context.space_data.region_3d bgl.glColor4f(*color) bgl.glLineWidth(width) if LINE_TYPE == "GL_LINE_STIPPLE": bgl.glLineStipple(4, 0x5555) bgl.glEnable(bgl.GL_LINE_STIPPLE) bgl.glBegin(bgl.GL_LINE_STRIP) for coord in points: vector3d = (coord.x, coord.y, coord.z) vector2d = view3d_utils.location_3d_to_region_2d( region, rv3d, vector3d) bgl.glVertex2f(*vector2d) bgl.glEnd() bgl.glLineWidth(1) return
def _draw_exception(self, context): """OpenGL drawing code for the EXCEPTION state.""" import textwrap content_height, content_width = self._window_size(context) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(0.2, 0.0, 0.0, 0.6) bgl.glRectf(0, 0, content_width, content_height) font_id = 0 ex = self.async_task.exception() if isinstance(ex, pillar.UserNotLoggedInError): ex_msg = 'You are not logged in on Blender ID. Please log in at User Preferences, ' \ 'System, Blender ID.' else: ex_msg = str(ex) if not ex_msg: ex_msg = str(type(ex)) text = "An error occurred:\n%s" % ex_msg lines = textwrap.wrap(text) bgl.glColor4f(1.0, 1.0, 1.0, 1.0) blf.size(font_id, 20, 72) _, text_height = blf.dimensions(font_id, 'yhBp') def position(line_nr): blf.position(font_id, content_width * 0.1, content_height * 0.8 - line_nr * text_height, 0) for line_idx, line in enumerate(lines): position(line_idx) blf.draw(font_id, line) bgl.glDisable(bgl.GL_BLEND)
def drawText(context, text, location): v3d = context.space_data; rv3d = v3d.region_3d; text_scale = TEXT_SCALE_VALUE * ((max(min(MAX_ZOOM_DISTANCE, rv3d.view_distance), MIN_ZOOM_DISTANCE)) / FRIENDLY_ZOOM_DISTANCE); # print("RV3D PARAMETERS ::: " , rv3d.view_location, rv3d.view_distance); # print('TEXT SCALE USED :::: ', text_scale); font_id = 0; axis, angle = getScreenLookAxis(context); bgl.glPushMatrix(); bgl.glTranslatef(location.x, location.y , location.z); bgl.glPushMatrix(); bgl.glRotatef(angle, axis.x, axis.y, axis.z); bgl.glPushMatrix(); bgl.glScalef(text_scale,text_scale,text_scale); bgl.glPushMatrix(); bgl.glRotatef(90.0, 1.0, 0.0, 0.0); blf.position(font_id, 0.0, 0.0 , 0.0); blf.size(font_id, 72, 72); bgl.glColor4f(0.0, 0.0, 0.0, 1.0); blf.draw(0, text); # blf.rotation(0, 1.57); bgl.glPopMatrix(); bgl.glPopMatrix(); bgl.glPopMatrix(); bgl.glPopMatrix();
def draw_texture(self, context): sc = context.scene # no textures are selected if sc.muv_texproj_tex_image == "None": return # setup rendering region rect = get_canvas(context, sc.muv_texproj_tex_magnitude) positions = [[rect.x0, rect.y0], [rect.x0, rect.y1], [rect.x1, rect.y1], [rect.x1, rect.y0]] tex_coords = [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]] # get texture to be renderred img = bpy.data.images[sc.muv_texproj_tex_image] # OpenGL configuration bgl.glEnable(bgl.GL_BLEND) bgl.glEnable(bgl.GL_TEXTURE_2D) if img.bindcode: bind = img.bindcode bgl.glBindTexture(bgl.GL_TEXTURE_2D, bind) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR) bgl.glTexEnvi(bgl.GL_TEXTURE_ENV, bgl.GL_TEXTURE_ENV_MODE, bgl.GL_MODULATE) # render texture bgl.glBegin(bgl.GL_QUADS) bgl.glColor4f(1.0, 1.0, 1.0, sc.muv_texproj_tex_transparency) for (v1, v2), (u, v) in zip(positions, tex_coords): bgl.glTexCoord2f(u, v) bgl.glVertex2f(v1, v2) bgl.glEnd()
def draw_main(context): region = bpy.context.region rv3d = bpy.context.space_data.region_3d scene = bpy.context.scene # Get visible layers layers = [] for x in range(0, 20): if bpy.context.scene.layers[x] is True: layers.extend([x]) bgl.glEnable(bgl.GL_BLEND) # Display selected or all if scene.measureit_gl_ghost is False: objlist = context.selected_objects else: objlist = context.scene.objects # --------------------------------------- # Generate all OpenGL calls # --------------------------------------- for myobj in objlist: if myobj.hide is False: if 'MeasureGenerator' in myobj: # verify visible layer for x in range(0, 20): if myobj.layers[x] is True: if x in layers: op = myobj.MeasureGenerator[0] draw_segments(context, myobj, op, region, rv3d) break # ----------------------- # 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): bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(1.0, 1.0, 1.0, 0.5) bgl.glLineWidth(2) if self.selecting: # when selecting draw dashed line box bgl.glEnable(bgl.GL_LINE_STIPPLE) bgl.glLineStipple(2, 0x3333) bgl.glBegin(bgl.GL_LINE_LOOP) bgl.glVertex2i(self.min_x, self.min_y) bgl.glVertex2i(self.min_x, self.max_y) bgl.glVertex2i(self.max_x, self.max_y) bgl.glVertex2i(self.max_x, self.min_y) bgl.glEnd() bgl.glDisable(bgl.GL_LINE_STIPPLE) else: # before selection starts draw infinite cross bgl.glBegin(bgl.GL_LINES) bgl.glVertex2i(0, self.max_y) bgl.glVertex2i(context.area.width, self.max_y) bgl.glVertex2i(self.max_x, 0) bgl.glVertex2i(self.max_x, context.area.height) 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_3d(self, context): global particle_vertices global particle_vertex_colors domain = context.scene.flip_fluid.get_domain_object() dprops = context.scene.flip_fluid.get_domain_properties() if domain is None or len(particle_vertices) == 0: return if vcu.get_object_hide_viewport(domain): return if not vcu.is_blender_28(): dlayers = [i for i,v in enumerate(domain.layers) if v] slayers = [i for i,v in enumerate(context.scene.layers) if v] if not (set(dlayers) & set(slayers)): return if vcu.is_blender_28(): global particle_shader global particle_batch_draw particle_batch_draw.draw(particle_shader) else: bgl.glPointSize(dprops.debug.particle_size) bgl.glBegin(bgl.GL_POINTS) current_color = None for i in range(len(particle_vertices)): if current_color != particle_vertex_colors[i]: current_color = particle_vertex_colors[i] bgl.glColor4f(current_color[0], current_color[1], current_color[2], 1.0) bgl.glVertex3f(*(particle_vertices[i])) bgl.glEnd() bgl.glPointSize(1) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_3d_points(context, points, color, size): ''' draw a bunch of dots args: points: a list of tuples representing x,y SCREEN coordinate eg [(10,30),(11,31),...] color: tuple (r,g,b,a) size: integer? maybe a float ''' points_2d = [ location_3d_to_region_2d(context.region, context.space_data.region_3d, loc) for loc in points ] if None in points_2d: points_2d = filter(None, points_2d) bgl.glColor4f(*color) bgl.glPointSize(size) bgl.glBegin(bgl.GL_POINTS) for coord in points_2d: #TODO: Debug this problem....perhaps loc_3d is returning points off of the screen. if coord: bgl.glVertex2f(*coord) bgl.glEnd() return
def _draw_line(space, text, size, r, g, b, a): ctx = bpy.context blf.size(0, size, 72) w, h = blf.dimensions(0, text) global _line_y if "LEFT" in space.alignment: x = space.offset elif "RIGHT" in space.alignment: x = ctx.region.width - w - space.offset else: x = 0.5 * ctx.region.width - 0.5 * w if "TOP" in space.alignment: _line_y += size + 3 y = ctx.region.height - _line_y - space.offset else: y = _line_y + space.offset _line_y += size + 3 blf.position(0, x, y, 0) bgl.glColor4f(r, g, b, a) blf.draw(0, text)
def draw_2dpolygon(points, linecolor=None, fillcolor=None, distance=0.2, linewidth=1): """ Args: points: linecolor: (Default value = None) fillcolor: (Default value = None) distance: (Default value = 0.2) linewidth: (Default value = 1) Returns: """ # background bgl.glEnable(bgl.GL_BLEND) bgl.glLineWidth(linewidth) if fillcolor: bgl.glColor4f(*fillcolor) bgl.glBegin(bgl.GL_POLYGON) for p in points: bgl.glVertex3f(*p, distance) bgl.glEnd() # frame if linecolor: bgl.glColor4f(*linecolor) bgl.glBegin(bgl.GL_LINE_STRIP) for p in points: bgl.glVertex3f(*p, distance) bgl.glVertex3f(*points[0], distance) bgl.glEnd() bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND)
def draw_callback_px(self, context): if (self.ShowCursor): region = bpy.context.region rv3d = bpy.context.space_data.region_3d view_width = context.region.width bgl.glEnable(bgl.GL_BLEND) bgl.glLineWidth(2) bgl.glColor4f(1.0, 0.8, 0.0, 1.0) bgl.glBegin(bgl.GL_LINE_STRIP) idx = 0 for i in range(int(len(self.CLR_C) / 3)): vector3d = (self.CLR_C[idx * 3] * self.CRadius + self.CurLoc.x, self.CLR_C[idx * 3 + 1] * self.CRadius + self.CurLoc.y, self.CLR_C[idx * 3 + 2] * self.CRadius + self.CurLoc.z) vector2d = bpy_extras.view3d_utils.location_3d_to_region_2d( region, rv3d, vector3d) bgl.glVertex2f(*vector2d) idx += 1 bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) idx = 0 for i in range(int(len(self.CLR_C) / 3)): vector3d = (self.CLR_C[idx * 3] * self.CRadius / 3.0 + self.CurLoc.x, self.CLR_C[idx * 3 + 1] * self.CRadius / 3.0 + self.CurLoc.y, self.CLR_C[idx * 3 + 2] * self.CRadius / 3.0 + self.CurLoc.z) vector2d = bpy_extras.view3d_utils.location_3d_to_region_2d( region, rv3d, vector3d) bgl.glVertex2f(*vector2d) idx += 1 bgl.glEnd() bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw(self, highlighted: bool): bgl.glEnable(bgl.GL_BLEND) if highlighted: bgl.glColor4f(0.555, 0.555, 0.555, 0.8) else: bgl.glColor4f(0.447, 0.447, 0.447, 0.8) bgl.glRectf(self.x, self.y, self.x + self.width, self.y + self.height) texture = self.icon err = texture.gl_load(filter=bgl.GL_NEAREST, mag=bgl.GL_NEAREST) assert not err, 'OpenGL error: %i' % err bgl.glColor4f(0.0, 0.0, 1.0, 0.5) # bgl.glLineWidth(1.5) # ------ TEXTURE ---------# bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture.bindcode[0]) 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(self.x + self.icon_margin_x, self.y) bgl.glTexCoord2d(0, 1) bgl.glVertex2d(self.x + self.icon_margin_x, self.y + ICON_HEIGHT) bgl.glTexCoord2d(1, 1) bgl.glVertex2d(self.x + self.icon_margin_x + ICON_WIDTH, self.y + ICON_HEIGHT) bgl.glTexCoord2d(1, 0) bgl.glVertex2d(self.x + self.icon_margin_x + ICON_WIDTH, self.y) bgl.glEnd() bgl.glDisable(bgl.GL_TEXTURE_2D) bgl.glDisable(bgl.GL_BLEND) texture.gl_free() # draw some text font_id = 0 blf.position( font_id, self.x + self.icon_margin_x + ICON_WIDTH + self.text_margin_x, self.y + ICON_HEIGHT * 0.5 - 0.25 * self.text_height, 0) blf.size(font_id, self.text_height, self.text_width) blf.draw(font_id, self.label_text)
def draw_brush(cls, obj, context): sc = context.scene user_prefs = compat.get_user_preferences(context) prefs = user_prefs.addons["magic_uv"].preferences num_segment = 180 theta = 2 * pi / num_segment fact_t = tan(theta) fact_r = cos(theta) color = prefs.uv_sculpt_brush_color bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glColor4f(color[0], color[1], color[2], color[3]) x = sc.muv_uv_sculpt_radius * cos(0.0) y = sc.muv_uv_sculpt_radius * sin(0.0) for _ in range(num_segment): bgl.glVertex2f(x + obj.current_mco.x, y + obj.current_mco.y) tx = -y ty = x x = x + tx * fact_t y = y + ty * fact_t x = x * fact_r y = y * fact_r bgl.glEnd()
def draw_callback(self): # 50% alpha, 2 pixel width line bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(1.0, 0.0, 0.0, 0.7) bgl.glLineWidth(2) # Draw POST cell to end for loc in self.post_cells_locs: bgl.glBegin(bgl.GL_LINES) # bgl.GL_LINE_STRIP for bgl.glVertex3f(*self.axon_end_pt) bgl.glVertex3f(*loc) bgl.glEnd() # Draw PRE cell to start for loc in self.pre_cells_locs: bgl.glBegin(bgl.GL_LINES) # bgl.GL_LINE_STRIP for bgl.glVertex3f(*self.axon_start_pt) bgl.glVertex3f(*loc) 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_image(self, image, x, y, w, h, color=(0, 0, 0, 0.1)): bgl.glColor4f(0.5, 0.0, 0.5, 0.7) # draw main line and handles # bgl.glBegin(bgl.GL_LINES) bgl.glRectf(x, y, x+w, y+h) # bgl.glEnd() x1 = x y1 = y x2 = x + w y2 = y + h color = [0.5, 0.5, 0.5, 1] idx = image.gl_load(bgl.GL_NEAREST, bgl.GL_NEAREST) print([i for i in image.bindcode]) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 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.glEnable(bgl.GL_BLEND) #bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) bgl.glColor4f(color[0], color[1], color[2], color[3]) bgl.glBegin(bgl.GL_QUADS) bgl.glTexCoord2f(0, 0) bgl.glVertex2f(x1, y1) bgl.glTexCoord2f(0, 1) bgl.glVertex2f(x1, y2) bgl.glTexCoord2f(1, 1) bgl.glVertex2f(x2, y2) bgl.glTexCoord2f(1, 0) bgl.glVertex2f(x2, y1) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_TEXTURE_2D)
def draw_points(context, points, size, gl_col): region = context.region rv3d = context.space_data.region_3d this_object = context.active_object matrix_world = this_object.matrix_world # needed for adjusting the size of gl_points bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glPointSize(size) bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) bgl.glBegin(bgl.GL_POINTS) bgl.glColor4f(*gl_col) for coord in points: # vector3d = matrix_world * (coord.x, coord.y, coord.z) vector3d = matrix_world * coord vector2d = loc3d2d(region, rv3d, vector3d) bgl.glVertex2f(*vector2d) bgl.glEnd() bgl.glDisable(bgl.GL_POINT_SMOOTH) bgl.glDisable(bgl.GL_POINTS) return
def image_quad(img, color, verts): img.gl_load(bgl.GL_NEAREST, bgl.GL_NEAREST) bgl.glBindTexture(bgl.GL_TEXTURE_2D, img.bindcode) 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.glEnable(bgl.GL_BLEND) #bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) bgl.glColor4f(color[0], color[1], color[2], color[3]) bgl.glBegin(bgl.GL_QUADS) #http://h30097.www3.hp.com/docs/base_doc/DOCUMENTATION/V51B_HTML/MAN/MAN3/2025____.HTM bgl.glTexCoord2f(0, 0) bgl.glVertex2f(verts[0][0], verts[0][1]) bgl.glTexCoord2f(0, 1) bgl.glVertex2f(verts[1][0], verts[1][1]) bgl.glTexCoord2f(1, 1) bgl.glVertex2f(verts[2][0], verts[2][1]) bgl.glTexCoord2f(1, 0) bgl.glVertex2f(verts[3][0], verts[3][1]) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_TEXTURE_2D)
def draw_VIEW3D(self, args): if self.stash.obj: mesh = self.stash.obj.data # NOTE you can also draw quads, perhaps even ngons: # https://blender.stackexchange.com/questions/71980/modal-operator-to-highlight # offset amount depends on size of active object offset = sum([d for d in self.active.dimensions]) / 3 * 0.001 edgewidth = 2 edgecolor = (1.0, 1.0, 1.0, 0.75) bgl.glEnable(bgl.GL_BLEND) if self.xray: bgl.glDisable(bgl.GL_DEPTH_TEST) for edge in mesh.edges: v1 = mesh.vertices[edge.vertices[0]] v2 = mesh.vertices[edge.vertices[1]] # bring the coordinates into world space # and push them out abit so they are drawn on top of the mesh v1co = v1.co + v1.normal * offset + self.active.location v2co = v2.co + v2.normal * offset + self.active.location bgl.glLineWidth(edgewidth) bgl.glColor4f(*edgecolor) bgl.glBegin(bgl.GL_LINES) bgl.glVertex3f(*v1co) bgl.glVertex3f(*v2co) draw_end()
def textbox_draw2D(self, text, pos: Point2D, padding=5, textbox_position=7, fontid=None): ''' textbox_position specifies where the textbox is drawn in relation to pos. ex: if textbox_position==7, then the textbox is drawn where pos is the upper-left corner tip: textbox_position is arranged same as numpad +-----+ |7 8 9| |4 5 6| |1 2 3| +-----+ ''' lh = self.line_height # TODO: wrap text! lines = text.splitlines() w = max(self.get_text_width(line) for line in lines) h = len(lines) * lh # find top-left corner (adjusting for textbox_position) l, t = round(pos[0]), round(pos[1]) textbox_position -= 1 lcr = textbox_position % 3 tmb = int(textbox_position / 3) l += [w + padding, round(w / 2), -padding][lcr] t += [h + padding, round(h / 2), -padding][tmb] bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 0.25) bgl.glBegin(bgl.GL_QUADS) bgl.glVertex2f(l + w + padding, t + padding) bgl.glVertex2f(l - padding, t + padding) bgl.glVertex2f(l - padding, t - h - padding) bgl.glVertex2f(l + w + padding, t - h - padding) bgl.glEnd() bgl.glColor4f(0.0, 0.0, 0.0, 0.75) self.drawing.line_width(1.0) bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(l + w + padding, t + padding) bgl.glVertex2f(l - padding, t + padding) bgl.glVertex2f(l - padding, t - h - padding) bgl.glVertex2f(l + w + padding, t - h - padding) bgl.glVertex2f(l + w + padding, t + padding) bgl.glEnd() bgl.glColor4f(1, 1, 1, 0.5) for i, line in enumerate(lines): th = self.get_text_height(line) y = t - (i + 1) * lh + int((lh - th) / 2) fm.draw(line, xyz=(l, y, 0), fontid=fontid)
def draw_callback_px(self, context): bgl.glPushAttrib(bgl.GL_CLIENT_ALL_ATTRIB_BITS) FONT_RGBA = (0.8, 0.1, 0.1, 0.5) bgl.glColor4f(*FONT_RGBA) font_size = 11 DPI = 72 blf.size(0, font_size, DPI) msg = "Head Camera on..." msg_w, msg_h = blf.dimensions(0, msg) pos_x = context.region.width - msg_w pos_y = font_size / 2 blf.position(0, pos_x, pos_y, 0) #blf.position(0, 10, 10, 0) blf.draw(0, msg) bgl.glPopAttrib() pass
def draw_2dpolygon(points, linecolor=None, fillcolor=None, distance=0.2, linewidth=1): # background bgl.glEnable(bgl.GL_BLEND) bgl.glLineWidth(linewidth) if fillcolor: bgl.glColor4f(*fillcolor) bgl.glBegin(bgl.GL_POLYGON) for p in points: bgl.glVertex3f(*p, distance) bgl.glEnd() # frame if linecolor: bgl.glColor4f(*linecolor) bgl.glBegin(bgl.GL_LINE_STRIP) for p in points: bgl.glVertex3f(*p, distance) bgl.glVertex3f(*points[0], distance) bgl.glEnd() bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND)
def draw_HUD(self, args): draw_init(self, args) # alpha = 0.5 alpha = self.countdown / self.time title = "Draw Timer" subtitle = "%.*fs" % (1, self.countdown) subtitleoffset = 200 HUDcolor = m3.MM_prefs().modal_hud_color bgl.glColor4f(*HUDcolor, alpha) blf.position(self.font_id, self.HUDx - 7, self.HUDy, 0) blf.size(self.font_id, 20, 72) blf.draw(self.font_id, "» " + title) if subtitle: bgl.glColor4f(*HUDcolor, 0.25) blf.position(self.font_id, self.HUDx - 7 + subtitleoffset, self.HUDy, 0) blf.size(self.font_id, 15, 72) blf.draw(self.font_id, subtitle) draw_end()
def img_editor_draw_callback_px(self, context): # draw text draw_typo_2d((1.0, 1.0, 1.0, 1), "Image Editor Window") #draw the user clicked points on the image bgl.glPointSize(5) bgl.glBegin(bgl.GL_POINTS) bgl.glColor4f(0.8, 0.2, 0.5, 1.0) for pix in self.pixel_coords: img_x, img_y = pix[0], pix[1] img_size = self.imgeditor_area.spaces.active.image.size rx,ry = context.region.view2d.view_to_region(img_x/img_size[0], img_y/img_size[1], clip=True) if rx and ry: bgl.glVertex2f(rx, ry) bgl.glEnd() # restore opengl defaults bgl.glPointSize(1) bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_polyline_2d_loop(verts, faces, loops, color, contour, width): dpi = int(bpy.context.user_preferences.system.pixel_size) bgl.glColor4f(*color) bgl.glEnable(bgl.GL_BLEND) bgl.glEnable(bgl.GL_LINE_SMOOTH) bgl.glColor4f(*color) for face in faces: bgl.glBegin(bgl.GL_POLYGON) for v_index in face: coord = verts[v_index] bgl.glVertex2f(coord[0], coord[1]) bgl.glEnd() #antialiasing contour bgl.glColor4f(*color) bgl.glLineWidth(1) for loop in loops: if faces: bgl.glBegin(bgl.GL_LINE_LOOP) else: bgl.glBegin(bgl.GL_LINE_STRIP) for v_index in loop: coord = verts[v_index] bgl.glVertex2f(coord[0], coord[1]) bgl.glEnd() if width: bgl.glLineWidth(width * dpi) bgl.glColor4f(*contour) for loop in loops: bgl.glBegin(bgl.GL_LINE_LOOP) for v_index in loop: coord = verts[v_index] bgl.glVertex2f(coord[0], coord[1]) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_LINE_SMOOTH) bgl.glEnd() return
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) 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: bgl.glBegin(bgl.GL_LINE_LOOP) bgl.glColor4f(0.99, 0.5, 0.99, 1.0) 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() bgl.glBegin(bgl.GL_POINTS) # bgl.glBegin(bgl.GL_POLYGON) 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) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback_wc_view(context): gta_tools = bpy.context.scene.gta_tools global wc_state if wc_state.check_suspend(): return bgl.glEnable(bgl.GL_BLEND) bgl.glShadeModel(bgl.GL_SMOOTH) # Mark Active VG Position if gta_tools.weight_props.mark_bone: active_bone_pos = get_acive_bone() bgl.glPointSize(10.0) bgl.glBegin(bgl.GL_POINTS) bgl.glColor4f(1.0, 1.0, 1.0, 1.0) bgl.glVertex3f(*active_bone_pos) bgl.glEnd() # Show Weight Color if gta_tools.weight_props.weight_color or gta_tools.weight_props.mark_unweighted: #if ditect_update(): update_vw() # maybe removed, later #wc_state.check_update() check_update() bgl.glPointSize(gta_tools.weight_props.weight_size) bgl.glBegin(bgl.GL_POINTS) for vw in wc_state.vws: if (gta_tools.weight_props.weight_calc_margin < vw[1]): if gta_tools.weight_props.weight_color: bgl.glColor4f(*get_heat4f( vw[1], gta_tools.weight_props.weight_alpha)) bgl.glVertex3f(*vw[0]) elif gta_tools.weight_props.weight_calc_margin < -vw[1]: if gta_tools.weight_props.mark_unweighted: bgl.glColor4f(1.0, 0.0, 1.0, gta_tools.weight_props.weight_alpha) bgl.glVertex3f(*vw[0]) bgl.glEnd() # restore opengl defaults bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def drawSegment(x1, y1, x2, y2, future=False, limit=False): dx = x2 - x1 dy = y2 - y1 if max(abs(dx), abs(dy)) < 20: return if future: alpha = 0.2 else: alpha = 0.5 if abs(dx) >= abs(dy): xa = x1 + sgn(dx) * 10 xb = x2 - sgn(dx) * 10 ratio = dy / abs(dx) ya = y1 + 10 * ratio yb = y2 - 10 * ratio else: ya = y1 + sgn(dy) * 10 yb = y2 - sgn(dy) * 10 ratio = dx / abs(dy) xa = x1 + 10 * ratio xb = x2 - 10 * ratio #bgl.glLineWidth(2) bgl.glEnable(bgl.GL_LINE_STIPPLE) bgl.glEnable(bgl.GL_BLEND) if limit: bgl.glColor4f(1.0, 0.0, 0.0, alpha) else: bgl.glColor4f(0.0, 0.0, 0.0, alpha) bgl.glLineStipple(1, 0x00FF) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(xa, ya) bgl.glVertex2f(xb, yb) bgl.glEnd() bgl.glColor4f(1.0, 1.0, 1.0, alpha) bgl.glLineStipple(1, 0xFF00) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(xa, ya) bgl.glVertex2f(xb, yb) bgl.glEnd() bgl.glLineStipple(1, 0xFFFF) bgl.glDisable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_LINE_STIPPLE)
def draw_line_3d(color, start, end, width=1.0): transparent = (color[0], color[1], color[2], 0) center = (start + end) * 0.5 bgl.glLineWidth(width) bgl.glBegin(bgl.GL_LINES) bgl.glColor4f(*transparent) bgl.glVertex3f(*start) bgl.glColor4f(*color) bgl.glVertex3f(*center) bgl.glEnd() bgl.glBegin(bgl.GL_LINES) bgl.glColor4f(*color) bgl.glVertex3f(*center) bgl.glColor4f(*transparent) bgl.glVertex3f(*end) bgl.glEnd()
def DynamicNodes_DrawCallBack(self, context): if context.scene.DynamicNodes_Properties.arrange_mode: return bgl.glColor4f(0.6, 0.6, 0.7, 1) font_id = 0 blf.size(font_id, 12, 0) blf.position(font_id, 12, context.area.height - 48, 0) blf.enable(font_id, blf.SHADOW) blf.shadow(font_id, 3, 0, 0, 0, 1) blf.draw(font_id, 'Dynamic Nodes') if self.ghost: bgl.glEnable(bgl.GL_BLEND) for node in context.selected_nodes: if node.parent: continue if hasattr(node, 'shrink'): continue x1, y1 = v2r(node.location[0] - 10, node.location[1] + 10) x2, y2 = v2r(node.location[0] + node.dimensions[0] + 10, node.location[1] - node.dimensions[1] - 10) bgl.glColor4f(0.5, 0.95, 1.0, 0.1) bgl.glBegin(bgl.GL_QUADS) bgl.glVertex2i(x1, y1) bgl.glVertex2i(x2, y1) bgl.glVertex2i(x2, y2) bgl.glVertex2i(x1, y2) bgl.glEnd() bgl.glColor4f(0.0, 0.4, 0.7, 1) bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2i(x1, y1) bgl.glVertex2i(x2, y1) bgl.glVertex2i(x2, y2) bgl.glVertex2i(x1, y2) bgl.glVertex2i(x1, y1) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0) blf.disable(font_id, blf.SHADOW)
def draw_callback_px(context): # Note that the "context" passed in here is a regular dictionary and not the Blender context global screen_display_lines pid = None if 'mcell' in bpy.context.scene: mcell = bpy.context.scene.mcell if 'run_simulation' in mcell: rs = mcell.run_simulation if len(rs.processes_list) > 0: pid_str = rs.processes_list[rs.active_process_index].name pid = pid_str.split(',')[0].split()[1] bgl.glPushAttrib(bgl.GL_ENABLE_BIT) if parameter_dictionary['Clear']['val']: bgl.glClearColor(0.0, 0.0, 0.0, 1.0) bgl.glClear(bgl.GL_COLOR_BUFFER_BIT) font_id = 0 # XXX, need to find out how best to get this. y_pos = 15 * (scroll_offset + 1) if pid and (pid in screen_display_lines): for l in screen_display_lines[pid]: blf.position(font_id, 15, y_pos, 0) y_pos += 15 blf.size(font_id, 14, 72) # fontid, size, DPI bgl.glColor4f(1.0, 1.0, 1.0, 0.5) blf.draw(font_id, l) else: keys = screen_display_lines.keys() for k in keys: for l in screen_display_lines[k]: blf.position(font_id, 15, y_pos, 0) y_pos += 15 blf.size(font_id, 14, 72) # fontid, size, DPI bgl.glColor4f(1.0, 1.0, 1.0, 0.5) blf.draw(font_id, l) # 100% alpha, 2 pixel width line bgl.glEnable(bgl.GL_BLEND) bgl.glPopAttrib() # restore opengl defaults bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)