def draw_circle_select(m_coords, radius = 16, p_col = (0.7,0.8,1.0,0.6), enabled = False, sub = False):
if(enabled):
f_col = p_col
if sub:
f_col = (1.0, 0.5, 0.4, 0.6)
bgl.glEnable(bgl.GL_BLEND)
bgl.glBegin(bgl.GL_POLYGON)
bgl.glColor4f(f_col[0], f_col[1], f_col[2], f_col[3]/3)
point_x = m_coords[0]
point_y = m_coords[1]
radius = int(radius)
for x in range(0, radius*2):
bgl.glVertex2f(point_x + radius * math.cos(x * (360/(radius*2)) / 180 * 3.14159), point_y + radius * math.sin(x * (360/(radius*2)) / 180 * 3.14159))
bgl.glEnd()
bgl.glBegin(bgl.GL_LINES)
bgl.glColor4f(f_col[0], f_col[1], f_col[2], f_col[3])
for x in range(0, radius*2):
bgl.glVertex2f(point_x + radius * math.cos(x * (360 / (radius * 2)) / 180 * 3.14159),
point_y + radius * math.sin(x * (360 / (radius * 2)) / 180 * 3.14159))
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def 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, "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()
# 50% alpha, 2 pixel width line
bgl.glColor4f(0.0, 1, 0.0, 1)
bgl.glPointSize(5)
bgl.glBegin(bgl.GL_POINTS)
for v in self.spline_end_dict:
bgl.glVertex2f(v[0], v[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(self, context, render=False):
"""
render flag when rendering
"""
# print("draw_line %s" % (type(self).__name__))
bgl.glPushAttrib(bgl.GL_ENABLE_BIT)
if self.style == bgl.GL_LINE_STIPPLE:
bgl.glLineStipple(1, 0x9999)
bgl.glEnable(self.style)
bgl.glEnable(bgl.GL_BLEND)
if render:
# enable anti-alias on lines
bgl.glEnable(bgl.GL_LINE_SMOOTH)
bgl.glColor4f(*self.colour)
bgl.glLineWidth(self.width)
if self.closed:
bgl.glBegin(bgl.GL_LINE_LOOP)
else:
bgl.glBegin(bgl.GL_LINE_STRIP)
for pt in self.pts:
x, y = self.position_2d_from_coord(context, pt, render)
bgl.glVertex2f(x, y)
self._end()
def cursor_history_draw(cls,context):
cc = context.scene.cursor_history
draw = 0
if hasattr(cc, "historyDraw"):
draw = cc.historyDraw
if(draw):
bgl.glEnable(bgl.GL_BLEND)
bgl.glShadeModel(bgl.GL_FLAT)
alpha = 1-PHI_INV
# History Trace
if cc.historyPosition[0]<0:
return
bgl.glBegin(bgl.GL_LINE_STRIP)
ccc = 0
for iii in range(cc.historyWindow+1):
ix_rel = iii - int(cc.historyWindow / 2)
ix = cc.historyPosition[0] + ix_rel
if(ix<0 or ix>=len(cc.historyLocation)):
continue
ppp = region3d_get_2d_coordinates(context, cc.historyLocation[ix])
if(ix_rel<=0):
bgl.glColor4f(0, 0, 0, alpha)
else:
bgl.glColor4f(1, 0, 0, alpha)
bgl.glVertex2f(ppp[0], ppp[1])
ccc = ccc + 1
bgl.glEnd()
def draw_polyline(points, width=2, color=(1.0, 1.0, 1.0, 1.0)):
"""Draw polyline, points = [(x1, y1, z1), (x2, y2, z2),...]"""
# [PART V]
# BRIDGEKEEPER: Stop! What... is your name?
# GALAHAD: 'Sir Galahad of Camelot'.
# BRIDGEKEEPER: What... is your line width?
# GALAHAD: width.
bgl.glLineWidth(width)
# BRIDGEKEEPER: What... is your favorite color?
# GALAHAD: color. No, *colo-- auuuuuuuugh!
# color is a 4-tuple of floats, don't forget unpacking with *!
bgl.glColor4f(*color)
bgl.glBegin(bgl.GL_LINE_STRIP)
for coord in points:
vector2d = to_screen_coord(coord)
if vector2d:
# if coord is not in the visible area (e.g. behind the camera)
# to_screen_coord returns None => don't draw this Vertex
bgl.glVertex2f(*vector2d)
else:
# stop drawing this line if vertex is invalid
bgl.glEnd()
# then start a new line
bgl.glBegin(bgl.GL_LINE_STRIP)
# note that the next vertex might be invalid too,
# so no new line is drawn
bgl.glEnd()
def draw_dot(position, size, color):
glColor4f(*color)
glEnable(GL_BLEND)
glPointSize(size)
glBegin(GL_POINTS)
glVertex2f(*position)
glEnd()
def draw_line(v1, v2):
if len(v1) == 3:
bgl.glVertex3f(*v1)
bgl.glVertex3f(*v2)
else:
bgl.glVertex2f(*v1)
bgl.glVertex2f(*v2)
def draw_polyline_from_points(context, points, color, thickness, LINE_TYPE):
'''
a simple way to draw a line
args:
points: a list of tuples representing x,y SCREEN coordinate eg [(10,30),(11,31),...]
color: tuple (r,g,b,a)
thickness: integer? maybe a float
LINE_TYPE: eg...bgl.GL_LINE_STIPPLE or
'''
if LINE_TYPE == "GL_LINE_STIPPLE":
bgl.glLineStipple(4, 0x5555) #play with this later
bgl.glEnable(bgl.GL_LINE_STIPPLE)
bgl.glEnable(bgl.GL_BLEND)
current_width = bgl.GL_LINE_WIDTH
bgl.glColor4f(*color)
bgl.glLineWidth(thickness)
bgl.glBegin(bgl.GL_LINE_STRIP)
for coord in points:
bgl.glVertex2f(*coord)
bgl.glEnd()
bgl.glLineWidth(1)
if LINE_TYPE == "GL_LINE_STIPPLE":
bgl.glDisable(bgl.GL_LINE_STIPPLE)
bgl.glEnable(bgl.GL_BLEND) # back to uninterupted lines
return
def draw_arc(x, y, radius, start_angle, end_angle, edgenum=16):
# 三時から反時計回りに描画 angle:radians
l = draw_arc_get_vectors(x, y, radius, start_angle, end_angle, edgenum)
bgl.glBegin(bgl.GL_LINE_STRIP)
for v in l:
bgl.glVertex2f(*v)
bgl.glEnd()
def draw_borders(x=0, y=0, w=30, h=10, color=(0.0, 0.0, 0.0, 1.0)):
# function to draw a border color around the texture
bgl.glColor4f(*color)
bgl.glBegin(bgl.GL_LINE_LOOP)
for coord in [(x, y), (x + w, y), (w + x, y - h), (x, y - h)]:
bgl.glVertex2f(*coord)
bgl.glEnd()
def draw_button(mx, my, x0, y0, width, height):
color_r = 0.0
color_g = 0.0
color_b = 0.0
color_a = 0.5
x1 = x0 + width
y1 = y0 - height/2
y0 += height/2
hover = False
if x0 <= mx <= x1 and y1 <= my <= y0:
color_r = 0.0
color_g = 0.5
color_b = 1.0
color_a = 0.8
hover = True
positions = [[x0, y0], [x0, y1], [x1, y1], [x1, y0]]
settings = [[bgl.GL_QUADS, min(0.0, color_a)], [bgl.GL_LINE_LOOP, min(0.0, color_a)]]
for mode, box_alpha in settings:
bgl.glEnable(bgl.GL_BLEND)
bgl.glBegin(mode)
bgl.glColor4f(color_r, color_g, color_b, color_a)
for v1, v2 in positions:
bgl.glVertex2f(v1, v2)
bgl.glEnd()
return hover
def draw_callback_px(self, context):
if(self.ShowCursor):
region = bpy.context.region
rv3d = bpy.context.space_data.region_3d
view_width = context.region.width
bgl.glEnable(bgl.GL_BLEND)
bgl.glLineWidth(2)
bgl.glColor4f(1.0, 0.8, 0.0, 1.0)
bgl.glBegin(bgl.GL_LINE_STRIP)
idx = 0
for i in range(int(len(self.CLR_C)/3)):
vector3d = (self.CLR_C[idx * 3] * self.CRadius + self.CurLoc.x,self.CLR_C[idx * 3 + 1] * self.CRadius + self.CurLoc.y,self.CLR_C[idx * 3 + 2] * self.CRadius + self.CurLoc.z)
vector2d = bpy_extras.view3d_utils.location_3d_to_region_2d(region, rv3d, vector3d)
bgl.glVertex2f(*vector2d)
idx += 1
bgl.glEnd()
bgl.glBegin(bgl.GL_LINE_STRIP)
idx = 0
for i in range(int(len(self.CLR_C)/3)):
vector3d = (self.CLR_C[idx * 3] * self.CRadius/3.0 + self.CurLoc.x,self.CLR_C[idx * 3 + 1] * self.CRadius/3.0 + self.CurLoc.y,self.CLR_C[idx * 3 + 2] * self.CRadius/3.0 + self.CurLoc.z)
vector2d = bpy_extras.view3d_utils.location_3d_to_region_2d(region, rv3d, vector3d)
bgl.glVertex2f(*vector2d)
idx += 1
bgl.glEnd()
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def screen_v3dBGL_overlay(context, args):
if not args[2]:
return
alpha = args[3]
region = context.region
region3d = context.space_data.region_3d
bgl.glEnable(bgl.GL_BLEND)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
for matrix, color in args[0]:
r, g, b = color
bgl.glColor4f(r, g, b, alpha)
bgl.glBegin(bgl.GL_QUADS)
M = Matrix(matrix)
for x, y in [(-.5, .5), (.5 ,.5), (.5 ,-.5), (-.5 ,-.5)]:
vector3d = M * Vector((x, y, 0))
vector2d = loc3d2d(region, region3d, vector3d)
bgl.glVertex2f(*vector2d)
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_3d_points_and_index(context, points, color, size):
'''
draw a bunch of dots
args:
points: a list of tuples representing x,y SCREEN coordinate eg [(10,30),(11,31),...]
color: tuple (r,g,b,a)
size: integer? maybe a float
'''
points_2d = [location_3d_to_region_2d(context.region, context.space_data.region_3d, loc) for loc in points]
bgl.glColor4f(*color)
bgl.glPointSize(size)
bgl.glBegin(bgl.GL_POINTS)
for coord in points_2d:
#TODO: Debug this problem....perhaps loc_3d is returning points off of the screen.
if coord:
bgl.glVertex2f(*coord)
else:
continue
bgl.glEnd()
blf.size(0, 14, 72)
for i, coord in enumerate(points_2d):
blf.position(0,coord[0]+3, coord[1]+3, 0)
blf.draw(0,str(i))
return
def draw_texture(x=0, y=0, w=30, h=10, texname=texname):
# function to draw a texture
bgl.glDisable(bgl.GL_DEPTH_TEST)
act_tex = bgl.Buffer(bgl.GL_INT, 1)
bgl.glGetIntegerv(bgl.GL_TEXTURE_2D, act_tex)
bgl.glEnable(bgl.GL_TEXTURE_2D)
bgl.glActiveTexture(bgl.GL_TEXTURE0)
bgl.glTexEnvf(bgl.GL_TEXTURE_ENV, bgl.GL_TEXTURE_ENV_MODE, bgl.GL_REPLACE)
bgl.glBindTexture(bgl.GL_TEXTURE_2D, texname)
texco = [(0, 1), (1, 1), (1, 0), (0, 0)]
verco = [(x, y), (x + w, y), (x + w, y - h), (x, y - h)]
bgl.glPolygonMode(bgl.GL_FRONT_AND_BACK, bgl.GL_FILL)
bgl.glBegin(bgl.GL_QUADS)
for i in range(4):
bgl.glTexCoord3f(texco[i][0], texco[i][1], 0.0)
bgl.glVertex2f(verco[i][0], verco[i][1])
bgl.glEnd()
# restoring settings
bgl.glBindTexture(bgl.GL_TEXTURE_2D, act_tex[0])
bgl.glDisable(bgl.GL_TEXTURE_2D)
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_polyline_from_3dpoints(context, points_3d, color, thickness, LINE_TYPE):
'''
a simple way to draw a line
slow...becuase it must convert to screen every time
but allows you to pan and zoom around
args:
points_3d: a list of tuples representing x,y SCREEN coordinate eg [(10,30),(11,31),...]
color: tuple (r,g,b,a)
thickness: integer? maybe a float
LINE_TYPE: eg...bgl.GL_LINE_STIPPLE or
'''
points = [location_3d_to_region_2d(context.region, context.space_data.region_3d, loc) for loc in points_3d]
if LINE_TYPE == "GL_LINE_STIPPLE":
bgl.glLineStipple(4, 0x5555) #play with this later
bgl.glEnable(bgl.GL_LINE_STIPPLE)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(*color)
bgl.glLineWidth(thickness)
bgl.glBegin(bgl.GL_LINE_STRIP)
for coord in points:
bgl.glVertex2f(*coord)
bgl.glEnd()
if LINE_TYPE == "GL_LINE_STIPPLE":
bgl.glDisable(bgl.GL_LINE_STIPPLE)
bgl.glEnable(bgl.GL_BLEND) # back to uninterupted lines
bgl.glLineWidth(1)
return
def h_draw_arc(cx, cy, r, start_angle, arc_angle, color=(1,1,1,1), segs=12):
bgl.glEnable(bgl.GL_BLEND)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
start_angle = math.radians(start_angle)
arc_angle = math.radians(arc_angle)
theta = arc_angle / (segs-1)
tangencial_factor = math.tan(theta)
radial_factor = math.cos(theta)
x = r * math.cos(start_angle)
y = r * math.sin(start_angle)
bgl.glColor4f(*color)
bgl.glBegin(bgl.GL_POLYGON)
bgl.glVertex2f(cx, cy)
for i in range(segs):
bgl.glVertex2f(x + cx, y + cy)
tx = -y
ty = x
x += tx * tangencial_factor
y += ty * tangencial_factor
x *= radial_factor
y *= radial_factor
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
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_postpixel(self):
Point_to_Point2D = self.rfcontext.Point_to_Point2D
self.drawing.point_size(10)
bgl.glBegin(bgl.GL_POINTS)
for (mv, e) in self.moves3D:
bgl.glColor4f(e, 0.1, 0.1, 1.0)
bgl.glVertex2f(*Point_to_Point2D(mv.co))
bgl.glEnd()
def draw_triangle(x=0, y=0, w=30, h=10, color=(1.0, 0.3, 0.3, 1.0)):
bgl.glColor4f(*color)
bgl.glBegin(bgl.GL_TRIANGLES)
for coord in [(x, y), (x+w, y), (x + (w/2), y-h)]:
bgl.glVertex2f(*coord)
bgl.glEnd()
def draw_rect(x=0, y=0, w=30, h=10, color=(0.0, 0.0, 0.0, 1.0)):
bgl.glColor4f(*color)
bgl.glBegin(bgl.GL_POLYGON)
for coord in [(x, y), (x + w, y), (w + x, y - h), (x, y - h)]:
bgl.glVertex2f(*coord)
bgl.glEnd()
def draw_angled_line(color, angle, bx, by):
x = math.cos(angle) * radius
y = math.sin(angle) * radius
bgl.glColor4f(color[0], color[1], color[2], color[3])
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(bx, by)
bgl.glVertex2f(bx + x, by + y)
bgl.glEnd()
def draw_gl_strip(coords, line_thickness):
bgl.glLineWidth(line_thickness)
bgl.glBegin(bgl.GL_LINES)
for coord in coords:
vector3d = matrix_world * coord
vector2d = loc3d2d(region, rv3d, vector3d)
bgl.glVertex2f(*vector2d)
bgl.glEnd()
def draw(self, thickness=2, color=(0.2, 0.2, 0.2, 1.0)):
glLineWidth(thickness)
glColor4f(*color)
glBegin(GL_LINES)
glVertex2f(*self.start)
glVertex2f(*self.end)
glEnd()
glLineWidth(1)
def draw_line(start, end, thickness, color):
glLineWidth(thickness)
glColor4f(*color)
glBegin(GL_LINES)
glVertex2f(*start)
glVertex2f(*end)
glEnd()
glLineWidth(1)
def crosshairs():
"""
Show crosshais in Manipulation Mode
Use the OpenGL-Wrapper to draw the image
"""
imageHeight = windowHeight * 0.05
imageWidth = imageHeight
x = windowWidth * 0.5 - imageWidth/2
y = windowHeight * 0.5 - imageHeight/2
gl_position = [[x, y],[x+imageWidth, y],[x+imageWidth, y+imageHeight],[x, y+imageHeight]]
view_buf = bgl.Buffer(bgl.GL_INT, 4)
bgl.glGetIntegerv(bgl.GL_VIEWPORT, view_buf)
view = view_buf.to_list() if hasattr(view_buf, "to_list") else view_buf.list
# Save the state
bgl.glPushAttrib(bgl.GL_ALL_ATTRIB_BITS)
# Disable depth test so we always draw over things
bgl.glDisable(bgl.GL_DEPTH_TEST)
# Disable lighting so everything is shadless
bgl.glDisable(bgl.GL_LIGHTING)
# Unbinding the texture prevents BGUI frames from somehow picking up on
# color of the last used texture
bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0)
# Make sure we're using smooth shading instead of flat
bgl.glShadeModel(bgl.GL_SMOOTH)
# Setup the matrices
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glPushMatrix()
bgl.glLoadIdentity()
bgl.gluOrtho2D(0, view[2], 0, view[3])
bgl.glMatrixMode(bgl.GL_MODELVIEW)
bgl.glPushMatrix()
bgl.glLoadIdentity()
bgl.glEnable(bgl.GL_TEXTURE_2D)
# Enable alpha blending
bgl.glEnable(bgl.GL_BLEND)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
# Bind the texture
bgl.glBindTexture(bgl.GL_TEXTURE_2D, crosshairs_id)
# Draw the textured quad
bgl.glColor4f(1, 1, 1, 1)
bgl.glEnable(bgl.GL_POLYGON_OFFSET_FILL)
bgl.glPolygonOffset(1.0, 1.0)
bgl.glBegin(bgl.GL_QUADS)
for i in range(4):
bgl.glTexCoord2f(texco[i][0], texco[i][1])
bgl.glVertex2f(gl_position[i][0], gl_position[i][1])
bgl.glEnd()
bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0)
bgl.glPopMatrix()
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glPopMatrix()
bgl.glPopAttrib()
def draw_texture(cls, _, context):
sc = context.scene
if not cls.is_running(context):
return
# no textures are selected
if sc.muv_texture_projection_tex_image == "None":
return
# get texture to be renderred
img = bpy.data.images[sc.muv_texture_projection_tex_image]
# setup rendering region
rect = _get_canvas(context, sc.muv_texture_projection_tex_magnitude)
positions = [
[rect.x0, rect.y0],
[rect.x0, rect.y1],
[rect.x1, rect.y1],
[rect.x1, rect.y0]
]
tex_coords = [
[0.0, 0.0],
[0.0, 1.0],
[1.0, 1.0],
[1.0, 0.0]
]
# OpenGL configuration
if compat.check_version(2, 80, 0) >= 0:
bgl.glEnable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_TEXTURE_2D)
bgl.glActiveTexture(bgl.GL_TEXTURE0)
if img.bindcode:
bind = img.bindcode
bgl.glBindTexture(bgl.GL_TEXTURE_2D, bind)
else:
bgl.glEnable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_TEXTURE_2D)
if img.bindcode:
bind = img.bindcode[0]
bgl.glBindTexture(bgl.GL_TEXTURE_2D, bind)
bgl.glTexParameteri(bgl.GL_TEXTURE_2D,
bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR)
bgl.glTexParameteri(bgl.GL_TEXTURE_2D,
bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR)
bgl.glTexEnvi(
bgl.GL_TEXTURE_ENV, bgl.GL_TEXTURE_ENV_MODE,
bgl.GL_MODULATE)
# render texture
bgl.glBegin(bgl.GL_QUADS)
bgl.glColor4f(1.0, 1.0, 1.0,
sc.muv_texture_projection_tex_transparency)
for (v1, v2), (u, v) in zip(positions, tex_coords):
bgl.glTexCoord2f(u, v)
bgl.glVertex2f(v1, v2)
bgl.glEnd()
def cursor_history_draw(cls,context):
cc = context.scene.cursor_history
draw = 0
if hasattr(cc, "historyDraw"):
draw = cc.historyDraw
if hasattr(cc, "historyEnabled"):
if(not cc.historyEnabled[0]):
draw = 0
if(draw):
bgl.glEnable(bgl.GL_BLEND)
bgl.glShadeModel(bgl.GL_FLAT)
alpha = 1-PHI_INV
# History Trace
if cc.historyPosition[0]<0:
return
bgl.glBegin(bgl.GL_LINE_STRIP)
ccc = 0
p2 = Vector(CursorAccess.getCursor())
pp = None
pn = None
for iii in range(cc.historyWindow+1):
ix_rel = iii - int(cc.historyWindow / 2)
ix = cc.historyPosition[0] + ix_rel
if(ix<0 or ix>=len(cc.historyLocation)):
continue
ppp = region3d_get_2d_coordinates(context, cc.historyLocation[ix])
if(ix_rel==-1):
pp = Vector(cc.historyLocation[ix])
if(ix_rel==1):
pn = Vector(cc.historyLocation[ix])
if(ix_rel<=0):
bgl.glColor4f(0, 0, 0, alpha)
else:
bgl.glColor4f(1, 0, 0, alpha)
bgl.glVertex2f(ppp[0], ppp[1])
ccc = ccc + 1
bgl.glEnd()
# Distance of last step
y=10
if(pn):
bgl.glColor4f(1, 0, 0, PHI_INV)
location=region3d_get_2d_coordinates(context, p2)
blf.size(0, 10, 72) # Prevent font size to randomly change.
d = (p2-pn).length
blf.position(0, location[0]+10, location[1]+y, 0)
blf.draw(0, str(round(d,PRECISION)))
y = y + 10;
if(pp):
bgl.glColor4f(0, 0, 0, PHI_INV)
location=region3d_get_2d_coordinates(context, p2)
blf.size(0, 10, 72) # Prevent font size to randomly change.
d = (p2-pp).length
blf.position(0, location[0]+10, location[1]+y, 0)
blf.draw(0, str(round(d,PRECISION)))
def Polygon(self, pts, colour):
bgl.glPushAttrib(bgl.GL_ENABLE_BIT)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(*colour)
bgl.glBegin(bgl.GL_POLYGON)
for pt in pts:
x, y = pt
bgl.glVertex2f(x, y)
self._end()
def draw_callback_px_box(self, context):
wm = context.window_manager
sc = context.scene
pos_x, pos_y = 0, 0 #getDisplayLocation(context)
# get text-width/height to resize the box
# Got the size right, now draw box using proper colors
box_color_r, box_color_g, box_color_b, box_color_alpha = .2, .6, .2, .1 #sc.screencast_keys_box_color
if hasattr(bpy.ops.object.print3d.__class__, 'print3d_processes'):
processes = bpy.ops.object.print3d.__class__.print3d_processes
i = 0
for p in processes:
#proc=p[1].proc
readthread = p[0]
tcom = p[1]
progress = tcom.progress * .01
box_width = context.region.width * progress
offset_y = 80
bar_height = 30
x0 = 0 # max(0, pos_x - padding_x)
y0 = context.region.height - offset_y - bar_height * i # max(0, pos_y - padding_y)
x1 = box_width
y1 = bar_height + y0
positions = [[x0, y0], [x0, y1], [x1, y1], [x1, y0]]
settings = [[bgl.GL_QUADS, min(0.0, box_color_alpha)],
[bgl.GL_LINE_LOOP,
min(0.0, box_color_alpha)]]
#print('boxie')
for mode, box_alpha in settings:
bgl.glEnable(bgl.GL_BLEND)
bgl.glBegin(mode)
bgl.glColor4f(box_color_r, box_color_g, box_color_b,
box_color_alpha)
for v1, v2 in positions:
bgl.glVertex2f(v1, v2)
bgl.glEnd()
#TEXT HERE
#calculate overall time
timer_color_r, timer_color_g, timer_color_b, timer_color_alpha = .9, .9, .9, .5
pos_x = 20
pos_y = context.region.height - offset_y - bar_height * i + int(
bar_height * .3)
#draw time
blf.size(0, int(bar_height * .45), 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, "Slicing %s : %s %%" % (tcom.obname, tcom.outtext))
i += 1
def img_editor_draw_callback_px(self, context):
# draw text
if len(self.pixel_coords) == 0:
draw_typo_2d((1.0, 1.0, 1.0, 1), "Click on Ala/Condyle")
elif len(self.pixel_coords) == 1:
draw_typo_2d((1.0, 1.0, 1.0, 1), "Click on Frankfurt/OrbitalRidge")
elif len(self.pixel_coords) == 2:
draw_typo_2d((1.0, 1.0, 1.0, 1), "Click Ref Point 1 (LEFT)")
elif len(self.pixel_coords) == 3:
draw_typo_2d((1.0, 1.0, 1.0, 1), "Click Ref Point 1 (RIGHT)")
elif len(self.pixel_coords) == 4:
draw_typo_2d((1.0, 1.0, 1.0, 1), "Click Ref Point 1 (TOP)")
elif len(self.pixel_coords) == 5:
draw_typo_2d((1.0, 1.0, 1.0, 1), "Click Ref Point 1 (BOTTOM)")
#draw the user clicked points on the image
bgl.glPointSize(5)
bgl.glBegin(bgl.GL_POINTS)
bgl.glColor4f(0.8, 0.2, 0.5, 1.0)
for pix in self.pixel_coords:
img_x, img_y = pix[0], pix[1]
img_size = self.imgeditor_area.spaces.active.image.size
rx, ry = context.region.view2d.view_to_region(
img_x / img_size[0], (img_size[1] - img_y) / img_size[1],
clip=True)
if rx and ry:
bgl.glVertex2f(rx, ry)
bgl.glEnd()
# restore opengl defaults
bgl.glPointSize(1)
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
font_id = 0
for pix in self.pixel_coords:
img_x, img_y = pix[0], pix[1]
img_size = self.imgeditor_area.spaces.active.image.size
rx, ry = context.region.view2d.view_to_region(
img_x / img_size[0], (img_size[1] - img_y) / img_size[1],
clip=True)
blf.position(font_id, rx + 5, ry + 5, 0)
text = str((round(pix[0]), round(pix[1])))
blf.draw(font_id, text)
blf.position(font_id, rx + 5, ry + 20, 0)
text = str((round(pix[0]), round(pix[1])))
def h_draw_circle(x, y, r, color, segs=16):
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
bgl.glColor4f(*color)
for i in range(segs):
theta = 2.0 * 3.1415926 * float(i) / float(segs)
tx = r * math.cos(theta)
ty = r * math.sin(theta)
bgl.glVertex2f(tx+x, ty+y)
bgl.glEnd()
def h_draw_circle_wire(x, y, r, segs=16):
bgl.glLineWidth(0.5)
bgl.glBegin(bgl.GL_LINE_LOOP)
for i in range(segs):
theta = 2.0 * 3.1415926 * float(i) / float(segs)
tx = r * math.cos(theta)
ty = r * math.sin(theta)
bgl.glVertex2f(tx+x, ty+y)
bgl.glEnd()
def __render_each_data(context, data):
sc = context.scene
# setup rendering region
for area in bpy.context.screen.areas:
if area.type == "VIEW_3D":
break
else:
return
for region in area.regions:
if region.type == "WINDOW":
break
else:
return
for space in area.spaces:
if space.type == "VIEW_3D":
break
else:
return
loc_on_screen = view3d_utils.location_3d_to_region_2d(
region,
space.region_3d,
data[1])
rect = get_canvas(context, loc_on_screen, len(str(data[0])), sc.iv_font_size)
positions = [
[rect.x0, rect.y0],
[rect.x0, rect.y1],
[rect.x1, rect.y1],
[rect.x1, rect.y0]
]
# render box
bgl.glEnable(bgl.GL_BLEND)
bgl.glBegin(bgl.GL_QUADS)
box_color_r, box_color_g, box_color_b, box_color_a = sc.iv_box_color
bgl.glColor4f(box_color_r, box_color_g, box_color_b, box_color_a)
for (v1, v2) in positions:
bgl.glVertex2f(v1, v2)
bgl.glEnd()
# render index
font_size = sc.iv_font_size
blf.size(0, font_size, 72)
blf.enable(0, blf.SHADOW)
blf.shadow_offset(0, 1, -1)
blf.shadow(0, 5, 0.0, 0.0, 0.0, 0.0)
blf.position(0, rect.x0 + (rect.x1 - rect.x0) * 0.18, rect.y0 + (rect.y1 - rect.y0) * 0.24, 0)
text_color_r, text_color_g, text_color_b, text_color_a = sc.iv_text_color
bgl.glColor4f(text_color_r, text_color_g, text_color_b, text_color_a)
blf.draw(0, str(data[0]))
blf.blur(0, 0)
blf.disable(0, blf.SHADOW)
def draw_bb(self, context):
props = context.scene.pt_props
x0, y0 = props.start
x1, y1 = props.end
verts = [[x0, y0], [x0, y1], [x1, y1], [x1, y0]]
bgl.glLineWidth(1)
bgl.glBegin(bgl.GL_LINE_LOOP)
bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
for (x, y) in verts:
bgl.glVertex2f(x, y)
bgl.glEnd()
def draw_point(p, color=(0, 0, 0, 1), size=4):
bgl.glPointSize(size)
bgl.glEnable(bgl.GL_BLEND)
bgl.glBegin(bgl.GL_POINTS)
bgl.glColor4f(
color[0],
color[1],
color[2],
color[3],
)
bgl.glVertex2f(p[0], p[1])
bgl.glEnd()
restore_bgl()
def draw_circle(x, y, radius, subdivide, poly=False):
r = 0.0
dr = math.pi * 2 / subdivide
if poly:
subdivide += 1
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
bgl.glVertex2f(x, y)
else:
bgl.glBegin(bgl.GL_LINE_LOOP)
for i in range(subdivide):
bgl.glVertex2f(x + radius * math.cos(r), y + radius * math.sin(r))
r += dr
bgl.glEnd()
def draw2D_arrow(p0: Point2D, p1: Point2D):
d = (p0 - p1) * 0.25
c = Vec2D((d.y, -d.x))
p2 = p1 + d + c
p3 = p1 + d - c
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2f(*p0)
bgl.glVertex2f(*p1)
bgl.glVertex2f(*p2)
bgl.glVertex2f(*p1)
bgl.glVertex2f(*p3)
bgl.glEnd()
def draw_line(self, v1, v2):
"""
Draws a line between the 2D position v1 and the 2D position v2
:param v1: First 2D point of the line
:param v2: Second 2D point of the line
"""
if v1 and v2:
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(*v1)
bgl.glVertex2f(*v2)
bgl.glEnd()
return
def simple_grid_xy(x, y, args):
func = args[0]
back_color, grid_color, line_color = args[1]
scale = args[2]
def draw_rect(x=0, y=0, w=30, h=10, color=(0.0, 0.0, 0.0, 1.0)):
bgl.glColor4f(*color)
bgl.glBegin(bgl.GL_POLYGON)
for coord in [(x, y), (x + w, y), (w + x, y - h), (x, y - h)]:
bgl.glVertex2f(*coord)
bgl.glEnd()
size = 140 * scale
# draw bg fill
draw_rect(x=x, y=y, w=size, h=size, color=back_color)
# draw grid
bgl.glColor4f(*grid_color)
num_divs = 8
offset = size / num_divs
line_parts_x = []
line_parts_y = []
for i in range(num_divs + 1):
xpos1 = x + (i * offset)
ypos1 = y
ypos2 = y - size
line_parts_x.extend([[xpos1, ypos1], [xpos1, ypos2]])
ypos = y - (i * offset)
line_parts_y.extend([[x, ypos], [x + size, ypos]])
bgl.glLineWidth(0.8)
bgl.glBegin(bgl.GL_LINES)
for coord in line_parts_x + line_parts_y:
bgl.glVertex2f(*coord)
bgl.glEnd()
# draw graph-line
bgl.glColor4f(*line_color)
bgl.glLineWidth(2.0)
bgl.glBegin(bgl.GL_LINE_STRIP)
num_points = 100
seg_diff = 1 / num_points
for i in range(num_points + 1):
_px = x + ((i * seg_diff) * size)
_py = y - (1 - func(i * seg_diff) * size) - size
bgl.glVertex2f(_px, _py)
bgl.glEnd()
def draw_call(self, context):
global x_loc
global y_loc
width = 30
height = 30
"""if start_draw == True:
bgl.glEnable(bgl.GL_BLEND)
bgl.glLineWidth(4)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glColor4f(0.0, 0.0, 0.0, 0.75)
for x, y in self.draw_mouse_path:
bgl.glVertex2i(x, y)
bgl.glEnd()"""
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, 0.98)
font_id = 0 # XXX, need to find out how best to get this.
# draw some text
blf.position(font_id, 25, 20, 0)
blf.size(font_id, 20, 57)
blf.draw(font_id, "Press Enter to Confirm")
blf.position(font_id, 40, 7, 0)
blf.size(font_id, 20, 40)
blf.draw(font_id, "Kaleidoscope Modal 0.1")
bgl.glBegin(bgl.GL_QUADS)
bgl.glColor3f(c[0][0], c[0][1], c[0][2])
bgl.glVertex3f(x_loc+10,y_loc+10,0)
bgl.glVertex3f(x_loc+10+width,y_loc+10,0)
bgl.glVertex3f(x_loc+10+width,y_loc+height+10,0)
bgl.glVertex3f(x_loc+10,y_loc+height+10,0)
bgl.glEnd()
if c[0][0] < 0.1 and c[0][1] < 0.1 and c[0][2] < 0.1:
bgl.glColor3f(1, 1, 1)
else:
bgl.glColor3f(0, 0, 0)
bgl.glEnable(bgl.GL_BLEND)
bgl.glLineWidth(1)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2f(x_loc+10-1, y_loc+10-1)
bgl.glVertex2f(x_loc+10+width+1, y_loc+10-1)
bgl.glVertex2f(x_loc+10+width, y_loc+10+height+1)
bgl.glVertex2f(x_loc+10-1, y_loc+10+height)
bgl.glVertex2f(x_loc+10-1, y_loc+10-1)
bgl.glEnd()
def color_placing():
"""
Draw the green rectangle via OpenGL-Wrapper
"""
imageHeight = windowHeight * 0.05
imageWidth = imageHeight
x = windowWidth * 0.5 - imageWidth / 2
y = windowHeight * 0.5 - imageHeight / 2
gl_position = [[x, y], [x + imageWidth, y],
[x + imageWidth, y + imageHeight], [x, y + imageHeight]]
view_buf = bgl.Buffer(bgl.GL_INT, 4)
bgl.glGetIntegerv(bgl.GL_VIEWPORT, view_buf)
view = view_buf.to_list() if hasattr(view_buf,
"to_list") else view_buf.list
# Save the state
bgl.glPushAttrib(bgl.GL_ALL_ATTRIB_BITS)
# Disable depth test so we always draw over things
bgl.glDisable(bgl.GL_DEPTH_TEST)
# Disable lighting so everything is shadless
bgl.glDisable(bgl.GL_LIGHTING)
# Make sure we're using smooth shading instead of flat
bgl.glShadeModel(bgl.GL_SMOOTH)
# Setup the matrices
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glPushMatrix()
bgl.glLoadIdentity()
bgl.gluOrtho2D(0, view[2], 0, view[3])
bgl.glMatrixMode(bgl.GL_MODELVIEW)
bgl.glPushMatrix()
bgl.glLoadIdentity()
# Enable alpha blending
bgl.glEnable(bgl.GL_BLEND)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
# Draw the colored quad
bgl.glColor4f(0, 1, 0, 0.25)
bgl.glEnable(bgl.GL_POLYGON_OFFSET_FILL)
bgl.glPolygonOffset(1.0, 1.0)
bgl.glBegin(bgl.GL_QUADS)
for i in range(4):
bgl.glTexCoord2f(texco[i][0], texco[i][1])
bgl.glVertex2f(gl_position[i][0], gl_position[i][1])
bgl.glEnd()
bgl.glPopMatrix()
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glPopMatrix()
bgl.glPopAttrib()
def draw_active_item_background(self):
prefs = self.prefs
colors = prefs.colors
menu = self.menu
items = menu.current_items
widget_unit = self.widget_unit
if menu.active_index == -1 or not menu.is_valid_click:
return
if not items[menu.active_index]:
return
r_icon = self.icon_box_size / 2
i = menu.active_index
subdiv = 32 if len(items) <= 2 else 16
if 0:
angle_start, angle_end = menu.item_boundary_angles[i]
else:
pie_angle = math.pi * 2 / len(items)
angle_start = math.pi * 0.5 - pie_angle * i + pie_angle / 2
angle_end = angle_start - pie_angle
angle_subdiv = (angle_start - angle_end) / subdiv
x, y = menu.co
bgl.glColor4f(*colors.pie_sel)
if menu.draw_type == 'SIMPLE':
if len(menu.menu_items) <= 4:
r1 = menu.radius_ - widget_unit * 0.2
else:
# この辺は適当
_, rect = self.calc_item_rect(
int(len(menu.menu_items) / 4) - 1, "DUMMY", 'NONE')
v = Vector((rect[0], rect[1]))
r1 = (rect[1] - menu.co[1]) - widget_unit * 0.2
# r2 = menu.radius_ + r_icon * 2 + widget_unit * 0.2
r2 = r1 + r_icon * 2 + widget_unit * 0.4
else:
r1 = menu.radius_ - widget_unit * 0.2
r2 = menu.radius_ + r_icon * 2 + widget_unit * 0.2
# r1 = prefs.menu_radius_center + widget_unit * 0.5
# r2 = prefs.menu_radius_center + widget_unit * 0.8
# bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
bgl.glBegin(bgl.GL_QUAD_STRIP)
for m in range(subdiv + 1):
ang = angle_start - angle_subdiv * m
cosf = math.cos(ang)
sinf = math.sin(ang)
bgl.glVertex2f(x + r1 * cosf, y + r1 * sinf)
bgl.glVertex2f(x + r2 * cosf, y + r2 * sinf)
bgl.glEnd()
def h_draw_gradient_rect(bounds, gradient, border_width=1, border_radius=0, border_color=(0, 0, 0, 1), wire=False):
if len(gradient.colors) != len(gradient.offsets): return
bgl.glEnable(bgl.GL_BLEND)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
h_mask_begin(bounds, border_radius)
mode = bgl.GL_LINE_STRIP if wire else bgl.GL_TRIANGLE_STRIP
bgl.glBegin(mode)
if gradient.orientation == 0: # HOR
for i in range(len(gradient.colors)):
bgl.glColor4f(*gradient.colors[i])
x = (bounds[2] * clamp(gradient.offsets[i], 0.0, 1.0)) + bounds[0]
bgl.glVertex2f(x, bounds[1])
bgl.glVertex2f(x, bounds[1]+bounds[3])
elif gradient.orientation == 1: # VER
for i in range(len(gradient.colors)):
bgl.glColor4f(*gradient.colors[i])
y = (bounds[3] * clamp(gradient.offsets[i], 0.0, 1.0)) + bounds[1]
bgl.glVertex2f(bounds[0], y)
bgl.glVertex2f(bounds[0]+bounds[2], y)
bgl.glEnd()
h_mask_end()
if border_width > 0:
h_round_rect_wire(bounds, border_radius, color=border_color, width=border_width)
bgl.glDisable(bgl.GL_BLEND)
def draw_outline_or_region(mode, points):
'''
arg: mode either bgl.GL_POLYGON or bgl.GL_LINE_LOOP
color will need to be set beforehand using theme colors. eg
bgl.glColor4f(self.ri, self.gi, self.bi, self.ai)
'''
bgl.glBegin(mode)
# start with corner right-bottom
for i in range(0, len(points)):
bgl.glVertex2f(points[i][0], points[i][1])
bgl.glEnd()
def draw_Cartesian(self): #vertices):
ob = bpy.context.scene.objects.active.location
rgn = bpy.context.region
rv3d = bpy.context.space_data.region_3d
#bgl.glClear()
bgl.glEnable(bgl.GL_BLEND)
bgl.glLineWidth(4)
bgl.glBegin(bgl.GL_LINE_STRIP)
v3d = Vector((0, 0, 0))
v2d = location_3d_to_region_2d(rgn, rv3d, v3d)
bgl.glVertex2f(*v2d)
bgl.glColor4f(100, 0.0, 0.0, 1)
v3d = mathutils.Vector((ob.x, 0, 0))
v2d = location_3d_to_region_2d(rgn, rv3d, v3d)
bgl.glVertex2f(*v2d)
bgl.glColor4f(0, 100.0, 0.0, 1)
v3d = mathutils.Vector((ob.x, ob.y, 0))
v2d = location_3d_to_region_2d(rgn, rv3d, v3d)
bgl.glVertex2f(*v2d)
bgl.glColor4f(0, 0.0, 100.0, 1)
v3d = mathutils.Vector((ob.x, ob.y, ob.z))
v2d = location_3d_to_region_2d(rgn, rv3d, v3d)
bgl.glVertex2f(*v2d)
bgl.glEnd()
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(1, 1, 1, 1)
self.draw_value(Vector((ob.x / 2, 0, 0)), str(round(ob.x, 2)))
self.draw_value(Vector((ob.x, ob.y / 2, 0)), str(round(ob.y, 2)))
self.draw_value(Vector((ob.x, ob.y, ob.z / 2)), str(round(ob.z, 2)))
def draw_sun(x, y, radius, subdivide=16, raydirections=(),
raylength=10, raystartoffset=0):
draw_circle(x, y, radius, subdivide)
bgl.glBegin(bgl.GL_LINES)
if isinstance(raylength, (int, float)):
llist = [raylength for i in range(len(raydirections))]
else:
llist = raylength
for i, angle in enumerate(raydirections):
bgl.glVertex2f(x + (radius + raystartoffset) * math.cos(angle), \
y + (radius + raystartoffset) * math.sin(angle))
bgl.glVertex2f(x + (radius + llist[i]) * math.cos(angle), \
y + (radius + llist[i]) * math.sin(angle))
bgl.glEnd()
def draw_preview(self):
bgl.glPushAttrib(bgl.GL_ALL_ATTRIB_BITS)
bgl.glMatrixMode(bgl.GL_MODELVIEW)
bgl.glPushMatrix()
bgl.glLoadIdentity()
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glPushMatrix()
bgl.glLoadIdentity()
bgl.glEnable(bgl.GL_BLEND)
bgl.glDisable(bgl.GL_DEPTH_TEST)
bgl.glBegin(bgl.GL_QUADS) # TODO: not use immediate mode
bgl.glColor4f(0,0,0.2,0.5)
bgl.glVertex2f(-1, -1)
bgl.glVertex2f( 1, -1)
bgl.glColor4f(0,0,0.2,0)
bgl.glVertex2f( 1, 1)
bgl.glVertex2f(-1, 1)
bgl.glEnd()
bgl.glPopMatrix()
bgl.glMatrixMode(bgl.GL_MODELVIEW)
bgl.glPopMatrix()
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glPopAttrib()
def draw_postpixel(self):
bgl.glPushAttrib(bgl.GL_ALL_ATTRIB_BITS)
bgl.glEnable(bgl.GL_BLEND)
bgl.glMatrixMode(bgl.GL_MODELVIEW)
bgl.glPushMatrix()
bgl.glLoadIdentity()
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glPushMatrix()
bgl.glLoadIdentity()
bgl.glColor4f(1,0,0,0.2) # TODO: use window background color??
bgl.glEnable(bgl.GL_BLEND)
bgl.glDisable(bgl.GL_DEPTH_TEST)
bgl.glBegin(bgl.GL_QUADS) # TODO: not use immediate mode
bgl.glVertex2f(-1, -1)
bgl.glVertex2f( 1, -1)
bgl.glVertex2f( 1, 1)
bgl.glVertex2f(-1, 1)
bgl.glEnd()
bgl.glPopMatrix()
bgl.glMatrixMode(bgl.GL_MODELVIEW)
bgl.glPopMatrix()
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glPopAttrib()
def draw_callback_px(tmp, self, context):
color = bpy.context.tool_settings.image_paint.brush.cursor_color_add
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(color[0], color[1], color[2], .5)
bgl.glLineWidth(1)
bgl.glEnable(bgl.GL_LINE_SMOOTH)
### draw curve gradient
ring_count = 12
segements = 36
for j in range(ring_count):
bgl.glBegin(bgl.GL_QUAD_STRIP)
for i in range(segements+1):
curve = self.brush.curve.curves[0]
curve_pos = (j*(1/ring_count))
curve_pos = min(curve_pos,1.0)
curve_pos = max(curve_pos,0.0)
curve_pos2 = curve_pos + (1/ring_count)
curve_pos2 = min(curve_pos2,1.0)
curve_pos2 = max(curve_pos2,0.0)
alpha1 = curve.evaluate(curve_pos)
alpha2 = curve.evaluate(curve_pos2)
offset = self.mouse_pos_init
angle = 2*pi/segements
size = self.brush_size * (j+1)*(1/ring_count)
size2 = self.brush_size * j*(1/ring_count)
point1 = offset + Vector((size* cos(i*angle),(size* sin(i*angle))))
point2 = offset + Vector((size2* cos(i*angle),(size2* sin(i*angle))))
bgl.glColor4f(self.brush_color[0], self.brush_color[1], self.brush_color[2], alpha2)
bgl.glVertex2f(point1[0],point1[1])
bgl.glColor4f(self.brush_color[0], self.brush_color[1], self.brush_color[2], alpha1)
bgl.glVertex2f(point2[0],point2[1])
bgl.glEnd()
### draw brush circles
bgl.glColor4f(color[0], color[1], color[2], .5)
bgl.glLineWidth(1)
bgl.glBegin(bgl.GL_LINE_LOOP)
segements = 42
for i in range(segements):
bgl.glVertex2f(self.mouse_pos_init.x + self.brush_size*cos(i*(2*pi/segements)),self.mouse_pos_init.y + self.brush_size*sin(i*(2*pi/segements)))
bgl.glEnd()
bgl.glBegin(bgl.GL_LINE_LOOP)
segements = 42
for i in range(segements):
bgl.glVertex2f(self.mouse_pos_init.x + self.brush_size_init*cos(i*(2*pi/segements)),self.mouse_pos_init.y + self.brush_size_init*sin(i*(2*pi/segements)))
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_underline_in_strip(strip_coords, pixel_size_x, color):
from bgl import glColor4f, glRectf, glEnable, glDisable, GL_BLEND
import bgl
context = bpy.context
# Strip coords
s_x1, s_y1, s_x2, s_y2 = strip_coords
# be careful not to draw over the current frame line
cf_x = context.scene.frame_current_final
bgl.glPushAttrib(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_LINE_BIT)
glColor4f(*color)
glEnable(GL_BLEND)
bgl.glLineWidth(2)
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(s_x1, s_y1)
if s_x1 < cf_x < s_x2:
# Bad luck, the line passes our strip
bgl.glVertex2f(cf_x - pixel_size_x, s_y1)
bgl.glVertex2f(cf_x + pixel_size_x, s_y1)
bgl.glVertex2f(s_x2, s_y1)
bgl.glEnd()
bgl.glPopAttrib()
def draw(self):
Widget.draw(self)
if self.texture is None:
return
self.texture.bind()
bgl.glBegin(bgl.GL_QUADS)
self.color.apply()
bgl.glTexCoord2f(0, 0)
bgl.glVertex2f(self.padding.x, self.padding.h)
bgl.glTexCoord2f(1, 0)
bgl.glVertex2f(self.allocation.w - self.padding.w, self.padding.h)
bgl.glTexCoord2f(1, 1)
bgl.glVertex2f(self.allocation.w - self.padding.w,
self.allocation.h - self.padding.y)
bgl.glTexCoord2f(0, 1)
bgl.glVertex2f(self.padding.x, self.allocation.h - self.padding.y)
bgl.glEnd()
self.texture.unbind()
def draw_image_data(file_path, center_coord):
bgl.glEnable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_TEXTURE_2D)
image = load_image_to_data(file_path)
width = get_image_width(image)
height = get_image_height(image)
top_left = (center_coord[0] - width/2, center_coord[1] - height/2)
top_right = (center_coord[0] + width/2, center_coord[1] - height/2)
bottom_right = (center_coord[0] + width/2, center_coord[1] + height/2)
bottom_left = center_coord(0 - width/2, center_coord[1] + height/2)
bind_image(image)
bgl.glBegin(bgl.GL_QUADS)
bgl.glTexCoord2f(0.0, 0.0)
bgl.glVertex2f(*top_left)
bgl.glTexCoord2f(1.0, 0.0)
bgl.glVertex2f(*top_right)
bgl.glTexCoord2f(1.0, 1.0)
bgl.glVertex2f(*bottom_right)
bgl.glTexCoord2f(0.0, 1.0)
bgl.glVertex2f(*bottom_left)
bgl.glEnd()
bgl.glDisable(bgl.GL_TEXTURE_2D)
bgl.glDisable(bgl.GL_BLEND)
def h_draw_texture(id, w, h, bounds, coords):
bgl.glEnable(bgl.GL_TEXTURE_2D)
bgl.glBindTexture(bgl.GL_TEXTURE_2D, id)
bgl.glEnable(bgl.GL_BLEND)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
bgl.glColor4f(*(1,1,1,1))
B = bounds
C = coords
D = [
(C[0][0]/w, C[0][1]/h),
(C[1][0]/w, C[1][1]/h),
(C[2][0]/w, C[2][1]/h),
(C[3][0]/w, C[3][1]/h),
]
#print(D)
bgl.glBegin(bgl.GL_QUADS)
bgl.glTexCoord2f(D[0][0], D[0][1])
bgl.glVertex2f(B[0], B[1])
bgl.glTexCoord2f(D[1][0], D[1][1])
bgl.glVertex2f(B[0]+B[2], B[1])
bgl.glTexCoord2f(D[2][0], D[2][1])
bgl.glVertex2f(B[0]+B[2], B[1]+B[3])
bgl.glTexCoord2f(D[3][0], D[3][1])
bgl.glVertex2f(B[0], B[1]+B[3])
bgl.glEnd()
bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0)
bgl.glDisable(bgl.GL_TEXTURE_2D)
def draw2d_polyline(points, color, thickness, stipple=False):
if stipple:
bgl.glLineStipple(4, 0x5555) #play with this later
bgl.glEnable(bgl.GL_LINE_STIPPLE)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(*color)
bgl.glLineWidth(thickness)
bgl.glBegin(bgl.GL_LINE_STRIP)
for coord in points: bgl.glVertex2f(*coord)
bgl.glEnd()
bgl.glLineWidth(1)
if stipple:
bgl.glDisable(bgl.GL_LINE_STIPPLE)
bgl.glEnable(bgl.GL_BLEND) # back to uninterupted lines
def display_line_between_two_points(region, rv3d, p1_3d, p2_3d):
bgl.glEnable(bgl.GL_BLEND)
p1_2d = view3d_utils.location_3d_to_region_2d(region, rv3d, p1_3d)
p2_2d = view3d_utils.location_3d_to_region_2d(region, rv3d, p2_3d)
if p1_2d is None:
p1_2d = (0.0, 0.0)
p2_2d = (0.0, 0.0)
col_line_main = addon_settings_graph('col_line_main')
col_line_shadow = addon_settings_graph('col_line_shadow')
bgl.glColor4f(*col_line_shadow)
bgl.glLineWidth(1.4)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2f((p1_2d[0] - 1), (p1_2d[1] - 1))
bgl.glVertex2f((p2_2d[0] - 1), (p2_2d[1] - 1))
bgl.glEnd()
bgl.glColor4f(*col_line_main)
bgl.glLineWidth(1.4)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2f(*p1_2d)
bgl.glVertex2f(*p2_2d)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
def draw_rounded_box(x, y, w, h, round_radius, fill=False, fill_color=None):
def circle_verts_num(r):
"""Get number of verticies for circle optimized for drawing."""
num_verts = 32
threshold = 2.0 # pixcel
while True:
if r * 2 * math.pi / num_verts > threshold:
return num_verts
num_verts -= 4
if num_verts < 1:
return 1
num_verts = circle_verts_num(round_radius)
n = int(num_verts / 4) + 1
dangle = math.pi * 2 / num_verts
x_origin = [
x + round_radius,
x + w - round_radius,
x + w - round_radius,
x + round_radius,
]
y_origin = [
y + round_radius,
y + round_radius,
y + h - round_radius,
y + h - round_radius,
]
angle_start = [
math.pi * 1.0,
math.pi * 1.5,
math.pi * 0.0,
math.pi * 0.5,
]
if fill:
bgl.glColor3f(*fill_color)
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
else:
bgl.glBegin(bgl.GL_LINE_LOOP)
for x0, y0, angle in zip(x_origin, y_origin, angle_start):
for _ in range(n):
x = x0 + round_radius * math.cos(angle)
y = y0 + round_radius * math.sin(angle)
bgl.glVertex2f(x, y)
angle += dangle
bgl.glEnd()
bgl.glColor3f(1.0, 1.0, 1.0)
def draw_box(xmin, ymin, w, h, poly=False):
bgl.glBegin(bgl.GL_QUADS if poly else bgl.GL_LINE_LOOP)
bgl.glVertex2f(xmin, ymin)
bgl.glVertex2f(xmin + w, ymin)
bgl.glVertex2f(xmin + w, ymin + h)
bgl.glVertex2f(xmin, ymin + h)
bgl.glEnd()
def draw_point(position, size=2, color=(1.0, 0.2, 0.2, 1.0)):
"""Draw single red point"""
bgl.glEnable(bgl.GL_POINT_SMOOTH)
bgl.glPointSize(size)
bgl.glColor4f(*color)
vec2d = to_screen_coord(position)
if vec2d:
bgl.glBegin(bgl.GL_POINTS)
bgl.glVertex2f(*vec2d)
bgl.glEnd()
bgl.glDisable(bgl.GL_POINT_SMOOTH)
