def draw_callback_px(self, context):
from bgl import glColor3f
font_id = 0 # XXX, need to find out how best to get this.
blf.size(font_id, 12, 72)
data_matrix, data_quat, data_euler, data_vector, data_vector_array = utils.console_math_data()
if not data_matrix and not data_quat and not data_euler and not data_vector and not data_vector_array:
# draw some text
glColor3f(1.0, 0.0, 0.0)
blf.position(font_id, 180, 10, 0)
blf.draw(font_id, "Python Console has no mathutils definitions")
return
glColor3f(1.0, 1.0, 1.0)
region = context.region
region3d = context.space_data.region_3d
region_mid_width = region.width / 2.0
region_mid_height = region.height / 2.0
# vars for projection
perspective_matrix = region3d.perspective_matrix.copy()
def draw_text(text, vec):
vec_4d = vec.to_4d()
vec_4d *= perspective_matrix
if vec_4d.w > 0.0:
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)
blf.position(font_id, x + 3.0, y - 4.0, 0.0)
blf.draw(font_id, text)
# points
if data_vector:
for key, vec in data_vector.items():
draw_text(key, vec)
# lines
if data_vector_array:
for key, vec in data_vector_array.items():
draw_text(key, vec[0])
# matrix
if data_matrix:
for key, mat in data_matrix.items():
draw_text(key, mat[3])
if data_quat:
loc = context.scene.cursor_location.copy()
for key, mat in data_quat.items():
draw_text(key, loc)
if data_euler:
loc = context.scene.cursor_location.copy()
for key, mat in data_euler.items():
draw_text(key, loc)
def text_line(fx, fy, reduce, c, str):
bgl.glColor4f(c[0], c[1], c[2], c[3])
blf.position(0, fx, fy, 0)
blf.draw(0, str)
if reduce:
fy -= 20
return fy
def __render_text(size, x, y, s):
# フォントサイズを指定
blf.size(0, size, 72)
# 描画位置を指定
blf.position(0, x, y, 0)
# テキストを描画
blf.draw(0, s)
def draw(self, text, x, y):
if self.shadowed:
blf.enable(self.id, blf.SHADOW)
blf.shadow_offset(self.id, self.shadow_offset[0],
self.shadow_offset[1])
blf.shadow(self.id, 3, 0, 0, 0, 0.8)
else:
blf.disable(self.id, blf.SHADOW)
_, h = self.measure("E]")
blf.position(self.id, x, -y, 0)
blf.size(self.id, int(self.size), 72)
glPushMatrix()
glLoadIdentity()
# horrible hack for issue #1
if Font.first:
glTranslatef(0, h / 2 + 4, 0)
Font.first = False
else:
glTranslatef(0, h, 0)
glScalef(1, -1, 1)
blf.draw(self.id, text)
glPopMatrix()
if self.shadowed:
blf.disable(self.id, blf.SHADOW)
def draw_callback_px(self, context):
"""Draw on the viewports"""
# BLF drawing routine
font_id = font_info["font_id"]
blf.position(font_id, 2, 80, 0)
blf.size(font_id, 50, 72)
blf.draw(font_id, "Hello World")
def draw_rectangle_callback_px(not_used):
import blf
if len(bpy.data.movieclips) < 1:
return
scene = bpy.context.scene
movieclip = bpy.data.movieclips[0]
region, width, height = get_clipeditor_region()
if not region:
return
viewport = Buffer(GL_INT, 4)
glGetIntegerv(GL_VIEWPORT, viewport)
# set identity matrices
view_setup()
draw_rectangle(region, width, height, 1.0)
# restore opengl defaults
view_reset(viewport)
glColor4f(1.0, 1.0, 1.0, 1.0)
# draw some text
font_id = 0
# draw some text
blf.position(font_id, 15, 30, 0)
blf.size(font_id, 20, 72)
blf.draw(font_id, "Movie Clip: {0}".format(movieclip.name))
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_callback(self, context):
# polling
if context.mode == "EDIT_MESH":
return
"""
# retrieving ID property data
try:
texts = context.scene['GamePropsVisualizer']
except:
return
if not texts:
return
"""
texts = context.scene["GamePropsVisualizer"]
# draw
i = 0
blf.size(0, 12, 72)
bgl.glColor3f(1.0, 1.0, 1.0)
for ob in bpy.context.selected_objects:
for pi, p in enumerate(ob.game.properties):
blf.position(0, texts[i], texts[i + 1] - (pi + 1) * 14, 0)
if p.type == "FLOAT":
t = p.name + ": " + str("%g" % p.value)
else:
t = p.name + ": " + str(p.value)
blf.draw(0, t)
i += 2
def draw_text(text, x, y, size, color=(1, 1, 1, 0.5)):
font_id = 0
# bgl.glColor4f(*color)
blf.color(font_id, color[0], color[1], color[2], color[3])
blf.position(font_id, x, y, 0)
blf.size(font_id, size, 72)
blf.draw(font_id, text)
def draw_text(text, position, align="LEFT"):
"""Draw 12pt white text at position (3D-Vector) aligned to the left"""
pos = to_screen_coord(position)
if pos is None:
# we cannot draw because the point is not on the screen
return
# [PART VI]
# BRIDGEKEEPER: Hee hee heh. Stop! What... is your name?
# ARTHUR: It is 'Arthur', King of the Britons.
# BRIDGEKEEPER: What... is your quest?
# ARTHUR: To draw text on the screen.
font_id = 0
size = 12
color = (1.0, 1.0, 1.0, 1.0)
bgl.glColor4f(*color)
blf.size(font_id, size, 72)
if align == "CENTER":
# get length of text, place text .5 of length to the left of the coord.
text_width, text_height = blf.dimensions(font_id, text)
pos.x -= text_width / 2
blf.position(font_id, pos.x, pos.y, 0)
# BRIDGEKEEPER: What... is the OpenGL command for drawing text?
# ARTHUR: What do you mean? Blender's bfl module can do that for me!
# BRIDGEKEEPER: Huh? I-- I didn't know that. Auuuuuuuugh!
blf.draw(font_id, text)
def draw_text(text, font_id, vec, region_data, x_offset=0, y_offset=0):
"""
:param text:
:type text:
:param vec:
:type vec:
:param font_id:
:type font_id:
:param region_data: (region3d_perspective_matrix, region2d_mid_width, region2d_mid_height)
:type region_data: tuple
:param x_offset:
:type x_offset:
:param y_offset:
:type y_offset:
:return:
:rtype:
"""
vec_4d = region_data[0] * vec.to_4d()
if vec_4d.w > 0.0:
x = region_data[1] + region_data[1] * (vec_4d.x / vec_4d.w)
y = region_data[2] + region_data[2] * (vec_4d.y / vec_4d.w)
blf.position(font_id, x + 15.0 + x_offset, y - 4.0 + y_offset, 0.0)
blf.draw(font_id, text)
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 text( self, text, arg1=0, arg2=0, arg3=0 ): x = 0 y = 0 z = 0 rx = 0 ry = 0 rz = 0 if type( arg1 ) is mathutils.Vector(): x = arg1.x y = arg1.y z = arg1.z if type( arg2 ) is mathutils.Vector(): rx = arg2.x ry = arg2.y rz = arg2.z elif type( arg1 ) is bge.types.KX_GameObject or type( arg1 ) is str: if type( arg1 ) is str: arg1 = self.getObjectByName( arg1 ) if arg1 is not 0: o = self.getPosition( arg1 ) x = o.x y = o.y z = o.z # translation vector if type( arg2 ) is mathutils.Vector(): x += arg2.x y += arg2.y z += arg2.z # rotation vector if type( arg3 ) is mathutils.Vector(): rx = arg3.x ry = arg3.y rz = arg3.z elif type( arg1 ) is float and type( arg2 ) is float and type( arg3 ) is float: x = arg1 y = arg2 z = arg3 elif type( arg1 ) is int and type( arg2 ) is int and type( arg3 ) is int: x = arg1 y = arg2 z = arg3 width = bge.render.getWindowWidth() height = bge.render.getWindowHeight() ratiow = 1./width ratioh = 1./height bgl.glPushMatrix() bgl.glTranslatef( x,y,z ) #TODO transform angles to matrix! # bgl.glRotate( rx,ry,rz ) bgl.glScalef( ratiow, ratioh, 0 ) blf.position( self.font, 0,0,0 ) blf.size( self.font, self.tsize, 300 ) bgl.glColor3f( self.tcolor.x, self.tcolor.y, self.tcolor.z ) blf.draw( self.font, text ) bgl.glPopMatrix()
def draw_callback_px(self, context):
wm = context.window_manager
sc = context.scene
if not wm.polycount_run:
return
font_size = sc.polycount_font_size
pos_x, pos_y = get_display_location(context)
# draw text in the 3d-view
# ========================
blf.size(0, sc.polycount_font_size, 72)
r, g, b = sc.polycount_font_color
bgl.glColor3f(r, g, b)
view3dId = get_space_id(context.space_data)
visible_tri_count = PolyCountOperator.visible_triangle_count.get(view3dId, -1)
if visible_tri_count > -1:
text = "All: " + format(visible_tri_count, 'd') + "triangles"
text1height = blf.dimensions(0, text)[1]
blf.position(0, pos_x, pos_y - text1height, 0)
blf.draw(0, text)
selection_tri_count = PolyCountOperator.selection_triangle_count.get(view3dId, -1);
if selection_tri_count > 0:
text = "Selection: " + format(selection_tri_count, ',d') + " triangles"
text2height = blf.dimensions(0, text)[1]
blf.position(0, pos_x, pos_y - text1height - text2height - 5, 0)
blf.draw(0, text)
def draw_text(x_pos, y_pos, display_text, rgb, fsize, right=False):
gap = 12
font_id = 0
blf.size(font_id, fsize, 72)
# height of one line
mwidth, mheight = blf.dimensions(font_id, "Tp") # uses high/low letters
# split lines
mylines = display_text.split("|")
idx = len(mylines) - 1
maxwidth = 0
maxheight = len(mylines) * mheight
# -------------------
# Draw all lines
# -------------------
for line in mylines:
text_width, text_height = blf.dimensions(font_id, line)
if right is True:
newx = x_pos - text_width - gap
else:
newx = x_pos
# calculate new Y position
new_y = y_pos + (mheight * idx)
# Draw
blf.position(font_id, newx, new_y, 0)
bgl.glColor4f(rgb[0], rgb[1], rgb[2], rgb[3])
blf.draw(font_id, " " + line)
# sub line
idx -= 1
# saves max width
if maxwidth < text_width:
maxwidth = text_width
return maxwidth, maxheight
def draw_callback_px(self, context):
scene = context.scene
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, 18, 72)
blf.enable(font_id, blf.SHADOW)
blf.shadow(font_id, 5, 0.0, 0.0, 0.0, 1.0)
# Shorten / cut off milliseconds
time_total = str(timedelta(seconds = timer["total"]))
pos = time_total.rfind(".")
if pos != -1:
time_total = time_total[0:pos+3]
time_estimated = str(timedelta(seconds = (timer["average"] * (scene.frame_end - scene.frame_current))))
pos = time_estimated.rfind(".")
if pos != -1:
time_estimated = time_estimated[0:pos]
blf.draw(font_id, "Total render time " + time_total)
if timer["is_rendering"] and scene.frame_current != scene.frame_start:
blf.position(font_id, 15, 12, 0)
blf.draw(font_id, "Estimated completion: " + time_estimated)
# restore defaults
blf.disable(font_id, blf.SHADOW)
def general_func_callback(self,context):
aspect, mid = menu_utils.view3d_get_size_and_mid(context)
# draw some text
blf.position(0, mid[0], mid[1]+100, 0)
blf.size(0, 20, 72)
blf.draw(0, self.message)
menu_utils.blf_text_wrap(self.help, self.wrap, 0, 12 , 76, 10, aspect[1]-30)
def draw_callback_px(n_id, data):
space = bpy.context.space_data
ng_view = space.edit_tree
# ng_view can be None
if not ng_view:
return
ng_name = space.edit_tree.name
if not (data['tree_name'] == ng_name):
return
if not isinstance(ng_view, node_tree.SverchCustomTree):
return
lines = data.get('content', 'no data')
x, y = data.get('location', (120, 120))
color = data.get('color', (0.1, 0.1, 0.1))
font_id = 0
text_height = 13
# why does the text look so jagged?
blf.size(font_id, text_height, 72) # should check prefs.dpi
bgl.glColor3f(*color)
# x = 30 # region.width
# y = region.height - 40
ypos = y
for line in lines:
blf.position(0, x, ypos, 0)
blf.draw(0, line)
ypos -= (text_height * 1.3)
def draw_callback_px(self, context):
font_id = 0 # XXX, need to find out how best to get this.
# draw some text
y = context.region.height
dims = blf.dimensions(0, 'A')
blf.position(font_id, 10, y - 20 - dims[1], 0)
blf.size(font_id, 20, 72)
if context.area.x == self.area_align.x:
blf.draw(font_id, "Align: "+ self.align_msg)
points = [self.obj_align.matrix_world * p for p in self.align_points]
color = (1,0,0,1)
else:
blf.draw(font_id, "Base: " + self.base_msg)
points = [self.obj_align.matrix_world * p for p in self.base_points]
color = (0,1,0,1)
draw_3d_points_revised(context, points, color, 4)
for i, vec in enumerate(points):
ind = str(i)
draw_3d_text(context, font_id, ind, vec)
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):
for n, area in enumerate(self.areas):
if context.area.x == area.x and context.area.y == area.y: #then this is where our mouse is
font_id = 0 # XXX, need to find out how best to get this.
height = context.region.height
width = context.region.width
dims = blf.dimensions(0, self.messages[n])
#blf.position(font_id, 10, height - 10 - dims[1], 0) #top left
blf.position(font_id, width - 10 - 2* dims[0], 10 + dims[1]/2, 0)
blf.size(font_id, 20, 72)
blf.draw(font_id, self.messages[n])
if (self.mouse_raw[0] > area.x and self.mouse_raw[0] < area.x + area.width) and \
(self.mouse_raw[1] > area.y and self.mouse_raw[1] < area.y + area.height):
#label the mouse
dims = blf.dimensions(0,'MOUSE %i' %n)
x = self.mouse_region_coord[0] - .5 * dims[0]
y = self.mouse_region_coord[1] + dims[1]
blf.position(font_id,x,y,0)
blf.draw(font_id,'MOUSE %i' % n)
if len(self.area_data[n]):
N = len(self.areas)
color = (n/N, .5*n/N, (1-n/N), 1)
draw_3d_points_specific_region(context.region, context.space_data.region_3d, self.area_data[n], color, 3)
def draw_index(rgb, rgb2, index, vec, text=''):
vec_4d = perspective_matrix * vec.to_4d()
if vec_4d.w <= 0.0:
return
x = region_mid_width + region_mid_width * (vec_4d.x / vec_4d.w)
y = region_mid_height + region_mid_height * (vec_4d.y / vec_4d.w)
if text:
index = str(text[0])
else:
index = str(index)
if draw_bg:
polyline = get_points(index)
''' draw polygon '''
bgl.glColor4f(*rgb2)
bgl.glBegin(bgl.GL_POLYGON)
for pointx, pointy in polyline:
bgl.glVertex2f(pointx+x, pointy+y)
bgl.glEnd()
''' draw text '''
txt_width, txt_height = blf.dimensions(0, index)
bgl.glColor4f(*rgb)
blf.position(0, x - (txt_width / 2), y - (txt_height / 2), 0)
blf.draw(0, index)
def draw_callback(self, context):
# polling
if context.mode == 'EDIT_MESH':
return
# retrieving ID property data
try:
#print(context.scene['GamePropsVisualiser'])
texts = context.scene['GamePropsVisualiser']
except:
return
if not texts:
return
# draw
i=0
blf.size(0, 12, 72)
bgl.glColor3f(1.0,1.0,1.0)
for ob in bpy.context.selected_objects:
for pi,p in enumerate(ob.game.properties):
blf.position(0, texts[i], texts[i+1]-(pi+1)*14, 0)
if p.type=='FLOAT':
t=p.name+': '+ str('%g'% p.value)
else:
t=p.name+': '+ str(p.value)
blf.draw(0, t)
i+=2
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 write_interaction_status():
"""
Write the interaction status on Screen
The status is stored in a property
"""
cam = logic.getCurrentScene().active_camera
# get the suffix of the human to reference the right objects
suffix = cam.name[-4:] if cam.name[-4] == "." else ""
hand = objects['Hand_Grab.R' + suffix]
# OpenGL setup
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glLoadIdentity()
bgl.gluOrtho2D(0, windowWidth, 0, windowHeight)
bgl.glMatrixMode(bgl.GL_MODELVIEW)
bgl.glLoadIdentity()
blf.size(font_id, int(windowHeight*0.04), 72)
# draw a black shadow around the text
blf.enable(font_id, blf.SHADOW)
blf.shadow(font_id, 5, 0.0, 0.0, 0.0, 1.0)
blf.position(font_id, windowWidth*0.4, windowHeight*0.4,0)
blf.draw(font_id, hand['Status'])
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 drawText2D(color, text):
font_id = 0 # XXX, need to find out how best to get this.
# draw some text
bgl.glColor4f(*color)
blf.position(font_id, 20, 70, 0)
blf.size(font_id, 20, 72)
blf.draw(font_id, text)
def draw(self,context, settings):
'''
setings are the addon preferences for contour tools
'''
debug = settings.debug
#settings = context.user_preferences.addons['contour_tools'].preferences
#this should be moved to only happen if the view changes :-/ I'ts only
#a few hundred calcs even with a lot of lines. Waste not want not.
if self.head.world_position:
self.head.screen_from_world(context)
if self.tail.world_position:
self.tail.screen_from_world(context)
if self.plane_tan.world_position:
self.plane_tan.screen_from_world(context)
#draw connecting line
points = [(self.head.x,self.head.y),(self.tail.x,self.tail.y)]
if settings.show_edges:
contour_utilities.draw_polyline_from_points(context, points, (0,.2,1,1), settings.line_thick, "GL_LINE_STIPPLE")
#draw the two handles
contour_utilities.draw_points(context, points, self.head.color, settings.handle_size)
#draw the current plane point and the handle to change plane orientation
if self.plane_pt:
point1 = location_3d_to_region_2d(context.region, context.space_data.region_3d, self.plane_pt)
point2 = (self.plane_tan.x, self.plane_tan.y)
if settings.show_edges:
contour_utilities.draw_polyline_from_points(context, [point1,point2], (0,.2,1,1), settings.line_thick, "GL_LINE_STIPPLE")
contour_utilities.draw_points(context, [point2], self.plane_tan.color, settings.handle_size)
contour_utilities.draw_points(context, [point1], self.head.color, settings.handle_size)
#draw the raw contour vertices
if (self.verts and self.verts_simple == []) or (debug > 0 and settings.show_verts):
contour_utilities.draw_3d_points(context, self.verts, (0,1,.2,1), settings.raw_vert_size)
#draw the simplified contour vertices and edges (rings)
if self.verts_simple:
points = self.verts_simple.copy()
if 0 in self.eds[-1]:
points.append(self.verts_simple[0])
if settings.show_ring_edges:
contour_utilities.draw_polyline_from_3dpoints(context, points, (0,1,.2,1), settings.line_thick,"GL_LINE_STIPPLE")
contour_utilities.draw_3d_points(context, self.verts_simple, (0,.2,1,1), settings.vert_size)
if debug:
if settings.vert_inds:
for i, point in enumerate(self.verts):
loc = location_3d_to_region_2d(context.region, context.space_data.region_3d, point)
blf.position(0, loc[0], loc[1], 0)
blf.draw(0, str(i))
if settings.simple_vert_inds:
for i, point in enumerate(self.verts_simple):
loc = location_3d_to_region_2d(context.region, context.space_data.region_3d, point)
blf.position(0, loc[0], loc[1], 0)
blf.draw(0, str(i))
def draw_callback_px(self, context):
#print("callback_px")
# Maybe print a nice red circle in some corner
bgl.glPushAttrib(bgl.GL_CLIENT_ALL_ATTRIB_BITS)
FONT_RGBA = (0.8, 0.1, 0.1, 0.5)
bgl.glColor4f(*FONT_RGBA)
font_size = 11
DPI = 72
blf.size(0, font_size, DPI)
msg = "Logging..."
msg_w,msg_h = blf.dimensions(0, msg)
pos_x = context.region.width - msg_w
pos_y = font_size / 2
blf.position(0, pos_x, pos_y, 0)
#blf.position(0, 10, 10, 0)
blf.draw(0, msg)
bgl.glPopAttrib()
pass
def drawLines(self):
baseLineOffset = blf.dimensions(font, "V")[1]
glColor4f(0, 0, 0, 1)
for i, line in enumerate(self.lines):
blf.position(font, self.boundary.left, self.boundary.top - i * self.lineHeight - baseLineOffset, 0)
blf.draw(font, line)
def write():
"""write on screen"""
width = render.getWindowWidth()
height = render.getWindowHeight()
# OpenGL setup
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glLoadIdentity()
bgl.gluOrtho2D(0, width, 0, height)
bgl.glMatrixMode(bgl.GL_MODELVIEW)
bgl.glLoadIdentity()
# BLF drawing routine
font_id = logic.font_id
blf.position(font_id, (width * 0.2), (height * 0.3), 0)
blf.size(font_id, 50, 72)
blf.draw(font_id, "Hello World")
def draw_text(self, ctx):
font_id = 0
font_size = 16
dpi = ctx.preferences.system.dpi
# pos = self.matrix_world @ Vector((0, 0, 0, 1))
# pos = Vector((0, 0, 0.5))
# region = ctx.region
# region3d = ctx.region_data
# pos = view3d_utils.location_3d_to_region_2d(region, region3d, pos)
# text = self.text_label
blf.size(font_id, font_size, dpi)
blf.position(font_id, 0, 0, 0)
blf.color(font_id, *self.color, self.alpha)
blf.draw(font_id, "ABC")
def draw_text(context, location, NUM_VERTS):
bgl.glColor4f(1.0, 1.0, 1.0, 0.8)
xpos, ypos = location
font_id = 0
blf.size(font_id, 12, 72) # fine tune
blf.position(font_id, location[0], location[1], 0)
num_edges = str(NUM_VERTS - 1)
if num_edges == str(1):
postfix = " edge"
else:
postfix = " edges"
display_text = str(NUM_VERTS) + " vert fillet, " + num_edges + postfix
blf.draw(font_id, display_text)
return
def draw_text(mouse, text, color):
dpi = int(bpy.context.user_preferences.system.pixel_size)
bgl.glEnable(bgl.GL_BLEND)
font_id = 0 # XXX, need to find out how best to get this.
# draw some text
bgl.glColor4f(0, 0, 0, 0.75)
blf.blur(font_id, 5)
blf.position(font_id, mouse[0] + 10 * dpi, mouse[1] - 20 * dpi, 0)
blf.size(font_id, 8 * dpi, 96)
blf.draw(font_id, text)
bgl.glEnd()
bgl.glColor4f(*color)
blf.blur(font_id, 0)
blf.draw(font_id, text)
bgl.glDisable(bgl.GL_BLEND)
def draw(self):
if not self.visible:
return
area_height = self.get_area_height()
blf.size(0, self._text_size, 72)
size = blf.dimensions(0, self._text)
textpos_y = area_height - self.y_screen - self.height
blf.position(0, self.x_screen, textpos_y, 0)
r, g, b, a = self._text_color
blf.color(0, r, g, b, a)
blf.draw(0, self._text)
def draw_gedge_text(gedge, context, text):
l = len(gedge.cache_igverts)
if l > 4:
n_quads = math.floor(l / 2) + 1
mid_vert_ind = math.floor(l / 2)
mid_vert = gedge.cache_igverts[mid_vert_ind]
position_3d = mid_vert.position + 1.5 * mid_vert.tangent_y * mid_vert.radius
else:
position_3d = (gedge.gvert0.position + gedge.gvert3.position) / 2
position_2d = location_3d_to_region_2d(context.region,
context.space_data.region_3d,
position_3d)
txt_width, txt_height = blf.dimensions(0, text)
blf.position(0, position_2d[0] - (txt_width / 2),
position_2d[1] - (txt_height / 2), 0)
blf.draw(0, text)
def draw_postpixel(self):
region = bpy.context.region
rv3d = bpy.context.space_data.region_3d
dpi = bpy.context.preferences.system.dpi
blf.size(0, 20, dpi) #fond_id = 0
for i,pt in enumerate(self.b_pts):
if pt.label:
if self.selected == i:
color = (0,1,1,1)
else:
color = (1,0,0,1)
#bgl.glColor4f(*color)
vector2d = view3d_utils.location_3d_to_region_2d(region, rv3d, pt.location)
if vector2d:
blf.position(0, vector2d[0] + 10, vector2d[1] - 5, 0)
blf.draw(0, pt.label) #font_id = 0
def write():
"""write on screen - it runs every frame"""
width = render.getWindowWidth()
height = render.getWindowHeight()
# OpenGL setup
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glLoadIdentity()
bgl.gluOrtho2D(0, width, 0, height)
bgl.glMatrixMode(bgl.GL_MODELVIEW)
bgl.glLoadIdentity()
# BLF fun
font_id = logic.font_id
blf.position(font_id, (width*0.2), (height*0.3), 0)
blf.size(font_id, 50, 72)
blf.draw(font_id, logic.text["text"])
def draw(self):
bgl.glEnable(bgl.GL_BLEND)
if self.batch_redraw or not self.batch:
self.update_batch()
bgl.glLineWidth(self.thickness)
self.shader.bind()
self.batch.draw(self.shader)
bgl.glLineWidth(1)
for text, location, size, color, dpi in self.text:
blf.position(0, location[0], location[1], 0)
blf.size(0, size, dpi)
blf.color(0, *color)
blf.shadow(0, 3, *self.font_shadow)
blf.draw(0, text)
bgl.glDisable(bgl.GL_BLEND)
def DrawHelp(htext, _uifactor):
textsize = 14
# blf.size(0, textsize, 72)
# get leftbottom corner
offset = textsize + 40
columnoffs = 320 * _uifactor
for line in reversed(htext):
blf.color(0, 1.0, 1.0, 1.0, 1.0)
blf.position(0, 60 * _uifactor, offset, 0)
blf.draw(0, line[0])
blf.color(0, 1.0, 0.86, 0.0, 1.0)
textdim = blf.dimensions(0, line[1])
coloffset = columnoffs - textdim[0]
blf.position(0, coloffset, offset, 0)
blf.draw(0, line[1])
offset += 20 * _uifactor
def draw_index(r, g, b, index, center):
vec = total_mat @ center # order is important
# dehomogenise
vec = mathutils.Vector(
(vec[0] / vec[3], vec[1] / vec[3], vec[2] / vec[3]))
x = int(mid_x + vec[0] * width / 2)
y = int(mid_y + vec[1] * height / 2)
# bgl.glColorMask(1,1,1,1)
blf.position(0, x, y, 0)
if isinstance(index, float):
blf.draw(0, '{:.2f}'.format(index))
else:
blf.draw(0, str(index))
def draw(self, highlighted: bool):
bgl.glEnable(bgl.GL_BLEND)
if highlighted:
bgl.glColor4f(0.555, 0.555, 0.555, 0.8)
else:
bgl.glColor4f(0.447, 0.447, 0.447, 0.8)
bgl.glRectf(self.x, self.y, self.x + self.width, self.y + self.height)
texture = self.icon
err = texture.gl_load(filter=bgl.GL_NEAREST, mag=bgl.GL_NEAREST)
assert not err, 'OpenGL error: %i' % err
bgl.glColor4f(0.0, 0.0, 1.0, 0.5)
# bgl.glLineWidth(1.5)
# ------ TEXTURE ---------#
bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture.bindcode[0])
bgl.glEnable(bgl.GL_TEXTURE_2D)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
bgl.glColor4f(1, 1, 1, 1)
bgl.glBegin(bgl.GL_QUADS)
bgl.glTexCoord2d(0, 0)
bgl.glVertex2d(self.x + self.icon_margin_x, self.y)
bgl.glTexCoord2d(0, 1)
bgl.glVertex2d(self.x + self.icon_margin_x, self.y + ICON_HEIGHT)
bgl.glTexCoord2d(1, 1)
bgl.glVertex2d(self.x + self.icon_margin_x + ICON_WIDTH,
self.y + ICON_HEIGHT)
bgl.glTexCoord2d(1, 0)
bgl.glVertex2d(self.x + self.icon_margin_x + ICON_WIDTH, self.y)
bgl.glEnd()
bgl.glDisable(bgl.GL_TEXTURE_2D)
bgl.glDisable(bgl.GL_BLEND)
texture.gl_free()
# draw some text
font_id = 0
blf.position(
font_id,
self.x + self.icon_margin_x + ICON_WIDTH + self.text_margin_x,
self.y + ICON_HEIGHT * 0.5 - 0.25 * self.text_height, 0)
blf.size(font_id, self.text_height, self.text_width)
blf.draw(font_id, self.label_text)
def _draw(self):
"""Display the text"""
linespacing = 1.2
blf.size(self.fontid, self.pt_size, 72)
glColor4f(self.color[0], self.color[1], self.color[2], self.color[3])
for i, txt in enumerate([i for i in self._text.split('\n')]):
blf.position(self.fontid, self.position[0],
self.position[1] - (self.size[1] * i * linespacing),
0)
blf.draw(self.fontid, txt.replace('\t', ' '))
self.dimension = list(
blf.dimensions(self.fontid, txt.replace('\t', ' ')))[:]
#draw children now
Widget._draw(self)
def draw_timer(context, pos_x, pos_y):
sc = context.scene
#calculate overall time
overall_time = datetime.timedelta(
seconds=int(time.time() - ScreencastKeysStatus.overall_time[0]))
timer_color_r, timer_color_g, timer_color_b, timer_color_alpha = sc.screencast_keys_timer_color
pos_x = context.region.width - (sc.screencast_keys_timer_size * 12) + 12
pos_y = 10
#draw time
blf.size(0, sc.screencast_keys_timer_size, 72)
blf.position(0, pos_x, pos_y, 0)
bgl.glColor4f(timer_color_r, timer_color_g, timer_color_b,
timer_color_alpha)
blf.draw(0, "Elapsed Time: %s" % (overall_time))
def draw_callback_iops_aotf_px(self, context, _uidpi, _uifactor):
prefs = bpy.context.preferences.addons['InteractionOps'].preferences
tColor = prefs.text_color
tKColor = prefs.text_color_key
tCSize = prefs.text_size
tCPosX = prefs.text_pos_x
tCPosY = prefs.text_pos_y
tShadow = prefs.text_shadow_toggle
tSColor = prefs.text_shadow_color
tSBlur = prefs.text_shadow_blur
tSPosX = prefs.text_shadow_pos_x
tSPosY = prefs.text_shadow_pos_y
iops_text = (
("Face edge index", str(self.get_edge_idx(self.counter))),
("Align to axis", str(self.axis_rotate)),
)
# FontID
font = 0
blf.color(font, tColor[0], tColor[1], tColor[2], tColor[3])
blf.size(font, tCSize, _uidpi)
if tShadow:
blf.enable(font, blf.SHADOW)
blf.shadow(font, int(tSBlur), tSColor[0], tSColor[1], tSColor[2],
tSColor[3])
blf.shadow_offset(font, tSPosX, tSPosY)
else:
blf.disable(0, blf.SHADOW)
textsize = tCSize
# get leftbottom corner
offset = tCPosY
columnoffs = (textsize * 10) * _uifactor
for line in reversed(iops_text):
blf.color(font, tColor[0], tColor[1], tColor[2], tColor[3])
blf.position(font, tCPosX * _uifactor, offset, 0)
blf.draw(font, line[0])
blf.color(font, tKColor[0], tKColor[1], tKColor[2], tKColor[3])
textdim = blf.dimensions(0, line[1])
coloffset = columnoffs - textdim[0] + tCPosX
blf.position(0, coloffset, offset, 0)
blf.draw(font, line[1])
offset += (tCSize + 5) * _uifactor
def text(pos2d: Float2,
display_text: typing.Union[str, typing.List[str]],
rgba: Float4 = (1.0, 1.0, 1.0, 1.0),
fsize=12,
align='L'):
"""Draw text with the top-left corner at 'pos2d'."""
dpi = bpy.context.preferences.system.dpi
gap = 12
x_pos, y_pos = pos2d
font_id = 0
blf.size(font_id, fsize, dpi)
# Compute the height of one line.
mwidth, mheight = blf.dimensions(font_id,
"Tp") # Use high and low letters.
mheight *= 1.5
# Split text into lines.
if isinstance(display_text, str):
mylines = display_text.split("\n")
else:
mylines = display_text
maxwidth = 0
maxheight = len(mylines) * mheight
for idx, line in enumerate(mylines):
text_width, text_height = blf.dimensions(font_id, line)
if align == 'C':
newx = x_pos - text_width / 2
elif align == 'R':
newx = x_pos - text_width - gap
else:
newx = x_pos
# Draw
blf.position(font_id, newx, y_pos - mheight * idx, 0)
blf.color(font_id, rgba[0], rgba[1], rgba[2], rgba[3])
blf.draw(font_id, " " + line)
# saves max width
if maxwidth < text_width:
maxwidth = text_width
return maxwidth, maxheight
def draw_text_box(
self, x, y, text, origin="lower_left",
col_back=None, col_inner=None, col_outline=None, col_text=None,
back_show_shaded=False, back_shadetop=0, back_shadedown=0,
inner_show_shaded=False, inner_shadetop=0, inner_shadedown=0,
is_mono=False):
"""
:param origin: x, yの基準がboxのどこにあるか。
enum in ["upper", "upper_left", "left", "lower_left",
"lower", "lower_right", "right", "upper_right"]
:type text: str
"""
prefs = self.prefs
widget_unit = self.widget_unit
_, w, h = self.gen_text_position(text, is_mono).send(None)
if "right" in origin:
x -= w
elif "left" not in origin: # ["upper", "lower"]
x -= w / 2
if "upper" in origin:
y -= h
elif "lower" not in origin: # ["left", "right"]
y -= h / 2
self.draw_box(x, y, w, h, col_back, col_inner, col_outline,
back_show_shaded, back_shadetop, back_shadedown,
inner_show_shaded, inner_shadetop, inner_shadedown)
if is_mono:
font_id = prefs.font_id_mono
else:
font_id = prefs.font_id
lines = text.split("\n")
if col_text:
bgl.glColor4f(*col_text)
g = self.gen_text_position(lines[0], is_mono)
y2 = None
for line in lines:
if y2 is None:
y2, _, _ = g.send(None)
else:
y2, _, _ = g.send(line)
blf.position(font_id, x + widget_unit / 2, y + h + y2, 0)
vagl.blf_draw(prefs.font_id, line)
def cursor_handler(context):
global ticks
global buf
bgl.glGetIntegerv(bgl.GL_VIEWPORT, buf)
width = buf[2]
t = localtime()
m = t[4]
h = (t[3] % 12) + m / 60.0 # fractional hours
twopi = 6.283
# draw text
font_id = 0
blf.position(font_id, width - 100, 15, 0)
blf.size(font_id, 12, 72) # 12pt text at 72dpi screen
blf.draw(font_id, strftime("%H:%M:%S", t))
# 50% alpha, 2 pixel lines
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
bgl.glLineWidth(2)
# draw a clock in the lower right hand corner
startx, starty = (width - 22.0, 22.0)
smallhandx, smallhandy = (startx + 9 * sin(twopi * h / 12),
starty + 9 * cos(twopi * h / 12))
bighandx, bighandy = (startx + 15 * sin(twopi * m / 60),
starty + 15 * cos(twopi * m / 60))
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(startx, starty)
bgl.glVertex2f(bighandx, bighandy)
bgl.glVertex2f(startx, starty)
bgl.glVertex2f(smallhandx, smallhandy)
# twelve small dots
for x, y in ticks:
bgl.glVertex2f(startx + 17 * x, starty + 17 * y)
bgl.glVertex2f(startx + 18 * x, starty + 18 * 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 onscreen_warning(self, x, y):
gamma = self.gamma_correction
fontid = 1
blf.size(fontid, self.prefs.view_font_size_report, 72)
blf.color(fontid, *gamma((1.0, 0.3, 0.3, 1.0)))
_, font_h = blf.dimensions(fontid, "Row Height")
font_row_height = font_h * 2
y += font_h
for row in self.warn:
y -= font_row_height
blf.position(fontid, x, y, 0.0)
blf.draw(fontid, row)
return y
def draw_text(text="",
position=(0, 0),
size=200,
horizontal_align="LEFT",
vertical_align="BOTTOM",
color=(0.2, 0.2, 0.2, 1.0),
font_id=font_id):
set_text_size(size, font_id)
dimensions = blf.dimensions(font_id, text)
if horizontal_align == "CENTER":
position = (position[0] - dimensions[0] / 2, position[1])
if vertical_align == "TOP":
position = (position[0], position[1] - dimensions[1])
glColor4f(*color)
blf.position(font_id, int(position[0]), int(position[1]), 0)
blf.draw(font_id, text)
def draw_callback(self, context):
# polling
if context.mode != "EDIT_MESH":
return
# retrieving ID property data
try:
texts = context.scene["IndexVisualiser"]
except:
return
if not texts:
return
# draw
blf.size(0, 13, 72)
for i in range(0, len(texts), 7):
bgl.glColor3f(texts[i], texts[i + 1], texts[i + 2])
blf.position(0, texts[i + 4], texts[i + 5], texts[i + 6])
blf.draw(0, str(int(texts[i + 3])))
def draw_last_operator(context, pos_x, pos_y):
wm = context.window_manager
sc = context.scene
font_color_r, font_color_g, font_color_b, font_color_alpha = sc.screencast_keys_text_color
pos_x, pos_y = getDisplayLocation(context)
if wm.operators:
last_operator = wm.operators[-1].bl_label
blf.enable(0, blf.SHADOW)
blf.shadow_offset(0, 1, -1)
blf.shadow(0, 5, 0.0, 0.0, 0.0, 0.8)
blf.size(0, sc.screencast_keys_font_size, 36)
blf.position(0, pos_x - 14, pos_y - 30, 0)
bgl.glColor4f(font_color_r, font_color_g, font_color_b, font_color_alpha * 0.8)
blf.draw(0, "Last: %s" % (last_operator))
blf.disable(0, blf.SHADOW)
def draw_callback_2d(self, op, context):
# Draw text for add object mode
header = "- Add Object Mode (Type: " + context.scene.add_object_type + ") -"
text = "Ctrl + Left Click = Add | Esc = Exit"
blf.color(1, 1, 1, 1, 1)
blf.size(0, 20, 72)
blf.size(1, 16, 72)
region = context.region
xt = int(region.width / 2.0)
blf.position(0, xt - blf.dimensions(0, header)[0] / 2, 50 , 0)
blf.draw(0, header)
blf.position(1, xt - blf.dimensions(1, text)[0] / 2, 20 , 0)
blf.draw(1, text)
def draw_gpatch_info(self, gpatch, context):
cp,cnt = Vector(),0
for p,_,_ in gpatch.pts:
cp += p
cnt += 1
cp /= max(1,cnt)
for i_ges,ges in enumerate(gpatch.gedgeseries):
l = ges.n_quads
p,c = Vector(),0
for gvert in ges.cache_igverts:
p += gvert.snap_pos
c += 1
p /= c
txt = '%d' % l # '%d %d' % (i_ges,l)
p2d = location_3d_to_region_2d(context.region, context.space_data.region_3d, cp*0.2+p*0.8)
txt_width, txt_height = blf.dimensions(0, txt)
blf.position(0, p2d[0]-(txt_width/2), p2d[1]-(txt_height/2), 0)
blf.draw(0, txt)
def _draw_callback_px(self, context):
try:
print("SELF", self)
except:
print("red err?")
r_width = context.region.width
r_height = context.region.height
font_id = 0 # TODO: need to find out how best to get font_id
blf.size(font_id, 11, 72)
text_size = blf.dimensions(0, self.view_name)
text_x = r_width - text_size[0] - 10
text_y = r_height - text_size[1] - 8
blf.position(font_id, text_x, text_y, 0)
blf.draw(font_id, self.view_name)
def draw_callback_2d(self, op, context):
# Draw text for primitive mode
region = context.region
text = "- Primitive mode -"
subtext = self.shape.get_text(context)
xt = int(region.width / 2.0)
blf.size(0, 24, 72)
blf.position(0, xt - blf.dimensions(0, text)[0] / 2, 60, 0)
blf.draw(0, text)
blf.size(1, 16, 72)
blf.color(1, 1, 1, 1, 1)
blf.position(1, xt - blf.dimensions(1, subtext)[0] / 2, 30, 1)
blf.draw(1, subtext)
def DrawTextS(self,
x,
y,
text,
size,
color=(1.0, 1.0, 1.0, 1.0),
showdowColor=(0.1, 0.1, 0.1, 1.0),
font_id=0):
blf.position(font_id, x, y, 0)
r, g, b, a = color
blf.color(font_id, r, g, b, a)
blf.size(font_id, size, 72)
sr, sg, sb, sa = showdowColor
blf.shadow(0, 3, sr, sg, sb, sa)
blf.enable(0, blf.SHADOW)
blf.draw(font_id, text)
blf.disable(0, blf.SHADOW)
def draw_index(rgb, index, coord):
vector3d = matrix_world * coord
x, y = loc3d2d(region, rv3d, vector3d)
index = str(index)
polyline = get_points(index)
''' draw polygon '''
bgl.glColor4f(0.103, 0.2, 0.2, 0.2)
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.glColor3f(*rgb)
blf.position(0, x - (txt_width / 2), y - (txt_height / 2), 0)
blf.draw(0, index)
def DynamicNodes_Arrange_DrawCallBack(self, context):
bgl.glColor4f(0.6, 0.6, 0.7, 1)
font_id = 0
blf.size(font_id, 12, 0)
blf.enable(font_id, blf.SHADOW)
blf.shadow(font_id, 3, 0, 0, 0, 1)
props = context.scene.DynamicNodes_Properties
blf.position(font_id, 12, context.area.height - 50, 0)
blf.draw(
font_id,
str(min(self.iteration_cnt, props.step1)) + '/' + str(props.step1))
blf.position(font_id, 12, context.area.height - 70, 0)
blf.draw(
font_id,
str(min(max(self.iteration_cnt - props.step1, 0), props.step2)) + '/' +
str(props.step2))
blf.position(font_id, 12, context.area.height - 90, 0)
blf.draw(
font_id,
str(
min(max(self.iteration_cnt - props.step1 - props.step2, 0),
props.step3)) + '/' + str(props.step3))
blf.position(font_id, 12, context.area.height - 110, 0)
blf.draw(
font_id,
str(
max(self.iteration_cnt - props.step1 - props.step2 - props.step3,
0)) + '/' + str(props.step4))
bgl.glBegin(bgl.GL_QUADS)
bgl.glColor4f(0.7, 0.7, 1.0, 1.0)
bgl.glVertex2i(8, context.area.height - 128)
bgl.glVertex2i(52, context.area.height - 128)
bgl.glVertex2i(52, context.area.height - 142)
bgl.glVertex2i(8, context.area.height - 142)
bgl.glColor4f(0.1, 0.1, 0.1, 1.0)
bgl.glVertex2i(9, context.area.height - 129)
bgl.glVertex2i(51, context.area.height - 129)
bgl.glVertex2i(51, context.area.height - 141)
bgl.glVertex2i(9, context.area.height - 141)
progress = self.iteration_cnt / (props.step1 + props.step2 + props.step3 +
props.step4)
bgl.glColor4f(0.7, 0.7, 1.0, 1.0)
bgl.glVertex2i(10, context.area.height - 130)
bgl.glVertex2i(int(10 + progress * 40), context.area.height - 130)
bgl.glVertex2i(int(10 + progress * 40), context.area.height - 140)
bgl.glVertex2i(10, context.area.height - 140)
bgl.glEnd()
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
blf.disable(font_id, blf.SHADOW)
def draw_text(myobj, x_pos, y_pos, display_text, rgb, fsize, right=False):
gap = 12
font_id = 0
blf.size(font_id, fsize, 72)
# height of one line
mwidth, mheight = blf.dimensions(font_id, "Tp") # uses high/low letters
# Calculate sum groups
m = 0
while "<#" in display_text:
m += 1
if m > 10: # limit loop
break
i = display_text.index("<#")
tag = display_text[i:i + 4]
display_text = display_text.replace(tag, get_group_sum(myobj, tag.upper()))
# split lines
mylines = display_text.split("|")
idx = len(mylines) - 1
maxwidth = 0
maxheight = len(mylines) * mheight
# -------------------
# Draw all lines
# -------------------
for line in mylines:
text_width, text_height = blf.dimensions(font_id, line)
if right is True:
newx = x_pos - text_width - gap
else:
newx = x_pos
# calculate new Y position
new_y = y_pos + (mheight * idx)
# Draw
blf.position(font_id, newx, new_y, 0)
bgl.glColor4f(rgb[0], rgb[1], rgb[2], rgb[3])
blf.draw(font_id, " " + line)
# sub line
idx -= 1
# saves max width
if maxwidth < text_width:
maxwidth = text_width
return maxwidth, maxheight
