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_box(xmin, ymin, w, h, poly=False): bgl.glBegin(bgl.GL_QUADS if poly else bgl.GL_LINE_LOOP) bgl.glVertex2f(xmin, ymin) bgl.glVertex2f(xmin + w, ymin) bgl.glVertex2f(xmin + w, ymin + h) bgl.glVertex2f(xmin, ymin + h) bgl.glEnd()
def draw_elipse(cen, r, axis, xy_ratio, mat): base_axis = mathutils.Vector((0, 0, 1)) axis = mathutils.Vector(axis) dot = base_axis.dot(axis) cross = base_axis.cross(axis) rot_mat = mathutils.Matrix.Rotation(math.acos(dot), 4, cross) bgl.glBegin(bgl.GL_LINE_STRIP) iterations = 32 for i in range (iterations + 1): i = (1 if i == iterations + 1 else i) i *= 2 * math.pi / iterations co = (math.cos(i) * r, math.sin(i) * r * xy_ratio, 0) co = mathutils.Vector(co) co = rot_mat * co co[0] += cen[0] co[1] += cen[1] co[2] += cen[2] co = mat * co bgl.glVertex3f(co[0], co[1], co[2]) bgl.glEnd()
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_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 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_line(vertexloc, vertexnorm, scale): bgl.glBegin(bgl.GL_LINES) bgl.glVertex3f(vertexloc[0], vertexloc[1], vertexloc[2]) bgl.glVertex3f(((vertexnorm[0] * scale) + vertexloc[0]), ((vertexnorm[1] * scale) + vertexloc[1]), ((vertexnorm[2] * scale) + vertexloc[2])) bgl.glEnd()
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 redraw(self): drawregion = bpy.context.region rv3d = self.rv3ds[drawregion] vec = self.originvert.co.copy() vec.rotate(self.selobj.matrix_world) vec.rotate(self.selobj.matrix_world) self.space3d.cursor_location = vec * self.selobj.matrix_world + self.selobj.matrix_world.to_translation() bgl.glColor3f(1.0, 1.0, 0) bgl.glBegin(bgl.GL_POLYGON) x, y = self.getscreencoords(Vector(self.originvert.co), drawregion, rv3d) bgl.glVertex2f(x-2, y-2) bgl.glVertex2f(x-2, y+2) bgl.glVertex2f(x+2, y+2) bgl.glVertex2f(x+2, y-2) bgl.glEnd() bgl.glColor3f(1, 1, 0.7) bgl.glMatrixMode(bgl.GL_PROJECTION) bgl.glLoadIdentity() bgl.gluOrtho2D(0, self.region.width, 0, self.region.height) bgl.glMatrixMode(bgl.GL_MODELVIEW) bgl.glLoadIdentity() blf.position(0, self.region.width/2 - 80, self.region.height - 20, 0) blf.size(0, 12, 72) blf.draw(0, "FastOrigin : Enter confirms - ESC cancels")
def draw_callback_postview(self, context): bgl.glPushAttrib(bgl.GL_ALL_ATTRIB_BITS) # save OpenGL attributes self.draw_postview(context) if len(self.selectCntrl): cntrlLength = len(self.selectCntrl) for x in range(0,cntrlLength): # assuming that we have only one control point, so if # anything is selected it would be the only point p111 = self.selectCntrl[x] t111 = p111.to_tuple() vrot = context.space_data.region_3d.view_rotation dx = (vrot * Vector((1,0,0))).normalized() # compute right dir relative to view dy = (vrot * Vector((0,1,0))).normalized() # compute up dir relative to view px = tuple(p111 + dx*0.5) py = tuple(p111 + dy*0.5) # highlight the point bgl.glColor3f(1,1,0) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex3f(*t111) bgl.glEnd() # draw lines to indicate right (red) and up (green) bgl.glBegin(bgl.GL_LINES) bgl.glColor3f(1,0,0) bgl.glVertex3f(*t111) bgl.glVertex3f(*px) bgl.glColor3f(0,1,0) bgl.glVertex3f(*t111) bgl.glVertex3f(*py) bgl.glEnd() bgl.glPopAttrib() # restore OpenGL attributes
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 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 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_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 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_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 drawPoint(x, y, main=True): r = 6 if main else 3 bgl.glBegin(bgl.GL_LINES) bgl.glColor3f(1.0, 1.0, 1.0) bgl.glVertex2i(x - r, y) bgl.glVertex2i(x - r, y + r) bgl.glVertex2i(x - r, y + r) bgl.glVertex2i(x, y + r) bgl.glVertex2i(x + r, y) bgl.glVertex2i(x + r, y - r) bgl.glVertex2i(x + r, y - r) bgl.glVertex2i(x, y - r) bgl.glColor3f(0.0, 0.0, 0.0) bgl.glVertex2i(x, y + r) bgl.glVertex2i(x + r, y + r) bgl.glVertex2i(x + r, y + r) bgl.glVertex2i(x + r, y) bgl.glVertex2i(x, y - r) bgl.glVertex2i(x - r, y - r) bgl.glVertex2i(x - r, y - r) bgl.glVertex2i(x - r, y) bgl.glEnd()
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 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(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 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_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 draw_arc(center, radius, axis, angle_min, angle_max, local_transf_mat=None): base_axis = mathutils.Vector((0, 0, 1)) axis = mathutils.Vector(axis) dot = base_axis.dot(axis) cross = base_axis.cross(axis) axis_rotation = mathutils.Matrix.Rotation(math.acos(dot), 4, cross) bgl.glBegin(bgl.GL_LINE_STRIP) phi_range = wrap_2pi(angle_max - angle_min) points = [] co_from = calc_circ_coords(center, radius, axis_rotation, angle_min, local_transf_mat) bgl.glVertex3f(co_from.x, co_from.y, co_from.z) points.append(co_from) for i in range(1, NUM_SECTORS + 1): i *= 2 * math.pi / NUM_SECTORS if i < phi_range: co = calc_circ_coords(center, radius, axis_rotation, i + angle_min, local_transf_mat) bgl.glVertex3f(co.x, co.y, co.z) points.append(co) co_to = calc_circ_coords(center, radius, axis_rotation, angle_max, local_transf_mat) bgl.glVertex3f(co_to.x, co_to.y, co_to.z) points.append(co_to) bgl.glEnd() return points
def draw_line(point0, point1, width): bgl.glLineWidth(width) bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex3f(point0.x, point0.y, point0.z) bgl.glVertex3f(point1.x, point1.y, point1.z) bgl.glEnd() bgl.glLineWidth(1)
def post_view_callback(self, context): start = self.vertex_co normal_size = context.tool_settings.normal_size view_3d_theme = context.user_preferences.themes['Default'].view_3d default_color = view_3d_theme.split_normal highlight_color = [0.25, 1.0, 0.56] # Draw all normals of selected vertex. bgl.glBegin(bgl.GL_LINES) bgl.glColor3f(*default_color) bgl.glLineWidth(1) for n in self.normals: end = start + Vector(n) * normal_size bgl.glVertex3f(*start) bgl.glVertex3f(*end) bgl.glEnd() # Highlight selected normal. bgl.glColor3f(*highlight_color) bgl.glLineWidth(2) bgl.glBegin(bgl.GL_LINES) end = start + Vector(self.normals[self.normals_idx]) * normal_size bgl.glVertex3f(*start) bgl.glVertex3f(*end) 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 drawCurvePoints(self): #Draw Lines between Control Points bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glColor3d(0,1,0) bgl.glPointSize(3) bgl.glBegin(bgl.GL_POINTS) for i in range(len(self.curvePoints)): tup = self.curvePoints[i].to_tuple() bgl.glVertex3f( *tup ) bgl.glEnd() bgl.glLineWidth(1) bgl.glColor3f(0,.5,0) bgl.glBegin(bgl.GL_LINES) ''' for i in range(0, len(self.curvePoints)-1): if i%(self.tesselate+1) != self.tesselate: tup = self.curvePoints[i] tup1 = self.curvePoints[i+1] bgl.glVertex3f( *tup ) bgl.glVertex3f( *tup1 ) ''' for i in range(0, len(self.curvePoints)-1): tup = self.curvePoints[i].to_tuple() tup1 = self.curvePoints[i+1].to_tuple() bgl.glVertex3f(tup[0], tup[1], tup[2]) bgl.glVertex3f(tup1[0], tup1[1], tup1[2]) bgl.glEnd()
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 draw_boundings(self, context): for obj in bpy.data.objects: if obj.type == 'MESH' and obj.data.b4w_override_boundings: bounding_box = obj.data.b4w_boundings min_x = bounding_box.min_x max_x = bounding_box.max_x min_y = bounding_box.min_y max_y = bounding_box.max_y min_z = bounding_box.min_z max_z = bounding_box.max_z x_width = max_x - min_x y_width = max_y - min_y z_width = max_z - min_z cen = [0] * 3 cen[0] = (max_x + min_x) / 2 cen[1] = (max_y + min_y) / 2 cen[2] = (max_z + min_z) / 2 wm = obj.matrix_world if context.window_manager.b4w_draw_bound_box: bgl.glEnable(bgl.GL_BLEND) bgl.glLineWidth(2) # set colour bgl.glColor4f(0.5, 1.0, 1.0, 1.0) # draw boundings bgl.glBegin(bgl.GL_LINE_STRIP) co = mathutils.Vector((min_x, min_y, min_z)) co = wm * co bgl.glVertex3f(co[0], co[1], co[2]) co = mathutils.Vector((max_x, min_y, min_z)) co = wm * co bgl.glVertex3f(co[0], co[1], co[2]) co = mathutils.Vector((max_x, max_y, min_z)) co = wm * co bgl.glVertex3f(co[0], co[1], co[2]) co = mathutils.Vector((min_x, max_y, min_z)) co = wm * co bgl.glVertex3f(co[0], co[1], co[2]) bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) co = mathutils.Vector((min_x, min_y, max_z)) co = wm * co bgl.glVertex3f(co[0], co[1], co[2]) co = mathutils.Vector((min_x, min_y, min_z)) co = wm * co bgl.glVertex3f(co[0], co[1], co[2]) co = mathutils.Vector((min_x, max_y, min_z)) co = wm * co bgl.glVertex3f(co[0], co[1], co[2]) co = mathutils.Vector((min_x, max_y, max_z)) co = wm * co bgl.glVertex3f(co[0], co[1], co[2]) bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) co = mathutils.Vector((max_x, min_y, max_z)) co = wm * co bgl.glVertex3f(co[0], co[1], co[2]) co = mathutils.Vector((min_x, min_y, max_z)) co = wm * co bgl.glVertex3f(co[0], co[1], co[2]) co = mathutils.Vector((min_x, max_y, max_z)) co = wm * co bgl.glVertex3f(co[0], co[1], co[2]) co = mathutils.Vector((max_x, max_y, max_z)) co = wm * co bgl.glVertex3f(co[0], co[1], co[2]) bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) co = mathutils.Vector((max_x, max_y, min_z)) co = wm * co bgl.glVertex3f(co[0], co[1], co[2]) co = mathutils.Vector((max_x, max_y, max_z)) co = wm * co bgl.glVertex3f(co[0], co[1], co[2]) co = mathutils.Vector((max_x, min_y, max_z)) co = wm * co bgl.glVertex3f(co[0], co[1], co[2]) co = mathutils.Vector((max_x, min_y, min_z)) co = wm * co bgl.glVertex3f(co[0], co[1], co[2]) bgl.glEnd() bgl.glLineWidth(1) if context.window_manager.b4w_draw_bound_sphere: #draw spehere bgl.glColor4f(1.0, 0.5, 1.0, 1.0) r = math.sqrt(x_width * x_width + y_width * y_width + z_width * z_width) / 2 draw_elipse(cen, r, (1, 0, 0), 1, wm) draw_elipse(cen, r, (0, 1, 0), 1, wm) draw_elipse(cen, r, (0, 0, 1), 1, wm) bgl.glDisable(bgl.GL_BLEND) if context.window_manager.b4w_draw_bound_ellipsoid: #draw ellipsoid bgl.glColor4f(1.0, 1.0, 0.5, 1.0) sq3 = math.sqrt(3) / 2 draw_elipse(cen, sq3 * z_width, (1, 0, 0), y_width / z_width, wm) draw_elipse(cen, sq3 * x_width, (0, 1, 0), z_width / x_width, wm) draw_elipse(cen, sq3 * x_width, (0, 0, 1), y_width / x_width, wm) bgl.glDisable(bgl.GL_BLEND)
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 settings old_mag_filter = Buffer(bgl.GL_INT, 1) glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, old_mag_filter) old_wrap_S = Buffer(GL_INT, 1) old_wrap_T = Buffer(GL_INT, 1) glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, old_wrap_S) glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, old_wrap_T) # Set texture filter bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST) bgl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT) bgl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT) 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.glTexParameteriv(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, old_mag_filter) bgl.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, old_wrap_S) bgl.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, old_wrap_T) # Draw label font_id = 0 font_size = 16 pad = 5 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 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) if tilegrid.grid[0] == 1 and tilegrid.grid[1] == 1: size_text = "%dx%d" % (tile_sel[2], tile_sel[3]) blf.size(font_id, font_size, 72) size = blf.dimensions(font_id, size_text) x_pos = view_max.x - size[0] - pad y_pos = view_max.y + pad blf.position(font_id, x_pos, y_pos, 0) blf.draw(font_id, size_text) bgl.glDisable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_TEXTURE_2D) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_tile_select_ui(view_min, view_max, view_size, tex_size, grid_size, tile_selection, padding, margin, show_extra, is_pixel): # Draw the texture quad bgl.glColor4f(1.0, 1.0, 1.0, 1.0) bgl.glBegin(bgl.GL_QUADS) uv = [(0, 0), (0, 1), (1, 1), (1, 0)] vtx = [(view_min.x, view_min.y), (view_min.x, view_max.y), (view_max.x, view_max.y), (view_max.x, view_min.y)] for i in range(4): glTexCoord2f(uv[i][0], uv[i][1]) glVertex2f(vtx[i][0], vtx[i][1]) bgl.glEnd() # Not drawing tile grid overlay if show_extra is False: return # Translate the gl context by grid matrix scale_factor = (view_size[0] / tex_size[0], view_size[1] / tex_size[1]) # Setup to draw grid into viewport offset_matrix = Matrix.Translation((view_min.x, view_min.y, 0)) grid_matrix = sprytile_utils.get_grid_matrix(SprytileGui.loaded_grid) grid_matrix = Matrix.Scale(scale_factor[0], 4, Vector( (1, 0, 0))) * Matrix.Scale(scale_factor[1], 4, Vector( (0, 1, 0))) * grid_matrix calc_matrix = offset_matrix * grid_matrix matrix_vals = [calc_matrix[j][i] for i in range(4) for j in range(4)] grid_buff = bgl.Buffer(bgl.GL_FLOAT, 16, matrix_vals) glPushMatrix() glLoadIdentity() glLoadMatrixf(grid_buff) glDisable(GL_TEXTURE_2D) glLineWidth(1) if is_pixel is False: glColor4f(0.0, 0.0, 0.0, 0.5) # Draw the grid cell_size = (grid_size[0] + padding[0] * 2 + margin[1] + margin[3], grid_size[1] + padding[1] * 2 + margin[0] + margin[2]) x_divs = ceil(tex_size[0] / cell_size[0]) y_divs = ceil(tex_size[1] / cell_size[1]) x_end = x_divs * cell_size[0] y_end = y_divs * cell_size[1] for x in range(x_divs + 1): x_pos = (x * cell_size[0]) glBegin(GL_LINES) glVertex2f(x_pos, 0) glVertex2f(x_pos, y_end) glEnd() for y in range(y_divs + 1): y_pos = (y * cell_size[1]) glBegin(GL_LINES) glVertex2f(0, y_pos) glVertex2f(x_end, y_pos) glEnd() if SprytileGui.is_selecting or (is_pixel and tile_selection[2] == 1 or tile_selection[3] == 1): sel_min, sel_max = SprytileGui.get_sel_bounds( grid_size, padding, margin, tile_selection[0], tile_selection[1], tile_selection[2], tile_selection[3]) glColor4f(1.0, 1.0, 1.0, 1.0) SprytileGui.draw_selection(sel_min, sel_max, 0) glPopMatrix()
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_DisplayCage(self, context): flag = NP020PS.flag flag = 'DISPLAY' cage3d = NP020PS.cage3d cross3d = NP020PS.cross3d c3d = NP020PS.c3d region = context.region rv3d = context.region_data cage2d = copy.deepcopy(cage3d) cross2d = copy.deepcopy(cross3d) for co in cage3d.items(): #np_print(co[0]) cage2d[co[0]] = view3d_utils.location_3d_to_region_2d( region, rv3d, co[1]) for co in cross3d.items(): cross2d[co[0]] = view3d_utils.location_3d_to_region_2d( region, rv3d, co[1]) c2d = view3d_utils.location_3d_to_region_2d(region, rv3d, c3d) points = copy.deepcopy(cage2d) points.update(cross2d) # DRAWING START: bgl.glEnable(bgl.GL_BLEND) if flag == 'DISPLAY': instruct = 'select a handle' keys_aff = 'LMB - confirm, CTRL - force proportional, SHIFT - force central, TAB - apply scale / rotation' keys_nav = '' keys_neg = 'ESC - quit' if self.flag_con: mark_col = (1.0, 0.5, 0.0, 1.0) else: mark_col = (0.3, 0.6, 1.0, 1.0) # ON-SCREEN INSTRUCTIONS: display_instructions(region, rv3d, instruct, keys_aff, keys_nav, keys_neg) sensor = 60 self.mode = None co2d = mathutils.Vector(self.co2d) distmin = mathutils.Vector(co2d - c2d).length # Hover markers - detection for co in points.items(): dist = mathutils.Vector(co2d - co[1]).length if dist < distmin: distmin = dist if distmin < sensor: self.mode = co[0] self.hoverco = co[1] # Drawing the graphical representation of scale cage, calculated from selection's bound box: if self.mode == None: bgl.glColor4f(1.0, 1.0, 1.0, 1.0) bgl.glLineWidth(1.4) else: bgl.glColor4f(1.0, 1.0, 1.0, 0.5) bgl.glLineWidth(1.0) bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(*cage2d[0]) bgl.glVertex2f(*cage2d[1]) bgl.glVertex2f(*cage2d[2]) bgl.glVertex2f(*cage2d[3]) bgl.glVertex2f(*cage2d[0]) bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(*cage2d[4]) bgl.glVertex2f(*cage2d[5]) bgl.glVertex2f(*cage2d[6]) bgl.glVertex2f(*cage2d[7]) bgl.glVertex2f(*cage2d[4]) bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(*cage2d[0]) bgl.glVertex2f(*cage2d[4]) bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(*cage2d[1]) bgl.glVertex2f(*cage2d[5]) bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(*cage2d[2]) bgl.glVertex2f(*cage2d[6]) bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(*cage2d[3]) bgl.glVertex2f(*cage2d[7]) bgl.glEnd() bgl.glColor4f(1.0, 1.0, 1.0, 0.5) bgl.glLineWidth(1.0) bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(*cross2d['xmin']) bgl.glVertex2f(*cross2d['xmax']) bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(*cross2d['ymin']) bgl.glVertex2f(*cross2d['ymax']) bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(*cross2d['zmin']) bgl.glVertex2f(*cross2d['zmax']) bgl.glEnd() #bgl.glDepthRange(0,0) bgl.glColor4f(0.35, 0.65, 1.0, 1.0) bgl.glPointSize(9) bgl.glBegin(bgl.GL_POINTS) for [a, b] in cross2d.values(): bgl.glVertex2f(a, b) bgl.glEnd() bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glColor4f(1.0, 1.0, 1.0, 1.0) bgl.glPointSize(11) bgl.glBegin(bgl.GL_POINTS) for co in cage2d.items(): if len(str(co[0])) == 1: bgl.glVertex2f(*co[1]) bgl.glEnd() bgl.glDisable(bgl.GL_POINT_SMOOTH) markers = {} markers[0] = (points[0], points[10], points[40], points[0], points[30], points[40], points[0], points[10], points[30]) markers[1] = (points[1], points[10], points[15], points[1], points[12], points[15], points[1], points[10], points[12]) markers[2] = (points[2], points[12], points[26], points[2], points[23], points[26], points[2], points[12], points[23]) markers[3] = (points[3], points[30], points[37], points[3], points[23], points[37], points[3], points[30], points[23]) markers[4] = (points[4], points[45], points[47], points[4], points[40], points[47], points[4], points[40], points[45]) markers[5] = (points[5], points[45], points[56], points[5], points[15], points[56], points[5], points[15], points[45]) markers[6] = (points[6], points[26], points[67], points[6], points[56], points[67], points[6], points[26], points[56]) markers[7] = (points[7], points[37], points[67], points[7], points[47], points[67], points[7], points[37], points[47]) markers['xmin'] = (points[0], points[3], points[7], points[4], points[0]) markers['xmax'] = (points[1], points[2], points[6], points[5], points[1]) markers['ymin'] = (points[0], points[1], points[5], points[4], points[0]) markers['ymax'] = (points[2], points[3], points[7], points[6], points[2]) markers['zmin'] = (points[0], points[1], points[2], points[3], points[0]) markers['zmax'] = (points[4], points[5], points[6], points[7], points[4]) pivot = {} if self.flag_cenpivot: pivot[0] = c2d pivot[1] = c2d pivot[2] = c2d pivot[3] = c2d pivot[4] = c2d pivot[5] = c2d pivot[6] = c2d pivot[7] = c2d pivot['xmin'] = c2d pivot['xmax'] = c2d pivot['ymin'] = c2d pivot['ymax'] = c2d pivot['zmin'] = c2d pivot['zmax'] = c2d else: pivot[0] = points[6] pivot[1] = points[7] pivot[2] = points[4] pivot[3] = points[5] pivot[4] = points[2] pivot[5] = points[3] pivot[6] = points[0] pivot[7] = points[1] pivot['xmin'] = points['xmax'] pivot['xmax'] = points['xmin'] pivot['ymin'] = points['ymax'] pivot['ymax'] = points['ymin'] pivot['zmin'] = points['zmax'] pivot['zmax'] = points['zmin'] np_print('self.mode = ', self.mode) fields = False field_contours = False pivots = True pivot_lines = True if fields: # Hover markers - fields bgl.glColor4f(0.65, 0.85, 1.0, 0.35) for mark in markers.items(): if mark[0] == self.mode: #if type(mark[0]) is not str: #bgl.glColor4f(1.0, 1.0, 1.0, 0.3) bgl.glBegin(bgl.GL_TRIANGLE_FAN) for x, y in mark[1]: bgl.glVertex2f(x, y) bgl.glEnd() if field_contours: # Hover markers - contours bgl.glColor4f(1.0, 1.0, 1.0, 1.0) bgl.glLineWidth(1.2) for mark in markers.items(): if mark[0] == self.mode: if type(mark[0]) is not str: #bgl.glColor4f(0.3, 0.6, 1.0, 0.5) bgl.glColor4f(1.0, 1.0, 1.0, 0.75) bgl.glLineWidth(1.0) bgl.glBegin(bgl.GL_LINE_STRIP) for x, y in mark[1]: bgl.glVertex2f(x, y) bgl.glEnd() # Hover markers - pivot bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glColor4f(*mark_col) bgl.glPointSize(12) for p in pivot.items(): if p[0] == self.mode: if pivots: bgl.glBegin(bgl.GL_POINTS) #np_print(p[1]) bgl.glVertex2f(*p[1]) bgl.glEnd() if pivot_lines: bgl.glLineWidth(1.0) #bgl.glEnable(bgl.GL_LINE_STIPPLE) bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(*points[self.mode]) bgl.glVertex2f(*p[1]) bgl.glEnd() #bgl.glDisable(bgl.GL_LINE_STIPPLE) if self.flag_cenpivot: bgl.glColor4f(1.0, 0.5, 0.0, 1.0) bgl.glPointSize(12) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex2f(*c2d) bgl.glEnd() bgl.glDisable(bgl.GL_POINT_SMOOTH) # Hover markers - points bgl.glColor4f(1.0, 1.0, 1.0, 1.0) bgl.glPointSize(16) for mark in markers.items(): if mark[0] == self.mode: if type(mark[0]) is not str: bgl.glColor4f(*mark_col) bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glPointSize(18) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex2f(*points[self.mode]) bgl.glEnd() bgl.glColor4f(*mark_col) bgl.glPointSize(12) if type(mark[0]) is not str: bgl.glColor4f(1.0, 1.0, 1.0, 1.0) bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glPointSize(14) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex2f(*points[self.mode]) bgl.glEnd() bgl.glDisable(bgl.GL_POINT_SMOOTH) if self.flag_force: flash_size = 7 flash = [[0, 0], [2, 2], [1, 2], [2, 4], [0, 2], [1, 2], [0, 0]] for co in flash: co[0] = round( (co[0] * flash_size), 0) + self.co2d[0] + flash_size * 2 co[1] = round( (co[1] * flash_size), 0) + self.co2d[1] - flash_size * 2 bgl.glColor4f(0.95, 0.95, 0.0, 1.0) bgl.glBegin(bgl.GL_TRIANGLE_FAN) for i, co in enumerate(flash): if i in range(0, 3): bgl.glVertex2f(*co) bgl.glEnd() bgl.glBegin(bgl.GL_TRIANGLE_FAN) for i, co in enumerate(flash): if i in range(3, 6): bgl.glVertex2f(*co) bgl.glEnd() bgl.glColor4f(1.0, 0.7, 0.0, 1.0) bgl.glBegin(bgl.GL_LINE_STRIP) for co in flash: bgl.glVertex2f(*co) bgl.glEnd() # 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_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 draw_mouse(context, shape, style, alpha): # shape and position sc = context.scene mouse_size = sc.screencast_keys_mouse_size font_size = sc.screencast_keys_font_size link = sc.screencast_keys_link pos_x, pos_y = getDisplayLocation(context) if link == True: offset_x = pos_x else: offset_x = context.region.width - pos_x - (mouse_size * MOUSE_RATIO) offset_y = pos_y if font_size > mouse_size: offset_y += (font_size - mouse_size) / 2 shape_data = get_shape_data(shape) bgl.glTranslatef(offset_x, offset_y, 0) # color r, g, b = sc.screencast_keys_color bgl.glEnable(bgl.GL_BLEND) #bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) #bgl.glColor4f(r, g, b, alpha) # inner shape for filled style if style == "filled": inner_shape = [] for i in shape_data: inner_shape.append(i[0]) # outer shape for i in shape_data: shape_segment = i shape_segment[0] = [mouse_size * k for k in shape_segment[0]] shape_segment[1] = [mouse_size * k for k in shape_segment[1]] shape_segment[2] = [mouse_size * k for k in shape_segment[2]] shape_segment[3] = [mouse_size * k for k in shape_segment[3]] # create the buffer shape_buffer = bgl.Buffer(bgl.GL_FLOAT, [4, 3], shape_segment) # create the map and draw the triangle fan bgl.glMap1f(bgl.GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, shape_buffer) bgl.glEnable(bgl.GL_MAP1_VERTEX_3) bgl.glColor4f(r, g, b, alpha) if style == "outline": bgl.glBegin(bgl.GL_LINE_STRIP) else: # style == "filled" bgl.glBegin(bgl.GL_TRIANGLE_FAN) for j in range(10): bgl.glEvalCoord1f(j / 10.0) x, y, z = shape_segment[3] # make sure the last vertex is indeed the last one, to avoid gaps bgl.glVertex3f(x, y, z) bgl.glEnd() bgl.glDisable(bgl.GL_MAP1_VERTEX_3) # draw interior if style == "filled": bgl.glColor4f(r, g, b, alpha) bgl.glBegin(bgl.GL_TRIANGLE_FAN) for i in inner_shape: j = [mouse_size * k for k in i] x, y, z = j bgl.glVertex3f(x, y, z) bgl.glEnd() bgl.glTranslatef(-offset_x, -offset_y, 0)
def DrawNorth_callback(self, context): if not Sun.SP.ShowNorth and North.isActive: North.deactivate() return # ------------------------------------------------------------------ # Set up the compass needle using the current north offset angle # less 90 degrees. This forces the unit circle to begin at the # 12 O'clock instead of 3 O'clock position. # ------------------------------------------------------------------ color = (0.2, 0.6, 1.0, 0.7) radius = 100 angle = -(Sun.NorthOffset - math.pi / 2) x = math.cos(angle) * radius y = math.sin(angle) * radius p1, p2 = (0, 0, 0), (x, y, 0) # Start & end of needle #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> # Thanks to Buerbaum Martin for the following which draws openGL # lines. ( From his script space_view3d_panel_measure.py ) #<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< # ------------------------------------------------------------------ # Convert the Perspective Matrix of the current view/region. # ------------------------------------------------------------------ view3d = bpy.context region = view3d.region_data perspMatrix = region.perspective_matrix tempMat = [perspMatrix[j][i] for i in range(4) for j in range(4)] perspBuff = bgl.Buffer(bgl.GL_FLOAT, 16, tempMat) # --------------------------------------------------------- # Store previous OpenGL settings. # --------------------------------------------------------- MatrixMode_prev = bgl.Buffer(bgl.GL_INT, [1]) bgl.glGetIntegerv(bgl.GL_MATRIX_MODE, MatrixMode_prev) MatrixMode_prev = MatrixMode_prev[0] # Store projection matrix ProjMatrix_prev = bgl.Buffer(bgl.GL_DOUBLE, [16]) bgl.glGetFloatv(bgl.GL_PROJECTION_MATRIX, ProjMatrix_prev) # Store Line width lineWidth_prev = bgl.Buffer(bgl.GL_FLOAT, [1]) bgl.glGetFloatv(bgl.GL_LINE_WIDTH, lineWidth_prev) lineWidth_prev = lineWidth_prev[0] # Store GL_BLEND blend_prev = bgl.Buffer(bgl.GL_BYTE, [1]) bgl.glGetFloatv(bgl.GL_BLEND, blend_prev) blend_prev = blend_prev[0] line_stipple_prev = bgl.Buffer(bgl.GL_BYTE, [1]) bgl.glGetFloatv(bgl.GL_LINE_STIPPLE, line_stipple_prev) line_stipple_prev = line_stipple_prev[0] # Store glColor4f color_prev = bgl.Buffer(bgl.GL_FLOAT, [4]) bgl.glGetFloatv(bgl.GL_COLOR, color_prev) # --------------------------------------------------------- # Prepare for 3D drawing # --------------------------------------------------------- bgl.glLoadIdentity() bgl.glMatrixMode(bgl.GL_PROJECTION) bgl.glLoadMatrixf(perspBuff) bgl.glEnable(bgl.GL_BLEND) bgl.glEnable(bgl.GL_LINE_STIPPLE) # ------------------ # and draw the line # ------------------ width = 2 bgl.glLineWidth(width) bgl.glColor4f(color[0], color[1], color[2], color[3]) bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex3f(p1[0], p1[1], p1[2]) bgl.glVertex3f(p2[0], p2[1], p2[2]) bgl.glEnd() # --------------------------------------------------------- # Restore previous OpenGL settings # --------------------------------------------------------- bgl.glLoadIdentity() bgl.glMatrixMode(MatrixMode_prev) bgl.glLoadMatrixf(ProjMatrix_prev) bgl.glLineWidth(lineWidth_prev) if not blend_prev: bgl.glDisable(bgl.GL_BLEND) if not line_stipple_prev: bgl.glDisable(bgl.GL_LINE_STIPPLE) bgl.glColor4f(color_prev[0], color_prev[1], color_prev[2], color_prev[3])
def draw_callback_px(self, context): font_id = 0 # XXX, need to find out how best to get this. screenPointsMomentum = [] screenPointsImpulses = [] screenPointsCOM = [] screenPointsAngularMomentum = [] screenPointsFreefallPath = [] for i in range(0, len(context.scene.momentum_trail.centerOfMasses)): centerOfMassPath = context.scene.momentum_trail.centerOfMasses[i] momentumVectorsForObj = context.scene.momentum_trail.momentumVectors[i] momentumImpulsesForObj = context.scene.momentum_trail.momentumImpulses[ i] angularMomentumsForObj = context.scene.momentum_trail.angularMomentum[ i] #create set of lines for momentum vectors for j in range(0, len(centerOfMassPath)): com = centerOfMassPath[j] moVecEnd = com + ( momentumVectorsForObj[j] * context.scene.momentum_trail.momentum_vector_scale) comPoint = world_to_screen(context, com) screenPointsCOM.append(comPoint) screenPointsMomentum.append(comPoint) screenPointsMomentum.append(world_to_screen(context, moVecEnd)) #create set of lines for impulses for j in range(0, len(momentumImpulsesForObj)): com = centerOfMassPath[j] impulseVecEnd = com + ( momentumImpulsesForObj[j] * context.scene.momentum_trail.momentum_vector_scale) screenPointsImpulses.append(world_to_screen(context, com)) screenPointsImpulses.append(world_to_screen( context, impulseVecEnd)) #create set of lines for angular momentum for j in range(0, len(centerOfMassPath)): com = centerOfMassPath[j] moVecEnd = com + ( angularMomentumsForObj[j] * context.scene.momentum_trail.momentum_vector_scale) screenPointsAngularMomentum.append(world_to_screen(context, com)) screenPointsAngularMomentum.append( world_to_screen(context, moVecEnd)) bgl.glEnable(bgl.GL_BLEND) #draw center of masses if context.scene.momentum_trail.showCOM: bgl.glColor4f(1.0, 1.0, 1.0, 0.5) bgl.glPointSize(4) bgl.glBegin(bgl.GL_POINTS) for x, y in screenPointsCOM: bgl.glVertex2i(int(x), int(y)) bgl.glEnd() #draw momentum vectors if context.scene.momentum_trail.showMomentum: bgl.glColor4f(1.0, 0.0, 0.0, 0.5) bgl.glLineWidth(2) bgl.glBegin(bgl.GL_LINES) for x, y in screenPointsMomentum: bgl.glVertex2i(int(x), int(y)) bgl.glEnd() #draw impulse vectors if context.scene.momentum_trail.showImpulse: bgl.glColor4f(1.0, 1.0, 0.0, 0.5) bgl.glBegin(bgl.GL_LINES) for x, y in screenPointsImpulses: bgl.glVertex2i(int(x), int(y)) bgl.glEnd() #mark current frame with a brighter dot if hasattr(context.scene.momentum_trail, "frameNums"): if len(context.scene.momentum_trail.frameNums) > 0: if context.scene.frame_current >= context.scene.momentum_trail.frameNums[ 0][0] and context.scene.frame_current <= context.scene.momentum_trail.frameNums[ 0][-1]: idx = context.scene.frame_current - context.scene.momentum_trail.frameNums[ 0][0] bgl.glPointSize(6) bgl.glColor4f(1.0, .8, .8, 0.8) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex2i(int(screenPointsCOM[idx][0]), int(screenPointsCOM[idx][1])) bgl.glEnd() if context.scene.momentum_trail.showAngularMomentum: bgl.glColor4f(0.0, 1.0, 0.0, 0.5) bgl.glBegin(bgl.GL_LINES) for x, y in screenPointsAngularMomentum: bgl.glVertex2i(int(x), int(y)) bgl.glEnd() if context.scene.momentum_trail.showFreefallPath: print("doing freefall path") # restore opengl defaults bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def Draw_map_callback(self, context): if context.area != Map.view3d_area: return elif context.area.type == 'PROPERTIES' and \ context.space_data.context != 'WORLD': return # Check if window area has changed for sticky zoom theMap = Map.object[0] if Map.region.width < Map.saved_region_width: diff = Map.saved_region_width - Map.region.width if theMap.origin.x + theMap.width > Map.saved_region_width: if theMap.origin.x > 0: theMap.origin.x -= diff else: theMap.width -= diff else: if Map.toolProps is not None: if Map.toolProps.width > Map.toolProps_width: theMap.origin.x -= diff Map.toolProps_width = Map.toolProps.width if theMap.origin.x < 0: theMap.origin.x += diff else: diff = Map.region.width - Map.saved_region_width if theMap.width > Map.saved_region_width: theMap.width += diff else: if Map.toolProps is not None: if Map.toolProps.width < Map.toolProps_width: theMap.origin.x += diff Map.toolProps_width = Map.toolProps.width theMap.set_dimensions(theMap.width) Map.saved_region_width = Map.region.width # Latitude and longitude are set to an equidistant # cylindrical projection with lat/long 0/0 exactly # in the middle of the image. zLong = theMap.width / 2 longFac = zLong / 180 zLat = theMap.height / 2 latFac = zLat / 90 crossChange = True if not Map.action == 'PAN': x = Map.mouse.x y = Map.mouse.y if x < theMap.origin.x or x > theMap.origin.x + theMap.width: crossChange = False x = 0 else: testBoundary = theMap.origin.x + theMap.width if testBoundary < Map.region.width: rightBoundary = testBoundary else: rightBoundary = Map.region.width if x > rightBoundary: crossChange = False x = rightBoundary cX = x - zLong - theMap.origin.x if longFac: newLongitude = cX / longFac else: newLongitude = 0.0 if y < theMap.origin.y or y < 0: crossChange = False y = 0 elif y > theMap.origin.y + theMap.height: crossChange = False y = theMap.origin.y + theMap.height cY = y - zLat - theMap.origin.y if latFac: newLatitude = cY / latFac else: newLatitude = 0.0 if newLatitude == Map.latitude and newLongitude == Map.longitude: crossChange = False else: Map.latitude = newLatitude Map.longitude = newLongitude else: if Map.grab.offset.x < Map.grab.spot.x: off = Map.grab.spot.x - Map.grab.offset.x theMap.origin.x -= off else: off = Map.grab.offset.x - Map.grab.spot.x theMap.origin.x += off if Map.grab.offset.y < Map.grab.spot.y: off = Map.grab.spot.y - Map.grab.offset.y theMap.origin.y -= off else: off = Map.grab.offset.y - Map.grab.spot.y theMap.origin.y += off Map.grab.spot.x = Map.mouse.x Map.grab.spot.y = Map.mouse.y Lx = theMap.origin.x Ly = theMap.origin.y # --------------------- # Draw a textured quad # --------------------- if not Map.textureless: bgl.glEnable(bgl.GL_BLEND) if Map.glImage.bindcode == 0: Map.load_gl_image() bgl.glBindTexture(bgl.GL_TEXTURE_2D, Map.glImage.bindcode) bgl.glEnable(bgl.GL_TEXTURE_2D) bgl.glColor4f(1.0, 1.0, 1.0, Map.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 + theMap.width, Ly) bgl.glTexCoord2f(1.0, 1.0) bgl.glVertex2f(Lx + theMap.width, Ly + theMap.height) bgl.glTexCoord2f(0.0, 1.0) bgl.glVertex2f(Lx, theMap.height + Ly) bgl.glEnd() bgl.glDisable(bgl.GL_TEXTURE_2D) # ----------------------- # Output text for stats # ----------------------- if Map.action == 'TIME' or Map.action == 'DAY' or Map.showInfo: Map.show_text_in_viewport(Map.object[1]) # --------------------- # draw the crosshair # --------------------- x = theMap.width / 2.0 if crossChange and not Map.lockCrosshair: if Map.action != 'Y': Sun.SP.Longitude = newLongitude longitude = (Sun.SP.Longitude * x / 180.0) + x bgl.glEnable(bgl.GL_BLEND) bgl.glEnable(bgl.GL_LINES) bgl.glLineWidth(1.0) alpha = 1.0 if Map.action == 'Y' else 0.5 color = (0.894, 0.741, .510, alpha) bgl.glColor4f(color[0], color[1], color[2], color[3]) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(Lx + longitude, Ly) bgl.glVertex2f(Lx + longitude, Ly + theMap.height) bgl.glEnd() y = theMap.height / 2.0 if crossChange and not Map.lockCrosshair: if Map.action != 'X': Sun.SP.Latitude = newLatitude latitude = (Sun.SP.Latitude * y / 90.0) + y alpha = 1.0 if Map.action == 'X' else 0.5 color = (0.894, 0.741, .510, alpha) bgl.glColor4f(color[0], color[1], color[2], color[3]) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(Lx, Ly + latitude) bgl.glVertex2f(Lx + theMap.width, Ly + latitude) 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 + theMap.width, Ly) bgl.glVertex2f(Lx + theMap.width, Ly + theMap.height) bgl.glVertex2f(Lx, theMap.height + Ly) bgl.glVertex2f(Lx, Ly) bgl.glEnd() if not Sun.ShowRiseSet or not Map.lineWidth: bgl.glDisable(bgl.GL_LINES) bgl.glFlush() return if Map.action == 'G': draw_text_region() # ------------------------ # draw the sunrise, sunset # ------------------------ def draw_angled_line(color, angle, bx, by): x = math.cos(angle) * radius y = math.sin(angle) * radius bgl.glColor4f(color[0], color[1], color[2], color[3]) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(bx, by) bgl.glVertex2f(bx + x, by + y) bgl.glEnd() px = Lx + longitude py = Ly + latitude radius = 30 + Map.lineWidth * 10 if Sun.RiseSetOK and Map.lineWidth: color = (0.2, 0.6, 1.0, 0.9) angle = -(degToRad(Sun.Sunrise.azimuth) - math.pi / 2) bgl.glLineWidth(Map.lineWidth) draw_angled_line(color, angle, px, py) color = (0.86, 0.18, 0.18, 0.9) angle = -(degToRad(Sun.Sunset.azimuth) - math.pi / 2) draw_angled_line(color, angle, px, py) # ------------------------ # draw current time line # ------------------------ if Map.textureless: phi = degToRad(Sun.AzNorth) * -1 else: phi = degToRad(Sun.Azimuth) * -1 x = math.sin(phi) * math.sin(-Sun.Theta) * (radius + 10) y = math.sin(Sun.Theta) * math.cos(phi) * (radius + 10) night = (0.24, 0.29, 0.94, 0.9) day = (0.85, 0.77, 0.60, 0.9) if Sun.SolarNoon.elevation < 0.0: color = night elif Sun.Elevation >= Sun.Sunrise.elevation: if Sun.Time >= Sun.Sunset.time and \ Sun.Elevation <= Sun.Sunset.elevation: color = night else: color = day else: color = night bgl.glLineWidth(Map.lineWidth + 1.0) bgl.glColor4f(color[0], color[1], color[2], color[3]) bgl.glBegin(bgl.GL_LINES) bgl.glVertex2f(px, py) bgl.glVertex2f(px + x, py + y) bgl.glEnd() bgl.glLineWidth(1.0) bgl.glDisable(bgl.GL_LINES) bgl.glFlush()
def draw_callback_px_box(self, context): wm = context.window_manager sc = context.scene if not wm.screencast_keys_keys: return font_size = sc.screencast_keys_font_size mouse_size = sc.screencast_keys_mouse_size if sc.screencast_keys_mouse_position == 'right': mouse_size = 25 box_draw = sc.screencast_keys_box_draw pos_x, pos_y = getDisplayLocation(context) # get text-width/height to resize the box blf.size(0, sc.screencast_keys_font_size, 72) box_width, box_height = sc.screencast_keys_box_width, 0 final = 0 row_count = 0 box_hide = sc.screencast_keys_box_hide label_time_max = sc.screencast_keys_fade_time for i in range(len(self.key)): label_time = time.time() - self.time[i] if label_time < label_time_max: # only display key-presses of last 4 seconds box_width, box_height = getBoundingBox(box_width, box_height, self.key[i]) row_count += 1 final = i + 1 box_hide = False else: break # Got the size right, now draw box using proper colors box_color_r, box_color_g, box_color_b, box_color_alpha = sc.screencast_keys_box_color if box_draw and not box_hide: padding_x = 16 padding_y = 12 x0 = max(0, pos_x - padding_x) y0 = max(0, pos_y - padding_y) x1 = pos_x + box_width + mouse_size * MOUSE_RATIO * 1.3 + padding_x y1 = pos_y + max(mouse_size, font_size * row_count) + padding_y positions = [[x0, y0], [x0, y1], [x1, y1], [x1, y0]] settings = [[bgl.GL_QUADS, min(0.0, box_color_alpha)], [bgl.GL_LINE_LOOP, min(0.0, box_color_alpha)]] for mode, box_alpha in settings: bgl.glEnable(bgl.GL_BLEND) bgl.glBegin(mode) bgl.glColor4f(box_color_r, box_color_g, box_color_b, box_color_alpha) for v1, v2 in positions: bgl.glVertex2f(v1, v2) bgl.glEnd() if sc.screencast_keys_show_operator: draw_last_operator(context, pos_x, pos_y) if sc.screencast_keys_timer_show: draw_timer(context, pos_x, pos_y) # get rid of status texts that aren't displayed anymore self.key = self.key[:final] self.time = self.time[:final]
def draw_callback_px(self, context): wm = context.window_manager sc = context.scene if not wm.screencast_keys_keys: return font_size = sc.screencast_keys_font_size mouse_size = sc.screencast_keys_mouse_size link = sc.screencast_keys_link pos_x, pos_y = getDisplayLocation(context) # draw text in the 3d-view # ======================== blf.size(0, sc.screencast_keys_font_size, 72) r, g, b = sc.screencast_keys_color final = 0 row_count = len(self.key) keypos_x = pos_x if link == True: keypos_x += mouse_size * MOUSE_RATIO * 1.3 shift = 0 if mouse_size > font_size * row_count: shift = (mouse_size - font_size * row_count) / 2 text_width, text_height = 0, 0 row_count = 0 alpha = 1.0 for i in range(len(self.key)): label_time = time.time() - self.time[i] if label_time < 2: # only display key-presses of last 2 seconds keypos_y = pos_y + shift + font_size * (i + 0.1) blf.position(0, keypos_x, keypos_y, 0) alpha = min(1.0, max(0.0, 2 * (2 - label_time))) bgl.glColor4f(r, g, b, alpha) blf.draw(0, self.key[i]) text_width, text_height = getBoundingBox(text_width, text_height, self.key[i]) row_count += 1 final = i else: break # get rid of status texts that aren't displayed anymore self.key = self.key[:final + 1] self.time = self.time[:final + 1] # draw graphical representation of the mouse # ========================================== if sc.screencast_keys_mouse == 'icon': for shape in ["mouse", "left_button", "middle_button", "right_button"]: draw_mouse(context, shape, "outline", 0.5) final = 0 for i in range(len(self.mouse)): click_time = time.time() - self.mouse_time[i] if click_time < 2: shape = map_mouse_event(self.mouse[i]) if shape: alpha = min(1.0, max(0.0, 2 * (2 - click_time))) draw_mouse(context, shape, "filled", alpha) final = i else: break # get rid of mouse clicks that aren't displayed anymore self.mouse = self.mouse[:final + 1] self.mouse_time = self.mouse_time[:final + 1] # Draw border (if enabled) # ======================== if link == True and row_count > 0: bgl.glEnable(bgl.GL_BLEND) bgl.glBegin(bgl.GL_QUADS) bgl.glLineWidth(2) bgl.glColor4f(r, g, b, 0.2) drawRectangle(pos_x, pos_y, text_width + mouse_size * MOUSE_RATIO * 1.3, max(mouse_size, font_size * row_count), 4) bgl.glEnd() bgl.glBegin(bgl.GL_LINES) bgl.glColor4f(r, g, b, alpha) drawRectangle(pos_x, pos_y, text_width + mouse_size * MOUSE_RATIO * 1.3, max(mouse_size, font_size * row_count), 4) bgl.glEnd()
def draw_2D(self, context): settings = common_utilities.get_settings() region, r3d = context.region, context.space_data.region_3d mx = self.mx mxnorm = matrix_normal(mx) color_inactive = settings.theme_colors_mesh[settings.theme] color_selection = settings.theme_colors_selection[settings.theme] color_active = settings.theme_colors_active[settings.theme] color_frozen = settings.theme_colors_frozen[settings.theme] color_warning = settings.theme_colors_warning[settings.theme] bgl.glEnable(bgl.GL_POINT_SMOOTH) color_handle = (color_inactive[0], color_inactive[1], color_inactive[2], 1.00) color_border = (color_inactive[0], color_inactive[1], color_inactive[2], 1.00) color_fill = (color_inactive[0], color_inactive[1], color_inactive[2], 0.20) if self.fsm_mode == 'sketch' and self.sketch: # Draw smoothing line (end of sketch to current mouse position) common_drawing_px.draw_polyline_from_points( context, [self.sketch_curpos, self.sketch[-1][0]], color_active, 1, "GL_LINE_SMOOTH") # Draw sketching stroke common_drawing_px.draw_polyline_from_points( context, [co[0] for co in self.sketch], color_selection, 2, "GL_LINE_STIPPLE") if self.fsm_mode in {'scale tool', 'rotate tool'}: # Draw a scale/rotate line from tool origin to current mouse position common_drawing_px.draw_polyline_from_points( context, [self.action_center, self.mode_pos], (0, 0, 0, 0.5), 1, "GL_LINE_STIPPLE") bgl.glLineWidth(1) if self.fsm_mode == 'brush scale tool': # scaling brush size self.sketch_brush.draw(context, color=(1, 1, 1, .5), linewidth=1, color_size=(1, 1, 1, 1)) elif self.fsm_mode not in {'grab tool', 'scale tool', 'rotate tool' } and not self.is_navigating: # draw the brush oriented to surface ray, hit = common_utilities.ray_cast_region2d_bvh( region, r3d, self.cur_pos, mesh_cache['bvh'], self.mx, settings) hit_p3d, hit_norm, hit_idx = hit if hit_idx != None: # and not self.hover_ed: #hit_p3d = mx * hit_p3d #hit_norm = mxnorm * hit_norm common_drawing_px.draw_circle(context, hit_p3d, hit_norm.normalized(), self.stroke_radius, (1, 1, 1, .5)) if self.fsm_mode == 'sketch' and self.sketch: ray, hit = common_utilities.ray_cast_region2d_bvh( region, r3d, self.sketch[0][0], mesh_cache['bvh'], self.mx, settings) hit_p3d, hit_norm, hit_idx = hit if hit_idx != None: #hit_p3d = mx * hit_p3d #hit_norm = mxnorm * hit_norm common_drawing_px.draw_circle(context, hit_p3d, hit_norm.normalized(), self.stroke_radius, (1, 1, 1, .5)) if self.hover_ed and False: #EXTEND to display hoverable edges color = (color_selection[0], color_selection[1], color_selection[2], 1.00) common_drawing_px.draw_bmedge(context, self.hover_ed, self.dest_obj.matrix_world, 2, color) if self.act_gedge: if settings.show_segment_count: bgl.glColor4f(*color_active) self.draw_gedge_info(self.act_gedge, context) if self.act_gpatch: if settings.show_segment_count: bgl.glColor4f(*color_active) self.draw_gpatch_info(self.act_gpatch, context) if True: txt = 'v:%d e:%d s:%d p:%d' % (len( self.polystrips.gverts), len( self.polystrips.gedges), len(self.polystrips.gedgeseries), len(self.polystrips.gpatches)) txt_width, txt_height = blf.dimensions(0, txt) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(0, 0, 0, 0.8) bgl.glBegin(bgl.GL_QUADS) bgl.glVertex2f(0, 0) bgl.glVertex2f(10 + txt_width, 0) bgl.glVertex2f(10 + txt_width, 10 + txt_height) bgl.glVertex2f(0, 10 + txt_height) bgl.glEnd() bgl.glColor4f(1, 1, 1, 1) blf.position(0, 5, 5, 0) blf.draw(0, txt)
def draw_callback_px(self, context): font_id = 0 alpha = context.scene.pt_custom_props.a font_size = context.scene.pt_custom_props.fs bgl.glColor4f(0.0, 0.6, 1.0, alpha) bgl.glPointSize(4.0) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex2f(pt_buf.x, pt_buf.y) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) # -- -- -- -- location 3d if context.scene.pt_custom_props.b2 == True: mloc3d = region_2d_to_location_3d(context.region, context.space_data.region_3d, Vector((pt_buf.x, pt_buf.y)), pt_buf.depth_location) blf.position(font_id, pt_buf.x + 15, pt_buf.y - 15, 0) blf.size(font_id, font_size, context.user_preferences.system.dpi) blf.draw(font_id, '(' + str(round(mloc3d[0], 4)) + ', ' + str(round(mloc3d[1], 4)) + ', ' + str(round(mloc3d[2], 4)) + ')') n = len(pt_buf.list_m_loc_3d) if n != 0: # -- -- -- -- add points bgl.glEnable(bgl.GL_BLEND) bgl.glPointSize(4.0) bgl.glBegin(bgl.GL_POINTS) for i in pt_buf.list_m_loc_3d: loc_0 = location_3d_to_region_2d(context.region, context.space_data.region_3d, i) bgl.glVertex2f(loc_0[0], loc_0[1]) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) # -- -- -- -- text next to the mouse m_loc_3d = region_2d_to_location_3d(context.region, context.space_data.region_3d, Vector((pt_buf.x, pt_buf.y)), pt_buf.depth_location) vec0 = pt_buf.list_m_loc_3d[-1] - m_loc_3d blf.position(font_id, pt_buf.x + 15, pt_buf.y + 15, 0) blf.size(font_id, font_size, context.user_preferences.system.dpi) blf.draw(font_id, str(round(vec0.length, 4))) # -- -- -- -- angle first after mouse if n >= 2: vec1 = pt_buf.list_m_loc_3d[-2] - pt_buf.list_m_loc_3d[-1] if vec0.length == 0.0 or vec1.length == 0.0: pass else: ang = vec0.angle(vec1) if round(degrees(ang), 2) == 180.0: text_0 = '0.0' elif round(degrees(ang), 2) == 0.0: text_0 = '180.0' else: text_0 = str(round(degrees(ang), 2)) loc_4 = location_3d_to_region_2d(context.region, context.space_data.region_3d, pt_buf.list_m_loc_3d[-1]) bgl.glColor4f(0.0, 1.0, 0.525, alpha) blf.position(font_id, loc_4[0] + 10, loc_4[1] + 10, 0) blf.size(font_id, font_size, context.user_preferences.system.dpi) blf.draw(font_id, text_0 + '') bgl.glLineStipple(4, 0x5555) bgl.glEnable(bgl.GL_LINE_STIPPLE) # enable line stipple bgl.glColor4f(0.0, 0.6, 1.0, alpha) # -- -- -- -- draw line between last point and mouse bgl.glEnable(bgl.GL_BLEND) bgl.glBegin(bgl.GL_LINES) loc_1 = location_3d_to_region_2d(context.region, context.space_data.region_3d, pt_buf.list_m_loc_3d[-1]) bgl.glVertex2f(loc_1[0], loc_1[1]) bgl.glVertex2f(pt_buf.x, pt_buf.y) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) # -- -- -- -- draw lines between points bgl.glEnable(bgl.GL_BLEND) bgl.glBegin(bgl.GL_LINE_STRIP) for j in pt_buf.list_m_loc_3d: loc_2 = location_3d_to_region_2d(context.region, context.space_data.region_3d, j) bgl.glVertex2f(loc_2[0], loc_2[1]) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_LINE_STIPPLE) # disable line stipple # -- -- -- -- draw line length between points if context.scene.pt_custom_props.b1 == True: for k in range(n - 1): loc_3 = location_3d_to_region_2d(context.region, context.space_data.region_3d, (pt_buf.list_m_loc_3d[k] + pt_buf.list_m_loc_3d[(k + 1) % n]) * 0.5) blf.position(font_id, loc_3[0] + 10, loc_3[1] + 10, 0) blf.size(font_id, font_size, context.user_preferences.system.dpi) blf.draw(font_id, str(round((pt_buf.list_m_loc_3d[k] - pt_buf.list_m_loc_3d[(k + 1) % n]).length, 4))) # -- -- -- -- draw all angles if context.scene.pt_custom_props.b0 == True: for h in range(n - 1): if n >= 2: if h == 0: pass else: vec_ = pt_buf.list_m_loc_3d[h] - pt_buf.list_m_loc_3d[(h - 1) % n] if vec_.length == 0.0: pass else: ang = vec_.angle(pt_buf.list_m_loc_3d[h] - pt_buf.list_m_loc_3d[(h + 1) % n]) if round(degrees(ang)) == 0.0: pass else: loc_4 = location_3d_to_region_2d(context.region, context.space_data.region_3d, pt_buf.list_m_loc_3d[h]) bgl.glColor4f(0.0, 1.0, 0.525, alpha) blf.position(font_id, loc_4[0] + 10, loc_4[1] + 10, 0) blf.size(font_id, font_size, context.user_preferences.system.dpi) blf.draw(font_id, str(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, 'Draw On')
def display_cursor_badge(co2d, symbol, badge_mode, message_main, message_aux, aux_num, aux_str): display_badge = addon_settings_graph('display_badge') size_badge = addon_settings_graph('size_badge') col_bg_fill_main_run = addon_settings_graph('col_bg_fill_main_run') col_bg_fill_main_nav = addon_settings_graph('col_bg_fill_main_nav') col_bg_fill_aux = addon_settings_graph('col_bg_fill_aux') col_bg_fill_square = addon_settings_graph('col_bg_fill_square') col_bg_line_symbol = addon_settings_graph('col_bg_line_symbol') col_bg_font_main = addon_settings_graph('col_bg_font_main') col_bg_font_aux = addon_settings_graph('col_bg_font_aux') if badge_mode == 'RUN': col_bg_fill_main = col_bg_fill_main_run elif badge_mode == 'NAV': col_bg_fill_main = col_bg_fill_main_nav if display_badge: font_id = 0 square = [[17, 30], [17, 40], [27, 40], [27, 30]] rectangle = [[27, 30], [27, 40], [67, 40], [67, 30]] ipx = 29 ipy = 33 for co in square: co[0] = round( (co[0] * size_badge), 0) - (size_badge * 10) + co2d[0] co[1] = round( (co[1] * size_badge), 0) - (size_badge * 25) + co2d[1] for co in rectangle: co[0] = round( (co[0] * size_badge), 0) - (size_badge * 10) + co2d[0] co[1] = round( (co[1] * size_badge), 0) - (size_badge * 25) + co2d[1] for co in symbol: co[0] = round( (co[0] * size_badge), 0) - (size_badge * 10) + co2d[0] co[1] = round( (co[1] * size_badge), 0) - (size_badge * 25) + co2d[1] ipx = round((ipx * size_badge), 0) - (size_badge * 10) + co2d[0] ipy = round((ipy * size_badge), 0) - (size_badge * 25) + co2d[1] ipsize = int(round((6 * size_badge), 0)) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(*col_bg_fill_square) bgl.glBegin(bgl.GL_TRIANGLE_FAN) for x, y in square: bgl.glVertex2f(x, y) bgl.glEnd() bgl.glColor4f(*col_bg_fill_main) bgl.glBegin(bgl.GL_TRIANGLE_FAN) for x, y in rectangle: bgl.glVertex2f(x, y) bgl.glEnd() bgl.glColor4f(*col_bg_line_symbol) bgl.glBegin(bgl.GL_LINE_STRIP) for x, y in symbol: bgl.glVertex2f(x, y) bgl.glEnd() bgl.glColor4f(*col_bg_font_main) blf.position(font_id, ipx, ipy, 0) blf.size(font_id, ipsize, 72) blf.draw(font_id, message_main) if message_aux != None: bgl.glColor4f(*col_bg_fill_aux) bgl.glBegin(bgl.GL_TRIANGLE_FAN) if aux_num == None and aux_str == None: rectangle = [[17, 30], [17, 40], [67, 40], [67, 30]] for co in rectangle: co[0] = round( (co[0] * size_badge), 0) - (size_badge * 10) + co2d[0] co[1] = round( (co[1] * size_badge), 0) - (size_badge * 25) + co2d[1] for x, y in rectangle: if aux_num == None and aux_str == None: bgl.glVertex2f(x, (y - (size_badge * 10))) np_print('111111111111') elif aux_num != None: bgl.glVertex2f(x, y - (size_badge * 35)) np_print('222222222222') elif aux_str != None: bgl.glVertex2f(x, y - (size_badge * 25)) np_print('3333333333333') bgl.glEnd() bgl.glColor4f(*col_bg_font_aux) if aux_num == None and aux_str == None: blf.position(font_id, ipx, ipy - (size_badge * 10), 0) elif aux_num != None: blf.position(font_id, ipx, ipy - (size_badge * 35), 0) elif aux_str != None: blf.position(font_id, ipx, ipy - (size_badge * 25), 0) blf.size(font_id, ipsize, 72) blf.draw(font_id, message_aux) if aux_num != None: bgl.glColor4f(*col_bg_font_aux) blf.position(font_id, ipx, int(ipy - size_badge * 25), 0) blf.size(font_id, int(size_badge * 24), 72) blf.draw(font_id, aux_num) if aux_str != None: bgl.glColor4f(*col_bg_font_aux) blf.position(font_id, ipx, int(ipy - size_badge * 15), 0) blf.size(font_id, ipsize, 72) blf.draw(font_id, aux_num) ''' if step == 'continuous': bgl.glBegin(bgl.GL_LINE_STRIP) for x, y in dots1: bgl.glVertex2f(x, y) bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) for x, y in dots2: bgl.glVertex2f(x, y) bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) for x, y in dots3: bgl.glVertex2f(x, y) bgl.glEnd() ''' bgl.glDisable(bgl.GL_BLEND)
def render_opengl(self, context): from math import ceil layers = [] scene = context.scene for x in range(0, 20): if scene.layers[x] is True: layers.extend([x]) objlist = context.scene.objects render_scale = scene.render.resolution_percentage / 100 width = int(scene.render.resolution_x * render_scale) height = int(scene.render.resolution_y * render_scale) # I cant use file_format becuase the pdf writer needs jpg format # the file_format returns 'JPEG' not 'JPG' # file_format = context.scene.render.image_settings.file_format.lower() ren_path = bpy.path.abspath(bpy.context.scene.render.filepath) + ".jpg" # if len(ren_path) > 0: # if ren_path.endswith(os.path.sep): # initpath = os.path.realpath(ren_path) + os.path.sep # else: # (initpath, filename) = os.path.split(ren_path) # outpath = os.path.join(initpath, "ogl_tmp.png") # else: # self.report({'ERROR'}, "Invalid render path") # return False img = get_render_image(ren_path) if img is None: self.report({'ERROR'}, "Invalid render path:" + ren_path) return False tile_x = 240 tile_y = 216 row_num = ceil(height / tile_y) col_num = ceil(width / tile_x) cut4 = (col_num * tile_x * 4) - width * 4 totpixel4 = width * height * 4 viewport_info = bgl.Buffer(bgl.GL_INT, 4) bgl.glGetIntegerv(bgl.GL_VIEWPORT, viewport_info) img.gl_load(0, bgl.GL_NEAREST, bgl.GL_NEAREST) # 2.77 API change if bpy.app.version >= (2, 77, 0): tex = img.bindcode[0] else: tex = img.bindcode if context.scene.name in bpy.data.images: old_img = bpy.data.images[context.scene.name] old_img.user_clear() bpy.data.images.remove(old_img) img_result = bpy.data.images.new(context.scene.name, width, height) tmp_pixels = [1] * totpixel4 #---------- Loop for all tiles for row in range(0, row_num): for col in range(0, col_num): buffer = bgl.Buffer(bgl.GL_FLOAT, width * height * 4) bgl.glDisable( bgl.GL_SCISSOR_TEST ) # if remove this line, get blender screenshot not image bgl.glViewport(0, 0, tile_x, tile_y) bgl.glMatrixMode(bgl.GL_PROJECTION) bgl.glLoadIdentity() # defines ortographic view for single tile x1 = tile_x * col y1 = tile_y * row bgl.gluOrtho2D(x1, x1 + tile_x, y1, y1 + tile_y) # Clear bgl.glClearColor(0.0, 0.0, 0.0, 0.0) bgl.glClear(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_DEPTH_BUFFER_BIT) bgl.glEnable(bgl.GL_TEXTURE_2D) bgl.glBindTexture(bgl.GL_TEXTURE_2D, tex) # defines drawing area bgl.glBegin(bgl.GL_QUADS) bgl.glColor3f(1.0, 1.0, 1.0) bgl.glTexCoord2f(0.0, 0.0) bgl.glVertex2f(0.0, 0.0) bgl.glTexCoord2f(1.0, 0.0) bgl.glVertex2f(width, 0.0) bgl.glTexCoord2f(1.0, 1.0) bgl.glVertex2f(width, height) bgl.glTexCoord2f(0.0, 1.0) bgl.glVertex2f(0.0, height) bgl.glEnd() for obj in objlist: if obj.mv.type == 'VISDIM_A': for x in range(0, 20): if obj.layers[x] is True: if x in layers: opengl_dim = obj.mv.opengl_dim if not opengl_dim.hide: draw_dimensions(context, obj, opengl_dim, None, None) break #---------- copy pixels to temporary area bgl.glFinish() bgl.glReadPixels(0, 0, width, height, bgl.GL_RGBA, bgl.GL_FLOAT, buffer) # read image data for y in range(0, tile_y): # final image pixels position p1 = (y * width * 4) + (row * tile_y * width * 4) + (col * tile_x * 4) p2 = p1 + (tile_x * 4) # buffer pixels position b1 = y * width * 4 b2 = b1 + (tile_x * 4) if p1 < totpixel4: # avoid pixel row out of area if col == col_num - 1: # avoid pixel columns out of area p2 -= cut4 b2 -= cut4 tmp_pixels[p1:p2] = buffer[b1:b2] img_result.pixels = tmp_pixels[:] img.gl_free() img.user_clear() bpy.data.images.remove(img) os.remove(ren_path) bgl.glEnable(bgl.GL_SCISSOR_TEST) #---------- restore opengl defaults bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0) if img_result is not None: return img_result
def display_instructions(region, rv3d, instruct, keys_aff, keys_nav, keys_neg): userpref = bpy.context.preferences system = userpref.system rwtools = 0 rwui = 0 np_print(system.use_region_overlap) if system.use_region_overlap: area = bpy.context.area np_print('GO', area.regions) for r in area.regions: if r.type == 'TOOLS': rwtools = r.width elif r.type == 'UI': rwui = r.width np_print('rwtools', rwtools, 'rwui', rwui) field_keys_y = 46 field_keys_x = 80 rw = region.width rh = region.height np_print('rw, rh', rw, rh) expand = False crop = False len_aff_max = rw - 140 - rwtools - rwui len_aff = len(keys_aff) * 5 len_neg = len(keys_neg) * 5 len_ins = len(instruct) * 18 if len_aff > len_aff_max: expand = True rw_min = 480 rh_min = 280 if rw - rwtools - rwui < rw_min or rh < rh_min: crop = True version = '020' font_id = 0 keys_aff_1 = copy.deepcopy(keys_aff) keys_aff_2 = ' ' if expand: keys_aff_1 = '' keys_aff_2 = '' np_print('len(keys_aff)', len(keys_aff)) stop = 0 for i in range(0, len(keys_aff) - 1): #np_print(keys_aff[i]) if keys_aff[i] == ',' and i * 5 <= len_aff_max and i > stop: stop = i np_print('stop', stop) for i in range(0, stop + 1): keys_aff_1 = keys_aff_1 + keys_aff[i] for i in range(stop + 2, len(keys_aff)): keys_aff_2 = keys_aff_2 + keys_aff[i] np_print(keys_aff_1) np_print(keys_aff_2) field_keys_aff_1 = [[field_keys_x + rwtools, field_keys_y + 21], [field_keys_x + rwtools, field_keys_y + 39], [rw - int(field_keys_x / 2) - rwui, field_keys_y + 39], [rw - int(field_keys_x / 2) - rwui, field_keys_y + 21]] field_keys_aff_2 = copy.deepcopy(field_keys_aff_1) field_keys_neg = [[field_keys_x + rwtools, field_keys_y], [field_keys_x + rwtools, field_keys_y + 18], [rw - int(field_keys_x / 2) - rwui, field_keys_y + 18], [rw - int(field_keys_x / 2) - rwui, field_keys_y]] if expand: field_keys_aff_2 = copy.deepcopy(field_keys_neg) field_keys_neg = [ [field_keys_x + rwtools, field_keys_y - 21], [field_keys_x + rwtools, field_keys_y - 3], [rw - int(field_keys_x / 2) - rwui, field_keys_y - 3], [rw - int(field_keys_x / 2) - rwui, field_keys_y - 21] ] size_font_np = 25 size_font_instruct = 21 size_font_keys = 11 len_np_ins = len_ins + int(size_font_np * 2.1) pos_font_np_x = (rw - len_np_ins / 2) / 2 + rwtools / 2 - rwui / 2 pos_font_np_y = 150 if crop: pos_font_np_y = 75 pos_font_instruct_x = pos_font_np_x + int(size_font_np * 2.1) pos_font_instruct_y = pos_font_np_y + 4 pos_font_keys_aff_1_x = field_keys_x + 8 + rwtools pos_font_keys_aff_1_y = field_keys_y + 26 pos_font_keys_aff_2_x = copy.deepcopy(pos_font_keys_aff_1_x) pos_font_keys_aff_2_y = copy.deepcopy(pos_font_keys_aff_1_y) pos_font_keys_nav_x = field_keys_x + 8 + rwtools pos_font_keys_nav_y = field_keys_y + 5 pos_font_keys_neg_x = rw - 52 - len_neg - rwui np_print('len_neg', len_neg) np_print('pos_font_keys_neg_x', pos_font_keys_neg_x) pos_font_keys_neg_y = field_keys_y + 5 if expand: pos_font_keys_aff_2_x = field_keys_x + 8 + rwtools pos_font_keys_aff_2_y = field_keys_y + 5 pos_font_keys_nav_x = field_keys_x + 8 + rwtools pos_font_keys_nav_y = field_keys_y - 16 pos_font_keys_neg_x = rw - 52 - len_neg - rwui pos_font_keys_neg_y = field_keys_y - 16 - rwui col_font_np = addon_settings_graph('col_font_np') col_font_instruct_main = addon_settings_graph('col_font_instruct_main') col_font_instruct_shadow = addon_settings_graph('col_font_instruct_shadow') col_font_keys = addon_settings_graph('col_font_keys') col_field_keys_aff = addon_settings_graph('col_field_keys_aff') col_field_keys_neg = addon_settings_graph('col_field_keys_neg') # instructions - NP: bgl.glColor4f(*col_font_np) blf.size(font_id, size_font_np, 72) blf.position(font_id, pos_font_np_x, pos_font_np_y, 0) blf.draw(font_id, 'NP') blf.enable(font_id, ROTATION) ang = radians(90) blf.size(font_id, int(size_font_np / 2.2), 72) blf.rotation(font_id, ang) blf.position(font_id, pos_font_np_x + int(size_font_np * 1.72), pos_font_np_y - 2, 0) blf.draw(font_id, version) blf.disable(font_id, ROTATION) # instructions - instruct: bgl.glColor4f(*col_font_instruct_shadow) blf.position(font_id, pos_font_instruct_x + 1, pos_font_instruct_y - 1, 0) blf.size(font_id, size_font_instruct, 72) blf.draw(font_id, instruct) bgl.glColor4f(*col_font_instruct_main) blf.position(font_id, pos_font_instruct_x, pos_font_instruct_y, 0) blf.size(font_id, size_font_instruct, 72) blf.draw(font_id, instruct) bgl.glDisable(bgl.GL_BLEND) # instructions - keys - backdrop fields: bgl.glEnable(bgl.GL_BLEND) if crop == False: bgl.glColor4f(*col_field_keys_aff) bgl.glBegin(bgl.GL_TRIANGLE_FAN) for co in field_keys_aff_1: bgl.glVertex2f(*co) bgl.glEnd() bgl.glColor4f(*col_field_keys_aff) bgl.glBegin(bgl.GL_TRIANGLE_FAN) for co in field_keys_aff_2: bgl.glVertex2f(*co) bgl.glEnd() bgl.glColor4f(*col_field_keys_neg) bgl.glBegin(bgl.GL_TRIANGLE_FAN) for co in field_keys_neg: bgl.glVertex2f(*co) bgl.glEnd() # instructions - keys - writing: bgl.glColor4f(*col_font_keys) blf.size(font_id, size_font_keys, 72) blf.position(font_id, pos_font_keys_aff_1_x, pos_font_keys_aff_1_y, 0) blf.draw(font_id, keys_aff_1) blf.position(font_id, pos_font_keys_aff_2_x, pos_font_keys_aff_2_y, 0) blf.draw(font_id, keys_aff_2) blf.position(font_id, pos_font_keys_nav_x, pos_font_keys_nav_y, 0) blf.draw(font_id, keys_nav) blf.position(font_id, pos_font_keys_neg_x, pos_font_keys_neg_y, 0) blf.draw(font_id, keys_neg)
def display_geowidget(region, rv3d, fac, ro_hor, q, helploc, n, qdef, geowidget_base, geowidget_top, geowidget_rest): geowidget_cross = [(0.0, 2.1, 0.0), (0.0, 0.9, 0.0), (-2.1, 0.0, 0.0), (-0.9, 0.0, 0.0)] # drawing of geowidget - cross part: for i, co in enumerate(geowidget_cross): co = Vector(co) co = co * fac geowidget_cross[i] = co geowidget_cross = rotate_graphic(geowidget_cross, ro_hor) geowidget_cross = rotate_graphic(geowidget_cross, q) geowidget_cross = translate_graphic(geowidget_cross, helploc) col_gw_line_cross = addon_settings_graph('col_gw_line_cross') col_gw_line_base_free = addon_settings_graph('col_gw_line_base_free') col_gw_line_base_lock_x = addon_settings_graph('col_gw_line_base_lock_x') col_gw_line_base_lock_y = addon_settings_graph('col_gw_line_base_lock_y') col_gw_line_base_lock_z = addon_settings_graph('col_gw_line_base_lock_z') col_gw_line_base_lock_arb = addon_settings_graph( 'col_gw_line_base_lock_arb') col_gw_line_all = addon_settings_graph('col_gw_line_all') col_gw_fill_base_x = addon_settings_graph('col_gw_fill_base_x') col_gw_fill_base_y = addon_settings_graph('col_gw_fill_base_y') col_gw_fill_base_z = addon_settings_graph('col_gw_fill_base_z') col_gw_fill_base_arb = addon_settings_graph('col_gw_fill_base_arb') bgl.glColor4f(*col_gw_line_cross) bgl.glLineWidth(1) bgl.glBegin(bgl.GL_LINE_STRIP) for i, co in enumerate(geowidget_cross): if i in range( 0, 2 ): # range is always - first as is, second one one higher than last #np_print(i) co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) bgl.glVertex2f(*co) geowidget_cross[i] = co bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) for i, co in enumerate(geowidget_cross): if i in range( 2, 4 ): # range is always - first as is, second one one higher than last #np_print(i) co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) bgl.glVertex2f(*co) geowidget_cross[i] = co bgl.glEnd() # drawing of geowidget - base part: for i, co in enumerate(geowidget_base): co = Vector(co) co = co * fac geowidget_base[i] = co geowidget_base = rotate_graphic(geowidget_base, ro_hor) geowidget_base = rotate_graphic(geowidget_base, q) geowidget_base = translate_graphic(geowidget_base, helploc) n = n.to_tuple() n = list(n) for i, co in enumerate(n): n[i] = abs(round(co, 4)) np_print('n for color', n) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(*col_gw_line_base_free) bgl.glLineWidth(1) if qdef != None: if n[0] == 0.0 and n[1] == 0.0 and n[2] == 1.0: bgl.glColor4f(*col_gw_line_base_lock_z) elif n[0] == 1.0 and n[1] == 0.0 and n[2] == 0.0: bgl.glColor4f(*col_gw_line_base_lock_x) elif n[0] == 0.0 and n[1] == 1.0 and n[2] == 0.0: bgl.glColor4f(*col_gw_line_base_lock_y) else: bgl.glColor4f(*col_gw_line_base_lock_arb) bgl.glBegin(bgl.GL_LINE_STRIP) for i, co in enumerate(geowidget_base): #np_print(i) co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) bgl.glVertex2f(*co) geowidget_base[i] = co bgl.glVertex2f(*geowidget_base[0]) bgl.glEnd() bgl.glColor4f(*col_gw_fill_base_arb) if n[0] == 0.0 and n[1] == 0.0 and n[2] == 1.0: bgl.glColor4f(*col_gw_fill_base_z) np_print('go_Z') elif n[0] == 1.0 and n[1] == 0.0 and n[2] == 0.0: bgl.glColor4f(*col_gw_fill_base_x) np_print('go_X') elif n[0] == 0.0 and n[1] == 1.0 and n[2] == 0.0: bgl.glColor4f(*col_gw_fill_base_y) np_print('go_Y') bgl.glBegin(bgl.GL_TRIANGLE_FAN) for co in geowidget_base: bgl.glVertex2f(*co) bgl.glEnd() # drawing of geowidget - top part: if geowidget_top != None: for i, co in enumerate(geowidget_top): co = Vector(co) co = co * fac geowidget_top[i] = co geowidget_top = rotate_graphic(geowidget_top, ro_hor) geowidget_top = rotate_graphic(geowidget_top, q) geowidget_top = translate_graphic(geowidget_top, helploc) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(*col_gw_line_all) bgl.glLineWidth(1) bgl.glBegin(bgl.GL_LINE_STRIP) for i, co in enumerate(geowidget_top): #np_print(i) co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) bgl.glVertex2f(*co) geowidget_top[i] = co bgl.glVertex2f(*geowidget_top[0]) bgl.glEnd() # drawing of geowidget - rest part: if geowidget_rest != None: for i, co in enumerate(geowidget_rest): co = Vector(co) co = co * fac geowidget_rest[i] = co geowidget_rest = rotate_graphic(geowidget_rest, ro_hor) geowidget_rest = rotate_graphic(geowidget_rest, q) geowidget_rest = translate_graphic(geowidget_rest, helploc) bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(*col_gw_line_all) bgl.glLineWidth(1) bgl.glBegin(bgl.GL_LINE_STRIP) for i, co in enumerate(geowidget_rest): #np_print(i) co = view3d_utils.location_3d_to_region_2d(region, rv3d, co) bgl.glVertex2f(*co) geowidget_rest[i] = co bgl.glVertex2f(*geowidget_rest[0]) bgl.glEnd()
def cursor_memory_draw(cls,context): cc = context.scene.cursor_memory draw = 0 if hasattr(cc, "savedLocationDraw"): draw = cc.savedLocationDraw if(draw): bgl.glEnable(bgl.GL_BLEND) bgl.glShadeModel(bgl.GL_FLAT) p1 = Vector(cc.savedLocation) location = region3d_get_2d_coordinates(context, p1) alpha = 1-PHI_INV # Circle color = ([0.33, 0.33, 0.33], [1, 1, 1], [0.33, 0.33, 0.33], [1, 1, 1], [0.33, 0.33, 0.33], [1, 1, 1], [0.33, 0.33, 0.33], [1, 1, 1], [0.33, 0.33, 0.33], [1, 1, 1], [0.33, 0.33, 0.33], [1, 1, 1], [0.33, 0.33, 0.33], [1, 1, 1]) offset = ([-4.480736161291701, -8.939966636005579], [-0.158097634992133, -9.998750178787843], [4.195854066857877, -9.077158622037636], [7.718765411993642, -6.357724476147943], [9.71288060283854, -2.379065025383466], [9.783240669628, 2.070797430975971], [7.915909938224691, 6.110513059466902], [4.480736161291671, 8.939966636005593], [0.15809763499209872, 9.998750178787843], [-4.195854066857908, 9.077158622037622], [-7.718765411993573, 6.357724476148025], [-9.712880602838549, 2.379065025383433], [-9.783240669627993, -2.070797430976005], [-7.915909938224757, -6.110513059466818]) bgl.glBegin(bgl.GL_LINE_LOOP) for i in range(14): bgl.glColor4f(color[i][0], color[i][1], color[i][2], alpha) bgl.glVertex2f(location[0]+offset[i][0], location[1]+offset[i][1]) bgl.glEnd() # Crosshair offset2 = 20 offset = 5 bgl.glColor4f(0, 0, 0, alpha) bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(location[0]-offset2, location[1]) bgl.glVertex2f(location[0]- offset, location[1]) bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(location[0]+ offset, location[1]) bgl.glVertex2f(location[0]+offset2, location[1]) bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(location[0], location[1]-offset2) bgl.glVertex2f(location[0], location[1]- offset) bgl.glEnd() bgl.glBegin(bgl.GL_LINE_STRIP) bgl.glVertex2f(location[0], location[1]+ offset) bgl.glVertex2f(location[0], location[1]+offset2) bgl.glEnd()
def render_main(self, context, objlist, animation=False): # noinspection PyBroadException,PyBroadException # Save old info scene = context.scene render = scene.render settings = render.image_settings depth = settings.color_depth settings.color_depth = '8' # noinspection PyBroadException try: # Get visible layers layers = [] for x in range(0, 20): if scene.layers[x] is True: layers.extend([x]) # -------------------- # Get resolution # -------------------- render_scale = render.resolution_percentage / 100 width = int(render.resolution_x * render_scale) height = int(render.resolution_y * render_scale) # --------------------------------------- # Get output path # --------------------------------------- temp_path = path.realpath(bpy.app.tempdir) if len(temp_path) > 0: outpath = path.join(temp_path, "archipack_tmp_render.png") else: self.report({ 'ERROR' }, "Archipack: Unable to save temporary render image. Define a valid temp path" ) settings.color_depth = depth return False # Get Render Image img = self.get_render_image(outpath) if img is None: self.report({ 'ERROR' }, "Archipack: Unable to save temporary render image. Define a valid temp path" ) settings.color_depth = depth return False # ----------------------------- # Calculate rows and columns # ----------------------------- tile_x = 240 tile_y = 216 row_num = ceil(height / tile_y) col_num = ceil(width / tile_x) print("Archipack: Image divided in " + str(row_num) + "x" + str(col_num) + " tiles") # pixels out of visible area cut4 = (col_num * tile_x * 4) - width * 4 # pixels aout of drawing area totpixel4 = width * height * 4 # total pixels RGBA viewport_info = bgl.Buffer(bgl.GL_INT, 4) bgl.glGetIntegerv(bgl.GL_VIEWPORT, viewport_info) # Load image on memory img.gl_load(0, bgl.GL_NEAREST, bgl.GL_NEAREST) # 2.77 API change if bpy.app.version >= (2, 77, 0): tex = img.bindcode[0] else: tex = img.bindcode # -------------------------------------------- # Create output image (to apply texture) # -------------------------------------------- if "archipack_output" in bpy.data.images: out_img = bpy.data.images["archipack_output"] if out_img is not None: # out_img.user_clear() bpy.data.images.remove(out_img, do_unlink=True) out = bpy.data.images.new("archipack_output", width, height) tmp_pixels = [1] * totpixel4 # -------------------------------- # Loop for all tiles # -------------------------------- for row in range(0, row_num): for col in range(0, col_num): buffer = bgl.Buffer(bgl.GL_FLOAT, width * height * 4) bgl.glDisable( bgl.GL_SCISSOR_TEST ) # if remove this line, get blender screenshot not image bgl.glViewport(0, 0, tile_x, tile_y) bgl.glMatrixMode(bgl.GL_PROJECTION) bgl.glLoadIdentity() # defines ortographic view for single tile x1 = tile_x * col y1 = tile_y * row bgl.gluOrtho2D(x1, x1 + tile_x, y1, y1 + tile_y) # Clear bgl.glClearColor(0.0, 0.0, 0.0, 0.0) bgl.glClear(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_DEPTH_BUFFER_BIT) bgl.glEnable(bgl.GL_TEXTURE_2D) bgl.glBindTexture(bgl.GL_TEXTURE_2D, tex) # defines drawing area bgl.glBegin(bgl.GL_QUADS) bgl.glColor3f(1.0, 1.0, 1.0) bgl.glTexCoord2f(0.0, 0.0) bgl.glVertex2f(0.0, 0.0) bgl.glTexCoord2f(1.0, 0.0) bgl.glVertex2f(width, 0.0) bgl.glTexCoord2f(1.0, 1.0) bgl.glVertex2f(width, height) bgl.glTexCoord2f(0.0, 1.0) bgl.glVertex2f(0.0, height) bgl.glEnd() # ----------------------------- # Loop to draw all lines # ----------------------------- for o, d in objlist: if o.hide is False: # verify visible layer for x in range(0, 20): if o.layers[x] is True: if x in layers: context.scene.objects.active = o # print("%s: %s" % (o.name, d.manip_stack)) manipulators = d.manip_stack if manipulators is not None: for m in manipulators: if m is not None: m.draw_callback( m, context, render=True) break # ----------------------------- # Loop to draw all debug # ----------------------------- """ if scene.archipack_debug is True: selobj = bpy.context.selected_objects for myobj in selobj: if scene.archipack_debug_vertices is True: draw_vertices(context, myobj, None, None) if scene.archipack_debug_faces is True or scene.archipack_debug_normals is True: draw_faces(context, myobj, None, None) """ """ if scene.archipack_rf is True: bgl.glColor3f(1.0, 1.0, 1.0) rfcolor = scene.archipack_rf_color rfborder = scene.archipack_rf_border rfline = scene.archipack_rf_line bgl.glLineWidth(rfline) bgl.glColor4f(rfcolor[0], rfcolor[1], rfcolor[2], rfcolor[3]) x1 = rfborder x2 = width - rfborder y1 = int(ceil(rfborder / (width / height))) y2 = height - y1 draw_rectangle((x1, y1), (x2, y2)) """ # -------------------------------- # copy pixels to temporary area # -------------------------------- bgl.glFinish() bgl.glReadPixels(0, 0, width, height, bgl.GL_RGBA, bgl.GL_FLOAT, buffer) # read image data for y in range(0, tile_y): # final image pixels position p1 = (y * width * 4) + (row * tile_y * width * 4) + (col * tile_x * 4) p2 = p1 + (tile_x * 4) # buffer pixels position b1 = y * width * 4 b2 = b1 + (tile_x * 4) if p1 < totpixel4: # avoid pixel row out of area if col == col_num - 1: # avoid pixel columns out of area p2 -= cut4 b2 -= cut4 tmp_pixels[p1:p2] = buffer[b1:b2] # ----------------------- # Copy temporary to final # ----------------------- out.pixels = tmp_pixels[:] # Assign image data img.gl_free() # free opengl image memory # delete image # img.user_clear() bpy.data.images.remove(img, do_unlink=True) # remove temp file remove(outpath) # reset bgl.glEnable(bgl.GL_SCISSOR_TEST) # ----------------------- # restore opengl defaults # ----------------------- bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0) # Saves image if out is not None: # and (scene.archipack_render is True or animation is True): ren_path = bpy.context.scene.render.filepath filename = "ap_frame" if len(ren_path) > 0: if ren_path.endswith(path.sep): initpath = path.realpath(ren_path) + path.sep else: (initpath, filename) = path.split(ren_path) ftxt = "%04d" % scene.frame_current outpath = path.realpath( path.join(initpath, filename + ftxt + ".png")) self.save_image(outpath, out) settings.color_depth = depth return True except: settings.color_depth = depth print("Unexpected error:" + str(exc_info())) self.report({ 'ERROR' }, "Archipack: Unable to create render image. Be sure the output render path is correct" ) return False
def draw_postview(self, context): ''' Place drawing code in here ''' t111 = self.cntrlList[0].to_tuple() # sample code to draw corners of cube bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glColor3d(0, 0, 0) bgl.glPointSize(3) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex3f( *t111 ) # Note: *t111 expands elements of tuple as individual parameters bgl.glVertex3f(1, -1, 1) bgl.glVertex3f(-1, -1, 1) bgl.glVertex3f(-1, 1, 1) bgl.glVertex3f(1, 1, -1) bgl.glVertex3f(1, -1, -1) bgl.glVertex3f(-1, -1, -1) bgl.glVertex3f(-1, 1, -1) bgl.glEnd() # sample code to draw top and bottom edges of cube bgl.glLineWidth(1) bgl.glColor3f(0, 0, 0) bgl.glBegin(bgl.GL_LINES) bgl.glVertex3f(*t111) bgl.glVertex3f(-1, 1, 1) bgl.glVertex3f(-1, 1, 1) bgl.glVertex3f(-1, -1, 1) bgl.glVertex3f(-1, -1, 1) bgl.glVertex3f(1, -1, 1) bgl.glVertex3f(1, -1, 1) bgl.glVertex3f(*t111) bgl.glVertex3f(1, 1, -1) bgl.glVertex3f(-1, 1, -1) bgl.glVertex3f(-1, 1, -1) bgl.glVertex3f(-1, -1, -1) bgl.glVertex3f(-1, -1, -1) bgl.glVertex3f(1, -1, -1) bgl.glVertex3f(1, -1, -1) bgl.glVertex3f(1, 1, -1) bgl.glVertex3f(*t111) bgl.glVertex3f(1, 1, -1) bgl.glEnd() # sample code to show highlighting picked geometry if len(self.selectCntrl): cntrlLength = len(self.selectCntrl) for x in range(0, cntrlLength): # assuming that we have only one control point, so if # anything is selected it would be the only point p111 = self.selectCntrl[x] t111 = p111.to_tuple() vrot = context.space_data.region_3d.view_rotation dx = (vrot * Vector( (1, 0, 0))).normalized() # compute right dir relative to view dy = (vrot * Vector( (0, 1, 0))).normalized() # compute up dir relative to view px = tuple(p111 + dx * 0.5) py = tuple(p111 + dy * 0.5) # highlight the point bgl.glColor3f(1, 1, 0) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex3f(*t111) bgl.glEnd() # draw lines to indicate right (red) and up (green) bgl.glBegin(bgl.GL_LINES) bgl.glColor3f(1, 0, 0) bgl.glVertex3f(*t111) bgl.glVertex3f(*px) bgl.glColor3f(0, 1, 0) bgl.glVertex3f(*t111) bgl.glVertex3f(*py) bgl.glEnd()
def draw_postview(self, context, mesh, isBaseMesh): #mesh = self.mesh #temporary in case we decide it should be named differently a1 = 1.0 a2 = 1.0 if isBaseMesh and self.sublvl > 0: a1 = 0.5 a2 = .75 bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glEnable(bgl.GL_BLEND) #draw the vertices for v in mesh.vertices: if v in self.selected: bgl.glColor4d(0.9, 0.5, 0, a2) bgl.glPointSize(4) else: bgl.glColor4d(1, 1, 0, a1) bgl.glPointSize(2) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex3f(*v.co.to_tuple()) bgl.glEnd() bgl.glDepthRange(0.0, 0.9999) #draw the edges for e in mesh.edges: if e in self.selected: bgl.glColor4d(0.9, 0.5, 0, a2) bgl.glLineWidth(2) else: bgl.glColor4d(0.5, 0.5, 0, a1) bgl.glLineWidth(1) bgl.glBegin(bgl.GL_LINES) bgl.glVertex3f(*e.v0.co.to_tuple()) bgl.glVertex3f(*e.v1.co.to_tuple()) bgl.glEnd() bgl.glDepthRange(0.0, 1.0) #draw the faces bgl.glBegin(bgl.GL_TRIANGLES) for f in mesh.faces: if f in self.selected: bgl.glColor4d(0.6, 0.2, 0, a2) else: bgl.glColor4d(0.3, 0.3, 0.3, a1) a = 0 b = 1 c = 2 for i in range(len(f.lvertices) - 2): bgl.glVertex3f(*f.lvertices[a].co.to_tuple()) bgl.glVertex3f(*f.lvertices[b].co.to_tuple()) bgl.glVertex3f(*f.lvertices[c].co.to_tuple()) b += 1 c += 1 bgl.glEnd() if False: bgl.glColor3f(0, 1, 1) bgl.glBegin(bgl.GL_LINES) for f in mesh.faces: p0 = Vector() for v in f.lvertices: p0 += v.co p0 /= len(f.lvertices) p1 = p0 + f.normal * 0.2 bgl.glVertex3f(*p0) bgl.glVertex3f(*p1) bgl.glEnd()
def draw_alpha_controls(self, context): """ Draws the line, 2 boxes, and the control square """ w = context.region.width h = context.region.height line_width = 2 * (w / 10) offset_x = (line_width / 2) - (line_width * self.alpha_init) x = self.first_mouse.x + offset_x y = self.first_mouse.y + self.pos.y bgl.glEnable(bgl.GL_BLEND) bgl.glLineWidth(1) bgl.glColor4f(0, 1, 1, 1) # Numbers bgl.glPushMatrix() bgl.glTranslatef(x - (w / 10) + self.pos.x, y, 0) font_id = 0 blf.position(font_id, 0, 10, 0) blf.size(font_id, 20, 72) blf.draw(font_id, str(self.fac)) bgl.glPopMatrix() # The Line bgl.glPushMatrix() bgl.glTranslatef(x, y, 0) bgl.glBegin(bgl.GL_LINE_LOOP) bgl.glVertex2f(-w / 10, 0) bgl.glVertex2f(w / 10, 0) bgl.glEnd() bgl.glPopMatrix() bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glPointSize(10) # End Squares bgl.glPushMatrix() bgl.glTranslatef(x, y, 0) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex2f(-w / 10, 0) bgl.glVertex2f(w / 10, 0) bgl.glEnd() bgl.glPopMatrix() # Control Square bgl.glColor4f(1, 0, 0, 1) bgl.glPushMatrix() bgl.glTranslatef(x - (w / 10) + self.pos.x, y, 0) bgl.glBegin(bgl.GL_POINTS) bgl.glVertex2f(0, 0) bgl.glEnd() bgl.glPopMatrix() bgl.glDisable(bgl.GL_POINT_SMOOTH) bgl.glPointSize(1) bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_simulation_voxel(): context = bpy.context domain = context.scene.flip_fluid.get_domain_object() dprops = context.scene.flip_fluid.get_domain_properties() if domain is None: 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 resolution = dprops.simulation.resolution bbox = AABB.from_blender_object(domain) max_dim = max(bbox.xdim, bbox.ydim, bbox.zdim) if dprops.simulation.lock_cell_size: unlocked_dx = max_dim / resolution locked_dx = dprops.simulation.locked_cell_size dx = locked_dx if abs(locked_dx - unlocked_dx) < 1e-6: dx = unlocked_dx else: dx = max_dim / resolution minx, maxx = bbox.x, bbox.x + dx miny, maxy = bbox.y, bbox.y + dx minz, maxz = bbox.z, bbox.z + dx voxel_coords = [ (minx, miny, minz), (maxx, miny, minz), (minx, maxy, minz), (maxx, maxy, minz), (minx, miny, maxz), (maxx, miny, maxz), (minx, maxy, maxz), (maxx, maxy, maxz), (minx, miny, minz), (minx, maxy, minz), (maxx, miny, minz), (maxx, maxy, minz), (minx, miny, maxz), (minx, maxy, maxz), (maxx, miny, maxz), (maxx, maxy, maxz), (minx, miny, minz), (minx, miny, maxz), (maxx, miny, minz), (maxx, miny, maxz), (minx, maxy, minz), (minx, maxy, maxz), (maxx, maxy, minz), (maxx, maxy, maxz) ] active_object = vcu.get_active_object(context) view_3d_theme = vcu.get_blender_preferences().themes[0].view_3d if domain == active_object: color = view_3d_theme.object_active elif domain in context.selected_objects: color = view_3d_theme.object_selected else: color = view_3d_theme.wire if vcu.is_blender_28(): shader = gpu.shader.from_builtin('3D_UNIFORM_COLOR') batch = batch_for_shader(shader, 'LINES', {"pos": voxel_coords}) shader.bind() shader.uniform_float("color", (*color, 1.0)) batch.draw(shader) else: bgl.glLineWidth(1) bgl.glBegin(bgl.GL_LINES) bgl.glColor4f(*color, 1.0) for c in voxel_coords: bgl.glVertex3f(*c) bgl.glEnd() bgl.glLineWidth(1) bgl.glEnable(bgl.GL_DEPTH_TEST) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def _end(self): bgl.glEnd() bgl.glPopAttrib() bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_matrix(mat): zero_tx = mat * zero glLineWidth(2.0) # x glColor3f(1.0, 0.2, 0.2) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * x_p)) glEnd() glColor3f(0.6, 0.0, 0.0) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * x_n)) glEnd() # y glColor3f(0.2, 1.0, 0.2) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * y_p)) glEnd() glColor3f(0.0, 0.6, 0.0) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * y_n)) glEnd() # z glColor3f(0.2, 0.2, 1.0) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * z_p)) glEnd() glColor3f(0.0, 0.0, 0.6) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * z_n)) glEnd() # bounding box i = 0 glColor3f(1.0, 1.0, 1.0) for x in (-1.0, 1.0): for y in (-1.0, 1.0): for z in (-1.0, 1.0): bb[i][:] = x, y, z bb[i] = mat * bb[i] i += 1 # strip glLineWidth(1.0) glLineStipple(1, 0xAAAA) glEnable(GL_LINE_STIPPLE) glBegin(GL_LINE_STRIP) for i in 0, 1, 3, 2, 0, 4, 5, 7, 6, 4: glVertex3f(*bb[i]) glEnd() # not done by the strip glBegin(GL_LINES) glVertex3f(*bb[1]) glVertex3f(*bb[5]) glVertex3f(*bb[2]) glVertex3f(*bb[6]) glVertex3f(*bb[3]) glVertex3f(*bb[7]) glEnd() glDisable(GL_LINE_STIPPLE)
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))) image = context.window_manager.love2d3d.image_front # Image ID if image == "": return self.image = context.blend_data.images[image] # Get image # 50% alpha, 2 pixel width line #bgl.glLineWidth(0) bgl.glEnable(bgl.GL_BLEND) #bgl.glClearColor(0.0, 0.0, 0.0, 0.0); #bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) self.image.gl_load() bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.image.bindcode[0]) bgl.glColor4f(1.0, 1.0, 1.0, 0.5) bgl.glEnable(bgl.GL_TEXTURE_2D) 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.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) #self.image.bind() #bgl.glLineWidth(2) # bgl.glBegin(bgl.GL_LINE_STRIP) # for x, y in self.mouse_path: # bgl.glVertex2i(x, y) # # bgl.glEnd() #camera = context.space_data.camera.location #sclip = context.space_data.clip_start #eclip = context.space_data.clip_end #lens = context.space_data.lens #pers = context.region_data.perspective_matrix #fovy = math.atan(pers[5]) * 2 #aspect = pers[5] / pers[0] #bgl.gluPerspective(fovy, aspect, sclip, eclip); bgl.glMatrixMode(bgl.GL_MODELVIEW) #print(context.region_data.view_matrix) #ob = context.active_object #buff = bgl.Buffer(bgl.GL_FLOAT, [4, 4], context.region_data.view_matrix.transposed()) #buff = bgl.Buffer(bgl.GL_FLOAT, [4, 4], ob.matrix_world.transposed()) #mat = Matrix.Identity(4) mat = Matrix.Translation(context.space_data.cursor_location) view_align = context.window_manager.love2d3d.view_align if view_align: iview = Matrix( context.region_data.view_matrix).inverted_safe().to_3x3().to_4x4() else: iview = Matrix.Identity(4) buff = bgl.Buffer(bgl.GL_FLOAT, [4, 4], (mat * iview).transposed()) bgl.glLoadMatrixf(buff) #bgl.glLoadIdentity() #camera = context.region_data.view_location #bgl.gluLookAt(camera.x, camera.y, camera.z, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0) bgl.glMatrixMode(bgl.GL_PROJECTION) #bgl.glLoadIdentity(); buff = bgl.Buffer(bgl.GL_FLOAT, [4, 4], context.region_data.perspective_matrix.transposed()) bgl.glLoadMatrixf(buff) scale = context.window_manager.love2d3d.scale w, h = self.image.size w *= scale h *= scale #lb = location_3d_to_region_2d(context.region, context.space_data.region_3d, (-w / 2.0, 0, -h / 2.0)) #rb = location_3d_to_region_2d(context.region, context.space_data.region_3d, (w / 2.0, 0, -h / 2.0)) #rt = location_3d_to_region_2d(context.region, context.space_data.region_3d, (w / 2.0, 0, h / 2.0)) #lt = location_3d_to_region_2d(context.region, context.space_data.region_3d, (-w / 2.0, 0, h /2.0)) if view_align: lb = Vector((-w / 2.0, -h / 2.0, 0)) rb = Vector((w / 2.0, -h / 2.0, 0)) rt = Vector((w / 2.0, h / 2.0, 0)) lt = Vector((-w / 2.0, h / 2.0, 0)) else: lb = Vector((-w / 2.0, 0, -h / 2.0)) rb = Vector((w / 2.0, 0, -h / 2.0)) rt = Vector((w / 2.0, 0, h / 2.0)) lt = Vector((-w / 2.0, 0, h / 2.0)) #print(lt) bgl.glBegin(bgl.GL_QUADS) bgl.glTexCoord2d(0.0, 0.0) bgl.glVertex3f(lb.x, lb.y, lb.z) bgl.glTexCoord2d(1.0, 0.0) bgl.glVertex3f(rb.x, rb.y, lb.z) bgl.glTexCoord2d(1.0, 1.0) bgl.glVertex3f(rt.x, rt.y, rt.z) bgl.glTexCoord2d(0.0, 1.0) bgl.glVertex3f(lt.x, lt.y, lt.z) bgl.glEnd() self.image.gl_free() # restore opengl defaults bgl.glLineWidth(1) bgl.glDisable(bgl.GL_TEXTURE_2D) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback_view(self, context): from bgl import glEnable, glDisable, glColor3f, glVertex3f, glPointSize, glLineWidth, glBegin, glEnd, glLineStipple, GL_POINTS, GL_LINE_STRIP, GL_LINES, GL_LINE_STIPPLE data_matrix, data_quat, data_euler, data_vector, data_vector_array = utils.console_math_data() # draw_matrix vars zero = Vector((0.0, 0.0, 0.0)) x_p = Vector((1.0, 0.0, 0.0)) x_n = Vector((-1.0, 0.0, 0.0)) y_p = Vector((0.0, 1.0, 0.0)) y_n = Vector((0.0, -1.0, 0.0)) z_p = Vector((0.0, 0.0, 1.0)) z_n = Vector((0.0, 0.0, -1.0)) bb = [Vector() for i in range(8)] def draw_matrix(mat): zero_tx = mat * zero glLineWidth(2.0) # x glColor3f(1.0, 0.2, 0.2) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * x_p)) glEnd() glColor3f(0.6, 0.0, 0.0) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * x_n)) glEnd() # y glColor3f(0.2, 1.0, 0.2) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * y_p)) glEnd() glColor3f(0.0, 0.6, 0.0) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * y_n)) glEnd() # z glColor3f(0.2, 0.2, 1.0) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * z_p)) glEnd() glColor3f(0.0, 0.0, 0.6) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * z_n)) glEnd() # bounding box i = 0 glColor3f(1.0, 1.0, 1.0) for x in (-1.0, 1.0): for y in (-1.0, 1.0): for z in (-1.0, 1.0): bb[i][:] = x, y, z bb[i] = mat * bb[i] i += 1 # strip glLineWidth(1.0) glLineStipple(1, 0xAAAA) glEnable(GL_LINE_STIPPLE) glBegin(GL_LINE_STRIP) for i in 0, 1, 3, 2, 0, 4, 5, 7, 6, 4: glVertex3f(*bb[i]) glEnd() # not done by the strip glBegin(GL_LINES) glVertex3f(*bb[1]) glVertex3f(*bb[5]) glVertex3f(*bb[2]) glVertex3f(*bb[6]) glVertex3f(*bb[3]) glVertex3f(*bb[7]) glEnd() glDisable(GL_LINE_STIPPLE) ######## # points if data_vector: glPointSize(3.0) glBegin(GL_POINTS) glColor3f(0.5, 0.5, 1) for key, vec in data_vector.items(): glVertex3f(*vec.to_3d()) glEnd() glPointSize(1.0) ####### # lines if data_vector_array: glColor3f(0.5, 0.5, 1) glLineWidth(2.0) for line in data_vector_array.values(): glBegin(GL_LINE_STRIP) for vec in line: glVertex3f(*vec) glEnd() glPointSize(1.0) glLineWidth(1.0) # matrix if data_matrix: for mat in data_matrix.values(): draw_matrix(mat) if data_quat: loc = context.scene.cursor_location.copy() for quat in data_quat.values(): mat = quat.to_matrix().to_4x4() mat.translation = loc draw_matrix(mat) if data_euler: loc = context.scene.cursor_location.copy() for eul in data_euler.values(): mat = eul.to_matrix().to_4x4() mat.translation = loc draw_matrix(mat)
def draw_callback_3d(self, context): global x_coords global y_coords global z_coords global bounds_coords domain = context.scene.flip_fluid.get_domain_object() if domain is None: return dprops = context.scene.flip_fluid.get_domain_properties() 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 x_color = dprops.debug.x_grid_color y_color = dprops.debug.y_grid_color z_color = dprops.debug.z_grid_color bounds_color = dprops.debug.domain_bounds_color # Draw if vcu.is_blender_28(): if dprops.debug.enabled_debug_grids[2]: shader = gpu.shader.from_builtin('3D_UNIFORM_COLOR') batch = batch_for_shader(shader, 'LINES', {"pos": z_coords}) shader.bind() shader.uniform_float("color", (z_color[0], z_color[1], z_color[2], 1.0)) batch.draw(shader) if dprops.debug.enabled_debug_grids[1]: shader = gpu.shader.from_builtin('3D_UNIFORM_COLOR') batch = batch_for_shader(shader, 'LINES', {"pos": y_coords}) shader.bind() shader.uniform_float("color", (y_color[0], y_color[1], y_color[2], 1.0)) batch.draw(shader) if dprops.debug.enabled_debug_grids[0]: shader = gpu.shader.from_builtin('3D_UNIFORM_COLOR') batch = batch_for_shader(shader, 'LINES', {"pos": x_coords}) shader.bind() shader.uniform_float("color", (x_color[0], x_color[1], x_color[2], 1.0)) batch.draw(shader) if dprops.debug.display_domain_bounds: shader = gpu.shader.from_builtin('3D_UNIFORM_COLOR') batch = batch_for_shader(shader, 'LINES', {"pos": bounds_coords}) shader.bind() shader.uniform_float("color", (bounds_color[0], bounds_color[1], bounds_color[2], 1.0)) batch.draw(shader) else: bgl.glLineWidth(1) bgl.glBegin(bgl.GL_LINES) if dprops.debug.enabled_debug_grids[2]: bgl.glColor4f(*z_color, 1.0) for c in z_coords: bgl.glVertex3f(*c) if dprops.debug.enabled_debug_grids[1]: bgl.glColor4f(*y_color, 1.0) for c in y_coords: bgl.glVertex3f(*c) if dprops.debug.enabled_debug_grids[0]: bgl.glColor4f(*x_color, 1.0) for c in x_coords: bgl.glVertex3f(*c) if dprops.debug.display_domain_bounds: bgl.glColor4f(*(bounds_color), 1.0) for c in bounds_coords: bgl.glVertex3f(*c) bgl.glEnd() bgl.glLineWidth(1) bgl.glEnable(bgl.GL_DEPTH_TEST) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)