def drawIcon(image_file, pos_x, pos_y):
bgl.glPushClientAttrib(bgl.GL_CURRENT_BIT|bgl.GL_ENABLE_BIT)
# transparence
bgl.glEnable(bgl.GL_BLEND)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
bgl.glRasterPos2f(pos_x, pos_y)
buf = buffers[image_file]
bgl.glDrawPixels(ICON_SIZE, ICON_SIZE, bgl.GL_RGBA, bgl.GL_FLOAT, buf)
bgl.glPopClientAttrib()
def draw_callback_px(self, context):
wm = context.window_manager
r = 0.8
g = 0.1
b = 0.2
if (context.window_manager.leap_nui_keyboardless_active):
#print("Draw Callback True")
# draw text in the 3D View
bgl.glPushClientAttrib(bgl.GL_CURRENT_BIT | bgl.GL_ENABLE_BIT)
blf.size(0, 12, 72)
blf.position(0, 10, 10, 0)
bgl.glColor4f(r, g, b, 0.7)
blf.blur(0, 1)
# shadow?
blf.enable(0, blf.SHADOW)
blf.shadow_offset(0, 1, -1)
blf.shadow(0, 5, 0.0, 0.0, 0.0, 0.8)
blf.draw(0, "Leap Active!")
bgl.glPopClientAttrib()
else:
#print("Draw Callback False")
pass
#
# Draw the LeapInfo log messages
font_size = 24
messages = wm.leap_info.log_messages
n_messages = len(messages)
log_y_size = LeapInfo.MAX_LOG_MESSAGES * font_size
#pos_y = context.region.height - ((context.region.height - log_y_size) / 2)
pos_y = ((context.region.height - log_y_size) / 2)
pos_x = 0
bgl.glPushClientAttrib(bgl.GL_CURRENT_BIT | bgl.GL_ENABLE_BIT)
blf.size(0, font_size, 72)
bgl.glColor4f(r, g, b, 0.7)
for time, msg in reversed(messages):
blf.position(0, pos_x, pos_y, 0)
blf.draw(0, msg)
pos_y += font_size
bgl.glPopClientAttrib()
#
# Draw icon if the hand is visible to the Leap
if (wm.leap_info.leap_listener.getHandId() == None): # NO HAND
pass
else:
pos_x = context.region.width - (Icons.ICON_SIZE * 1.5)
pos_y = (Icons.ICON_SIZE / 2)
if (wm.leap_info.isTracking()): # GREEN HAND
Icons.drawIcon("5-spreadfingers-icon-green.png", pos_x, pos_y)
pass
else: # RED HAND
Icons.drawIcon("5-spreadfingers-icon-red.png", pos_x, pos_y)
pass
def draw_callback_px_moving_arrow(self, context):
#print("drawing")
DPI = bpy.context.user_preferences.system.dpi
print("Rendering moving arrow with DPI " + str(DPI))
int_selection_num = int(self.selection_num)
n_items = len(self.selectable_items)
# Phylosophy
# We try to use the fraction of the current heght of the area, but up to a maximum font size
# Number of items to really display
n_items_to_display = min(MAX_DISPLAY_ELEMENTS,
len(self.selectable_items))
# Calculate the top point
text_top_y = context.region.height * (
(1 + SELECTION_DISPLAY_HEIGHT) / 2)
# calc the desired text area height
desired_bottom_y = context.region.height * (
(1 - SELECTION_DISPLAY_HEIGHT) / 2)
desired_text_area_height = text_top_y - desired_bottom_y
# calc the desired the font size
font_size = int(desired_text_area_height / n_items_to_display)
# But limit the font size to their maximum
font_size = min(font_size, self.FONT_MAX_SIZE)
# The effective size of the text area, according to the chosen font size
text_area_height = font_size * n_items_to_display
# recompute the bottom point according to chosen font size
text_bottom_y = text_top_y - text_area_height
#print("Font_size = " + str(font_size))
bgl.glPushAttrib(bgl.GL_CLIENT_ALL_ATTRIB_BITS)
blf.size(0, font_size, DPI)
#
# Draw background
max_text_width = 0
for item in self.selectable_items:
item_w, item_h = blf.dimensions(0, item)
if (item_w > max_text_width):
max_text_width = item_w
self.draw_bg(context=context,
top_y=text_top_y,
bottom_y=text_bottom_y,
width=max_text_width * 1.5)
#
# Draw entries
pos_x = 0
pos_y = text_top_y - font_size
pos_y += self.selection_window_first_item * font_size
for item_id in range(0, len(self.selectable_items)):
item = self.selectable_items[item_id]
item_w, item_h = blf.dimensions(0, item)
pos_x = (context.region.width / 2) - item_w
blf.position(0, pos_x, pos_y, 0)
if (item_id == int_selection_num):
bgl.glColor4f(*self.SELECTED_FONT_RGBA)
else:
bgl.glColor4f(*self.FONT_RGBA)
blf.draw(0, item)
pos_y -= font_size
bgl.glPopAttrib()
#
# Draw pointing finger
bgl.glPushClientAttrib(bgl.GL_CURRENT_BIT | bgl.GL_ENABLE_BIT)
# transparence
bgl.glEnable(bgl.GL_BLEND)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
if (not self.selector_visible):
pos_x = (context.region.width / 2) + self.ICON_SIZE
pos_y = text_top_y - self.ICON_SIZE
bgl.glRasterPos2f(pos_x, pos_y)
bgl.glDrawPixels(self.ICON_SIZE, self.ICON_SIZE, bgl.GL_RGBA,
bgl.GL_FLOAT, icon_pointing_finger_missing)
else:
pos_x = (context.region.width / 2)
pos_y = text_bottom_y + self.normalized_finger_y * text_area_height - (
self.ICON_SIZE * 0.625)
bgl.glRasterPos2f(pos_x, pos_y)
bgl.glDrawPixels(self.ICON_SIZE, self.ICON_SIZE, bgl.GL_RGBA,
bgl.GL_FLOAT, icon_pointing_finger)
bgl.glPopClientAttrib()
pass
def draw_callback_px_moving_text(self, context):
DPI = bpy.context.user_preferences.system.dpi
#print("Rendering moving text with DPI "+str(DPI))
#print("selection= "+str(self.selection_num))
int_selection_num = int(self.selection_num)
n_items = len(self.selectable_items)
# Phylosophy
# We try to use the fraction of the current heght of the area, but up to a maximum font size
# Number of items to really display
n_items_to_display = min(MAX_DISPLAY_ELEMENTS,
len(self.selectable_items))
# Calculate the top point
text_top_y = context.region.height * (
(1 + SELECTION_DISPLAY_HEIGHT) / 2)
# calc the desired text area height
desired_bottom_y = context.region.height * (
(1 - SELECTION_DISPLAY_HEIGHT) / 2)
desired_text_area_height = text_top_y - desired_bottom_y
# calc the desired the font size
font_size = int(desired_text_area_height / n_items_to_display)
# But limit the font size to their maximum
font_size = min(font_size, self.FONT_MAX_SIZE)
# The effective size of the text area, according to the chosen font size
text_area_height = font_size * n_items_to_display
# recompute the bottom point according to chosen font size
text_bottom_y = text_top_y - text_area_height
#print(str(self.FONT_MAX_SIZE)+" fs="+str(font_size))
central_y = text_bottom_y + int(text_area_height / 2)
bgl.glPushAttrib(bgl.GL_CLIENT_ALL_ATTRIB_BITS)
# Set the font size now, because it will be needed to estimate the background size.
blf.size(0, font_size, DPI)
#
# Draw background
max_text_width = 0
for item in self.selectable_items:
item_w, item_h = blf.dimensions(0, item)
if (item_w > max_text_width):
max_text_width = item_w
self.draw_bg(context,
top_y=text_top_y,
bottom_y=text_bottom_y,
width=max_text_width * 1.5,
cover_pointer=True)
#
# Draw entries
#
pos_x = 0
# The first item will be drawn on the very top, according to the current selection and its position on screen
# The offset uses (self.selection_num - 1) because the text is written with the y at the bottom line.
# However, it is easier to calculate thinking of its beginning at the top. So we shift the text up of one line.
pos_y = central_y + ((self.selection_num - 1) * font_size)
for item_id in range(0, n_items):
item = self.selectable_items[item_id]
item_w, item_h = blf.dimensions(0, item)
pos_x = (context.region.width / 2) - item_w
blf.position(0, pos_x, pos_y, 0)
if (item_id == int_selection_num):
bgl.glColor4f(*self.SELECTED_FONT_RGBA)
else:
bgl.glColor4f(*self.FONT_RGBA)
#print("Drawing item at "+str(pos_x) + "\t" + str(pos_y))
blf.draw(0, item)
pos_y -= font_size
bgl.glPopAttrib()
#
# Draw pointing finger
bgl.glPushClientAttrib(bgl.GL_CURRENT_BIT | bgl.GL_ENABLE_BIT)
# transparence
bgl.glEnable(bgl.GL_BLEND)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
# The finger icon (64x64) has the finget tip at pixel 23 from the top, or 40 from the bottom
pos_y = central_y - 40
if (not self.selector_visible):
pos_x = (context.region.width / 2) + self.ICON_SIZE
bgl.glRasterPos2f(pos_x, pos_y)
bgl.glDrawPixels(self.ICON_SIZE, self.ICON_SIZE, bgl.GL_RGBA,
bgl.GL_FLOAT, icon_pointing_finger_missing)
else:
pos_x = (context.region.width / 2)
bgl.glRasterPos2f(pos_x, pos_y)
bgl.glDrawPixels(self.ICON_SIZE, self.ICON_SIZE, bgl.GL_RGBA,
bgl.GL_FLOAT, icon_pointing_finger)
bgl.glPopClientAttrib()
pass
def drawIcons(self):
global s_registration_active_space
#print("Callback drawIcons")
context = bpy.context
#print("Drawing Icons in active space "+str(context.area.spaces.active.as_pointer()))
if (s_registration_active_space != None):
if (not (s_registration_active_space.as_pointer()
== context.area.spaces.active.as_pointer())):
#print("Skipping...")
return
#print("Drawing icons on context " + str(context) + "\tarea is " + str(context.area) + "(" + context.area.type +")")
#glDrawPixels(width, height, format, type, pixels)
#Write a block of pixels to the frame buffer
#
#height (width,) – Specify the dimensions of the pixel rectangle to be written into the frame buffer.
#format (Enumerated constant) – Specifies the format of the pixel data.
#type (Enumerated constant) – Specifies the data type for pixels.
#pixels (bgl.Buffer object) – Specifies a pointer to the pixel data.
bgl.glPushClientAttrib(bgl.GL_CURRENT_BIT | bgl.GL_ENABLE_BIT)
# transparence
bgl.glEnable(bgl.GL_BLEND)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
ICON_SIZE = 64
GRID_SIZE = 3
BORDER_SIZE = 5
blf.size(0, self.FONT_SIZE, 72)
#bgl.glColor4f(*self.FONT_RGBA)
blf.blur(0, 1)
#bgl.glScalef(0.5,0.5,0.5)
# Cycle to draw all the cells
cell_num = 0
pos_y = context.region.height - ICON_SIZE - BORDER_SIZE
for buffers_line in self.buffers:
#pos_x = (context.region.width - (ICON_SIZE * GRID_SIZE) - (BORDER_SIZE * (GRID_SIZE-1)) ) / 2
pos_x = context.region.width - (
(ICON_SIZE + BORDER_SIZE) * GRID_SIZE)
for buf in buffers_line:
#print("Drawing icon for pos "+ str(cell_num))
bgl.glRasterPos2f(pos_x, pos_y)
bgl.glDrawPixels(ICON_SIZE, ICON_SIZE, bgl.GL_RGBA,
bgl.GL_FLOAT, buf)
# Print the char
blf.position(0, pos_x, pos_y, 0)
#bgl.glPushClientAttrib(bgl.GL_CLIENT_ALL_ATTRIB_BITS) #CURRENT_BIT|bgl.GL_ENABLE_BIT)
bgl.glPushAttrib(bgl.GL_CLIENT_ALL_ATTRIB_BITS)
blf.size(0, self.FONT_SIZE, 72)
#blf.blur(0, 10)
#blf.shadow(0, 3, 0.5, 0.5, 0.5, 0.2)
#blf.shadow_offset(0, int(self.FONT_SIZE/10), int(self.FONT_SIZE/10))
bgl.glColor4f(*self.FONT_RGBA)
blf.draw(0, self.shortcut_keys[cell_num])
bgl.glPopAttrib()
#bgl.glPopClientAttrib()
pos_x += ICON_SIZE + BORDER_SIZE
cell_num += 1
pos_y -= ICON_SIZE + BORDER_SIZE
bgl.glPopClientAttrib()
pass