def draw_callback_px(self, context):
if self.moves % 3 == 0 and len(self.colors) < 32:
self.mouse_path.append(self.mouse_pos)
view = get_viewport()
x, y = self.mouse_pos
c = bgl.Buffer(bgl.GL_FLOAT, 4)
bgl.glReadPixels(x + view[0], y + view[1], 1, 1, bgl.GL_RGB,
bgl.GL_FLOAT, c)
self.colors.append(c.to_list())
# 50% alpha, 2 pixel width line
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1, 1, 1, 0.5)
bgl.glLineWidth(4)
bgl.glBegin(bgl.GL_LINE_STRIP)
for x, y in self.mouse_path:
bgl.glVertex2i(x, y)
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_select(self, context):
"""
Draw a box around each selected strip in the preview window
"""
bgl.glEnable(bgl.GL_BLEND)
bgl.glLineWidth(4)
theme = context.user_preferences.themes['Default']
active_color = theme.view_3d.object_active
select_color = theme.view_3d.object_selected
opacity = 0.9 - (self.seconds / self.fadeout_duration)
active_strip = context.scene.sequence_editor.active_strip
offset_x, offset_y, fac, preview_zoom = get_preview_offset()
for strip in context.selected_sequences:
if strip == active_strip:
bgl.glColor4f(active_color[0], active_color[1], active_color[2],
opacity)
else:
bgl.glColor4f(select_color[0], select_color[1], select_color[2],
opacity)
bgl.glBegin(bgl.GL_LINE_LOOP)
corners = get_strip_corners(strip)
for corner in corners:
corner_x = int(corner[0] * preview_zoom * fac) + offset_x
corner_y = int(corner[1] * preview_zoom * fac) + offset_y
bgl.glVertex2i(corner_x, corner_y)
bgl.glEnd()
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
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(.7, .7, .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.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 draw_callback(self, context):
scene = context.scene
x = int(round(context.region.width * 0.01 + (self._t_target - scene.frame_start) * self._ppf))
string = str(self._t_target)
string = string[0 : string.index(".") + 3]
font_id = 0 # XXX, need to find out how best to get this.
# draw marker
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1, 0, 0, 1)
bgl.glLineWidth(2)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(x, 17)
bgl.glVertex2i(x, context.region.height)
bgl.glEnd()
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
# draw frame number
if self._show_frame_indicator:
blf.position(font_id, x + 5, 21, 0)
blf.size(font_id, 12, 72)
blf.draw(font_id, string)
def draw_callback_px(self, context):
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, str(self.mouse_pos[0]) + ',' + str(self.mouse_pos[1]))
# 50% alpha, 2 pixel width line
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 1.0, 0.0, 0.5)
bgl.glLineWidth(2)
bgl.glBegin(bgl.GL_LINE_STRIP)
for x, y in self.poly_points:
bgl.glVertex2i(x, y)
bgl.glColor4f(1.0, 0.0, 0.0, 0.5)
bgl.glVertex2i(self.mouse_pos[0], self.mouse_pos[1])
bgl.glEnd()
bgl.glPointSize(4.0)
bgl.glBegin(bgl.GL_POINTS)
bgl.glColor4f(0.0, 1.0, 1.0, 0.5)
for obj, point in self.visible_objects:
bgl.glVertex2f(point[0], point[1])
for vert, point in self.verts:
bgl.glVertex2f(point[0], point[1])
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback_px(self, context):
#print("mouse points", self.mouse_path[len(self.mouse_path)-1])
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, "Mouse " + str(self.mouse_path[len(self.mouse_path)-1]))
x1=bpy.context.scene['xmin']
y1=bpy.context.scene['ymin']
x2=self.mouse_path[len(self.mouse_path)-1][0]
y2=self.mouse_path[len(self.mouse_path)-1][1]
# 50% alpha, 2 pixel width line
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0.8, 0.0, 0.8, 0.5)
bgl.glLineWidth(3)
if bpy.context.scene['SupIzq']:
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(x1, y1)
bgl.glVertex2i(x2, y1)
bgl.glVertex2i(x2, y2)
bgl.glVertex2i(x1, y2)
bgl.glVertex2i(x1, y1)
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
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 draw_callback_px(self, context):
print("mouse points", len(self.mouse_path))
font_id = 0 # XXX, need to find out how best to get this.
# draw some text
blf.position(font_id, 15, 30, 0)
blf.size(font_id, 20, 72)
blf.draw(font_id, "Hello Word " + str(len(self.mouse_path)))
# 50% alpha, 2 pixel width line
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 0.5)
bgl.glLineWidth(2)
bgl.glBegin(bgl.GL_LINE_STRIP)
for x, y in self.mouse_path:
bgl.glVertex2i(x, y)
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback_px(self, context):
print("mouse points", len(self.mouse_path))
font_id = 0 # XXX, need to find out how best to get this.
# draw some text
blf.position(font_id, 15, 30, 0)
blf.size(font_id, 20, 72)
blf.draw(font_id, "Hello Word " + str(len(self.mouse_path)))
# 50% alpha, 2 pixel width line
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 0.5)
bgl.glLineWidth(2)
bgl.glBegin(bgl.GL_LINE_STRIP)
for x, y in self.mouse_path:
bgl.glVertex2i(x, y)
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback(self, context):
scene = context.scene
x = int(
round(context.region.width * 0.01 +
(self._t_target - scene.frame_start) * self._ppf))
string = str(self._t_target)
string = string[0:string.index('.') + 3]
font_id = 0 # XXX, need to find out how best to get this.
# draw marker
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1, 0, 0, 1)
bgl.glLineWidth(2)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(x, 17)
bgl.glVertex2i(x, context.region.height)
bgl.glEnd()
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
# draw frame number
if self._show_frame_indicator:
blf.position(font_id, x + 5, 21, 0)
blf.size(font_id, 12, 72)
blf.draw(font_id, string)
def draw_callback_px(self, context):
if self.moves % 3 == 0 and len(self.colors) < 32:
self.mouse_path.append(self.mouse_pos)
view = get_viewport()
x, y = self.mouse_pos
c = bgl.Buffer(bgl.GL_FLOAT, 4)
bgl.glReadPixels(x + view[0], y + view[1], 1, 1, bgl.GL_RGB, bgl.GL_FLOAT, c)
self.colors.append(c.to_list())
# 50% alpha, 2 pixel width line
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1, 1, 1, 0.5)
bgl.glLineWidth(4)
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 Rectangle(self, x0, y0, x1, y1, colour, width=2, style=bgl.GL_LINE):
self._start_line(colour, width, style)
bgl.glVertex2i(x0, y0)
bgl.glVertex2i(x1, y0)
bgl.glVertex2i(x1, y1)
bgl.glVertex2i(x0, y1)
bgl.glVertex2i(x0, y0)
self._end()
def Rectangle(self, x0, y0, x1, y1, colour, width=2, style=bgl.GL_LINE):
self._start_line(colour, width, style)
bgl.glVertex2i(x0, y0)
bgl.glVertex2i(x1, y0)
bgl.glVertex2i(x1, y1)
bgl.glVertex2i(x0, y1)
bgl.glVertex2i(x0, y0)
self._end()
def draw_line(origin, length, thickness, vertical=False):
"""Drawing lines with polys, its faster"""
x = (origin[0] + thickness) if vertical else (origin[0] + length)
y = (origin[1] + length) if vertical else (origin[1] + thickness)
bgl.glBegin(bgl.GL_QUADS)
for v1, v2 in [origin, (x, origin[1]), (x, y), (origin[0], y)]:
bgl.glVertex2i(v1, v2)
bgl.glEnd()
return
def draw_line(origin, length, thickness, vertical=False):
"""Drawing lines with polys, its faster"""
x = (origin[0] + thickness) if vertical else (origin[0] + length)
y = (origin[1] + length) if vertical else (origin[1] + thickness)
bgl.glBegin(bgl.GL_QUADS)
for v1, v2 in [origin, (x, origin[1]), (x, y), (origin[0], y)]:
bgl.glVertex2i(v1, v2)
bgl.glEnd()
return
def draw_callback_px(self, context):
bgl.glPushAttrib(bgl.GL_ENABLE_BIT)
# glPushAttrib is done to return everything to normal after drawing
bgl.glLineStipple(10, 0x9999)
bgl.glEnable(bgl.GL_LINE_STIPPLE)
# 50% alpha, 2 pixel width line
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, 0.8)
bgl.glLineWidth(5)
bgl.glBegin(bgl.GL_LINE_STRIP)
for x, y in self.mouse_path:
bgl.glVertex2i(x, y)
bgl.glEnd()
bgl.glPopAttrib()
bgl.glEnable(bgl.GL_BLEND)
# ...api_current/bpy.types.Area.html?highlight=bpy.types.area
header_height = context.area.regions[0].height # 26px
width = context.area.width
height = context.area.height - header_height
p1_2d = (0,0)
p2_2d = (width, height)
p3_2d = (width, 0)
p4_2d = (0, height)
# green line
bgl.glLineWidth(3)
draw_line_2d((0.0, 1.0, 0.0, 0.8), p1_2d, p2_2d)
# yellow line
bgl.glLineWidth(5)
draw_line_2d((1.0, 1.0, 0.0, 0.8), p3_2d, p4_2d)
# white circle
bgl.glLineWidth(4)
draw_circle_2d((1.0, 1.0, 1.0, 0.8), width/2, height/2, 70, 360)
# red circle
bgl.glLineWidth(5)
draw_circle_2d((1.0, 0.0, 0.0, 0.4), width/2, height/2, 230, 5)
# draw text
draw_typo_2d((1.0, 1.0, 1.0, 1), "Hello Word " + str(len(self.mouse_path)))
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback_px(self, context):
bgl.glPushAttrib(bgl.GL_ENABLE_BIT)
# glPushAttrib is done to return everything to normal after drawing
bgl.glLineStipple(10, 0x9999)
bgl.glEnable(bgl.GL_LINE_STIPPLE)
# 50% alpha, 2 pixel width line
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, 0.8)
bgl.glLineWidth(5)
bgl.glBegin(bgl.GL_LINE_STRIP)
for x, y in self.mouse_path:
bgl.glVertex2i(x, y)
bgl.glEnd()
bgl.glPopAttrib()
bgl.glEnable(bgl.GL_BLEND)
# ...api_current/bpy.types.Area.html?highlight=bpy.types.area
header_height = context.area.regions[0].height # 26px
width = context.area.width
height = context.area.height - header_height
p1_2d = (0, 0)
p2_2d = (width, height)
p3_2d = (width, 0)
p4_2d = (0, height)
# green line
bgl.glLineWidth(3)
draw_line_2d((0.0, 1.0, 0.0, 0.8), p1_2d, p2_2d)
# yellow line
bgl.glLineWidth(5)
draw_line_2d((1.0, 1.0, 0.0, 0.8), p3_2d, p4_2d)
# white circle
bgl.glLineWidth(4)
draw_circle_2d((1.0, 1.0, 1.0, 0.8), width / 2, height / 2, 70, 360)
# red circle
bgl.glLineWidth(5)
draw_circle_2d((1.0, 0.0, 0.0, 0.4), width / 2, height / 2, 230, 5)
# draw text
draw_typo_2d((1.0, 1.0, 1.0, 1), "Hello Word " + str(len(self.mouse_path)))
# 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):
self.font_id = 0 # XXX, need to find out how best to get this.
global_pos = self.region_height - 60
# draw some text
headline_color = [1.0, 0.9, 0.6, 1.0]
### draw gradient overlay
bgl.glEnable(bgl.GL_BLEND)
line_width = 10
bgl.glLineWidth(line_width)
width = int(525/line_width)
start_at = .2
for i in range(width):
bgl.glBegin(bgl.GL_LINE_STRIP)
alpha = (width-i)/width/(1-start_at)
if i > width*start_at:
bgl.glColor4f(0.0, 0.0, 0.0, .7*self.alpha_current*alpha)
else:
bgl.glColor4f(0.0, 0.0, 0.0, .7*self.alpha_current)
x = (i*line_width) + self.region_offset
y = self.region_height
bgl.glVertex2i(x, 0)
bgl.glVertex2i(x, y)
bgl.glEnd()
### draw hotkeys
self.write_text("Hotkeys - Object Mode",size=20,pos_y=global_pos,color=headline_color)
self.write_text(" F - Contextual Pie Menu",size=15,pos_y=global_pos-20)
self.write_text("Hotkeys - Object Outliner",size=20,pos_y=global_pos-60,color=headline_color)
self.write_text(" Ctrl + Click - Add Item to Selection",size=15,pos_y=global_pos-80)
self.write_text(" Shift + Click - Multi Selection",size=15,pos_y=global_pos-100)
self.write_text("Hotkeys - Keyframing",size=20,pos_y=global_pos-160,color=headline_color)
self.write_text(" Ctrl + Click on Key Operator - Opens Curve Interpolation Options",size=15,pos_y=global_pos-180)
self.write_text("Hotkeys - Edit Armature Mode",size=20,pos_y=global_pos-240,color=headline_color)
self.write_text(" Click + Drag - Draw Bone",size=15,pos_y=global_pos-260)
self.write_text(" Shift + Click + Drag - Draw Bone locked to 45 Angle",size=15,pos_y=global_pos-280)
self.write_text(" Alt + Click - Bind Sprite to selected Bones",size=15,pos_y=global_pos-300)
self.write_text(" ESC/Tab - Exit Armature Mode",size=15,pos_y=global_pos-320)
self.write_text("Hotkeys - Edit Mesh Mode",size=20,pos_y=global_pos-380,color=headline_color)
self.write_text(" Click + Drag - Draw Vertex Contour",size=15,pos_y=global_pos-400)
self.write_text(" Alt + Click on Vertex - Close Contour",size=15,pos_y=global_pos-420)
self.write_text(" ESC/Tab - Exit Mesh Mode",size=15,pos_y=global_pos-440)
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
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_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 drawloop(x1, y1, x2, y2):
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
bgl.glBegin(bgl.GL_LINE_LOOP)
bgl.glVertex2i(x1, y2)
bgl.glVertex2i(x2, y2)
bgl.glVertex2i(x2, y1)
bgl.glVertex2i(x1, y1)
bgl.glEnd()
def li3D_legend(self, context, simnode, connode, geonode):
scene = context.scene
try:
if scene.vi_leg_display != True or scene.vi_display == 0 or (scene.wr_disp_panel != 1 and scene.li_disp_panel != 2 and scene.ss_disp_panel != 2) or scene.frame_current not in range(scene.fs, scene.fe + 1):
return
else:
if max(simnode['maxres']) > 100:
resvals = ['{:.0f}'.format(min(simnode['minres'])+i*(max(simnode['maxres'])-min(simnode['minres']))/19) for i in range(20)]
else:
resvals = ['{:.1f}'.format(min(simnode['minres'])+i*(max(simnode['maxres'])-min(simnode['minres']))/19) for i in range(20)]
height = context.region.height
lenres = len(resvals[-1])
font_id = 0
vi_func.drawpoly(20, height - 40, 70 + lenres*8, height - 520)
vi_func.drawloop(19, height - 40, 70 + lenres*8, height - 520)
for i in range(20):
h = 0.75 - 0.75*(i/19)
if connode:
bgl.glColor4f(colorsys.hsv_to_rgb(h, 1.0, 1.0)[0], colorsys.hsv_to_rgb(h, 1.0, 1.0)[1], colorsys.hsv_to_rgb(h, 1.0, 1.0)[2], 1.0)
else:
bgl.glColor4f(i/19, i/19, i/19, 1)
bgl.glBegin(bgl.GL_POLYGON)
bgl.glVertex2i(20, (i*20)+height - 460)
bgl.glVertex2i(60, (i*20)+height - 460)
bgl.glVertex2i(60, (i*20)+height - 440)
bgl.glVertex2i(20, (i*20)+height - 440)
bgl.glEnd()
blf.size(font_id, 20, 48)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
blf.position(font_id, 65, (i*20)+height - 455, 0)
blf.draw(font_id, " "*(lenres - len(resvals[i]) ) + resvals[i])
blf.size(font_id, 20, 56)
cu = connode['unit'] if connode else '% Sunlit'
vi_func.drawfont(cu, font_id, 0, height, 25, 57)
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
height = context.region.height
font_id = 0
if scene.frame_current in range(scene.fs, scene.fe + 1):
findex = scene.frame_current - scene.frame_start if simnode['Animation'] != 'Static' else 0
bgl.glColor4f(0.0, 0.0, 0.0, 0.8)
blf.size(font_id, 20, 48)
if context.active_object and (context.active_object.get('lires') or context.active_object.get('licalc')):
vi_func.drawfont("Ave: {:.1f}".format(context.active_object['oave'][str(scene.frame_current)]), font_id, 0, height, 22, 480)
vi_func.drawfont("Max: {:.1f}".format(context.active_object['omax'][str(scene.frame_current)]), font_id, 0, height, 22, 495)
vi_func.drawfont("Min: {:.1f}".format(context.active_object['omin'][str(scene.frame_current)]), font_id, 0, height, 22, 510)
else:
vi_func.drawfont("Ave: {:.1f}".format(simnode['avres'][findex]), font_id, 0, height, 22, 480)
vi_func.drawfont("Max: {:.1f}".format(simnode['maxres'][findex]), font_id, 0, height, 22, 495)
vi_func.drawfont("Min: {:.1f}".format(simnode['minres'][findex]), font_id, 0, height, 22, 510)
except Exception as e:
print(e, 'Turning off legend display')
scene.vi_leg_display = 0
scene.update()
def viwr_legend(self, context, simnode):
scene = context.scene
if scene.vi_leg_display != True or scene.vi_display == 0:
return
else:
try:
resvals = [
'{0:.0f} to {1:.0f}'.format(2 * i, 2 * (i + 1))
for i in range(simnode['nbins'])
]
resvals[-1] = resvals[
-1][:-int(len('{:.0f}'.format(simnode['maxres'])))] + u"\u221E"
height, lenres, font_id = context.region.height, len(
resvals[-1]), 0
drawpoly(20, height - 40, 70 + lenres * 8,
height - (simnode['nbins'] + 6) * 20)
drawloop(19, height - 40, 70 + lenres * 8,
height - (simnode['nbins'] + 6) * 20)
cm = matplotlib.cm.jet if simnode.wrtype in (
'0', '1') else matplotlib.cm.hot
for i in range(simnode['nbins']):
bgl.glColor4f(*cm(i * 1 / (simnode['nbins'] - 1), 1))
bgl.glBegin(bgl.GL_POLYGON)
bgl.glVertex2i(
20, height - 70 - (simnode['nbins'] * 20) + (i * 20))
bgl.glVertex2i(
60, height - 70 - (simnode['nbins'] * 20) + (i * 20))
bgl.glVertex2i(
60, height - 50 - (simnode['nbins'] * 20) + (i * 20))
bgl.glVertex2i(
20, height - 50 - (simnode['nbins'] * 20) + (i * 20))
bgl.glEnd()
blf.size(font_id, 20, 48)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
blf.position(font_id, 65,
height - 65 - (simnode['nbins'] * 20) + (i * 20),
0)
blf.draw(font_id,
" " * (lenres - len(resvals[i])) + resvals[i])
blf.size(font_id, 20, 56)
cu = 'Speed (m/s)'
drawfont(cu, font_id, 0, height, 25, 57)
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
height = context.region.height
font_id = 0
bgl.glColor4f(0.0, 0.0, 0.0, 0.8)
blf.size(font_id, 20, 48)
drawfont("Ave: {:.1f}".format(simnode['avres']), font_id, 0,
height, 22, simnode['nbins'] * 20 + 85)
drawfont("Max: {:.1f}".format(simnode['maxres']), font_id, 0,
height, 22, simnode['nbins'] * 20 + 100)
drawfont("Min: {:.1f}".format(simnode['minres']), font_id, 0,
height, 22, simnode['nbins'] * 20 + 115)
except:
scene.vi_display = 0
def draw_border(self):
self.on_set_foreground()
bgl.glLineWidth(2)
bgl.glBegin(bgl.GL_LINE_LOOP)
bgl.glVertex2i(self.ox, self.oy)
bgl.glVertex2i(self.ox, self.oy + self.dy)
bgl.glVertex2i(self.ox + self.dx, self.oy + self.dy)
bgl.glVertex2i(self.ox + self.dx, self.oy)
bgl.glEnd()
def outline_region(region, color):
bgl.glEnable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_LINE_SMOOTH)
bgl.glColor4f(*color)
lw = 4 // 2
bgl.glLineWidth(lw * 4)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(lw, lw)
bgl.glVertex2i(region.width - lw, lw)
bgl.glVertex2i(region.width - lw, region.height - lw)
bgl.glVertex2i(lw, region.height - lw)
bgl.glVertex2i(lw, lw)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
bgl.glDisable(bgl.GL_LINE_SMOOTH)
def draw_callback_px(self, context):
# 50% alpha, 2 pixel width line
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
bgl.glLineWidth(2)
bgl.glBegin(bgl.GL_LINES)
if self.started:
bgl.glVertex2i(self.start_vertex[0], self.start_vertex[1])
bgl.glVertex2i(self.end_vertex[0], self.end_vertex[1])
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def drawpoly(x1, y1, x2, y2):
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, 0.8)
bgl.glBegin(bgl.GL_POLYGON)
bgl.glVertex2i(x1, y2)
bgl.glVertex2i(x2, y2)
bgl.glVertex2i(x2, y1)
bgl.glVertex2i(x1, y1)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
def draw_border(self, context):
region = context.region
bgl.glEnable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_LINE_SMOOTH)
bgl.glColor4f(1, 1, 1, 0.75)
lw = 2
bgl.glLineWidth(lw)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(lw, lw)
bgl.glVertex2i(region.width - lw, lw)
bgl.glVertex2i(region.width - lw, region.height - lw)
bgl.glVertex2i(lw, region.height - lw)
bgl.glVertex2i(lw, lw)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
bgl.glDisable(bgl.GL_LINE_SMOOTH)
def draw_gl_line(context,pts,width,dash,color): #pts matrix_world
bgl.glLineWidth(width)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(color[0],color[1],color[2],color[3])
if dash:
bgl.glEnable(bgl.GL_LINE_STIPPLE)
# Draw stuff.
bgl.glBegin(bgl.GL_LINE_STRIP)
for pt in pts:
bgl.glVertex2i(pt[0], pt[1])
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
bgl.glDisable(bgl.GL_LINE_STIPPLE)
def draw_callback_px(self, context):
bpy.context.scene.retopo_wire.useRetopoWire = True #Uses Draw Xray Addon to Render vertices while in edge mode
# 50% alpha, 2 pixel width line
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
bgl.glLineWidth(2)
bgl.glBegin(bgl.GL_LINES)
if self.started:
bgl.glVertex2i(self.start_vertex[0], self.start_vertex[1])
bgl.glVertex2i(self.end_vertex[0], self.end_vertex[1])
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback_px(self, context):
"""From blender's operator_modal_draw.py modal operator template"""
if self.do_draw:
bgl.glEnable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_LINE_STIPPLE)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
bgl.glLineWidth(1)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(int(self.draw_start.x), int(self.draw_start.y))
bgl.glVertex2i(int(self.draw_end.x), int(self.draw_end.y))
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glDisable(bgl.GL_LINE_STIPPLE)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback_px(self, context):
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.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(self.startX, y)
for x, y in self.mouse_path:
bgl.glVertex2i(x, self.startY)
bgl.glEnd()
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 0.0, 0.0, 1.0)
def draw_callback_px(self, context):
"""From blender's operator_modal_draw.py modal operator template"""
if self.do_draw:
bgl.glEnable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_LINE_STIPPLE)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
bgl.glLineWidth(1)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(int(self.draw_start.x), int(self.draw_start.y))
bgl.glVertex2i(int(self.draw_end.x), int(self.draw_end.y))
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glDisable(bgl.GL_LINE_STIPPLE)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def li3D_legend(self, context, simnode, connode, geonode):
scene = context.scene
fc = str(scene.frame_current)
try:
if scene.vi_leg_display != True or scene.vi_display == 0 or (scene.wr_disp_panel != 1 and scene.li_disp_panel != 2 and scene.ss_disp_panel != 2) or scene.frame_current not in range(scene.fs, scene.fe + 1):
return
else:
resvals = [('{:.1f}', '{:.0f}')[scene.vi_leg_max >= 100].format(scene.vi_leg_min+i*(scene.vi_leg_max - scene.vi_leg_min)/19) for i in range(20)]
height = context.region.height
lenres = len(resvals[-1])
font_id = 0
drawpoly(20, height - 40, 70 + lenres*8, height - 520)
drawloop(19, height - 40, 70 + lenres*8, height - 520)
for i in range(20):
h = 0.75 - 0.75*(i/19)
if connode:
bgl.glColor4f(colorsys.hsv_to_rgb(h, 1.0, 1.0)[0], colorsys.hsv_to_rgb(h, 1.0, 1.0)[1], colorsys.hsv_to_rgb(h, 1.0, 1.0)[2], 1.0)
else:
bgl.glColor4f(i/19, i/19, i/19, 1)
bgl.glBegin(bgl.GL_POLYGON)
bgl.glVertex2i(20, (i*20)+height - 460)
bgl.glVertex2i(60, (i*20)+height - 460)
bgl.glVertex2i(60, (i*20)+height - 440)
bgl.glVertex2i(20, (i*20)+height - 440)
bgl.glEnd()
blf.size(font_id, 20, 48)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
blf.position(font_id, 65, (i*20)+height - 455, 0)
blf.draw(font_id, " "*(lenres - len(resvals[i]) ) + resvals[i])
blf.size(font_id, 20, 56)
# print(connode)
# cu = connode['unit'] if connode else '% Sunlit'
drawfont(scene['liparams']['unit'], font_id, 0, height, 25, 57)
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
height = context.region.height
font_id = 0
bgl.glColor4f(0.0, 0.0, 0.0, 0.8)
blf.size(font_id, 20, 48)
if context.active_object and context.active_object.get('lires'):
drawfont("Ave: {:.1f}".format(context.active_object['oave'][fc]), font_id, 0, height, 22, 480)
drawfont("Max: {:.1f}".format(context.active_object['omax'][fc]), font_id, 0, height, 22, 495)
drawfont("Min: {:.1f}".format(context.active_object['omin'][fc]), font_id, 0, height, 22, 510)
else:
drawfont("Ave: {:.1f}".format(simnode['avres'][fc]), font_id, 0, height, 22, 480)
drawfont("Max: {:.1f}".format(simnode['maxres'][fc]), font_id, 0, height, 22, 495)
drawfont("Min: {:.1f}".format(simnode['minres'][fc]), font_id, 0, height, 22, 510)
except Exception as e:
print(e, 'Turning off legend display')
scene.vi_leg_display = 0
scene.update()
def draw_rect_px(self, context):
if len(self.strokes) < 2:
return
bgl.glEnable(bgl.GL_BLEND)
bgl.glLineWidth(1)
bgl.glColor4f(0.75, 0.75, 0.75, 1.0)
bgl.glBegin(bgl.GL_LINE_STRIP)
sx, sy = self.strokes[0]["mouse"]
ex, ey = self.strokes[-1]["mouse"]
bgl.glVertex2i(int(sx), int(sy))
bgl.glVertex2i(int(sx), int(ey))
bgl.glVertex2i(int(ex), int(ey))
bgl.glVertex2i(int(ex), int(sy))
bgl.glVertex2i(int(sx), int(sy))
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_pen_px(self, context):
if len(self.strokes) < 1:
return
bgl.glEnable(bgl.GL_BLEND)
width = context.scene.quicker_props.bevel_depth
tool_setting = context.scene.tool_settings
rad = 5 * tool_setting.curve_paint_settings.radius_max * width * 10
pre = [stroke for stroke in self.strokes]
a = []
a.append(self.strokes[0])
a.extend(pre)
pre = a
bgl.glLineWidth(1)
bgl.glColor4f(0.75, 0.75, 0.75, 1.0)
bgl.glBegin(bgl.GL_LINE_STRIP)
for n, stroke in enumerate(self.strokes): # Size line
x, y = stroke["mouse"]
pres = stroke["pressure"]
p = pre[n]
px, py = p["mouse"]
ang = math.atan2(y - py, x - px)
pos = ang + PI_H
x = x + math.cos(pos) * rad * pres
y = y + math.sin(pos) * rad * pres
bgl.glVertex2i(int(x), int(y))
bgl.glEnd()
bgl.glBegin(bgl.GL_LINE_STRIP)
for n, stroke in enumerate(self.strokes): # Size line
x, y = stroke["mouse"]
pres = stroke["pressure"]
p = pre[n]
px, py = p["mouse"]
ang = math.atan2(y - py, x - px)
neg = ang - PI_H
x = x + math.cos(neg) * rad * pres
y = y + math.sin(neg) * rad * pres
bgl.glVertex2i(int(x), int(y))
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback_axis(self, context):
# X AXIS
bgl.glEnable(bgl.GL_BLEND)
if self.snap_axis_x:
bgl.glColor4f(1.0, 0.0, 0.0, 0.7)
bgl.glLineWidth(1)
elif self.middlemouse:
bgl.glColor4f(1.0, 0.0, 0.0, 0.3)
bgl.glLineWidth(1)
else:
bgl.glColor4f(0.0, 0.0, 0.0, 0.0)
bgl.glLineWidth(0)
bgl.glBegin(bgl.GL_LINE_STRIP)
for x in range(context.area.width):
bgl.glVertex2i(x, self.init_pos_y)
bgl.glEnd()
# Y AXIS
bgl.glEnable(bgl.GL_BLEND)
if self.snap_axis_y:
bgl.glColor4f(0.0, 1.0, 0.0, 0.7)
bgl.glLineWidth(1)
elif self.middlemouse:
bgl.glColor4f(0.0, 1.0, 0.0, 0.3)
bgl.glLineWidth(1)
else:
bgl.glColor4f(0.0, 0.0, 0.0, 0.0)
bgl.glLineWidth(0)
bgl.glBegin(bgl.GL_LINE_STRIP)
for y in range(context.area.height):
bgl.glVertex2i(self.init_pos_x, y)
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_lines(self, args):
self, context = args
# draw confirmed lines
bgl.glEnable(bgl.GL_BLEND)
bgl.glLineWidth(self.thickness)
bgl.glColor4f(*colorcodes[self.color], self.alpha)
bgl.glBegin(bgl.GL_LINE_STRIP)
for x, y in self.mouse_coords:
bgl.glVertex2i(int(x), int(y))
bgl.glEnd()
# draw preview line
if self.mouse_coords:
# see https://blender.stackexchange.com/a/21526/33919
bgl.glPushAttrib(bgl.GL_ENABLE_BIT)
bgl.glLineStipple(1, 0x9999)
bgl.glEnable(bgl.GL_LINE_STIPPLE)
# 50% alpha, 2 pixel width line
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(*colorcodes[self.color], 0.4)
bgl.glLineWidth(self.thickness)
bgl.glBegin(bgl.GL_LINE_STRIP)
for x, y in [
self.mouse_coords[-1],
mathutils.Vector((self.mouse_x, self.mouse_y))
]:
bgl.glVertex2i(int(x), int(y))
bgl.glEnd()
bgl.glPopAttrib()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def defilento(self):
pat = self._pattern
pat_one = pat << 1
pat = pat >> 15
pat |= pat_one & 0xFFFF
self._pattern = pat
bgl.glEnable(bgl.GL_LINE_STIPPLE)
bgl.glLineStipple(55, self._pattern)
width = abs(math.sin(time.time()) * 11.0)
bgl.glLineWidth(width)
# 2D drawing code example
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(0, 0)
bgl.glVertex2i(80, 100)
bgl.glEnd()
def draw_callback_px(self, context):
"""Modally called function that draws the lines as they are streamed.
Firstly updates the viewport's text.
Then draws the line based on points in self.point_path.
"""
print("data points", len(self.point_path))
# get region so can draw intermediate lines
region = context.region
rv3d = context.space_data.region_3d
draw_text_on_viewport("{} vertices added, timestamp {}"
.format(str(len(self.point_path)), str(self.latest_ts)))
# set the line parameters
# 50% alpha, 2 pixel width line
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 0.5)
bgl.glLineWidth(2)
# draw the line here.....
bgl.glBegin(bgl.GL_LINE_STRIP)
# start from the origin for visual purposes
for i in [0]:
vertex = loc3d2d(region, rv3d, (i, i, i))
print('vertex is', vertex)
bgl.glVertex2f(vertex[0], vertex[1])
for i, loc3d in enumerate(self.point_path):
loc2d = loc3d2d(region, rv3d, loc3d)
print(loc2d[0], loc2d[1], 'is the viewport coordinates')
bgl.glVertex2i(math.floor(loc2d[0]), math.floor(loc2d[1]))
#bgl.glVertex2i(math.floor(loc2d[0]%10), math.floor(loc2d[1]%10))
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def sync_draw_callback(self, context):
# polling
if context.mode != "EDIT_MESH":
return
# draw vertices
bgl.glColor4f(1.0, 0.0, 0.0, 1.0)
bgl.glPointSize(4)
bgl.glBegin(bgl.GL_POINTS)
for x, y in self.position_vertices:
bgl.glVertex2i(x, y)
bgl.glEnd()
# draw edges
bgl.glColor4f(1.0, 0.0, 0.0, 1.0)
bgl.glLineWidth(1.5)
bgl.glBegin(bgl.GL_LINES)
for x, y in self.position_edges:
bgl.glVertex2i(x, y)
bgl.glEnd()
bgl.glLineWidth(1)
# draw faces
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 0.0, 0.0, 0.3)
bgl.glBegin(bgl.GL_QUADS)
for x, y in self.position_faces:
bgl.glVertex2i(x, y)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
def draw_callback_px(self, context):
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 0.5)
bgl.glLineWidth(2)
if context.scene.curve_freehand.use_pressure:
from mathutils import noise
pt_a = self.mouse_path[0]
for i in range(1, len(self.mouse_path)):
# weak but good enough for preview
pt_b = self.mouse_path[i]
bgl.glPointSize(1 + (pt_a[2] * 40.0))
bgl.glBegin(bgl.GL_POINTS)
bgl.glVertex2i(pt_a[0], pt_a[1])
bgl.glVertex2i(pt_b[0], pt_b[1])
bgl.glEnd()
pt_a = pt_b
else:
bgl.glBegin(bgl.GL_LINE_STRIP)
for pt in self.mouse_path:
bgl.glVertex2i(pt[0], pt[1])
bgl.glEnd()
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback(self, context):
r, g, b = context.tool_settings.image_paint.brush.cursor_color_add
#x0, y0, x1, y1 = context.window_manager["straight_line"]
start = self.stroke[0]
end = self.stroke[-1]
x0 = start["mouse"][0]
y0 = start["mouse"][1]
x1 = end["mouse"][0]
y1 = end["mouse"][1]
# draw straight line
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(r, g, b, 1.0)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(x0, y0)
bgl.glVertex2i(x1, y1)
bgl.glEnd()
# restore opengl defaults
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback_abc(self, context):
font_id = 0
scene = context.scene
region = context.region
rv3d = context.region_data
obj_matrix_world = self.obj.matrix_world
a_3d = obj_matrix_world * self.obj.data.vertices[self.snap_points[self.index].a].co
b_3d = obj_matrix_world * self.obj.data.vertices[self.snap_points[self.index].b].co
c_3d = obj_matrix_world * self.obj.data.vertices[self.snap_points[self.index].c].co
a_2d = tuple(map(ceil, view3d_utils.location_3d_to_region_2d(region, rv3d, a_3d)))
b_2d = tuple(map(ceil, view3d_utils.location_3d_to_region_2d(region, rv3d, b_3d)))
c_2d = tuple(map(ceil, view3d_utils.location_3d_to_region_2d(region, rv3d, c_3d)))
bgl.glColor3f(0.0, 0.0, 0.0)
bgl.glPointSize(8)
bgl.glBegin(bgl.GL_POINTS)
for x, y in (a_2d, b_2d, c_2d):
bgl.glVertex2i(x, y)
bgl.glEnd()
bgl.glPointSize(4)
bgl.glColor3f(0.9, 0.1, 0.1)
bgl.glBegin(bgl.GL_POINTS)
bgl.glVertex2i(a_2d[0], a_2d[1])
bgl.glEnd()
bgl.glColor3f(0.1, 0.9, 0.1)
bgl.glBegin(bgl.GL_POINTS)
bgl.glVertex2i(b_2d[0], b_2d[1])
bgl.glEnd()
bgl.glColor3f(0.3, 0.3, 0.9)
bgl.glBegin(bgl.GL_POINTS)
bgl.glVertex2i(c_2d[0], c_2d[1])
bgl.glEnd()
# restore opengl defaults
bgl.glPointSize(1)
bgl.glLineWidth(1)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def rect_round_corners(x1,y1, x2,y2):
k = 2 # length of edge ~ border-radius
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(x1, y1 + k)
bgl.glVertex2i(x1, y2 - k)
bgl.glVertex2i(x1 + k, y2)
bgl.glVertex2i(x2 - k, y2)
bgl.glVertex2i(x2, y2 - k)
bgl.glVertex2i(x2, y1 + k)
bgl.glVertex2i(x2 - k, y1)
bgl.glVertex2i(x1 + k, y1)
bgl.glVertex2i(x1, y1 + k)
bgl.glEnd()
def rad_3D_legend(self, context):
scene = bpy.context.scene
if bpy.context.scene['metric'] == 2:
lenres = int(math.floor(math.log10(max(scene['resmax']))) + 2)
else:
lenres = int(math.floor(math.log10(max(scene['resmax']))) + 2)
font_id = 0
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
bgl.glLineWidth(2)
bgl.glBegin(bgl.GL_POLYGON)
bgl.glVertex2i(20, 20)
bgl.glVertex2i(70 + lenres*7, 20)
bgl.glVertex2i(70 + lenres*7, 440)
bgl.glVertex2i(20, 440)
bgl.glEnd()
for i in range(20):
h = 0.75 - 0.75*(i/19)
bgl.glColor4f(colorsys.hsv_to_rgb(h, 1.0, 1.0)[0], colorsys.hsv_to_rgb(h, 1.0, 1.0)[1], colorsys.hsv_to_rgb(h, 1.0, 1.0)[2], 1.0)
bgl.glBegin(bgl.GL_POLYGON)
bgl.glVertex2i(20, (i*20)+20)
bgl.glVertex2i(60, (i*20)+20)
bgl.glVertex2i(60, (i*20)+40)
bgl.glVertex2i(20, (i*20)+40)
bgl.glEnd()
if bpy.context.scene['metric'] == 2:
singlelenres = int(math.log10(math.floor(min(scene['resmin'])+i*(max(scene['resmax'])-min(scene['resmin']))/19)+1))
else:
singlelenres = int(math.log10(math.floor(min(scene['resmin'])+i*(max(scene['resmax'])-min(scene['resmin']))/19)+1))
blf.position(font_id, 60, (i*20)+25, 0)
blf.size(font_id, 20, 48)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
if bpy.context.scene['metric'] == 2:
blf.draw(font_id, " "*(lenres - singlelenres - 2) + str(round(min(scene['resmin'])+i*(max(scene['resmax'])-min(scene['resmin']))/19, 1)+1))
else:
blf.draw(font_id, " "*(lenres - singlelenres - 1) + str(int(min(scene['resmin'])+i*(max(scene['resmax'])-min(scene['resmin']))/19)+1))
blf.position(font_id, 25, 425, 0)
blf.size(font_id, 20, 56)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
blf.draw(font_id, scene['unit'])
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_edit_mode(self,context,color=[0.41, 0.38, 1.0, 1.0],text="Edit Shapekey Mode",offset=0):
region = context.region
x = region.width
y = region.height
scale = x / 1200
scale = clamp(scale,.5,1.5)
r_offset = 0
if context.user_preferences.system.use_region_overlap:
r_offset = context.area.regions[1].width
### draw box behind text
b_width = int(240*scale)
b_height = int(36*scale)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(color[0],color[1],color[2],color[3])
bgl.glBegin(bgl.GL_QUADS)
bgl.glVertex2i(x-b_width, 0)
bgl.glVertex2i(x, 0)
bgl.glVertex2i(x, b_height)
bgl.glVertex2i(x-b_width, b_height)
bgl.glVertex2i(x-b_width, 0)
bgl.glEnd()
### draw edit type
font_id = 0 # XXX, need to find out how best to get this.
bgl.glColor4f(0.041613, 0.041613, 0.041613, 1.000000)
text_offset = int((220+offset)*scale)
text_y_offset = int(11 * scale)
blf.position(font_id, x-text_offset, text_y_offset, 0)
blf.size(font_id, 20, int(72*scale))
blf.draw(font_id, text)
### draw viewport outline
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(color[0],color[1],color[2],color[3])
bgl.glLineWidth(4)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(r_offset, 0)
bgl.glVertex2i(r_offset+x, 0)
bgl.glVertex2i(r_offset+x, y)
bgl.glVertex2i(r_offset+0, y)
bgl.glVertex2i(r_offset, 0)
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def drawZoomBox(self, context): bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(0, 0, 0, 0.5) bgl.glLineWidth(2) if self.zoomBoxMode and not self.zoomBoxDrag: # before selection starts draw infinite cross bgl.glBegin(bgl.GL_LINES) px, py = self.zb_xmax, self.zb_ymax bgl.glVertex2i(0, py) bgl.glVertex2i(context.area.width, py) bgl.glVertex2i(px, 0) bgl.glVertex2i(px, context.area.height) bgl.glEnd() elif self.zoomBoxMode and self.zoomBoxDrag: # when selecting draw dashed line box bgl.glEnable(bgl.GL_LINE_STIPPLE) bgl.glLineStipple(2, 0x3333) bgl.glBegin(bgl.GL_LINE_LOOP) bgl.glVertex2i(self.zb_xmin, self.zb_ymin) bgl.glVertex2i(self.zb_xmin, self.zb_ymax) bgl.glVertex2i(self.zb_xmax, self.zb_ymax) bgl.glVertex2i(self.zb_xmax, self.zb_ymin) bgl.glEnd() bgl.glDisable(bgl.GL_LINE_STIPPLE) # restore opengl defaults bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_UI(self, context):
# creates all lines and appends them to a list, then draws these to the UI
font_id = 0
lines = []
if self.switch:
blf.position(font_id, self.initial_mouse_region[0]+5, self.current_mouse_region[1]+8, 0)
blf.size(font_id, 20, 38)
blf.draw(font_id, str(round(self.offset, 3)))
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, 0.2)
bgl.glLineWidth(2)
length = 0
while length < abs(self.current_mouse_region[0] - self.initial_mouse_region[0])-10:
if self.current_mouse_region[0] - self.initial_mouse_region[0] >= 0:
lines.append([(self.initial_mouse_region[0]+length+4, self.current_mouse_region[1]),
(self.initial_mouse_region[0]+length+10, self.current_mouse_region[1])])
else:
lines.append([(self.initial_mouse_region[0]-length-4, self.current_mouse_region[1]),
(self.initial_mouse_region[0]-length-10, self.current_mouse_region[1])])
length +=10
lines.append([(self.initial_mouse_region[0]+1, self.current_mouse_region[1]+15),
(self.initial_mouse_region[0]+1, self.current_mouse_region[1]-8)])
else:
blf.position(font_id, self.current_mouse_region[0]+5, self.initial_mouse_region[1]+8, 0)
blf.size(font_id, 20, 38)
blf.draw(font_id, str(round(self.displace, 3)))
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, 0.2)
bgl.glLineWidth(2)
length = 0
while length < abs(self.current_mouse_region[1] - self.initial_mouse_region[1])-10:
if self.current_mouse_region[1] - self.initial_mouse_region[1] >= 0:
lines.append([(self.current_mouse_region[0], self.initial_mouse_region[1]+length+4),
(self.current_mouse_region[0], self.initial_mouse_region[1]+length+10)])
else:
lines.append([(self.current_mouse_region[0], self.initial_mouse_region[1]-length-4),
(self.current_mouse_region[0], self.initial_mouse_region[1]-length-10)])
length +=10
lines.append([(self.current_mouse_region[0]+15, self.initial_mouse_region[1]+1),
(self.current_mouse_region[0]-8, self.initial_mouse_region[1]+1)])
# draw lines
for i in lines:
bgl.glBegin(bgl.GL_LINE_STRIP)
for x, y in i:
bgl.glVertex2i(x, y)
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback(self, context):
if context.mode not in ['OBJECT', 'POSE']:
return
area = MotionPath.get_area(context, 'VIEW_3D')
if not self._is_2d or not area:
return
LINE_WIDTH = 1
POINT_SIZE = 1
STAR_SIZE = 10
CROSS_SIZE = 7.07106781186547
# draw line
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor3f(self.props.color.r, self.props.color.g, self.props.color.b)
bgl.glLineWidth(LINE_WIDTH)
bgl.glBegin(bgl.GL_LINE_STRIP)
for sample in self._samples:
if sample._proj is not None:
bgl.glVertex2i(int(sample._proj.x), int(sample._proj.y))
bgl.glEnd()
feature_count = 1
# draw points
bgl.glPointSize(POINT_SIZE)
for sample in self._samples:
if sample._proj is None:
continue
x = sample._proj.x
y = sample._proj.y
# if self._features_type_color:
# if sample._flag == 'MINMAX_X':
# bgl.glColor3f(0, 1, 0)
# elif sample._flag == 'MINMAX_Y':
# bgl.glColor3f(1, 1, 0)
# elif sample._flag == 'MINMAX_XY':
# bgl.glColor3f(1, 0, 0)
# elif sample._flag == 'CLEANED':
# bgl.glColor3f(0, 0, 1)
# elif sample._flag in {'START', 'END'}:
# bgl.glColor3f(1, 0, 1)
if sample._flag in {'MINMAX_X', 'MINMAX_Y', 'MINMAX_XY', 'START', 'END'}:
# shape
if self.props.features_shape == 'star':
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2i(int(x - STAR_SIZE), int(y))
bgl.glVertex2i(int(x + STAR_SIZE + 1), int(y))
bgl.glVertex2i(int(x), int(y - STAR_SIZE))
bgl.glVertex2i(int(x), int(y + STAR_SIZE + 1))
bgl.glEnd()
blf.position(0, int(x) + 15, int(y) - 5, 0)
blf.size(0, 14, 72)
blf.draw(0, str(feature_count))
elif self.props.features_shape == 'cross':
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2i(int(x - CROSS_SIZE), int(y - CROSS_SIZE))
bgl.glVertex2i(int(x + CROSS_SIZE + 1), int(y + CROSS_SIZE + 1))
bgl.glVertex2i(int(x - CROSS_SIZE), int(y + CROSS_SIZE))
bgl.glVertex2i(int(x + CROSS_SIZE + 1), int(y - CROSS_SIZE - 1))
bgl.glEnd()
blf.position(0, int(x) + 15, int(y) - 5, 0)
blf.size(0, 14, 72)
blf.draw(0, str(feature_count))
feature_count += 1
else:
# point
bgl.glBegin(bgl.GL_POINTS)
bgl.glVertex2i(int(x), int(y))
bgl.glEnd()
area.tag_redraw()
def draw_callback(x_offset, y_offset, slider_width, slider_height):
''' draw sliders on the screen conditionally '''
context = bpy.context
area = context.area
region = context.region
rv3d = context.space_data.region_3d
anim_color =\
context.user_preferences.themes[0].user_interface.wcol_state.inner_anim
key_color =\
context.user_preferences.themes[0].user_interface.wcol_state.inner_key
if area.type == 'VIEW_3D':
if context.mode == 'POSE' and context.active_pose_bone:
x0, y0, x_start, x_end, y_start, y_min, y_max, bone, items =\
locator(
context, x_offset, y_offset, slider_width, slider_height)
bgl.glEnable(bgl.GL_BLEND)
font_id = 0 # XXX, need to find out how best to get this.
for index, prop in enumerate(items):
animated, keyframed = is_animated(context, prop)
prop_min = bone["_RNA_UI"][prop]["min"]
prop_max = bone["_RNA_UI"][prop]["max"]
offset = index * 40
bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
# draw some text
blf.position(font_id, x_end + 10, y_start - offset, 0)
blf.size(font_id, 12, 72)
if animated:
color = key_color if keyframed else anim_color
bgl.glColor4f(color[0], color[1], color[2], 0.9)
blf.draw(font_id, '{} {:.3f}'.format(prop,bone[prop]))
bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
bgl.glLineWidth(1)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(x_start, y_start - offset )
bgl.glVertex2i(x_end, y_start - offset)
bgl.glEnd()
bgl.glLineWidth(2)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(x_start, y_min - offset)
bgl.glVertex2i(x_start, y_max - offset)
bgl.glEnd()
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(x_end, y_min - offset)
bgl.glVertex2i(x_end, y_max - offset)
bgl.glEnd()
bgl.glColor4f(1.0, 0.0, 0.0, 0.8)
bgl.glLineWidth(3)
bgl.glBegin(bgl.GL_LINE_STRIP)
percent = (bone[prop] - prop_min) / (prop_max - prop_min)
value = x_start + int(percent * slider_width)
bgl.glVertex2i(value - 2, y_start - 2 - offset)
bgl.glVertex2i(value + 2, y_start - 2 - offset)
bgl.glVertex2i(value + 2, y_start + 2 - offset)
bgl.glVertex2i(value - 2, y_start + 2 - offset)
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_preview_callback(self):
"""TODO Missing documentation"""
# Search for View_3d window
area = None
if bpy.context.area.type != 'VIEW_3D':
return bpy.context.area
else:
for oWindow in bpy.context.window_manager.windows:
oScreen = oWindow.screen
for oArea in oScreen.areas:
if oArea.type == 'VIEW_3D':
area = oArea
modelsPosesColl = bUtils.getPhobosPreferences().models_poses
activeModelPoseIndex = bpy.context.scene.active_ModelPose
if (len(modelsPosesColl) > 0) and area:
# Draw a textured quad
area_widths = [
region.width for region in bpy.context.area.regions if region.type == 'WINDOW'
]
area_heights = [
region.height for region in bpy.context.area.regions if region.type == 'WINDOW'
]
if (len(area_widths) > 0) and (len(area_heights) > 0):
active_preview = modelsPosesColl[bpy.data.images[activeModelPoseIndex].name]
im = bpy.data.images[activeModelPoseIndex]
view_width = area_widths[0]
view_height = area_heights[0]
tex_start_x = 50
tex_end_x = view_width - 50
tex_start_y = 50
tex_end_y = view_height - 50
if im.size[0] < view_width:
diff = int((view_width - im.size[0]) / 2)
tex_start_x = diff
tex_end_x = diff + im.size[0]
if im.size[1] < view_height:
diff = int((view_height - im.size[1]) / 2)
tex_start_y = diff
tex_end_y = diff + im.size[1]
# Draw information
font_id = 0 # XXX, need to find out how best to get this.
blf.position(font_id, tex_start_x, tex_end_y + 20, 0)
blf.size(font_id, 20, 72)
blf.draw(font_id, active_preview.label)
tex = im.bindcode
bgl.glEnable(bgl.GL_TEXTURE_2D)
# if using blender 2.77 change tex to tex[0]
bgl.glBindTexture(bgl.GL_TEXTURE_2D, tex)
# Background
bgl.glEnable(bgl.GL_BLEND)
bgl.glBegin(bgl.GL_QUADS)
bgl.glColor4f(0, 0, 0, 0.3)
bgl.glVertex2i(0, 0)
bgl.glVertex2i(0, view_height)
bgl.glVertex2i(view_width, view_height)
bgl.glVertex2i(view_width, 0)
# Draw Image
bgl.glColor4f(1, 1, 1, 1)
bgl.glTexCoord2f(0, 0)
bgl.glVertex2i(int(tex_start_x), int(tex_start_y))
bgl.glTexCoord2f(0, 1)
bgl.glVertex2i(int(tex_start_x), int(tex_end_y))
bgl.glTexCoord2f(1, 1)
bgl.glVertex2i(int(tex_end_x), int(tex_end_y))
bgl.glTexCoord2f(1, 0)
bgl.glVertex2i(int(tex_end_x), int(tex_start_y))
bgl.glEnd()
# restore opengl defaults
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
bgl.glDisable(bgl.GL_QUADS)
bgl.glDisable(bgl.GL_BLEND)
bgl.glDisable(bgl.GL_TEXTURE_2D)
def draw_callback_px(self, context):
"""Draws Code Editors Minimap and indentation marks"""
def draw_line(origin, length, thickness, vertical=False):
"""Drawing lines with polys, its faster"""
x = (origin[0] + thickness) if vertical else (origin[0] + length)
y = (origin[1] + length) if vertical else (origin[1] + thickness)
bgl.glBegin(bgl.GL_QUADS)
for v1, v2 in [origin, (x, origin[1]), (x, y), (origin[0], y)]:
bgl.glVertex2i(v1, v2)
bgl.glEnd()
return
# abort if another text editor
if self.area == context.area and self.window == context.window:
bgl.glEnable(bgl.GL_BLEND)
else:
return
start = time.clock()
# init params
font_id = 0
self.width = next(region.width for region in context.area.regions if region.type == "WINDOW")
self.height = next(region.height for region in context.area.regions if region.type == "WINDOW")
dpi_r = context.user_preferences.system.dpi / 72.0
self.left_edge = self.width - round(dpi_r * (self.width + 5 * self.minimap_width) / 10.0)
self.right_edge = self.width - round(dpi_r * 15)
self.opacity = min(max(0, (self.width - self.min_width) / 100.0), 1)
# compute character dimensions
mcw = dpi_r * self.minimap_symbol_width # minimap char width
mlh = round(dpi_r * self.minimap_line_height) # minimap line height
fs = context.space_data.font_size
cw = round(dpi_r * round(2 + 0.6 * (fs - 4))) # char width
ch = round(dpi_r * round(2 + 1.3 * (fs - 2) + ((fs % 10) == 0))) # char height
# panel background box
self.tab_width = round(dpi_r * 25) if (self.tabs and len(bpy.data.texts) > 1) else 0
bgl.glColor4f(self.background.r, self.background.g, self.background.b, (1 - self.bg_opacity) * self.opacity)
bgl.glBegin(bgl.GL_QUADS)
for x, y in [
(self.left_edge - self.tab_width, self.height),
(self.right_edge, self.height),
(self.right_edge, 0),
(self.left_edge - self.tab_width, 0),
]:
bgl.glVertex2i(x, y)
bgl.glEnd()
# line numbers background
space = context.space_data
if space.text:
lines = len(space.text.lines)
lines_digits = len(str(lines)) if space.show_line_numbers else 0
self.line_bar_width = int(dpi_r * 5) + cw * (lines_digits)
bgl.glColor4f(self.background.r, self.background.g, self.background.b, 1)
bgl.glBegin(bgl.GL_QUADS)
for x, y in [(0, self.height), (self.line_bar_width, self.height), (self.line_bar_width, 0), (0, 0)]:
bgl.glVertex2i(x, y)
bgl.glEnd()
# shadow
bgl.glLineWidth(1.0 * dpi_r)
for id, intensity in enumerate([0.2, 0.1, 0.07, 0.05, 0.03, 0.02, 0.01]):
bgl.glColor4f(0.0, 0.0, 0.0, intensity)
bgl.glBegin(bgl.GL_LINE_STRIP)
for x, y in [(self.line_bar_width + id, 0), (self.line_bar_width + id, self.height)]:
bgl.glVertex2i(x, y)
bgl.glEnd()
# minimap shadow
for id, intensity in enumerate([0.2, 0.1, 0.07, 0.05, 0.03, 0.02, 0.01]):
bgl.glColor4f(0.0, 0.0, 0.0, intensity * self.opacity)
bgl.glBegin(bgl.GL_LINE_STRIP)
for x, y in [(self.left_edge - id - self.tab_width, 0), (self.left_edge - id - self.tab_width, self.height)]:
bgl.glVertex2i(x, y)
bgl.glEnd()
# divider
if self.tab_width:
bgl.glColor4f(0.0, 0.0, 0.0, 0.2 * self.opacity)
bgl.glBegin(bgl.GL_LINE_STRIP)
for x, y in [(self.left_edge, 0), (self.left_edge, self.height)]:
bgl.glVertex2i(x, y)
bgl.glEnd()
# if there is text in window
if space.text and self.opacity:
# minimap horizontal sliding based on text block length
max_slide = max(0, mlh * (lines + self.height / ch) - self.height)
self.slide = int(max_slide * space.top / lines)
minimap_top_line = int(self.slide / mlh)
minimap_bot_line = int((self.height + self.slide) / mlh)
# draw minimap visible box
if self.in_minimap:
bgl.glColor4f(1.0, 1.0, 1.0, 0.1 * self.opacity)
else:
bgl.glColor4f(1.0, 1.0, 1.0, 0.07 * self.opacity)
bgl.glBegin(bgl.GL_QUADS)
for x, y in [
(self.left_edge, self.height - mlh * space.top + self.slide),
(self.right_edge, self.height - mlh * space.top + self.slide),
(self.right_edge, self.height - mlh * (space.top + space.visible_lines) + self.slide),
(self.left_edge, self.height - mlh * (space.top + space.visible_lines) + self.slide),
]:
bgl.glVertex2i(x, y)
bgl.glEnd()
# draw minimap code
for segment in self.segments[:-1]:
bgl.glColor4f(segment["col"][0], segment["col"][1], segment["col"][2], 0.4 * self.opacity)
for id, element in enumerate(segment["elements"][minimap_top_line:minimap_bot_line]):
loc_y = mlh * (id + minimap_top_line + 3) - self.slide
for sub_element in element:
draw_line(
(self.left_edge + int(mcw * (sub_element[0] + 4)), self.height - loc_y),
int(mcw * (sub_element[1] - sub_element[0])),
int(0.5 * mlh),
)
# minimap code marks
bgl.glColor4f(
self.segments[-2]["col"][0],
self.segments[-2]["col"][1],
self.segments[-2]["col"][2],
0.3 * self.block_trans * self.opacity,
)
for id, element in enumerate(self.segments[-2]["elements"]):
for sub_element in element:
if sub_element[2] >= space.top or id < space.top + space.visible_lines:
draw_line(
(self.left_edge + int(mcw * (sub_element[0] + 4)), self.height - mlh * (id + 3) + self.slide),
-int(mlh * (sub_element[2] - id - 1)),
int(0.5 * mlh),
True,
)
# draw dotted indentation marks
bgl.glLineWidth(1.0 * dpi_r)
if space.text:
bgl.glColor4f(
self.segments[0]["col"][0], self.segments[0]["col"][1], self.segments[0]["col"][2], self.indent_trans
)
for id, element in enumerate(self.segments[-1]["elements"][space.top : space.top + space.visible_lines]):
loc_y = id
for sub_element in element:
draw_line(
(int(dpi_r * 10) + cw * (lines_digits + sub_element[0] + 4), self.height - ch * (loc_y)),
-ch,
int(1 * dpi_r),
True,
)
# draw code block marks
bgl.glColor4f(
self.segments[-2]["col"][0], self.segments[-2]["col"][1], self.segments[-2]["col"][2], self.block_trans
)
for id, element in enumerate(self.segments[-2]["elements"]):
for sub_element in element:
if sub_element[2] >= space.top or id < space.top + space.visible_lines:
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(
int(dpi_r * 10 + cw * (lines_digits + sub_element[0])), self.height - ch * (id + 1 - space.top)
)
bgl.glVertex2i(
int(dpi_r * 10 + cw * (lines_digits + sub_element[0])),
self.height - int(ch * (sub_element[2] - space.top)),
)
bgl.glVertex2i(
int(dpi_r * 10 + cw * (lines_digits + sub_element[0] + 1)),
self.height - int(ch * (sub_element[2] - space.top)),
)
bgl.glEnd()
# tab dividers
if self.tab_width and self.opacity:
self.tab_height = min(200, int(self.height / len(bpy.data.texts)))
y_loc = self.height - 5
for text in bpy.data.texts:
# tab selection
if text.name == self.in_tab:
bgl.glColor4f(1.0, 1.0, 1.0, 0.05 * self.opacity)
bgl.glBegin(bgl.GL_QUADS)
for x, y in [
(self.left_edge - self.tab_width, y_loc),
(self.left_edge, y_loc),
(self.left_edge, y_loc - self.tab_height),
(self.left_edge - self.tab_width, y_loc - self.tab_height),
]:
bgl.glVertex2i(x, y)
bgl.glEnd()
# tab active
if context.space_data.text and text.name == context.space_data.text.name:
bgl.glColor4f(1.0, 1.0, 1.0, 0.05 * self.opacity)
bgl.glBegin(bgl.GL_QUADS)
for x, y in [
(self.left_edge - self.tab_width, y_loc),
(self.left_edge, y_loc),
(self.left_edge, y_loc - self.tab_height),
(self.left_edge - self.tab_width, y_loc - self.tab_height),
]:
bgl.glVertex2i(x, y)
bgl.glEnd()
bgl.glColor4f(0.0, 0.0, 0.0, 0.2 * self.opacity)
y_loc -= self.tab_height
bgl.glBegin(bgl.GL_LINE_STRIP)
for x, y in [(self.left_edge - self.tab_width, y_loc), (self.left_edge, y_loc)]:
bgl.glVertex2i(x, y)
bgl.glEnd()
# draw fps
# bgl.glColor4f(1, 1, 1, 0.2)
# blf.size(font_id, fs, int(dpi_r*72))
# blf.position(font_id, self.left_edge-50, 5, 0)
# blf.draw(font_id, str(round(1/(time.clock() - start),3)))
# draw line numbers
if space.text:
bgl.glColor4f(self.segments[0]["col"][0], self.segments[0]["col"][1], self.segments[0]["col"][2], 0.5)
for id in range(space.top, min(space.top + space.visible_lines + 1, lines + 1)):
if self.in_line_bar and self.segments[-2]["elements"][id - 1]:
bgl.glColor4f(self.segments[-2]["col"][0], self.segments[-2]["col"][1], self.segments[-2]["col"][2], 1)
blf.position(
font_id, 2 + int(0.5 * cw * (len(str(lines)) - 1)), self.height - ch * (id - space.top) + 3, 0
)
# blf.draw(font_id, '→')
blf.draw(font_id, "↓")
bgl.glColor4f(self.segments[0]["col"][0], self.segments[0]["col"][1], self.segments[0]["col"][2], 0.5)
else:
blf.position(
font_id,
2 + int(0.5 * cw * (len(str(lines)) - len(str(id)))),
self.height - ch * (id - space.top) + 3,
0,
)
blf.draw(font_id, str(id))
# draw file names
if self.tab_width:
blf.enable(font_id, blf.ROTATION)
blf.rotation(font_id, 1.570796)
y_loc = self.height
for text in bpy.data.texts:
text_max_length = max(2, int((self.tab_height - 40) / cw))
name = text.name[:text_max_length]
if text_max_length < len(text.name):
name += "..."
bgl.glColor4f(
self.segments[0]["col"][0],
self.segments[0]["col"][1],
self.segments[0]["col"][2],
(0.7 if text.name == self.in_tab else 0.4) * self.opacity,
)
blf.position(
font_id,
self.left_edge - round((self.tab_width - ch) / 2.0) - 5,
round(y_loc - (self.tab_height / 2) - cw * len(name) / 2),
0,
)
blf.draw(font_id, name)
y_loc -= self.tab_height
# restore opengl defaults
bgl.glColor4f(0, 0, 0, 1)
bgl.glLineWidth(1.0)
bgl.glDisable(bgl.GL_BLEND)
blf.disable(font_id, blf.ROTATION)
return
def draw_callback_px(self, context):
font_id = 0 # XXX, need to find out how best to get this.
region = context.region
# Tente de positionner le texte au milieu de la fenetre (à refaire)
xt = int(region.width / 2.0)
yt = 70
# Position et affichage du texte du mode en cours avec les infos dessous (Voir pour mieux centrer le texte)
blf.position(font_id, xt - blf.dimensions(font_id, "CREATE")[0], 65 + yt, 0)
blf.size(font_id, 20, 82)
bgl.glColor4f(0.900, 0.4, 0.00, 1.0)
blf.draw(font_id, "CREATE")
bgl.glLineWidth(2)
bgl.glColor4f(0.900, 0.4, 0.00, 1.0)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(int(xt - blf.dimensions(font_id, "CREATE")[0] + 0), 55 + yt)
bgl.glVertex2i(int(xt - blf.dimensions(font_id, "CREATE")[0] + 200), 55 + yt)
bgl.glEnd()
# Selon le mode, l'ecriture change de largeur donc le centre est décalé. Ca permet de "réparer" les erreurs.
xt = xt - blf.dimensions(font_id, "CREATE")[0]
# Affichage des infos
blf.size(font_id, 20, 50)
blf.position(font_id, xt + 15, 35 + yt, 0)
bgl.glColor4f(0.912, 0.919, 0.994, 1.0)
if(self.CreateMode == 0):
blf.draw(font_id, "Type Rectangle [SPACE]")
if(self.CreateMode == 1):
blf.draw(font_id, "Type Circle [SPACE]")
if(self.CreateMode == 2):
if(self.Closed == False):
blf.draw(font_id, "Type Line [SPACE] ([C] to close geometry)")
else:
blf.draw(font_id, "Type closed Line [SPACE] ([C] to open geometry) ")
if(self.CreateMode == 0):
blf.size(font_id, 20, 50)
blf.position(font_id, xt + 15, 15 + yt, 0)
bgl.glColor4f(0.912, 0.919, 0.994, 1.0)
blf.draw(font_id, "Dimension (MouseMove)")
blf.position(font_id, xt + 15, -5 + yt, 0)
bgl.glColor4f(0.912, 0.919, 0.994, 1.0)
blf.draw(font_id, "Move all (Alt + MouseMove)")
if(self.CreateMode == 1):
blf.size(font_id, 20, 50)
blf.position(font_id, xt + 15, 15 + yt, 0)
bgl.glColor4f(0.912, 0.919, 0.994, 1.0)
blf.draw(font_id, "Rotation (Ctrl + MouseWheel)")
blf.position(font_id, xt + 15, -5 + yt, 0)
blf.draw(font_id, "Definition (MouseWheel)")
blf.position(font_id, xt + 15, -25 + yt, 0)
blf.draw(font_id, "Move all (Alt + MouseMove)")
if(self.CreateMode == 2):
blf.size(font_id, 20, 50)
blf.position(font_id, xt + 15, 15 + yt, 0)
bgl.glColor4f(0.912, 0.919, 0.994, 1.0)
blf.draw(font_id, "New point (Left Mouse)")
blf.position(font_id, xt + 15, -5 + yt, 0)
blf.draw(font_id, "Move all (Alt + MouseMove)")
blf.position(font_id, xt + 15, -25 + yt, 0)
blf.draw(font_id, "Incremental (Ctrl)")
# Mode, couleur et largeur des lignes
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0.812, 0.519, 0.094, 0.5)
bgl.glLineWidth(2)
# Permet de smoother les points pour les arrondir
bgl.glEnable(bgl.GL_POINT_SMOOTH)
if(self.bDone):
# Affichage des primitives selon le type de découpe choisie
if(len(self.mouse_path) > 1):
x0 = self.mouse_path[0][0]
y0 = self.mouse_path[0][1]
x1 = self.mouse_path[1][0]
y1 = self.mouse_path[1][1]
# Affichage de la ligne de coupe
if(self.CreateMode == 2):
bgl.glBegin(bgl.GL_LINE_STRIP)
for x, y in self.mouse_path:
bgl.glVertex2i(x + self.xpos, y + self.ypos)
bgl.glEnd()
bgl.glPointSize(6)
bgl.glBegin(bgl.GL_POINTS)
for x, y in self.mouse_path:
bgl.glVertex2i(x + self.xpos, y + self.ypos)
bgl.glEnd()
# Affichage du rectange de découpe
if(self.CreateMode == 0):
bgl.glColor4f(0.812, 0.519, 0.094, 0.5)
# Selon si on appuie sur SHIFT, le rectangle est plein ou pas
bgl.glBegin(bgl.GL_QUADS)
bgl.glVertex2i(x0 + self.xpos, y0 + self.ypos)
bgl.glVertex2i(x1 + self.xpos, y0 + self.ypos)
bgl.glVertex2i(x1 + self.xpos, y1 + self.ypos)
bgl.glVertex2i(x0 + self.xpos, y1 + self.ypos)
bgl.glEnd()
bgl.glPointSize(6)
bgl.glColor4f(0.812, 0.519, 0.094, 1.0)
bgl.glBegin(bgl.GL_POINTS)
bgl.glVertex2i(x0 + self.xpos, y0 + self.ypos)
bgl.glVertex2i(x1 + self.xpos, y0 + self.ypos)
bgl.glVertex2i(x1 + self.xpos, y1 + self.ypos)
bgl.glVertex2i(x0 + self.xpos, y1 + self.ypos)
bgl.glEnd()
# Affichage du cercle
if(self.CreateMode == 1):
DEG2RAD = 3.14159 / 180
v0 = mathutils.Vector((self.mouse_path[0][0], self.mouse_path[0][1], 0))
v1 = mathutils.Vector((self.mouse_path[1][0], self.mouse_path[1][1], 0))
v0 -= v1
radius = self.mouse_path[1][0] - self.mouse_path[0][0]
DEG2RAD = 3.14159 / (180 / self.stepAngle[self.step])
if(self.ctrl):
shift = (3.14159 / (360 / self.stepAngle[self.step])) * self.stepRotation
else:
shift = (self.mouse_path[1][1] - self.mouse_path[0][1]) / 50
# Selon si on appuie sur SHIFT, le cercle est plein ou pas
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
bgl.glVertex2i(x0 + self.xpos, y0 + self.ypos)
for i in range(0, int(360 / self.stepAngle[self.step])):
degInRad = i * DEG2RAD
bgl.glVertex2i(x0 + self.xpos + int(math.cos(degInRad + shift) * radius), y0 + self.ypos + int(math.sin(degInRad + shift) * radius))
bgl.glVertex2i(x0 + self.xpos + int(math.cos(0 + shift) * radius), y0 + self.ypos + int(math.sin(0 + shift) * radius))
bgl.glEnd()
# Opengl par défaut
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
bgl.glDisable(bgl.GL_POINT_SMOOTH)
def draw_callback_px(self, context):
# circle graphic, text, and slider
unify_settings = bpy.context.tool_settings.unified_paint_settings
strength = unify_settings.strength if self.uni_str else self.brush.strength
size = unify_settings.size if self.uni_size else self.brush.size
if self.graphic:
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(self.brushcolor.r, self.brushcolor.g, self.brushcolor.b, strength * 0.25)
bgl.glBegin(bgl.GL_POLYGON)
for x, y in self.circlepoints:
bgl.glVertex2i(int(size * x) + self.cur[0], int(size * y) + self.cur[1])
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
if self.text != 'NONE' and self.doingstr:
if self.text == 'MEDIUM':
fontsize = 11
elif self.text == 'LARGE':
fontsize = 22
else:
fontsize = 8
font_id = 0
blf.size(font_id, fontsize, 72)
blf.shadow(font_id, 0, 0.0, 0.0, 0.0, 1.0)
blf.enable(font_id, blf.SHADOW)
if strength < 0.001:
text = "0.001"
else:
text = str(strength)[0:5]
textsize = blf.dimensions(font_id, text)
xpos = self.start[0] + self.offset[0]
ypos = self.start[1] + self.offset[1]
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(self.backcolor.r, self.backcolor.g, self.backcolor.b, 0.5)
bgl.glBegin(bgl.GL_POLYGON)
for x, y in self.rectpoints:
bgl.glVertex2i(int(textsize[0] * x) + xpos, int(textsize[1] * y) + ypos)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
blf.position(font_id, xpos, ypos, 0)
blf.draw(font_id, text)
blf.disable(font_id, blf.SHADOW)
if self.slider != 'NONE' and self.doingstr:
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(self.backcolor.r, self.backcolor.g, self.backcolor.b, 0.5)
xpos = self.start[0] + self.offset[0] - self.sliderwidth + (32 if self.text == 'MEDIUM' else 64 if self.text == 'LARGE' else 23)
ypos = self.start[1] + self.offset[1] - self.sliderheight# + (1 if self.slider != 'SMALL' else 0)
if strength <= 1.0:
sliderscale = strength
elif strength > 5.0:
sliderscale = strength / 10
elif strength > 2.0:
sliderscale = strength / 5
else:
sliderscale = strength / 2
bgl.glBegin(bgl.GL_POLYGON)
for x, y in self.rectpoints:
bgl.glVertex2i(int(self.sliderwidth * x) + xpos, int(self.sliderheight * y) + ypos - 1)
bgl.glEnd()
bgl.glColor4f(self.frontcolor.r, self.frontcolor.g, self.frontcolor.b, 0.8)
bgl.glBegin(bgl.GL_POLYGON)
for x, y in self.rectpoints:
bgl.glVertex2i(int(self.sliderwidth * x * sliderscale) + xpos, int(self.sliderheight * y * 0.75) + ypos)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
