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_ephestos(self,context):
global show_world
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 0.5)
bgl.glLineWidth(1.5)
"""
#set colour to use
bgl.glColor4f(0.5,0.0,0.5,0.3)
x_region = round((bpy.context.area.regions[4].width-5)/2)
y_region = round((bpy.context.area.regions[4].height-5)/2)
print("x_region : ",x_region)
print("y_region : ",y_region)
bgl.glRecti(5,5,x_region, y_region)
"""
# if show_world:
world.draw()
'''
good_rounded_box.draw_new(ephestos)
world.draw_new(ephestos)
# show_world = False
red_morph.draw_new(ephestos)
green_morph.draw_new(ephestos)
blue_morph.draw_new(ephestos)
multiline_text.draw_new(ephestos)
rounded_box.draw_new(ephestos)
one_String.draw_new(ephestos)
#PKHG.stringfieldTest.???
test_stringfield.draw_new( ephestos)
'''
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
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 screen_v3dBGL(context, args):
region = context.region
region3d = context.space_data.region_3d
points = args[0]
colors = args[1]
size= 5.0
bgl.glEnable(bgl.GL_POINT_SMOOTH) # for round vertex
bgl.glPointSize(size)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
if colors:
bgl.glBegin(bgl.GL_POINTS)
for coord, color in zip(points, colors):
bgl.glColor4f(*color)
bgl.glVertex3f(*coord)
bgl.glEnd()
else:
gl_col = (0.9, 0.9, 0.8, 1.0)
bgl.glColor4f(*gl_col)
bgl.glBegin(bgl.GL_POINTS)
for coord in points:
bgl.glVertex3f(*coord)
bgl.glEnd()
bgl.glDisable(bgl.GL_POINT_SMOOTH)
bgl.glDisable(bgl.GL_POINTS)
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 reload(self, path):
bgl.glEnable(bgl.GL_TEXTURE_2D)
if path == self.path: return
if path in logic.texture_cache:
img = logic.texture_cache[path]
else:
img = texture.ImageFFmpeg(path)
img.scale = False
if self._cache:
logic.texture_cache[path] = img
data = img.image
if data == None:
print("Could not load the image", img)
self.valid = False
return
self.bind()
bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA, img.size[0],
img.size[1], 0, bgl.GL_RGBA,
bgl.GL_UNSIGNED_BYTE, data)
self.size = img.size[:]
self.path = path
img = None
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_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_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 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 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 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_one(u):
c = PCVCache.cache[u]
# update matrix, every frame for now, it should be done better.. but it works well..
m = c['object'].matrix_world
matrix = []
for v in m.transposed():
matrix.extend(list(v.to_tuple()))
matrix_buffer = bgl.Buffer(bgl.GL_FLOAT, len(matrix), matrix)
c['matrix'] = m
c['matrix_buffer'] = matrix_buffer
bgl.glPushMatrix()
bgl.glMultMatrixf(c['matrix_buffer'])
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glEnableClientState(bgl.GL_VERTEX_ARRAY)
bgl.glVertexPointer(3, bgl.GL_FLOAT, 0, c['vertex_buffer'])
bgl.glEnableClientState(bgl.GL_COLOR_ARRAY)
bgl.glColorPointer(3, bgl.GL_FLOAT, 0, c['color_buffer'])
if(PCVCache.cache[u]['smooth']):
bgl.glEnable(bgl.GL_POINT_SMOOTH)
l = int((c['length'] / 100) * c['display_percent'])
bgl.glDrawArrays(bgl.GL_POINTS, 0, l)
bgl.glDisableClientState(bgl.GL_VERTEX_ARRAY)
bgl.glDisableClientState(bgl.GL_COLOR_ARRAY)
if(c['smooth']):
bgl.glDisable(bgl.GL_POINT_SMOOTH)
bgl.glDisable(bgl.GL_DEPTH_TEST)
bgl.glPopMatrix()
def mi_draw_3d_polyline(points, p_size, p_col, x_ray):
bgl.glEnable(bgl.GL_BLEND)
bgl.glLineWidth(1)
if x_ray is True:
bgl.glDisable(bgl.GL_DEPTH_TEST)
bgl.glPointSize(p_size)
# bgl.glBegin(bgl.GL_LINE_LOOP)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glColor4f(p_col[0], p_col[1], p_col[2], p_col[3])
# bgl.glBegin(bgl.GL_POLYGON)
for point in points:
bgl.glVertex3f(point[0], point[1], point[2])
if x_ray is True:
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback_px(self, context):
if context.region.id != self.region_id:
return
posx = 70
posy1 = 30
posy2 = 50
text_interval = 5
font_id = 0
blf.size(font_id, 11, context.user_preferences.system.dpi)
bgl.glEnable(bgl.GL_BLEND)
if self.changing_mgtype:
bgl.glColor4f(1.0, 1.0, 0.0, 1.0)
else:
bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
# draw origin
bgl.glLineWidth(2)
radius = path_threthold
radius2 = radius + 5
x, y, z = self.path[0]
bgl.glBegin(bgl.GL_LINES)
for i in range(4):
r = math.pi / 2 * i + math.pi / 4
bgl.glVertex2f(x + radius * math.cos(r), y + radius * math.sin(r))
bgl.glVertex2f(x + radius2 * math.cos(r),
y + radius2 * math.sin(r))
bgl.glEnd()
bgl.glLineWidth(1)
# draw lines
bgl.glEnable(bgl.GL_LINE_STIPPLE)
bgl.glLineStipple(1, int(0b101010101010101)) # (factor, pattern)
bgl.glBegin(bgl.GL_LINE_STRIP)
for v in self.path:
bgl.glVertex2f(v[0], v[1])
bgl.glEnd()
bgl.glLineStipple(1, 1)
bgl.glDisable(bgl.GL_LINE_STIPPLE)
# draw txt
if self.action or self.mgitem:
x = posx
for txt in self.action:
blf.position(font_id, x, posy1, 0)
blf.draw(font_id, txt)
text_width, text_height = blf.dimensions(font_id, txt)
x += text_width + text_interval
if self.mgitem:
blf.position(font_id, posx, posy2, 0)
blf.draw(font_id, self.mgitem.name)
else:
#blf.position(font_id, posx, posy2, 0)
#blf.draw(font_id, '[Mouse Gesture]')
pass
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
blf.size(0, 11, context.user_preferences.system.dpi)
def draw_texture(x, y, w, h, texture, mode=None):
mode_bak = bgl.Buffer(bgl.GL_INT, 1)
bgl.glGetIntegerv(bgl.GL_DRAW_BUFFER, mode_bak)
if mode is not None:
bgl.glDrawBuffer(mode)
bgl.glEnable(bgl.GL_TEXTURE_2D)
bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture)
bgl.glColor4d(1.0, 1.0, 1.0, 1.0)
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
bgl.glTexCoord2d(0.0, 0.0)
bgl.glVertex2i(x, y)
bgl.glTexCoord2d(1.0, 0.0)
bgl.glVertex2i(x + w, y)
bgl.glTexCoord2d(1.0, 1.0)
bgl.glVertex2i(x + w, y + h)
bgl.glTexCoord2d(0.0, 1.0)
bgl.glVertex2i(x, y + h)
bgl.glEnd()
bgl.glDisable(bgl.GL_TEXTURE_2D)
bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0)
if mode is not None:
bgl.glDrawBuffer(mode_bak[0])
def draw_channel_color(scroller_width, channel_coords, curx, color):
from bgl import glColor4f, glRectf, glEnable, glDisable, glBlendFunc, GL_BLEND, GL_ONE, GL_SRC_ALPHA
context = bpy.context
# Strip coords
s_x1, s_y1, s_x2, s_y2 = channel_coords
# Drawing coords
x = 0
d_y1 = s_y1
d_y2 = s_y2
d_x1 = s_x1
d_x2 = s_x2
# be careful not to override the current frame line
cf_x = context.scene.frame_current_final
y = 0
r, g, b, a = color
glColor4f(r, g, b, a)
glEnable(GL_BLEND)
# glBlendFunc(GL_SRC_ALPHA, GL_ONE);
if d_x1 < cf_x and cf_x < d_x2:
# current frame line over strip
glRectf(d_x1, d_y1, cf_x - curx, d_y2)
glRectf(cf_x + curx, d_y1, d_x2, d_y2)
else:
# Normal, full rectangle draw
glRectf(d_x1, d_y1, d_x2, d_y2)
glDisable(GL_BLEND)
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 drawCurvePoints(self): #Draw Lines between Control Points bgl.glEnable(bgl.GL_POINT_SMOOTH) bgl.glColor3d(0,1,0) bgl.glPointSize(3) bgl.glBegin(bgl.GL_POINTS) for i in range(len(self.curvePoints)): tup = self.curvePoints[i].to_tuple() bgl.glVertex3f( *tup ) bgl.glEnd() bgl.glLineWidth(1) bgl.glColor3f(0,.5,0) bgl.glBegin(bgl.GL_LINES) ''' for i in range(0, len(self.curvePoints)-1): if i%(self.tesselate+1) != self.tesselate: tup = self.curvePoints[i] tup1 = self.curvePoints[i+1] bgl.glVertex3f( *tup ) bgl.glVertex3f( *tup1 ) ''' for i in range(0, len(self.curvePoints)-1): tup = self.curvePoints[i].to_tuple() tup1 = self.curvePoints[i+1].to_tuple() bgl.glVertex3f(tup[0], tup[1], tup[2]) bgl.glVertex3f(tup1[0], tup1[1], tup1[2]) bgl.glEnd()
def draw_normal(context, vertexloc, vertexnorm, objscale, is_selected = True):
# draw normals in object mode
obj = context.active_object
color1, thick1 = (0.5, 1.0, 1.0, 1.0), 3
# input in localspace
vertexloc = copy.copy(vertexloc)
vertexloc.resize_4d()
obmat = obj.matrix_world
r1 = obmat*vertexloc
r1.resize_3d()
del vertexloc
r2 = obj.rotation_euler.to_matrix() * mathutils.Vector(vertexnorm)
r2 = r2* objscale
r2 = r2* context.scene.tool_settings.normal_size + r1
bgl.glEnable(bgl.GL_BLEND)
bgl.glLineWidth(thick1)
# set colour
bgl.glColor4f(*color1)
# draw line
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex3f(r1.x,r1.y,r1.z)
bgl.glVertex3f(r2.x,r2.y,r2.z)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
def 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_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.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
return
def __exit__(self, type, value, traceback):
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw(self):
width = render.getWindowWidth()
height = render.getWindowHeight()
# 2D Projection
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glLoadIdentity()
bgl.glOrtho(0, width, height, 0, -1, 1)
bgl.glMatrixMode(bgl.GL_MODELVIEW)
bgl.glLoadIdentity()
# 2D Shading
bgl.glDisable(bgl.GL_CULL_FACE)
bgl.glDisable(bgl.GL_LIGHTING)
bgl.glDisable(bgl.GL_DEPTH_TEST)
bgl.glShadeModel(bgl.GL_SMOOTH)
# Line antialias
bgl.glEnable(bgl.GL_LINE_SMOOTH)
bgl.glHint(bgl.GL_LINE_SMOOTH_HINT, bgl.GL_NICEST)
# 2D Blending (Alpha)
bgl.glEnable(bgl.GL_BLEND)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
if len(self.controls.values()) <= 0: return
ctrls = sorted(self.controls.values(), key=lambda x: x.zorder)
for c in ctrls:
c.draw()
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_line(self, context, vertexloc, vertexnorm, colour, thick):
obj = context.active_object
#get obj rotation
rot = obj.rotation_euler.to_matrix().inverted()
scale = obj.scale
vertex = vertexloc * rot
normal = vertexnorm * rot
x1 = vertex[0] * scale[0] + obj.location[0]
y1 = vertex[1] * scale[1] + obj.location[1]
z1 = vertex[2] * scale[2] + obj.location[2]
x2 = normal[0]*context.scene.tool_settings.normal_size* scale[0] + x1
y2 = normal[1]*context.scene.tool_settings.normal_size* scale[1] + y1
z2 = normal[2]*context.scene.tool_settings.normal_size* scale[2] + z1
bgl.glEnable(bgl.GL_BLEND)
bgl.glLineWidth(thick)
# set colour
bgl.glColor4f(*colour)
# draw line
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex3f(x1,y1,z1)
bgl.glVertex3f(x2,y2,z2)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
def viconutil_draw_lineloop_smooth(pts):
linesmooth = vagl.Buffer('bool', 0, bgl.GL_LINE_SMOOTH)
if not linesmooth:
bgl.glEnable(bgl.GL_LINE_SMOOTH)
viconutil_draw_lineloop(pts)
if not linesmooth:
bgl.glDisable(bgl.GL_LINE_SMOOTH)
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)
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 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 visualise(self, context):
area = context.area
speaker = context.scene.speaker
action = getAction(speaker)
scene = context.scene
frame = scene.frame_current
"""
print("MHHM")
action = context.screen.sound_driver_areas["VIEW_3D_4"].action
print("THIS WORKING", action)
#action = context.area.sound_action # NEW IDEA REFACTO
"""
if action is None:
return None
area_settings = self.area_settings(context)
if area_settings is None:
return None
(x, y) = area_settings.loc
fw = context.area.regions[-1].width - (x + 20)
fh = context.area.regions[-1].height - 50
area_settings = self.area_settings(context)
AMP = area_settings.height * fh / 100
if action.get("MIDI"):
bgl.glEnable(bgl.GL_BLEND)
self.draw_box(x, y + AMP, 3 * fw, 20, color=self.gridcol)
bgl.glDisable(bgl.GL_BLEND)
self.draw_action_header_text(x, y + AMP, speaker, action)
self.draw_midi_keyboard(x, y, fw, AMP, action=action, frame=frame)
else:
self.draw_spectrum(context, x, y, speaker, action)
def render_main(self, context, objlist, animation=False):
# noinspection PyBroadException,PyBroadException
# Save old info
scene = context.scene
render = scene.render
settings = render.image_settings
depth = settings.color_depth
settings.color_depth = '8'
# noinspection PyBroadException
try:
# Get visible layers
layers = []
for x in range(0, 20):
if scene.layers[x] is True:
layers.extend([x])
# --------------------
# Get resolution
# --------------------
render_scale = render.resolution_percentage / 100
width = int(render.resolution_x * render_scale)
height = int(render.resolution_y * render_scale)
# ---------------------------------------
# Get output path
# ---------------------------------------
temp_path = path.realpath(bpy.app.tempdir)
if len(temp_path) > 0:
outpath = path.join(temp_path, "archipack_tmp_render.png")
else:
self.report({
'ERROR'
}, "Archipack: Unable to save temporary render image. Define a valid temp path"
)
settings.color_depth = depth
return False
# Get Render Image
img = self.get_render_image(outpath)
if img is None:
self.report({
'ERROR'
}, "Archipack: Unable to save temporary render image. Define a valid temp path"
)
settings.color_depth = depth
return False
# -----------------------------
# Calculate rows and columns
# -----------------------------
tile_x = 240
tile_y = 216
row_num = ceil(height / tile_y)
col_num = ceil(width / tile_x)
print("Archipack: Image divided in " + str(row_num) + "x" +
str(col_num) + " tiles")
# pixels out of visible area
cut4 = (col_num * tile_x *
4) - width * 4 # pixels aout of drawing area
totpixel4 = width * height * 4 # total pixels RGBA
viewport_info = bgl.Buffer(bgl.GL_INT, 4)
bgl.glGetIntegerv(bgl.GL_VIEWPORT, viewport_info)
# Load image on memory
img.gl_load(0, bgl.GL_NEAREST, bgl.GL_NEAREST)
# 2.77 API change
if bpy.app.version >= (2, 77, 0):
tex = img.bindcode[0]
else:
tex = img.bindcode
# --------------------------------------------
# Create output image (to apply texture)
# --------------------------------------------
if "archipack_output" in bpy.data.images:
out_img = bpy.data.images["archipack_output"]
if out_img is not None:
out_img.user_clear()
bpy.data.images.remove(out_img)
out = bpy.data.images.new("archipack_output", width, height)
tmp_pixels = [1] * totpixel4
# --------------------------------
# Loop for all tiles
# --------------------------------
for row in range(0, row_num):
for col in range(0, col_num):
buffer = bgl.Buffer(bgl.GL_FLOAT, width * height * 4)
bgl.glDisable(
bgl.GL_SCISSOR_TEST
) # if remove this line, get blender screenshot not image
bgl.glViewport(0, 0, tile_x, tile_y)
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glLoadIdentity()
# defines ortographic view for single tile
x1 = tile_x * col
y1 = tile_y * row
bgl.gluOrtho2D(x1, x1 + tile_x, y1, y1 + tile_y)
# Clear
bgl.glClearColor(0.0, 0.0, 0.0, 0.0)
bgl.glClear(bgl.GL_COLOR_BUFFER_BIT
| bgl.GL_DEPTH_BUFFER_BIT)
bgl.glEnable(bgl.GL_TEXTURE_2D)
bgl.glBindTexture(bgl.GL_TEXTURE_2D, tex)
# defines drawing area
bgl.glBegin(bgl.GL_QUADS)
bgl.glColor3f(1.0, 1.0, 1.0)
bgl.glTexCoord2f(0.0, 0.0)
bgl.glVertex2f(0.0, 0.0)
bgl.glTexCoord2f(1.0, 0.0)
bgl.glVertex2f(width, 0.0)
bgl.glTexCoord2f(1.0, 1.0)
bgl.glVertex2f(width, height)
bgl.glTexCoord2f(0.0, 1.0)
bgl.glVertex2f(0.0, height)
bgl.glEnd()
# -----------------------------
# Loop to draw all lines
# -----------------------------
for o, d in objlist:
if o.hide is False:
# verify visible layer
for x in range(0, 20):
if o.layers[x] is True:
if x in layers:
context.scene.objects.active = o
# print("%s: %s" % (o.name, d.manip_stack))
manipulators = d.manip_stack
if manipulators is not None:
for m in manipulators:
if m is not None:
m.draw_callback(
m,
context,
render=True)
break
# -----------------------------
# Loop to draw all debug
# -----------------------------
"""
if scene.archipack_debug is True:
selobj = bpy.context.selected_objects
for myobj in selobj:
if scene.archipack_debug_vertices is True:
draw_vertices(context, myobj, None, None)
if scene.archipack_debug_faces is True or scene.archipack_debug_normals is True:
draw_faces(context, myobj, None, None)
"""
"""
if scene.archipack_rf is True:
bgl.glColor3f(1.0, 1.0, 1.0)
rfcolor = scene.archipack_rf_color
rfborder = scene.archipack_rf_border
rfline = scene.archipack_rf_line
bgl.glLineWidth(rfline)
bgl.glColor4f(rfcolor[0], rfcolor[1], rfcolor[2], rfcolor[3])
x1 = rfborder
x2 = width - rfborder
y1 = int(ceil(rfborder / (width / height)))
y2 = height - y1
draw_rectangle((x1, y1), (x2, y2))
"""
# --------------------------------
# copy pixels to temporary area
# --------------------------------
bgl.glFinish()
bgl.glReadPixels(0, 0, width, height, bgl.GL_RGBA,
bgl.GL_FLOAT, buffer) # read image data
for y in range(0, tile_y):
# final image pixels position
p1 = (y * width * 4) + (row * tile_y * width *
4) + (col * tile_x * 4)
p2 = p1 + (tile_x * 4)
# buffer pixels position
b1 = y * width * 4
b2 = b1 + (tile_x * 4)
if p1 < totpixel4: # avoid pixel row out of area
if col == col_num - 1: # avoid pixel columns out of area
p2 -= cut4
b2 -= cut4
tmp_pixels[p1:p2] = buffer[b1:b2]
# -----------------------
# Copy temporary to final
# -----------------------
out.pixels = tmp_pixels[:] # Assign image data
img.gl_free() # free opengl image memory
# delete image
img.user_clear()
bpy.data.images.remove(img)
# remove temp file
remove(outpath)
# reset
bgl.glEnable(bgl.GL_SCISSOR_TEST)
# -----------------------
# restore opengl defaults
# -----------------------
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
# Saves image
if out is not None:
# and (scene.archipack_render is True or animation is True):
ren_path = bpy.context.scene.render.filepath
filename = "ap_frame"
if len(ren_path) > 0:
if ren_path.endswith(path.sep):
initpath = path.realpath(ren_path) + path.sep
else:
(initpath, filename) = path.split(ren_path)
ftxt = "%04d" % scene.frame_current
outpath = path.realpath(
path.join(initpath, filename + ftxt + ".png"))
self.save_image(outpath, out)
settings.color_depth = depth
return True
except:
settings.color_depth = depth
print("Unexpected error:" + str(exc_info()))
self.report({
'ERROR'
}, "Archipack: Unable to create render image. Be sure the output render path is correct"
)
return False
def draw_2D(self, context):
settings = common_utilities.get_settings()
region,r3d = context.region,context.space_data.region_3d
color_inactive = settings.theme_colors_mesh[settings.theme]
color_selection = settings.theme_colors_selection[settings.theme]
color_active = settings.theme_colors_active[settings.theme]
color_frozen = settings.theme_colors_frozen[settings.theme]
color_warning = settings.theme_colors_warning[settings.theme]
bgl.glEnable(bgl.GL_POINT_SMOOTH)
color_handle = (color_inactive[0], color_inactive[1], color_inactive[2], 1.00)
color_border = (color_inactive[0], color_inactive[1], color_inactive[2], 1.00)
color_fill = (color_inactive[0], color_inactive[1], color_inactive[2], 0.20)
if self.fsm_mode == 'sketch' and self.sketch:
# Draw smoothing line (end of sketch to current mouse position)
common_drawing_px.draw_polyline_from_points(context, [self.sketch_curpos, self.sketch[-1][0]], color_active, 1, "GL_LINE_SMOOTH")
# Draw sketching stroke
common_drawing_px.draw_polyline_from_points(context, [co[0] for co in self.sketch], color_selection, 2, "GL_LINE_STIPPLE")
if self.fsm_mode in {'scale tool','rotate tool'}:
# Draw a scale/rotate line from tool origin to current mouse position
common_drawing_px.draw_polyline_from_points(context, [self.action_center, self.mode_pos], (0, 0, 0, 0.5), 1, "GL_LINE_STIPPLE")
bgl.glLineWidth(1)
if self.fsm_mode == 'brush scale tool':
# scaling brush size
self.sketch_brush.draw(context, color=(1, 1, 1, .5), linewidth=1, color_size=(1, 1, 1, 1))
elif self.fsm_mode not in {'grab tool','scale tool','rotate tool'} and not self.is_navigating:
# draw the brush oriented to surface
ray,hit = common_utilities.ray_cast_region2d_bvh(region, r3d, self.cur_pos, mesh_cache['bvh'], self.mx, settings)
hit_p3d,hit_norm,hit_idx = hit
if hit_idx != None: # and not self.hover_ed:
mx = self.mx
mxnorm = mx.transposed().inverted().to_3x3()
hit_p3d = mx * hit_p3d
hit_norm = mxnorm * hit_norm
common_drawing_px.draw_circle(context, hit_p3d, hit_norm.normalized(), self.stroke_radius, (1,1,1,.5))
if self.fsm_mode == 'sketch' and self.sketch:
ray,hit = common_utilities.ray_cast_region2d_bvh(region, r3d, self.sketch[0][0], mesh_cache['bvh'],self.mx, settings)
hit_p3d,hit_norm,hit_idx = hit
if hit_idx != None:
mx = self.mx
mxnorm = mx.transposed().inverted().to_3x3()
hit_p3d = mx * hit_p3d
hit_norm = mxnorm * hit_norm
common_drawing_px.draw_circle(context, hit_p3d, hit_norm.normalized(), self.stroke_radius, (1,1,1,.5))
if self.hover_ed and False: #EXTEND to display hoverable edges
color = (color_selection[0], color_selection[1], color_selection[2], 1.00)
common_drawing_px.draw_bmedge(context, self.hover_ed, self.dest_obj.matrix_world, 2, color)
if self.act_gedge:
if settings.show_segment_count:
bgl.glColor4f(*color_active)
self.draw_gedge_info(self.act_gedge, context)
if self.act_gpatch:
if settings.show_segment_count:
bgl.glColor4f(*color_active)
self.draw_gpatch_info(self.act_gpatch, context)
if True:
txt = 'v:%d e:%d s:%d p:%d' % (len(self.polystrips.gverts), len(self.polystrips.gedges), len(self.polystrips.gedgeseries), len(self.polystrips.gpatches))
txt_width, txt_height = blf.dimensions(0, txt)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0,0,0,0.8)
bgl.glBegin(bgl.GL_QUADS)
bgl.glVertex2f(0, 0)
bgl.glVertex2f(10+txt_width, 0)
bgl.glVertex2f(10+txt_width, 10+txt_height)
bgl.glVertex2f(0, 10+txt_height)
bgl.glEnd()
bgl.glColor4f(1,1,1,1)
blf.position(0, 5, 5, 0)
blf.draw(0, txt)
def draw_3d(self, context):
settings = common_utilities.get_settings()
region,r3d = context.region,context.space_data.region_3d
color_inactive = settings.theme_colors_mesh[settings.theme]
color_selection = settings.theme_colors_selection[settings.theme]
color_active = settings.theme_colors_active[settings.theme]
color_frozen = settings.theme_colors_frozen[settings.theme]
color_warning = settings.theme_colors_warning[settings.theme]
bgl.glEnable(bgl.GL_POINT_SMOOTH)
color_handle = (color_inactive[0], color_inactive[1], color_inactive[2], 1.00)
color_border = (color_inactive[0], color_inactive[1], color_inactive[2], 1.00)
color_fill = (color_inactive[0], color_inactive[1], color_inactive[2], 0.20)
color_mirror = (color_frozen[0], color_frozen[1], color_frozen[2], 0.20)
bgl.glDepthRange(0.0, 0.999)
bgl.glEnable(bgl.GL_DEPTH_TEST)
def draw3d_polyline(context, points, color, thickness, LINE_TYPE):
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.glDepthRange(0.0, 0.997)
bgl.glBegin(bgl.GL_LINE_STRIP)
for coord in points: bgl.glVertex3f(*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 uninterrupted lines
def draw3d_closed_polylines(context, lpoints, color, thickness, LINE_TYPE):
lpoints = list(lpoints)
if LINE_TYPE == "GL_LINE_STIPPLE":
bgl.glLineStipple(4, 0x5555) #play with this later
bgl.glEnable(bgl.GL_LINE_STIPPLE)
bgl.glEnable(bgl.GL_BLEND)
bgl.glLineWidth(thickness)
bgl.glDepthRange(0.0, 0.997)
bgl.glColor4f(*color)
for points in lpoints:
bgl.glBegin(bgl.GL_LINE_STRIP)
for coord in points:
bgl.glVertex3f(*coord)
bgl.glVertex3f(*points[0])
bgl.glEnd()
if settings.symmetry_plane == 'x':
bgl.glColor4f(*color_mirror)
for points in lpoints:
bgl.glBegin(bgl.GL_LINE_STRIP)
for coord in points:
bgl.glVertex3f(-coord.x, coord.y, coord.z)
bgl.glVertex3f(-points[0].x, points[0].y, points[0].z)
bgl.glEnd()
bgl.glLineWidth(1)
if LINE_TYPE == "GL_LINE_STIPPLE":
bgl.glDisable(bgl.GL_LINE_STIPPLE)
bgl.glEnable(bgl.GL_BLEND) # back to uninterrupted lines
def draw3d_quad(context, points, color):
bgl.glEnable(bgl.GL_BLEND)
bgl.glDepthRange(0.0, 0.999)
bgl.glBegin(bgl.GL_QUADS)
bgl.glColor4f(*color)
for coord in points:
bgl.glVertex3f(*coord)
if settings.symmetry_plane == 'x':
bgl.glColor4f(*color_mirror)
for coord in points:
bgl.glVertex3f(-coord.x,coord.y,coord.z)
bgl.glEnd()
def draw3d_quads(context, lpoints, color, color_mirror):
lpoints = list(lpoints)
bgl.glEnable(bgl.GL_BLEND)
bgl.glDepthRange(0.0, 0.999)
bgl.glBegin(bgl.GL_QUADS)
bgl.glColor4f(*color)
for points in lpoints:
for coord in points:
bgl.glVertex3f(*coord)
if settings.symmetry_plane == 'x':
bgl.glColor4f(*color_mirror)
for points in lpoints:
for coord in points:
bgl.glVertex3f(-coord.x,coord.y,coord.z)
bgl.glEnd()
def draw3d_points(context, points, color, size):
bgl.glColor4f(*color)
bgl.glPointSize(size)
bgl.glDepthRange(0.0, 0.997)
bgl.glBegin(bgl.GL_POINTS)
for coord in points: bgl.glVertex3f(*coord)
bgl.glEnd()
bgl.glPointSize(1.0)
def freeze_color(c):
return (
c[0] * 0.5 + color_frozen[0] * 0.5,
c[1] * 0.5 + color_frozen[1] * 0.5,
c[2] * 0.5 + color_frozen[2] * 0.5,
c[3])
### Existing Geometry ###
opts = {
'poly color': (color_frozen[0], color_frozen[1], color_frozen[2], 0.20),
'poly depth': (0, 0.999),
'poly mirror color': (color_mirror[0], color_mirror[1], color_mirror[2], color_mirror[3]),
'poly mirror depth': (0, 0.999),
'line color': (color_frozen[0], color_frozen[1], color_frozen[2], 1.00),
'line depth': (0, 0.997),
'line mirror color': (color_mirror[0], color_mirror[1], color_mirror[2], color_mirror[3]),
'line mirror depth': (0, 0.997),
'line mirror stipple': True,
'mirror x': self.settings.symmetry_plane == 'x',
}
self.tar_bmeshrender.draw(opts=opts)
### Patches ###
for gpatch in self.polystrips.gpatches:
if gpatch == self.act_gpatch:
color_border = (color_active[0], color_active[1], color_active[2], 0.50)
color_fill = (color_active[0], color_active[1], color_active[2], 0.20)
else:
color_border = (color_inactive[0], color_inactive[1], color_inactive[2], 0.50)
color_fill = (color_inactive[0], color_inactive[1], color_inactive[2], 0.10)
if gpatch.is_frozen() and gpatch == self.act_gpatch:
color_border = (color_frozen[0], color_frozen[1], color_frozen[2], 1.00)
color_fill = (color_active[0], color_active[1], color_active[2], 0.20)
elif gpatch.is_frozen():
color_border = (color_frozen[0], color_frozen[1], color_frozen[2], 1.00)
color_fill = (color_frozen[0], color_frozen[1], color_frozen[2], 0.20)
if gpatch.count_error and gpatch == self.act_gpatch:
color_border = (color_warning[0], color_warning[1], color_warning[2], 0.50)
color_fill = (color_active[0], color_active[1], color_active[2], 0.20)
elif gpatch.count_error:
color_border = (color_warning[0], color_warning[1], color_warning[2], 0.50)
color_fill = (color_warning[0], color_warning[1], color_warning[2], 0.10)
draw3d_quads(context, gpatch.iter_segments(), color_fill, color_mirror)
draw3d_closed_polylines(context, gpatch.iter_segments(), color_border, 1, "GL_LINE_STIPPLE")
draw3d_points(context, [p for p,v,k in gpatch.pts if v], color_border, 3)
### Edges ###
for gedge in self.polystrips.gedges:
# Color active strip
if gedge == self.act_gedge:
color_border = (color_active[0], color_active[1], color_active[2], 1.00)
color_fill = (color_active[0], color_active[1], color_active[2], 0.20)
# Color selected strips
elif gedge in self.sel_gedges:
color_border = (color_selection[0], color_selection[1], color_selection[2], 0.75)
color_fill = (color_selection[0], color_selection[1], color_selection[2], 0.20)
# Color unselected strips
else:
color_border = (color_inactive[0], color_inactive[1], color_inactive[2], 1.00)
color_fill = (color_inactive[0], color_inactive[1], color_inactive[2], 0.20)
if gedge.is_frozen() and gedge in self.sel_gedges:
color_border = (color_frozen[0], color_frozen[1], color_frozen[2], 1.00)
color_fill = (color_active[0], color_active[1], color_active[2], 0.20)
elif gedge.is_frozen():
color_border = (color_frozen[0], color_frozen[1], color_frozen[2], 1.00)
color_fill = (color_frozen[0], color_frozen[1], color_frozen[2], 0.20)
draw3d_quads(context, gedge.iter_segments(), color_fill, color_mirror)
draw3d_closed_polylines(context, gedge.iter_segments(), color_border, 1, "GL_LINE_STIPPLE")
if settings.debug >= 2:
# draw bezier
p0,p1,p2,p3 = gedge.gvert0.snap_pos, gedge.gvert1.snap_pos, gedge.gvert2.snap_pos, gedge.gvert3.snap_pos
p3d = [cubic_bezier_blend_t(p0,p1,p2,p3,t/16.0) for t in range(17)]
draw3d_polyline(context, p3d, (1,1,1,0.5),1, "GL_LINE_STIPPLE")
if settings.debug >= 2:
for gp in self.polystrips.gpatches:
for rev,gedgeseries in zip(gp.rev, gp.gedgeseries):
for revge,ge in zip(gedgeseries.rev, gedgeseries.gedges):
color = (0.25,0.5,0.25,0.9) if not revge else (0.5,0.25,0.25,0.9)
draw3d_arrow(context, ge.gvert0.snap_pos, ge.gvert3.snap_pos, ge.gvert0.snap_norm, color, 2, '')
color = (0.5,1.0,0.5,0.5) if not rev else (1,0.5,0.5,0.5)
draw3d_arrow(context, gedgeseries.gvert0.snap_pos, gedgeseries.gvert3.snap_pos, gedgeseries.gvert0.snap_norm, color, 2, '')
### Verts ###
for gv in self.polystrips.gverts:
p0,p1,p2,p3 = gv.get_corners()
if gv.is_unconnected() and not gv.from_mesh: continue
is_active = False
is_active |= gv == self.act_gvert
is_active |= self.act_gedge!=None and (self.act_gedge.gvert0 == gv or self.act_gedge.gvert1 == gv)
is_active |= self.act_gedge!=None and (self.act_gedge.gvert2 == gv or self.act_gedge.gvert3 == gv)
# Theme colors for selected and unselected gverts
if is_active:
color_border = (color_active[0], color_active[1], color_active[2], 0.75)
color_fill = (color_active[0], color_active[1], color_active[2], 0.20)
else:
color_border = (color_inactive[0], color_inactive[1], color_inactive[2], 1.00)
color_fill = (color_inactive[0], color_inactive[1], color_inactive[2], 0.20)
# # Take care of gverts in selected edges
if gv in self.sel_gverts:
color_border = (color_selection[0], color_selection[1], color_selection[2], 0.75)
color_fill = (color_selection[0], color_selection[1], color_selection[2], 0.20)
if gv.is_frozen() and is_active :
color_border = (color_frozen[0], color_frozen[1], color_frozen[2], 1.00)
color_fill = (color_active[0], color_active[1], color_active[2], 0.20)
elif gv.is_frozen():
color_border = (color_frozen[0], color_frozen[1], color_frozen[2], 1.00)
color_fill = (color_frozen[0], color_frozen[1], color_frozen[2], 0.20)
p3d = [p0,p1,p2,p3,p0]
draw3d_quads(context, [[p0,p1,p2,p3]], color_fill, color_mirror)
draw3d_polyline(context, p3d, color_border, 1, "GL_LINE_STIPPLE")
# Draw inner gvert handles (dots) on each gedge
p3d = [gvert.position for gvert in self.polystrips.gverts if not gvert.is_unconnected()]
# color_handle = (color_active[0], color_active[1], color_active[2], 1.00)
draw3d_points(context, p3d, color_handle, 4)
### Vert Handles ###
if self.act_gvert:
color_handle = (color_active[0], color_active[1], color_active[2], 1.00)
gv = self.act_gvert
p0 = gv.position
draw3d_points(context, [p0], color_handle, 8)
if gv.is_inner():
# Draw inner handle when selected
p1 = gv.gedge_inner.get_outer_gvert_at(gv).position
draw3d_polyline(context, [p0,p1], color_handle, 2, "GL_LINE_SMOOTH")
else:
# Draw both handles when gvert is selected
p3d = [ge.get_inner_gvert_at(gv).position for ge in gv.get_gedges_notnone() if not ge.is_zippered() and not ge.is_frozen()]
draw3d_points(context, p3d, color_handle, 8)
# Draw connecting line between handles
for p1 in p3d:
draw3d_polyline(context, [p0,p1], color_handle, 2, "GL_LINE_SMOOTH")
# Draw gvert handles on active gedge
if self.act_gedge and not self.act_gedge.is_frozen():
color_handle = (color_active[0], color_active[1], color_active[2], 1.00)
ge = self.act_gedge
if self.act_gedge.is_zippered():
p3d = [ge.gvert0.position, ge.gvert3.position]
draw3d_points(context, p3d, color_handle, 8)
else:
p3d = [gv.position for gv in ge.gverts()]
draw3d_points(context, p3d, color_handle, 8)
draw3d_polyline(context, [p3d[0], p3d[1]], color_handle, 2, "GL_LINE_SMOOTH")
draw3d_polyline(context, [p3d[2], p3d[3]], color_handle, 2, "GL_LINE_SMOOTH")
if False:
# draw each normal of each gvert
for p,n in zip(p3d,[gv.snap_norm for gv in ge.gverts()]):
draw3d_polyline(context, [p,p+n*0.1], color_handle, 1, "GL_LINE_SMOOTH")
if self.hov_gvert: #TODO, hover color
color_border = (color_selection[0], color_selection[1], color_selection[2], 1.00)
color_fill = (color_selection[0], color_selection[1], color_selection[2], 0.20)
gv = self.hov_gvert
p0,p1,p2,p3 = gv.get_corners()
p3d = [p0,p1,p2,p3,p0]
draw3d_quad(context, [p0,p1,p2,p3], color_fill)
draw3d_polyline(context, p3d, color_border, 1, "GL_LINE_STIPPLE")
bgl.glLineWidth(1)
bgl.glDepthRange(0.0, 1.0)
def restore_gl_defaults():
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_mouse(context, shape, style, alpha):
# shape and position
sc = context.scene
mouse_size = sc.screencast_keys_mouse_size
font_size = sc.screencast_keys_font_size
box_draw = sc.screencast_keys_box_draw
pos_x, pos_y = getDisplayLocation(context)
if sc.screencast_keys_mouse_position == 'left':
offset_x = pos_x
if sc.screencast_keys_mouse_position == 'right':
offset_x = context.region.width - pos_x - (mouse_size * MOUSE_RATIO)
offset_y = pos_y
if font_size > mouse_size:
offset_y += (font_size - mouse_size) / 2
shape_data = get_shape_data(shape)
bgl.glTranslatef(offset_x, offset_y, 0)
# color
r, g, b, a = sc.screencast_keys_text_color
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(r, g, b, alpha)
# inner shape for filled style
if style == "filled":
inner_shape = []
for i in shape_data:
inner_shape.append(i[0])
# outer shape
for i in shape_data:
shape_segment = i
shape_segment[0] = [mouse_size * k for k in shape_segment[0]]
shape_segment[1] = [mouse_size * k for k in shape_segment[1]]
shape_segment[2] = [mouse_size * k for k in shape_segment[2]]
shape_segment[3] = [mouse_size * k for k in shape_segment[3]]
# create the buffer
shape_buffer = bgl.Buffer(bgl.GL_FLOAT, [4, 3], shape_segment)
# create the map and draw the triangle fan
bgl.glMap1f(bgl.GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, shape_buffer)
bgl.glEnable(bgl.GL_MAP1_VERTEX_3)
if style == "outline":
bgl.glBegin(bgl.GL_LINE_STRIP)
else: # style == "filled"
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
for j in range(10):
bgl.glEvalCoord1f(j / 10.0)
x, y, z = shape_segment[3]
# make sure the last vertex is indeed the last one, to avoid gaps
bgl.glVertex3f(x, y, z)
bgl.glEnd()
bgl.glDisable(bgl.GL_MAP1_VERTEX_3)
# draw interior
if style == "filled":
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
for i in inner_shape:
j = [mouse_size * k for k in i]
x, y, z = j
bgl.glVertex3f(x, y, z)
bgl.glEnd()
bgl.glTranslatef(-offset_x, -offset_y, 0)
def draw_callback_px_box(self, context):
wm = context.window_manager
sc = context.scene
if not wm.screencast_keys_keys:
return
font_size = sc.screencast_keys_font_size
mouse_size = sc.screencast_keys_mouse_size
if sc.screencast_keys_mouse_position == 'right':
mouse_size = 25
box_draw = sc.screencast_keys_box_draw
pos_x, pos_y = getDisplayLocation(context)
# get text-width/height to resize the box
blf.size(0, sc.screencast_keys_font_size, 72)
box_width, box_height = sc.screencast_keys_box_width, 0
final = 0
row_count = 0
box_hide = sc.screencast_keys_box_hide
label_time_max = sc.screencast_keys_fade_time
for i in range(len(self.key)):
label_time = time.time() - self.time[i]
if label_time < label_time_max: # only display key-presses of last 4 seconds
box_width, box_height = getBoundingBox(box_width, box_height,
self.key[i])
row_count += 1
final = i + 1
box_hide = False
else:
break
# Got the size right, now draw box using proper colors
box_color_r, box_color_g, box_color_b, box_color_alpha = sc.screencast_keys_box_color
if box_draw and not box_hide:
padding_x = 16
padding_y = 12
x0 = max(0, pos_x - padding_x)
y0 = max(0, pos_y - padding_y)
x1 = pos_x + box_width + mouse_size * MOUSE_RATIO * 1.3 + padding_x
y1 = pos_y + max(mouse_size, font_size * row_count) + padding_y
positions = [[x0, y0], [x0, y1], [x1, y1], [x1, y0]]
settings = [[bgl.GL_QUADS, min(0.0, box_color_alpha)],
[bgl.GL_LINE_LOOP,
min(0.0, box_color_alpha)]]
for mode, box_alpha in settings:
bgl.glEnable(bgl.GL_BLEND)
bgl.glBegin(mode)
bgl.glColor4f(box_color_r, box_color_g, box_color_b,
box_color_alpha)
for v1, v2 in positions:
bgl.glVertex2f(v1, v2)
bgl.glEnd()
if sc.screencast_keys_show_operator:
draw_last_operator(context, pos_x, pos_y)
if sc.screencast_keys_timer_show:
draw_timer(context, pos_x, pos_y)
# get rid of status texts that aren't displayed anymore
self.key = self.key[:final]
self.time = self.time[:final]
def glSetDefaultOptions():
# bgl.glEnable(bgl.GL_MULTISAMPLE)
bgl.glEnable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_DEPTH_TEST)
def draw_callback(self, context):
ctx = bpy.context
region = context.region
rv3d = context.region_data
viewport_center = (region.x + region.width / 2,
region.y + region.height / 2)
view_vector = view3d_utils.region_2d_to_vector_3d(region, rv3d,
viewport_center)
ray_origin = view3d_utils.region_2d_to_origin_3d(region, rv3d,
viewport_center)
shader.bind()
bgl.glEnable(bgl.GL_DEPTH_TEST)
#Draw cursor
if self.show_cursor:
brush_radius = context.scene.normal_brush_props.radius
m = calc_vertex_transform_world(self.cursor_pos, self.cursor_normal)
mS = mathutils.Matrix.Scale(brush_radius, 4)
m = m @ mS
#Tangent to mesh
gpu.matrix.push()
gpu.matrix.multiply_matrix(m)
shader.uniform_float("color", (1, 0, 1, 1))
batchCircle.draw(shader)
gpu.matrix.pop()
#Brush normal direction
brush_type = context.scene.normal_brush_props.brush_type
brush_normal = context.scene.normal_brush_props.normal
if brush_type == "FIXED":
gpu.matrix.push()
m = calc_vertex_transform_world(self.cursor_pos, brush_normal)
gpu.matrix.multiply_matrix(m)
shader.uniform_float("color", (0, 1, 1, 1))
batchLine.draw(shader)
gpu.matrix.pop()
#Draw editable normals
shader.uniform_float("color", (1, 1, 0, 1))
normLength = context.scene.normal_brush_props.normal_length
mS = mathutils.Matrix.Scale(normLength, 4)
shader.uniform_float("color", (1, 1, 0, 1))
for obj in ctx.selected_objects:
if obj.type == 'MESH':
success = obj.update_from_editmode()
mesh = obj.data
mesh.calc_normals_split()
coordsNormals = []
for l in mesh.loops:
v = mesh.vertices[l.vertex_index]
coordsNormals.append(v.co)
coordsNormals.append(v.co + l.normal * normLength)
batchNormals = batch_for_shader(shader, 'LINES',
{"pos": coordsNormals})
gpu.matrix.push()
gpu.matrix.multiply_matrix(obj.matrix_world)
batchNormals.draw(shader)
gpu.matrix.pop()
bgl.glDisable(bgl.GL_DEPTH_TEST)
def draw_to_viewport(view_min, view_max, show_extra, label_counter,
tilegrid, sprytile_data, cursor_loc, region, rv3d,
middle_btn, context):
"""Draw the offscreen texture into the viewport"""
# Prepare some data that will be used for drawing
grid_size = SprytileGui.loaded_grid.grid
padding = SprytileGui.loaded_grid.padding
# Draw work plane
SprytileGui.draw_work_plane(grid_size, sprytile_data, cursor_loc,
region, rv3d, middle_btn)
# Setup GL for drawing the offscreen texture
bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
bgl.glBindTexture(bgl.GL_TEXTURE_2D, SprytileGui.texture)
# Backup texture filter
old_mag_filter = Buffer(bgl.GL_INT, [1])
bgl.glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
old_mag_filter)
# Set texture filter
bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER,
bgl.GL_NEAREST)
bgl.glEnable(bgl.GL_TEXTURE_2D)
bgl.glEnable(bgl.GL_BLEND)
# Draw the preview tile
if middle_btn is False:
SprytileGui.draw_preview_tile(context, region, rv3d)
# Calculate actual view size
view_size = int(view_max.x - view_min.x), int(view_max.y - view_min.y)
# Save the original scissor box, and then set new scissor setting
scissor_box = bgl.Buffer(bgl.GL_INT, [4])
bgl.glGetIntegerv(bgl.GL_SCISSOR_BOX, scissor_box)
bgl.glScissor(
int(view_min.x) + scissor_box[0],
int(view_min.y) + scissor_box[1], view_size[0], view_size[1])
# Draw the tile select UI
SprytileGui.draw_tile_select_ui(view_min, view_max, view_size,
SprytileGui.tex_size, grid_size,
padding, show_extra)
# restore opengl defaults
bgl.glScissor(scissor_box[0], scissor_box[1], scissor_box[2],
scissor_box[3])
bgl.glLineWidth(1)
bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER,
old_mag_filter[0])
# Draw label
if label_counter > 0:
import math
def ease_out_circ(t, b, c, d):
t /= d
t -= 1
return c * math.sqrt(1 - t * t) + b
font_id = 0
font_size = 16
pad = 5
box_pad = font_size + (pad * 2)
fade = label_counter
fade = ease_out_circ(fade, 0, SprytileGui.label_frames,
SprytileGui.label_frames)
fade /= SprytileGui.label_frames
bgl.glColor4f(0.0, 0.0, 0.0, 0.75 * fade)
bgl.glBegin(bgl.GL_QUADS)
uv = [(0, 0), (0, 1), (1, 1), (1, 0)]
vtx = [(view_min.x, view_max.y),
(view_min.x, view_max.y + box_pad),
(view_max.x, view_max.y + +box_pad),
(view_max.x, view_max.y)]
for i in range(4):
glTexCoord2f(uv[i][0], uv[i][1])
glVertex2f(vtx[i][0], vtx[i][1])
bgl.glEnd()
bgl.glColor4f(1.0, 1.0, 1.0, 1.0 * fade)
blf.size(font_id, font_size, 72)
x_pos = view_min.x + pad
y_pos = view_max.y + pad
label_string = "%dx%d" % (tilegrid.grid[0], tilegrid.grid[1])
if tilegrid.name != "":
label_string = "%s - %s" % (label_string, tilegrid.name)
blf.position(font_id, x_pos, y_pos, 0)
blf.draw(font_id, label_string)
bgl.glDisable(bgl.GL_BLEND)
bgl.glDisable(bgl.GL_TEXTURE_2D)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_midi_keyboard(self, mx, my, w, h, action=None, frame=0):
'''
Intented to create a keyboard where key widths are
accurately in position.
See http://www.mathpages.com/home/kmath043.htm
for the math.
This keyboard has following properties (x=octave width).
1. All white keys have equal width in front (W=x/7).
2. All black keys have equal width (B=x/12).
3. The narrow part of white keys C, D and E is W - B*2/3
4. The narrow part of white keys F, G, A, and B is W - B*3/4
'''
bgl.glEnable(bgl.GL_BLEND)
octaves = 7
octave_width = (w - 20) / octaves
wkw = octave_width / 7
bkw = octave_width / 12
cde = wkw - 2 * bkw / 3
fgab = wkw - 3 * bkw / 4
wkh = h
bkh = 0.60 * h
by = my + wkh - bkh
x = mx
y = my
white = (1.0, 1.0, 1.0, 1.0)
black = (0.0, 0.0, 0.0, 1.0)
# draw the white keys
fc_color = True
whitenotes = [0, 2, 4, 5, 7, 9, 11]
blacknotes_1 = [1, 3]
blacknotes_2 = [6, 8, 10]
for octave in range(octaves):
for i in range(7):
col = white
if action:
#print("XXXXXXXX", '%d"]' % (octave * 12 + whitenotes[i]))
fcurves = [fc for fc in action.fcurves if (fc.group.select or fc.select) and fc.data_path.endswith('%d"]' % (octave * 12 + whitenotes[i]))]
#fc = action.fcurves.find('["%s%d"]' % (action["channel_name"], octave * 12 + whitenotes[i]))
for fc in fcurves:
if fc.evaluate(frame) > 0:
debug.print("BGL", fc.data_path)
r, g, b = fc.color if fc_color else (1, 0, 0)
col = (r, g, b, 1.0)
self.draw_box(x, y, wkw, wkh, color=col)
x += (wkw + 1)
# draw the black keys
x = octave * 7 * (wkw + 1) + cde + mx + 1
for i in range(2):
col = black
if action:
fc = action.fcurves.find('["%s%d"]' % (action["channel_name"], octave * 12 + blacknotes_1[i]))
if fc:
if fc.evaluate(frame) > 0:
r, g, b = fc.color if fc_color else (1, 0, 0)
col = (r, g, b, 1.0)
self.draw_box(x, by, bkw, bkh, color=col)
x += cde + bkw + 1
x += fgab
for i in range(3):
col = black
if action:
fc = action.fcurves.find('["%s%d"]' % (action["channel_name"], octave * 12 + blacknotes_2[i]))
if fc:
if fc.evaluate(frame) > 0:
r, g, b = fc.color if fc_color else (1, 0, 0)
col = (r, g, b, 1.0)
self.draw_box(x, by, bkw, bkh, color=col)
x += fgab + bkw + 1
x += 1
def draw_callback_px(self, context):
"""Draws Code Editors Minimap and indentation marks"""
def draw_line(origin, length, thickness, vertical=False):
"""Drawing lines with polys, its faster"""
x = (origin[0] + thickness) if vertical else (origin[0] + length)
y = (origin[1] + length) if vertical else (origin[1] + thickness)
bgl.glBegin(bgl.GL_QUADS)
for v1, v2 in [origin, (x, origin[1]), (x, y), (origin[0], y)]:
bgl.glVertex2i(v1, v2)
bgl.glEnd()
return
# abort if another text editor
try:
if self.window == context.window and self.area == context.area:
bgl.glEnable(bgl.GL_BLEND)
else:
return
except:
return
start = time.clock()
# init params
font_id = 0
self.width = next(region.width for region in context.area.regions
if region.type == 'WINDOW')
self.height = next(region.height for region in context.area.regions
if region.type == 'WINDOW')
dpi_r = context.user_preferences.system.dpi / 72.0
self.left_edge = self.width - round(
dpi_r * (self.width + 5 * self.minimap_width) / 10.0)
self.right_edge = self.width - round(dpi_r * 15)
self.opacity = min(max(0, (self.width - self.min_width) / 100.0), 1)
# compute character dimensions
mcw = dpi_r * self.minimap_symbol_width # minimap char width
mlh = round(dpi_r * self.minimap_line_height) # minimap line height
fs = context.space_data.font_size
cw = round(dpi_r * round(2 + 0.6 * (fs - 4))) # char width
ch = round(dpi_r * round(2 + 1.3 * (fs - 2) +
((fs % 10) == 0))) # char height
#chfx = round(dpi_r * (2 + 1.3 * (fs - 2) + ((fs % 10) == 0))) # char height fixed
# panel background box
#self.tab_width = round(dpi_r * 25) if (self.tabs and len(bpy.data.texts) > 1) else 0
bgl.glColor4f(self.background.r, self.background.g, self.background.b,
(1 - self.bg_opacity) * self.opacity)
bgl.glBegin(bgl.GL_QUADS)
#bgl.glVertex2i(self.left_edge-self.tab_width, self.height)
bgl.glVertex2i(self.left_edge, self.height)
bgl.glVertex2i(self.right_edge, self.height)
bgl.glVertex2i(self.right_edge, 0)
#bgl.glVertex2i(self.left_edge-self.tab_width, 0)
bgl.glVertex2i(self.left_edge, 0)
bgl.glEnd()
# space = context.space_data
# if space.text:
# lines = len(space.text.lines)
# lines_digits = len(str(lines)) if space.show_line_numbers else 0
#### AQUI Y AHORA
#line numbers background
space = context.space_data
if space.text:
lines = len(space.text.lines)
lines_digits = len(str(lines)) if space.show_line_numbers else 0
self.line_bar_width = int(dpi_r * 5) + cw * (lines_digits)
# bgl.glColor4f(1, 0, 0, 0.3)
# for id in range(space.top, min(space.top+space.visible_lines+1, lines+1)):
# if id in [2, 1, 4, 8, 24, 55]:
# bgl.glBegin(bgl.GL_QUADS)
# bgl.glVertex2i(0, self.height-chfx*(id-space.top))
# bgl.glVertex2i(self.line_bar_width, self.height-chfx*(id-space.top))
# bgl.glVertex2i(self.line_bar_width, self.height-chfx*(id-1-space.top))
# bgl.glVertex2i(0, self.height-chfx*(id-1-space.top))
# bgl.glEnd()
# #bgl.glColor4f(1, 0, 0, 0.5)
#blf.size(font_id, fs, int(dpi_r)*72)
#blf.position(font_id, 2+int(0.5*cw*(len(str(lines))-len(str(id)))), self.height-ch*(id-space.top)+3, 0)
#blf.draw(font_id, '*')
# blf.position(font_id,
# 2+int(0.5*cw*(len(str(lines))-len(str(id)))),
# self.height-ch*(id-space.top)+3, 0)
# blf.draw(font_id, u'▓▓')
# minimap shadow
for id, intensity in enumerate([0.2, 0.1, 0.07, 0.05, 0.03, 0.02, 0.01]):
bgl.glColor4f(0.0, 0.0, 0.0, intensity * self.opacity)
bgl.glBegin(bgl.GL_LINE_STRIP)
#bgl.glVertex2i(self.left_edge-id-self.tab_width, 0)
#bgl.glVertex2i(self.left_edge-id-self.tab_width, self.height)
bgl.glVertex2i(self.left_edge - id, 0)
bgl.glVertex2i(self.left_edge - id, self.height)
bgl.glEnd()
# divider
# if self.tab_width:
# bgl.glColor4f(0.0, 0.0, 0.0, 0.2*self.opacity)
# bgl.glBegin(bgl.GL_LINE_STRIP)
# bgl.glVertex2i(self.left_edge, 0)
# bgl.glVertex2i(self.left_edge, self.height)
# bgl.glEnd()
# if there is text in window
if space.text and self.opacity:
# minimap horizontal sliding based on text block length
max_slide = max(0, mlh * (lines + self.height / ch) - self.height)
self.slide = int(max_slide * space.top / lines)
minimap_top_line = int(self.slide / mlh)
minimap_bot_line = int((self.height + self.slide) / mlh)
# draw minimap visible box
if self.in_minimap:
bgl.glColor4f(1.0, 1.0, 1.0, 0.1 * self.opacity)
else:
bgl.glColor4f(1.0, 1.0, 1.0, 0.07 * self.opacity)
bgl.glBegin(bgl.GL_QUADS)
bgl.glVertex2i(self.left_edge,
self.height - mlh * space.top + self.slide)
bgl.glVertex2i(self.right_edge,
self.height - mlh * space.top + self.slide)
bgl.glVertex2i(
self.right_edge,
self.height - mlh * (space.top + space.visible_lines) + self.slide)
bgl.glVertex2i(
self.left_edge,
self.height - mlh * (space.top + space.visible_lines) + self.slide)
bgl.glEnd()
# draw minimap code
for segment in self.segments[:-1]:
bgl.glColor4f(segment['col'][0], segment['col'][1],
segment['col'][2], 0.4 * self.opacity)
for id, element in enumerate(
segment['elements'][minimap_top_line:minimap_bot_line]):
loc_y = mlh * (id + minimap_top_line + 3) - self.slide
for sub_element in element:
draw_line(
(self.left_edge + int(mcw * (sub_element[0] + 4)),
self.height - loc_y),
int(mcw * (sub_element[1] - sub_element[0])),
int(0.5 * mlh))
# minimap code marks
bgl.glColor4f(self.segments[-2]['col'][0], self.segments[-2]['col'][1],
self.segments[-2]['col'][2],
0.3 * self.block_trans * self.opacity)
for id, element in enumerate(self.segments[-2]['elements']):
for sub_element in element:
if sub_element[
2] >= space.top or id < space.top + space.visible_lines:
draw_line(
(self.left_edge + int(mcw * (sub_element[0] + 4)),
self.height - mlh * (id + 3) + self.slide),
-int(mlh * (sub_element[2] - id - 1)), int(0.5 * mlh),
True)
# draw dotted indentation marks
bgl.glLineWidth(1.0 * dpi_r)
if space.text:
bgl.glColor4f(self.segments[0]['col'][0], self.segments[0]['col'][1],
self.segments[0]['col'][2], self.indent_trans)
for id, element in enumerate(
self.segments[-1]['elements'][space.top:space.top +
space.visible_lines]):
loc_y = id
for sub_element in element:
draw_line(
(int(dpi_r * 10) + cw *
(lines_digits + sub_element[0] + 4), self.height - ch *
(loc_y)), -ch, int(1 * dpi_r), True)
# draw code block marks
bgl.glColor4f(self.segments[-2]['col'][0], self.segments[-2]['col'][1],
self.segments[-2]['col'][2], self.block_trans)
for id, element in enumerate(self.segments[-2]['elements']):
for sub_element in element:
if sub_element[
2] >= space.top or id < space.top + space.visible_lines:
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2i(
int(dpi_r * 10 + cw * (lines_digits + sub_element[0])),
self.height - ch * (id + 1 - space.top))
bgl.glVertex2i(
int(dpi_r * 10 + cw * (lines_digits + sub_element[0])),
self.height - int(ch * (sub_element[2] - space.top)))
bgl.glVertex2i(
int(dpi_r * 10 + cw *
(lines_digits + sub_element[0] + 1)),
self.height - int(ch * (sub_element[2] - space.top)))
bgl.glEnd()
# tab dividers
# if self.tab_width and self.opacity:
# self.tab_height = min(200, int(self.height/len(bpy.data.texts)))
# y_loc = self.height-5
# for text in bpy.data.texts:
# # tab selection
# if text.name == self.in_tab:
# bgl.glColor4f(1.0, 1.0, 1.0, 0.05*self.opacity)
# bgl.glBegin(bgl.GL_QUADS)
# bgl.glVertex2i(self.left_edge-self.tab_width, y_loc)
# bgl.glVertex2i(self.left_edge, y_loc)
# bgl.glVertex2i(self.left_edge, y_loc-self.tab_height)
# bgl.glVertex2i(self.left_edge-self.tab_width, y_loc-self.tab_height)
# bgl.glEnd()
# # tab active
# if context.space_data.text and text.name == context.space_data.text.name:
# bgl.glColor4f(1.0, 1.0, 1.0, 0.05*self.opacity)
# bgl.glBegin(bgl.GL_QUADS)
# bgl.glVertex2i(self.left_edge-self.tab_width, y_loc)
# bgl.glVertex2i(self.left_edge, y_loc)
# bgl.glVertex2i(self.left_edge, y_loc-self.tab_height)
# bgl.glVertex2i(self.left_edge-self.tab_width, y_loc-self.tab_height)
# bgl.glEnd()
# bgl.glColor4f(0.0, 0.0, 0.0, 0.2*self.opacity)
# y_loc -= self.tab_height
# bgl.glBegin(bgl.GL_LINE_STRIP)
# bgl.glVertex2i(self.left_edge-self.tab_width, y_loc)
# bgl.glVertex2i(self.left_edge, y_loc)
# bgl.glEnd()
# draw fps
# bgl.glColor4f(1, 1, 1, 0.2)
# blf.size(font_id, fs, int(dpi_r*72))
# blf.position(font_id, self.left_edge-50, 5, 0)
# blf.draw(font_id, str(round(1/(time.clock() - start),3)))
# draw line numbers
# if space.text:
# bgl.glColor4f(1, 0, 0, 0.5)
# for id in range(space.top, min(space.top+space.visible_lines+1, lines+1)):
# blf.size(font_id, fs, int(dpi_r*72))
# blf.position(font_id, 2+int(0.5*cw*(len(str(lines))-len(str(id)))), self.height-ch*(id-space.top)+3, 0)
# blf.draw(font_id, '*')
# # # bgl.glColor4f(self.segments[0]['col'][0],
# # self.segments[0]['col'][1],
# # self.segments[0]['col'][2],
# # 0.5)
# for id in range(space.top, min(space.top+space.visible_lines+1, lines+1)):
# blf.position(font_id, 2+int(0.5*cw*(len(str(lines))-len(str(id)))), self.height-ch*(id-space.top)+3, 0)
# blf.draw(font_id, u'▓▓')
# draw file names
# if self.tab_width:
# blf.enable(font_id, blf.ROTATION)
# blf.rotation(font_id, 1.570796)
# y_loc = self.height
# for text in bpy.data.texts:
# text_max_length = max(2,int((self.tab_height - 40)/cw))
# name = text.name[:text_max_length]
# if text_max_length < len(text.name):
# name += '...'
# bgl.glColor4f(self.segments[0]['col'][0],
# self.segments[0]['col'][1],
# self.segments[0]['col'][2],
# (0.7 if text.name == self.in_tab else 0.4)*self.opacity)
# blf.position(font_id,
# self.left_edge-round((self.tab_width-ch)/2.0)-5,
# round(y_loc-(self.tab_height/2)-cw*len(name)/2),
# 0)
# blf.draw(font_id, name)
# y_loc -= self.tab_height
# restore opengl defaults
bgl.glColor4f(0, 0, 0, 1)
bgl.glLineWidth(1.0)
bgl.glDisable(bgl.GL_BLEND)
blf.disable(font_id, blf.ROTATION)
return
def glsl_draw(self):
if GlslDrawObj.myinstance is None and GlslDrawObj.draw_func is None:
glsl_draw_obj = GlslDrawObj()
glsl_draw_obj.build_scene()
else:
glsl_draw_obj = GlslDrawObj.myinstance
model_offset = Matrix.Translation((glsl_draw_obj.draw_x_offset, 0, 0))
light_pos = [
i + n
for i, n in zip(
glsl_draw_obj.light.location, [-glsl_draw_obj.draw_x_offset, 0, 0]
)
]
batches = glsl_draw_obj.batches
depth_shader = glsl_draw_obj.depth_shader
toon_shader = glsl_draw_obj.toon_shader
offscreen = glsl_draw_obj.offscreen
# need bone etc changed only update
depth_matrix = None
light = glsl_draw_obj.light
light_lookat = light.rotation_euler.to_quaternion() @ Vector((0, 0, -1))
# TODO このへん
tar = light_lookat.normalized()
up = light.rotation_euler.to_quaternion() @ Vector((0, 1, 0))
tmp_bound_len = Vector(glsl_draw_obj.bounding_center).length
camera_bias = 0.2
loc = Vector(
[
glsl_draw_obj.bounding_center[i]
+ tar[i] * (tmp_bound_len + camera_bias)
for i in range(3)
]
)
loc = model_offset @ loc
v_matrix = lookat_cross(loc, tar, up)
const_proj = 2 * max(glsl_draw_obj.bounding_size) / 2
p_matrix = ortho_proj_mat(
-const_proj, const_proj, -const_proj, const_proj, -const_proj, const_proj
)
depth_matrix = v_matrix @ p_matrix # reuse in main shader
depth_matrix.transpose()
# region shader depth path
with offscreen.bind():
bgl.glClearColor(10, 10, 10, 1)
bgl.glClear(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_DEPTH_BUFFER_BIT)
for bat in batches:
mat = bat[0]
mat.update()
depth_bat = bat[2]
depth_shader.bind()
bgl.glEnable(bgl.GL_BLEND)
if mat.alpha_method == "TRANSPARENT":
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
bgl.glDepthMask(bgl.GL_TRUE)
bgl.glEnable(bgl.GL_DEPTH_TEST)
elif mat.alpha_method == "OPAQUE":
bgl.glBlendFunc(bgl.GL_ONE, bgl.GL_ZERO)
bgl.glDepthMask(bgl.GL_TRUE)
bgl.glEnable(bgl.GL_DEPTH_TEST)
elif mat.alpha_method == "CLIP":
bgl.glBlendFunc(bgl.GL_ONE, bgl.GL_ZERO)
bgl.glDepthMask(bgl.GL_TRUE)
bgl.glEnable(bgl.GL_DEPTH_TEST)
if mat.cull_mode == "BACK":
bgl.glEnable(bgl.GL_CULL_FACE)
bgl.glCullFace(bgl.GL_BACK)
else:
bgl.glDisable(bgl.GL_CULL_FACE)
bgl.glEnable(bgl.GL_CULL_FACE) # そも輪郭線がの影は落ちる?
bgl.glCullFace(bgl.GL_BACK)
depth_shader.uniform_float(
"obj_matrix", model_offset
) # obj.matrix_world)
depth_shader.uniform_float("depthMVP", depth_matrix)
depth_bat.draw(depth_shader)
# endregion shader depth path
# region shader main
vp_mat = bpy.context.region_data.perspective_matrix
projection_mat = bpy.context.region_data.window_matrix
view_dir = bpy.context.region_data.view_matrix[2][:3]
view_up = bpy.context.region_data.view_matrix[1][:3]
normal_world_to_view_matrix = (
bpy.context.region_data.view_matrix.inverted_safe().transposed()
)
aspect = bpy.context.area.width / bpy.context.area.height
for is_outline in [0, 1]:
for bat in batches:
toon_bat = bat[1]
toon_shader.bind()
mat = bat[0]
if is_outline == 1 and mat.float_dic["OutlineWidthMode"] == 0:
continue
# mat.update() #already in depth path
bgl.glEnable(bgl.GL_BLEND)
bgl.glDepthMask(bgl.GL_TRUE)
bgl.glEnable(bgl.GL_DEPTH_TEST)
if mat.alpha_method == "TRANSPARENT":
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
elif mat.alpha_method == "OPAQUE":
bgl.glBlendFunc(bgl.GL_ONE, bgl.GL_ZERO)
elif mat.alpha_method == "CLIP":
bgl.glBlendFunc(bgl.GL_ONE, bgl.GL_ZERO)
if is_outline == 0:
if mat.cull_mode == "BACK":
bgl.glEnable(bgl.GL_CULL_FACE)
bgl.glCullFace(bgl.GL_BACK)
else:
bgl.glDisable(bgl.GL_CULL_FACE)
else:
bgl.glEnable(bgl.GL_CULL_FACE)
bgl.glCullFace(bgl.GL_BACK)
toon_shader.uniform_float(
"obj_matrix", model_offset
) # obj.matrix_world)
toon_shader.uniform_float("projectionMatrix", projection_mat)
toon_shader.uniform_float("viewProjectionMatrix", vp_mat)
toon_shader.uniform_float("viewDirection", view_dir)
toon_shader.uniform_float("viewUpDirection", view_up)
toon_shader.uniform_float(
"normalWorldToViewMatrix", normal_world_to_view_matrix
)
toon_shader.uniform_float("depthMVP", depth_matrix)
toon_shader.uniform_float("lightpos", light_pos)
toon_shader.uniform_float("aspect", aspect)
toon_shader.uniform_float("is_outline", is_outline)
toon_shader.uniform_float("isDebug", 0.0)
toon_shader.uniform_float(
"is_cutout", 1.0 if mat.alpha_method == "CLIP" else 0.0
)
float_keys = [
"CutoffRate",
"BumpScale",
"ReceiveShadowRate",
"ShadeShift",
"ShadeToony",
"RimLightingMix",
"RimFresnelPower",
"RimLift",
"ShadingGradeRate",
"LightColorAttenuation",
"IndirectLightIntensity",
"OutlineWidth",
"OutlineScaleMaxDistance",
"OutlineLightingMix",
"UV_Scroll_X",
"UV_Scroll_Y",
"UV_Scroll_Rotation",
"OutlineWidthMode",
"OutlineColorMode",
]
for k in float_keys:
toon_shader.uniform_float(k, mat.float_dic[k])
for k, v in mat.vector_dic.items():
toon_shader.uniform_float(k, v)
bgl.glActiveTexture(bgl.GL_TEXTURE0)
bgl.glBindTexture(bgl.GL_TEXTURE_2D, offscreen.color_texture)
bgl.glTexParameteri(
bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_S, bgl.GL_CLAMP_TO_EDGE
) # TODO
bgl.glTexParameteri(
bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_T, bgl.GL_CLAMP_TO_EDGE
)
toon_shader.uniform_int("depth_image", 0)
for i, k in enumerate(mat.texture_dic.keys()):
bgl.glActiveTexture(bgl.GL_TEXTURE1 + i)
texture = mat.texture_dic[k]
bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture.bindcode)
bgl.glTexParameteri(
bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_S, bgl.GL_CLAMP_TO_EDGE
) # TODO
bgl.glTexParameteri(
bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_T, bgl.GL_CLAMP_TO_EDGE
)
toon_shader.uniform_int(k, 1 + i)
toon_bat.draw(toon_shader)
def draw_callback_px(self, context):
# circle graphic, text, and slider
unify_settings = bpy.context.tool_settings.unified_paint_settings
strength = unify_settings.strength if self.uni_str else self.brush.strength
size = unify_settings.size if self.uni_size else self.brush.size
if self.graphic:
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(self.brushcolor.r, self.brushcolor.g, self.brushcolor.b,
strength * 0.25)
bgl.glBegin(bgl.GL_POLYGON)
for x, y in self.circlepoints:
bgl.glVertex2i(
int(size * x) + self.cur[0],
int(size * y) + self.cur[1])
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
if self.text != 'NONE' and self.doingstr:
if self.text == 'MEDIUM':
fontsize = 11
elif self.text == 'LARGE':
fontsize = 22
else:
fontsize = 8
font_id = 0
blf.size(font_id, fontsize, 72)
blf.shadow(font_id, 0, 0.0, 0.0, 0.0, 1.0)
blf.enable(font_id, blf.SHADOW)
if strength < 0.001:
text = "0.001"
else:
text = str(strength)[0:5]
textsize = blf.dimensions(font_id, text)
xpos = self.start[0] + self.offset[0]
ypos = self.start[1] + self.offset[1]
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(self.backcolor.r, self.backcolor.g, self.backcolor.b,
0.5)
bgl.glBegin(bgl.GL_POLYGON)
for x, y in self.rectpoints:
bgl.glVertex2i(
int(textsize[0] * x) + xpos,
int(textsize[1] * y) + ypos)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
blf.position(font_id, xpos, ypos, 0)
blf.draw(font_id, text)
blf.disable(font_id, blf.SHADOW)
if self.slider != 'NONE' and self.doingstr:
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(self.backcolor.r, self.backcolor.g, self.backcolor.b,
0.5)
xpos = self.start[0] + self.offset[0] - self.sliderwidth + (
32
if self.text == 'MEDIUM' else 64 if self.text == 'LARGE' else 23)
ypos = self.start[1] + self.offset[
1] - self.sliderheight # + (1 if self.slider != 'SMALL' else 0)
if strength <= 1.0:
sliderscale = strength
elif strength > 5.0:
sliderscale = strength / 10
elif strength > 2.0:
sliderscale = strength / 5
else:
sliderscale = strength / 2
bgl.glBegin(bgl.GL_POLYGON)
for x, y in self.rectpoints:
bgl.glVertex2i(
int(self.sliderwidth * x) + xpos,
int(self.sliderheight * y) + ypos - 1)
bgl.glEnd()
bgl.glColor4f(self.frontcolor.r, self.frontcolor.g, self.frontcolor.b,
0.8)
bgl.glBegin(bgl.GL_POLYGON)
for x, y in self.rectpoints:
bgl.glVertex2i(
int(self.sliderwidth * x * sliderscale) + xpos,
int(self.sliderheight * y * 0.75) + ypos)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def glEnableStipple(enable=True):
if enable:
bgl.glLineStipple(4, 0x5555)
bgl.glEnable(bgl.GL_LINE_STIPPLE)
else:
bgl.glDisable(bgl.GL_LINE_STIPPLE)
def gui_update(self, context):
xvalue = round(
bpy.context.object.modifiers["Array"].constant_offset_displace[0] *
10000) / 10000
yvalue = round(
bpy.context.object.modifiers["Array"].constant_offset_displace[1] *
10000) / 10000
zvalue = round(
bpy.context.object.modifiers["Array"].constant_offset_displace[2] *
10000) / 10000
font_id = 0 # XXX, need to find out how best to get this.
is_bool = False
is_bevel = False
is_bevel_3 = False
is_bevel_2 = False
is_solidify = False
is_multiselected = False
is_notselected = False
is_noactiveobject = False
multislist = bpy.context.selected_objects
activeobject = bpy.context.scene.objects.active
is_formerge = False
current_dir = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
user_preferences = bpy.context.user_preferences
#addon_pref = user_preferences.addons[current_dir].preferences
if len(multislist) > 1:
is_multiselected = True
if len(multislist) < 1:
is_notselected = True
if activeobject == None:
is_noactiveobject = True
for obj in bpy.context.selected_objects:
if obj.name.startswith("AP"):
is_formerge = True
pass
for mode in bpy.context.object.modifiers:
if mode.type == 'BEVEL':
if mode.limit_method == 'WEIGHT':
is_bevel = True
if mode.type == "BEVEL":
if mode.profile > 0.70 and mode.profile < 0.72:
is_bevel_3 = True
#print("Bevel 3 is true")
if mode.type == "BEVEL":
if mode.limit_method == 'ANGLE' or mode.limit_method == 'NONE':
is_bevel_2 = True
#print("Bevel 2 is true")
if mode.type == 'BOOLEAN':
is_bool = True
if mode.type == 'SOLIDIFY':
is_solidify = True
arraycount = 0,
try:
arraycount = bpy.context.object.modifiers[self.id].count
except:
arraycount = 0
#Show Count
bgl.glEnable(bgl.GL_BLEND)
blf.position(font_id, self.click_pos[0],
self.click_pos[1] + 0.55 * get_dpi(), 0)
bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
blf.size(font_id, 36, get_dpi())
#blf.draw(font_id, str(bpy.context.object.modifiers[self.id].count))
# Underline Up Top
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
bgl.glLineWidth(int(0.032 * get_dpi()))
bgl.glBegin(bgl.GL_LINE_STRIP)
#bgl.glVertex2d(20, 40)
for n in range(-1, int(2.9 * get_dpi())):
bgl.glVertex2i(self.click_pos[0] + n + 2,
self.click_pos[1] + int(get_dpi() / 3.2))
bgl.glEnd()
# draw some text / Needs To Show Axis
bgl.glEnable(bgl.GL_BLEND)
blf.position(font_id, self.click_pos[0],
self.click_pos[1] + 0.1 * get_dpi(), 0)
bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
blf.size(font_id, 12, get_dpi())
blf.draw(font_id, "Array | Axis(X/Y/Z)")
# draw some text / Needs To Show Axis
'''
bgl.glEnable(bgl.GL_BLEND)
blf.position(font_id, self.click_pos[0], self.click_pos[1]+0.083 * get_dpi(), 0)
bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
blf.size(font_id, 12, get_dpi())
blf.draw(font_id, "Q >> X/Y/Z - Additional Array Axis" )
'''
# draw some text / Needs To Show Axis
bgl.glEnable(bgl.GL_BLEND)
blf.position(font_id, self.click_pos[0],
self.click_pos[1] - 0.1 * get_dpi(), 0)
bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
blf.size(font_id, 12, get_dpi())
blf.draw(font_id, "R >> Radial Array Toggle")
# And Underline Up Top
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
bgl.glLineWidth(int(0.032 * get_dpi()))
bgl.glBegin(bgl.GL_LINE_STRIP)
for n in range(-1, int(2.9 * get_dpi())):
bgl.glVertex2i(self.click_pos[0] + n + 2,
self.click_pos[1] + int(get_dpi() / 26) - 30)
bgl.glEnd()
#Show X
bgl.glEnable(bgl.GL_BLEND)
blf.position(font_id, self.click_pos[0],
self.click_pos[1] - 0.400 * get_dpi(), 0)
bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
blf.size(font_id, 12, get_dpi())
blf.draw(font_id, "x: " + str(xvalue))
#Show y
bgl.glEnable(bgl.GL_BLEND)
blf.position(font_id, self.click_pos[0],
self.click_pos[1] - 0.600 * get_dpi(), 0)
bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
blf.size(font_id, 12, get_dpi())
blf.draw(font_id, "y: " + str(yvalue))
#Show z
bgl.glEnable(bgl.GL_BLEND)
blf.position(font_id, self.click_pos[0],
self.click_pos[1] - 0.800 * get_dpi(), 0)
bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
blf.size(font_id, 12, get_dpi())
blf.draw(font_id, "z: " + str(zvalue))
#Show Additional Mesh Information
bgl.glEnable(bgl.GL_BLEND)
blf.position(font_id, self.click_pos[0], self.click_pos[1] - 1 * get_dpi(),
0)
bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
blf.size(font_id, 12, get_dpi())
if is_bevel_2 == True:
#blf.draw(font_id, "Standard Mesh")
blf.draw(font_id, "Adding Array On A Bevelled Mesh")
elif is_bevel_3 == True:
#blf.draw(font_id, "CStep / Sstep")
blf.draw(font_id, "Adding Array On A (C/S)Stepped Mesh")
elif is_bevel == True:
#blf.draw(font_id, "CSsharp / Ssharp")
blf.draw(font_id, "Adding Array On A CSharpened Mesh")
elif is_bool == True:
#blf.draw(font_id, "Pending Boolean")
blf.draw(font_id, "There Is A Pending Boolean On This Mesh")
else:
blf.draw(font_id, "Normal Mesh ")
'''
if addon_pref.Diagnostics_Mode :
#Diagnostic
bgl.glEnable(bgl.GL_BLEND)
blf.position(font_id, self.click_pos[0], self.click_pos[1]-27, 0)
bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
blf.size(font_id, 12, get_dpi())
blf.draw(font_id, "Standard is - " + str(is_bevel_2) + " " + "Sstep is - " + str(is_bevel_3)+ " " + "CSharp is - " + str(is_bevel))
'''
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_view():
######################
######## BIND ########
######################
first_time = not bgl.glIsVertexArray(namespace['vao'][0])
if first_time:
namespace['uniform_set'] = False
# Unlike VBOs, a VAO has to be generated and deleted from within the draw callback in which it will be bound.
bgl.glGenVertexArrays(1, namespace['vao'])
bgl.glBindVertexArray(namespace['vao'][0])
float_byte_count = 4
# Attribute: "point", 3D float vector
bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, namespace['vbo_point'][0])
bgl.glBufferData(bgl.GL_ARRAY_BUFFER,
len(namespace['data_point']) * float_byte_count,
namespace['data_point'], bgl.GL_DYNAMIC_DRAW)
bgl.glVertexAttribPointer(0, 3, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None)
bgl.glEnableVertexAttribArray(0)
# Attribute: "color", 4D float vector
bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, namespace['vbo_color'][0])
bgl.glBufferData(bgl.GL_ARRAY_BUFFER,
len(namespace['data_color']) * float_byte_count,
namespace['data_color'], bgl.GL_DYNAMIC_DRAW)
bgl.glVertexAttribPointer(1, 4, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None)
bgl.glEnableVertexAttribArray(1)
bgl.glBindVertexArray(0)
######################
######## DRAW ########
######################
bgl.glEnable(bgl.GL_BLEND)
bgl.glUseProgram(namespace['shader_program'])
if not namespace['uniform_set']:
bgl.glUniformMatrix4fv(
namespace['perspective_uniform_location'],
1,
bgl.
GL_TRUE, # Matrices in Blender are row-major while matrices in OpenGL are column-major, so Blender's perspective matrix has to be transposed for OpenGL.
namespace['projection_matrix'])
# In this case I only want to update the uniform once, even though namespace['projection_matrix'] is being updated constantly.
namespace['uniform_set'] = True
bgl.glBindVertexArray(namespace['vao'][0])
bgl.glDrawArrays(bgl.GL_TRIANGLES, 0, 3)
bgl.glUseProgram(0)
bgl.glBindVertexArray(0)
bgl.glDisable(bgl.GL_BLEND)
def draw_3D_stuff(self):
context = self.context
region,r3d = context.region,context.space_data.region_3d
view_dir = r3d.view_rotation * Vector((0,0,-1))
view_loc = r3d.view_location - view_dir * r3d.view_distance
view_ortho = (r3d.view_perspective == "ORTHO")
if view_ortho: view_loc -= view_dir * 1000.0
bgl.glEnable(bgl.GL_POINT_SMOOTH)
bgl.glDepthRange(0.0, 1.0)
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glLineWidth(1)
bgl.glDepthRange(0.0, 1.0)
if self._state != "segmentation":
#CurveNetwork, BezierSegments
for seg in self.spline_net.segments:
if len(seg.draw_tessellation) == 0: continue
#has not been successfully converted to InputPoints and InputSegments
if seg.is_inet_dirty:
draw3d_polyline(seg.draw_tessellation, orange2, 4, view_loc, view_ortho)
#if len(seg.ip_tesselation):
# draw3d_polyline(seg.ip_tesselation, blue, 2, view_loc, view_ortho)
# draw3d_points(seg.ip_tesselation, green2, 4, view_loc, view_ortho)
draw3d_points(self.spline_net.point_world_locs, green2, 6, view_loc, view_ortho)
# Polylines...InputSegments
for seg in self.input_net.segments:
#bad segment with a preview path provided by geodesic
if seg.bad_segment and not len(seg.path) > 2:
draw3d_polyline([seg.ip0.world_loc, seg.ip1.world_loc], pink, 2, view_loc, view_ortho)
#s
elif len(seg.path) >= 2 and not seg.bad_segment and seg not in self.network_cutter.completed_segments:
draw3d_polyline(seg.path, blue, 2, view_loc, view_ortho)
elif len(seg.path) >= 2 and not seg.bad_segment and seg in self.network_cutter.completed_segments:
draw3d_polyline(seg.path, green2, 2, view_loc, view_ortho)
elif len(seg.path) >= 2 and seg.bad_segment:
draw3d_polyline(seg.path, orange2, 2, view_loc, view_ortho)
draw3d_polyline([seg.ip0.world_loc, seg.ip1.world_loc], orange2, 2, view_loc, view_ortho)
elif seg.calculation_complete == False:
draw3d_polyline([seg.ip0.world_loc, seg.ip1.world_loc], orange2, 2, view_loc, view_ortho)
else:
draw3d_polyline([seg.ip0.world_loc, seg.ip1.world_loc], blue2, 2, view_loc, view_ortho)
if self.network_cutter.the_bad_segment:
seg = self.network_cutter.the_bad_segment
draw3d_polyline([seg.ip0.world_loc, seg.ip1.world_loc], red, 4, view_loc, view_ortho)
if self._state == "segmentation":
#draw the hovered patch
#TODO, segmentation only happens AFTER CUtting
#So it would be MUCH easier to just draw the damn edges of the patch
if self.net_ui_context.hovered_near[0] == "PATCH":
p = self.net_ui_context.hovered_near[1]
if p != self.network_cutter.active_patch:
for spline_seg in p.spline_net_segments:
for iseg in spline_seg.input_segments:
draw3d_polyline([iseg.ip0.world_loc] + iseg.path + [iseg.ip1.world_loc], orange2, 4, view_loc, view_ortho)
if self.network_cutter.active_patch:
for spline_seg in self.network_cutter.active_patch.spline_net_segments:
for iseg in spline_seg.input_segments:
draw3d_polyline([iseg.ip0.world_loc] + iseg.path + [iseg.ip1.world_loc], orange2, 4, view_loc, view_ortho)
if self._state == "spline":
draw3d_points(self.input_net.point_world_locs, blue, 2, view_loc, view_ortho)
elif self._state != "segmentation":
draw3d_points(self.input_net.point_world_locs, blue, 6, view_loc, view_ortho)
#draw the seed/face patch points
draw3d_points([p.world_loc for p in self.network_cutter.face_patches], orange2, 6, view_loc, view_ortho)
#draw the actively processing Input Point (IP Steper Debug) for debug stepper cutting
if self.network_cutter.active_ip:
draw3d_points([self.network_cutter.active_ip.world_loc], purple, 20, view_loc, view_ortho)
draw3d_points([ip.world_loc for ip in self.network_cutter.ip_chain], purple, 12, view_loc, view_ortho)
if self.network_cutter.seg_enter:
draw3d_polyline(self.network_cutter.seg_enter.path, green2, 4, view_loc, view_ortho)
if self.network_cutter.seg_exit:
draw3d_polyline(self.network_cutter.seg_exit.path, red, 4, view_loc, view_ortho)
bgl.glLineWidth(1)
bgl.glDepthFunc(bgl.GL_LEQUAL)
bgl.glDepthRange(0.0, 1.0)
bgl.glDepthMask(bgl.GL_TRUE)
def draw_boundings(self, context):
for obj in bpy.data.objects:
if obj.type == 'MESH' and obj.data.b4w_override_boundings:
bounding_box = obj.data.b4w_boundings
min_x = bounding_box.min_x
max_x = bounding_box.max_x
min_y = bounding_box.min_y
max_y = bounding_box.max_y
min_z = bounding_box.min_z
max_z = bounding_box.max_z
x_width = max_x - min_x
y_width = max_y - min_y
z_width = max_z - min_z
cen = [0] * 3
cen[0] = (max_x + min_x) / 2
cen[1] = (max_y + min_y) / 2
cen[2] = (max_z + min_z) / 2
wm = obj.matrix_world
if context.window_manager.b4w_draw_bound_box:
bgl.glEnable(bgl.GL_BLEND)
bgl.glLineWidth(2)
# set colour
bgl.glColor4f(0.5, 1.0, 1.0, 1.0)
# draw boundings
bgl.glBegin(bgl.GL_LINE_STRIP)
co = mathutils.Vector((min_x, min_y, min_z))
co = wm * co
bgl.glVertex3f(co[0], co[1], co[2])
co = mathutils.Vector((max_x, min_y, min_z))
co = wm * co
bgl.glVertex3f(co[0], co[1], co[2])
co = mathutils.Vector((max_x, max_y, min_z))
co = wm * co
bgl.glVertex3f(co[0], co[1], co[2])
co = mathutils.Vector((min_x, max_y, min_z))
co = wm * co
bgl.glVertex3f(co[0], co[1], co[2])
bgl.glEnd()
bgl.glBegin(bgl.GL_LINE_STRIP)
co = mathutils.Vector((min_x, min_y, max_z))
co = wm * co
bgl.glVertex3f(co[0], co[1], co[2])
co = mathutils.Vector((min_x, min_y, min_z))
co = wm * co
bgl.glVertex3f(co[0], co[1], co[2])
co = mathutils.Vector((min_x, max_y, min_z))
co = wm * co
bgl.glVertex3f(co[0], co[1], co[2])
co = mathutils.Vector((min_x, max_y, max_z))
co = wm * co
bgl.glVertex3f(co[0], co[1], co[2])
bgl.glEnd()
bgl.glBegin(bgl.GL_LINE_STRIP)
co = mathutils.Vector((max_x, min_y, max_z))
co = wm * co
bgl.glVertex3f(co[0], co[1], co[2])
co = mathutils.Vector((min_x, min_y, max_z))
co = wm * co
bgl.glVertex3f(co[0], co[1], co[2])
co = mathutils.Vector((min_x, max_y, max_z))
co = wm * co
bgl.glVertex3f(co[0], co[1], co[2])
co = mathutils.Vector((max_x, max_y, max_z))
co = wm * co
bgl.glVertex3f(co[0], co[1], co[2])
bgl.glEnd()
bgl.glBegin(bgl.GL_LINE_STRIP)
co = mathutils.Vector((max_x, max_y, min_z))
co = wm * co
bgl.glVertex3f(co[0], co[1], co[2])
co = mathutils.Vector((max_x, max_y, max_z))
co = wm * co
bgl.glVertex3f(co[0], co[1], co[2])
co = mathutils.Vector((max_x, min_y, max_z))
co = wm * co
bgl.glVertex3f(co[0], co[1], co[2])
co = mathutils.Vector((max_x, min_y, min_z))
co = wm * co
bgl.glVertex3f(co[0], co[1], co[2])
bgl.glEnd()
bgl.glLineWidth(1)
if context.window_manager.b4w_draw_bound_sphere:
#draw spehere
bgl.glColor4f(1.0, 0.5, 1.0, 1.0)
r = math.sqrt(x_width * x_width + y_width * y_width +
z_width * z_width) / 2
draw_elipse(cen, r, (1, 0, 0), 1, wm)
draw_elipse(cen, r, (0, 1, 0), 1, wm)
draw_elipse(cen, r, (0, 0, 1), 1, wm)
bgl.glDisable(bgl.GL_BLEND)
if context.window_manager.b4w_draw_bound_ellipsoid:
#draw ellipsoid
bgl.glColor4f(1.0, 1.0, 0.5, 1.0)
sq3 = math.sqrt(3) / 2
draw_elipse(cen, sq3 * z_width, (1, 0, 0), y_width / z_width,
wm)
draw_elipse(cen, sq3 * x_width, (0, 1, 0), z_width / x_width,
wm)
draw_elipse(cen, sq3 * x_width, (0, 0, 1), y_width / x_width,
wm)
bgl.glDisable(bgl.GL_BLEND)
def draw_callback_px(self, context):
bgl.glColor4f(0, 1, 0.0, 0.9)
bgl.glEnable(bgl.GL_BLEND)
font_id = 0
so = bpy.context.selected_objects
v = []
vv = []
caml = 0.125 * sum(
(Vector(b) for b in bpy.context.scene.camera.bound_box), Vector())
camw = bpy.context.scene.camera.matrix_world * caml
objl = bpy.context.active_object
v.append(camw)
local_bbox_center = 0.125 * sum(
(Vector(b) for b in objl.bound_box), Vector())
#vv.append(local_bbox_center)
global_bbox_center = objl.matrix_world * local_bbox_center
#print(global_bbox_center)
v.append(global_bbox_center)
#for n in range(len(x)-1,-1,1):
# for objl in so:
# vx=[]
# vy=[]
# vz=[]
# local_bbox_center = 0.125 * sum((Vector(b) for b in objl.bound_box), Vector())
# #vv.append(local_bbox_center)
# global_bbox_center = objl.matrix_world * local_bbox_center
# #print(global_bbox_center)
# v.append(global_bbox_center)
# #for n in range(len(x)-1,-1,1):
v0 = v[0]
v1 = v[1]
x = (v1[0] - v0[0])**2
y = (v1[1] - v0[1])**2
z = (v1[2] - v0[2])**2
dist = sqrt(x + y + z)
dir = v1 - v0
print(dist)
print(dir)
verts2d = []
new2dCo = location_3d_to_region_2d(bpy.context.region, \
bpy.context.space_data.region_3d, \
v[0])
new2dCo1 = location_3d_to_region_2d(bpy.context.region, \
bpy.context.space_data.region_3d, \
v[1])
verts2d.append([new2dCo.x, new2dCo.y])
verts2d.append([new2dCo1.x, new2dCo1.y])
#print(ve)
bgl.glLineWidth(2)
bgl.glBegin(bgl.GL_LINE_LOOP)
for x, y in verts2d:
bgl.glVertex2f(x, y)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
#restore defaults
bgl.glLineWidth(1)
bgl.glColor4f(1, 1, 1, 1.0)
blf.position(font_id, 15, 30, 0)
blf.size(font_id, 20, 72)
blf.draw(font_id, "DISTANCIA:" + str(round(dist)))
return
def draw_callback_px(self, context):
# draw 3d point OpenGL in the 3D View
bgl.glEnable(bgl.GL_BLEND)
if self.bool_constrain:
if self.vector_constrain == Vector((1, 0, 0)):
Color4f = (self.axis_x_color + (1.0, ))
elif self.vector_constrain == Vector((0, 1, 0)):
Color4f = (self.axis_y_color + (1.0, ))
elif self.vector_constrain == Vector((0, 0, 1)):
Color4f = (self.axis_z_color + (1.0, ))
else:
Color4f = self.constrain_shift_color
else:
if self.type == 'OUT':
Color4f = self.out_color
elif self.type == 'FACE':
Color4f = self.face_color
elif self.type == 'EDGE':
Color4f = self.edge_color
elif self.type == 'VERT':
Color4f = self.vert_color
elif self.type == 'CENTER':
Color4f = self.center_color
elif self.type == 'PERPENDICULAR':
Color4f = self.perpendicular_color
bgl.glColor4f(*Color4f)
bgl.glDepthRange(0, 0)
bgl.glPointSize(10)
bgl.glBegin(bgl.GL_POINTS)
bgl.glVertex3f(*self.location)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
# draw 3d line OpenGL in the 3D View
bgl.glEnable(bgl.GL_BLEND)
bgl.glDepthRange(0, 0.9999)
bgl.glColor4f(1.0, 0.8, 0.0, 1.0)
bgl.glLineWidth(2)
bgl.glEnable(bgl.GL_LINE_STIPPLE)
bgl.glBegin(bgl.GL_LINE_STRIP)
for vert_co in self.list_vertices_co:
bgl.glVertex3f(*vert_co)
bgl.glVertex3f(*self.location)
bgl.glEnd()
# restore opengl defaults
bgl.glDepthRange(0, 1)
bgl.glPointSize(1)
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glDisable(bgl.GL_LINE_STIPPLE)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
a = ""
if self.list_vertices_co != [] and self.length_entered == "":
a = 'length: ' + str(
round((self.list_vertices_co[-1] - self.location).length, 3))
elif self.list_vertices_co != [] and self.length_entered != "":
a = 'length: ' + self.length_entered
context.area.header_text_set(
"hit: %.3f %.3f %.3f %s" %
(self.location[0], self.location[1], self.location[2], a))
def draw_callback_px(self, context):
allocate_main_ui(self, context)
shader = gpu.shader.from_builtin('2D_UNIFORM_COLOR')
shader.bind()
addon_prefs = context.preferences.addons[__package__].preferences
# main window background
main_window = self.areas["Main Window"]
outline_color = addon_prefs.qcd_ogl_widget_menu_back_outline
background_color = addon_prefs.qcd_ogl_widget_menu_back_inner
draw_rounded_rect(main_window,
shader,
outline_color[:] + (1, ),
outline=True)
draw_rounded_rect(main_window, shader, background_color)
# draw window title
window_title = self.areas["Window Title"]
x = window_title["vert"][0]
y = window_title["vert"][1]
h = window_title["height"]
text = window_title["value"]
text_color = addon_prefs.qcd_ogl_widget_menu_back_text
font_id = 0
blf.position(font_id, x, y, 0)
blf.size(font_id, int(h), 72)
blf.color(font_id, text_color[0], text_color[1], text_color[2], 1)
blf.draw(font_id, text)
# refresh shader - not sure why this is needed
shader.bind()
in_tooltip_area = False
for num in range(20):
slot_num = num + 1
qcd_slot = qcd_slots.get_name(f"{slot_num}")
if qcd_slot:
qcd_laycol = layer_collections[qcd_slot]["ptr"]
collection_objects = qcd_laycol.collection.objects
selected_objects = qcd_operators.get_move_selection()
active_object = qcd_operators.get_move_active()
button_area = self.areas[f"Button {slot_num}"]
# colors
button_color = addon_prefs.qcd_ogl_widget_tool_inner
icon_color = addon_prefs.qcd_ogl_widget_tool_text
if not qcd_laycol.exclude:
button_color = addon_prefs.qcd_ogl_widget_tool_inner_sel
icon_color = addon_prefs.qcd_ogl_widget_tool_text_sel
if mouse_in_area(self.mouse_pos, button_area):
in_tooltip_area = True
mod = 0.1
if button_color[0] + mod > 1 or button_color[
1] + mod > 1 or button_color[2] + mod > 1:
mod = -mod
button_color = (button_color[0] + mod, button_color[1] + mod,
button_color[2] + mod, button_color[3])
# button roundness
tl = tr = bl = br = 0
rounding = 5
if num < 10:
if not f"{num+2}" in qcd_slots:
tr = rounding
if not f"{num}" in qcd_slots:
tl = rounding
else:
if not f"{num+2}" in qcd_slots:
br = rounding
if not f"{num}" in qcd_slots:
bl = rounding
if num in [0, 5]:
tl = rounding
elif num in [4, 9]:
tr = rounding
elif num in [10, 15]:
bl = rounding
elif num in [14, 19]:
br = rounding
# draw button
outline_color = addon_prefs.qcd_ogl_widget_tool_outline
draw_rounded_rect(button_area,
shader,
outline_color[:] + (1, ),
tl,
tr,
bl,
br,
outline=True)
draw_rounded_rect(button_area, shader, button_color, tl, tr, bl,
br)
# ACTIVE OBJECT
if active_object and active_object in selected_objects and active_object.name in collection_objects:
active_object_indicator = self.areas[
f"Button {slot_num} Active Object Indicator"]
vertices = get_circle_coords(active_object_indicator)
shader.uniform_float("color", icon_color[:] + (1, ))
batch = batch_for_shader(shader, 'TRI_FAN', {"pos": vertices})
bgl.glEnable(bgl.GL_BLEND)
batch.draw(shader)
bgl.glDisable(bgl.GL_BLEND)
# SELECTED OBJECTS
elif not set(selected_objects).isdisjoint(collection_objects):
selected_object_indicator = self.areas[
f"Button {slot_num} Selected Object Indicator"]
alpha = addon_prefs.qcd_ogl_selected_icon_alpha
vertices = get_circle_coords(selected_object_indicator)
shader.uniform_float("color", icon_color[:] + (alpha, ))
batch = batch_for_shader(shader, 'LINE_STRIP',
{"pos": vertices})
bgl.glLineWidth(2 * scale_factor())
bgl.glEnable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_LINE_SMOOTH)
bgl.glHint(bgl.GL_LINE_SMOOTH_HINT, bgl.GL_NICEST)
batch.draw(shader)
bgl.glDisable(bgl.GL_LINE_SMOOTH)
bgl.glDisable(bgl.GL_BLEND)
# OBJECTS
elif collection_objects:
object_indicator = self.areas[
f"Button {slot_num} Object Indicator"]
alpha = addon_prefs.qcd_ogl_objects_icon_alpha
vertices, indices = get_coords(object_indicator)
shader.uniform_float("color", icon_color[:] + (alpha, ))
batch = batch_for_shader(shader,
'TRIS', {"pos": vertices},
indices=indices)
bgl.glEnable(bgl.GL_BLEND)
batch.draw(shader)
bgl.glDisable(bgl.GL_BLEND)
# X ICON
else:
X_icon = self.areas[f"X_icon {slot_num}"]
X_icon_color = addon_prefs.qcd_ogl_widget_menu_back_text
vertices, indices = get_x_coords(X_icon)
shader.uniform_float("color", X_icon_color[:] + (1, ))
batch = batch_for_shader(shader,
'TRIS', {"pos": vertices},
indices=indices)
bgl.glEnable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_POLYGON_SMOOTH)
bgl.glHint(bgl.GL_POLYGON_SMOOTH_HINT, bgl.GL_NICEST)
batch.draw(shader)
bgl.glDisable(bgl.GL_POLYGON_SMOOTH)
bgl.glDisable(bgl.GL_BLEND)
if in_tooltip_area:
if self.draw_tooltip:
draw_tooltip(
self, context, shader,
"Move Object To QCD Slot\n * Shift-Click to toggle objects\' slot"
)
self.hover_time = None
else:
if not self.hover_time:
self.hover_time = time.time()
def draw_callback_3d(operator, context):
scn = context.scene
dofu = scn.dof_utils
if is_camera(context.object):
cam_ob = context.object
elif is_camera(scn.camera):
cam_ob = scn.camera
else:
return
mat = cam_ob.matrix_world
cam = cam_ob.data
nmat = mat.normalized()
target_scale = (1, 1, 1)
smat = Matrix()
for i in range(3):
smat[i][i] = target_scale[i]
temp_matrix = nmat @ smat # cam_ob.matrix_world = nmat * smat
start = temp_matrix @ Vector((0, 0, -cam.clip_start))
end = temp_matrix @ Vector((0, 0, -cam.clip_end))
d = cam.dof.focus_distance
if cam.dof.focus_object is None:
near_limit, far_limit = dof_calculation(cam, d)
dof_loc = temp_matrix @ Vector((0, 0, -(near_limit)))
dof_loc_end = temp_matrix @ Vector((0, 0, -(far_limit)))
else:
pt = cam.dof.focus_object.matrix_world.translation
loc = intersect_point_line(pt, temp_matrix.translation,
temp_matrix @ Vector((0, 0, -1)))
d = ((loc[0] - start).length
) + cam.clip_start # respect the clipping start value
near_limit, far_limit = dof_calculation(cam, d)
dof_loc = temp_matrix @ Vector((0, 0, -(near_limit)))
dof_loc_end = temp_matrix @ Vector((0, 0, -(far_limit)))
dofu.limits = (d, near_limit, far_limit)
# 80% alpha, 2 pixel width line
bgl.glEnable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_LINE_SMOOTH)
bgl.glEnable(bgl.GL_DEPTH_TEST)
# check overlay
if dofu.overlay:
bgl.glDisable(bgl.GL_DEPTH_TEST)
else:
bgl.glEnable(bgl.GL_DEPTH_TEST)
# set line width
bgl.glLineWidth(2)
def line(color, start, end):
vertices = [start, end]
shader = gpu.shader.from_builtin('3D_UNIFORM_COLOR')
batch = batch_for_shader(shader, 'LINE_STRIP', {"pos": vertices})
shader.bind()
shader.uniform_float("color", color)
batch.draw(shader)
#bgl.glColor4f(*color)
#bgl.glBegin(bgl.GL_LINES)
#bgl.glVertex3f(*start)
#bgl.glVertex3f(*end)
#bgl.glEnd()
# define the lines
line((1.0, 1.0, 1.0, 0.1), dof_loc_end, end)
line((1.0, 1.0, 1.0, 0.1), dof_loc, start)
line((dofu.color_limits[0], dofu.color_limits[1], dofu.color_limits[2],
dofu.opacity_limits), dof_loc_end, dof_loc)
if dofu.size_limits > 0.0:
#draw_empty(matrix=temp_matrix, offset=-near_limit, size=1)
for i in [near_limit, far_limit]:
draw_circle(matrix=temp_matrix,
offset=-i,
color=(dofu.color_limits[0], dofu.color_limits[1],
dofu.color_limits[2], dofu.opacity_limits),
radius=dofu.size_limits,
fill=dofu.fill_limits,
num_segments=dofu.segments_limits)
if dofu.draw_focus:
draw_empty_2d(matrix=temp_matrix,
offset=-d,
size=dofu.size_limits * 1.7,
color=(dofu.color_limits[0], dofu.color_limits[1],
dofu.color_limits[2], dofu.opacity_limits))
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glDisable(bgl.GL_LINE_SMOOTH)
bgl.glEnable(bgl.GL_DEPTH_TEST)
def draw_callback_px(self, context):
# draw 3d point OpenGL in the 3D View
bgl.glEnable(bgl.GL_BLEND)
bgl.glDisable(bgl.GL_DEPTH_TEST)
# bgl.glPushMatrix()
# bgl.glMultMatrixf(self.obj_glmatrix)
if self.vector_constrain:
vc = self.vector_constrain
if hasattr(self, 'preloc') and self.type in {'VERT', 'FACE'}:
bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
bgl.glPointSize(5)
bgl.glBegin(bgl.GL_POINTS)
bgl.glVertex3f(*self.preloc)
bgl.glEnd()
if vc[2] == 'X':
Color4f = (self.axis_x_color + (1.0, ))
elif vc[2] == 'Y':
Color4f = (self.axis_y_color + (1.0, ))
elif vc[2] == 'Z':
Color4f = (self.axis_z_color + (1.0, ))
else:
Color4f = self.constrain_shift_color
else:
if self.type == 'OUT':
Color4f = self.out_color
elif self.type == 'FACE':
Color4f = self.face_color
elif self.type == 'EDGE':
Color4f = self.edge_color
elif self.type == 'VERT':
Color4f = self.vert_color
elif self.type == 'CENTER':
Color4f = self.center_color
elif self.type == 'PERPENDICULAR':
Color4f = self.perpendicular_color
else: # self.type == None
Color4f = self.out_color
bgl.glColor4f(*Color4f)
bgl.glPointSize(10)
bgl.glBegin(bgl.GL_POINTS)
bgl.glVertex3f(*self.location)
bgl.glEnd()
# draw 3d line OpenGL in the 3D View
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glDepthRange(0, 0.9999)
bgl.glColor4f(1.0, 0.8, 0.0, 1.0)
bgl.glLineWidth(2)
bgl.glEnable(bgl.GL_LINE_STIPPLE)
bgl.glBegin(bgl.GL_LINE_STRIP)
for vert_co in self.list_verts_co:
bgl.glVertex3f(*vert_co)
bgl.glVertex3f(*self.location)
bgl.glEnd()
# restore opengl defaults
# bgl.glPopMatrix()
bgl.glDepthRange(0, 1)
bgl.glPointSize(1)
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glDisable(bgl.GL_LINE_STIPPLE)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_rounded_rect(area,
shader,
color,
tl=5,
tr=5,
bl=5,
br=5,
outline=False):
sides = 32
tl = round(tl * scale_factor())
tr = round(tr * scale_factor())
bl = round(bl * scale_factor())
br = round(br * scale_factor())
bgl.glEnable(bgl.GL_BLEND)
if outline:
thickness = round(2 * scale_factor())
thickness = max(thickness, 2)
bgl.glLineWidth(thickness)
bgl.glEnable(bgl.GL_LINE_SMOOTH)
bgl.glHint(bgl.GL_LINE_SMOOTH_HINT, bgl.GL_NICEST)
draw_type = 'TRI_FAN' if not outline else 'LINE_STRIP'
# top left corner
vert_x = area["vert"][0] + tl
vert_y = area["vert"][1] - tl
tl_vert = (vert_x, vert_y)
vertices = [(vert_x, vert_y)] if not outline else []
for side in range(sides + 1):
if (8 <= side <= 16):
cosine = tl * cos(side * 2 * pi / sides) + vert_x
sine = tl * sin(side * 2 * pi / sides) + vert_y
vertices.append((cosine, sine))
batch = batch_for_shader(shader, draw_type, {"pos": vertices})
shader.bind()
shader.uniform_float("color", color)
batch.draw(shader)
# top right corner
vert_x = area["vert"][0] + area["width"] - tr
vert_y = area["vert"][1] - tr
tr_vert = (vert_x, vert_y)
vertices = [(vert_x, vert_y)] if not outline else []
for side in range(sides + 1):
if (0 <= side <= 8):
cosine = tr * cos(side * 2 * pi / sides) + vert_x
sine = tr * sin(side * 2 * pi / sides) + vert_y
vertices.append((cosine, sine))
batch = batch_for_shader(shader, draw_type, {"pos": vertices})
shader.bind()
shader.uniform_float("color", color)
batch.draw(shader)
# bottom left corner
vert_x = area["vert"][0] + bl
vert_y = area["vert"][1] - area["height"] + bl
bl_vert = (vert_x, vert_y)
vertices = [(vert_x, vert_y)] if not outline else []
for side in range(sides + 1):
if (16 <= side <= 24):
cosine = bl * cos(side * 2 * pi / sides) + vert_x
sine = bl * sin(side * 2 * pi / sides) + vert_y
vertices.append((cosine, sine))
batch = batch_for_shader(shader, draw_type, {"pos": vertices})
shader.bind()
shader.uniform_float("color", color)
batch.draw(shader)
# bottom right corner
vert_x = area["vert"][0] + area["width"] - br
vert_y = area["vert"][1] - area["height"] + br
br_vert = (vert_x, vert_y)
vertices = [(vert_x, vert_y)] if not outline else []
for side in range(sides + 1):
if (24 <= side <= 32):
cosine = br * cos(side * 2 * pi / sides) + vert_x
sine = br * sin(side * 2 * pi / sides) + vert_y
vertices.append((cosine, sine))
batch = batch_for_shader(shader, draw_type, {"pos": vertices})
shader.bind()
shader.uniform_float("color", color)
batch.draw(shader)
if not outline:
vertices = []
indices = []
base_ind = 0
# left edge
width = max(tl, bl)
le_x = tl_vert[0] - tl
vertices.extend([(le_x, tl_vert[1]), (le_x + width, tl_vert[1]),
(le_x, bl_vert[1]), (le_x + width, bl_vert[1])])
indices.extend([(base_ind, base_ind + 1, base_ind + 2),
(base_ind + 2, base_ind + 3, base_ind + 1)])
base_ind += 4
# right edge
width = max(tr, br)
re_x = tr_vert[0] + tr
vertices.extend([(re_x, tr_vert[1]), (re_x - width, tr_vert[1]),
(re_x, br_vert[1]), (re_x - width, br_vert[1])])
indices.extend([(base_ind, base_ind + 1, base_ind + 2),
(base_ind + 2, base_ind + 3, base_ind + 1)])
base_ind += 4
# top edge
width = max(tl, tr)
te_y = tl_vert[1] + tl
vertices.extend([(tl_vert[0], te_y), (tl_vert[0], te_y - width),
(tr_vert[0], te_y), (tr_vert[0], te_y - width)])
indices.extend([(base_ind, base_ind + 1, base_ind + 2),
(base_ind + 2, base_ind + 3, base_ind + 1)])
base_ind += 4
# bottom edge
width = max(bl, br)
be_y = bl_vert[1] - bl
vertices.extend([(bl_vert[0], be_y), (bl_vert[0], be_y + width),
(br_vert[0], be_y), (br_vert[0], be_y + width)])
indices.extend([(base_ind, base_ind + 1, base_ind + 2),
(base_ind + 2, base_ind + 3, base_ind + 1)])
base_ind += 4
# middle
vertices.extend([tl_vert, tr_vert, bl_vert, br_vert])
indices.extend([(base_ind, base_ind + 1, base_ind + 2),
(base_ind + 2, base_ind + 3, base_ind + 1)])
batch = batch_for_shader(shader,
'TRIS', {"pos": vertices},
indices=indices)
shader.uniform_float("color", color)
batch.draw(shader)
else:
overlap = round(thickness / 2 - scale_factor() / 2)
# left edge
le_x = tl_vert[0] - tl
vertices = [(le_x, tl_vert[1] + (overlap if tl == 0 else 0)),
(le_x, bl_vert[1] - (overlap if bl == 0 else 0))]
batch = batch_for_shader(shader, 'LINE_STRIP', {"pos": vertices})
batch.draw(shader)
# right edge
re_x = tr_vert[0] + tr
vertices = [(re_x, tr_vert[1] + (overlap if tr == 0 else 0)),
(re_x, br_vert[1] - (overlap if br == 0 else 0))]
batch = batch_for_shader(shader, 'LINE_STRIP', {"pos": vertices})
batch.draw(shader)
# top edge
te_y = tl_vert[1] + tl
vertices = [(tl_vert[0] - (overlap if tl == 0 else 0), te_y),
(tr_vert[0] + (overlap if tr == 0 else 0), te_y)]
batch = batch_for_shader(shader, 'LINE_STRIP', {"pos": vertices})
batch.draw(shader)
# bottom edge
be_y = bl_vert[1] - bl
vertices = [(bl_vert[0] - (overlap if bl == 0 else 0), be_y),
(br_vert[0] + (overlap if br == 0 else 0), be_y)]
batch = batch_for_shader(shader, 'LINE_STRIP', {"pos": vertices})
batch.draw(shader)
bgl.glDisable(bgl.GL_LINE_SMOOTH)
bgl.glDisable(bgl.GL_BLEND)
def draw_postpixel(self):
# TODO: put all logic into set_next_state(), such as vertex snapping, edge splitting, etc.
#if self.rfcontext.nav or self.mode != 'main': return
if not self.actions.using_onlymods('insert'): return # 'insert alt1'??
hit_pos = self.actions.hit_pos
if not hit_pos: return
self.set_next_state()
bgl.glEnable(bgl.GL_BLEND)
CC_DRAW.stipple(pattern=[4, 4])
CC_DRAW.point_size(8)
CC_DRAW.line_width(2)
if self.next_state == 'knife selected edge':
bmv1, bmv2 = self.nearest_edge.verts
faces = self.nearest_edge.link_faces
if faces:
for f in faces:
lco = []
for v0, v1 in iter_pairs(f.verts, True):
lco.append(v0.co)
if (v0 == bmv1 and v1 == bmv2) or (v0 == bmv2
and v1 == bmv1):
lco.append(hit_pos)
self.draw_lines(lco)
else:
self.draw_lines([bmv1.co, hit_pos])
self.draw_lines([bmv2.co, hit_pos])
elif self.next_state == 'new vertex':
p0 = hit_pos
e1, d = self.rfcontext.nearest2D_edge(edges=self.vis_edges)
if e1:
bmv1, bmv2 = e1.verts
if d is not None and d < self.rfcontext.drawing.scale(15):
f = next(iter(e1.link_faces), None)
if f:
lco = []
for v0, v1 in iter_pairs(f.verts, True):
lco.append(v0.co)
if (v0 == bmv1 and v1 == bmv2) or (v0 == bmv2
and v1 == bmv1):
lco.append(p0)
self.draw_lines(lco)
else:
self.draw_lines([bmv1.co, hit_pos])
self.draw_lines([bmv2.co, hit_pos])
else:
self.draw_lines([hit_pos])
else:
self.draw_lines([hit_pos])
elif self.next_state in {'vert-edge', 'vert-edge-vert'}:
sel_verts = self.sel_verts
bmv0 = next(iter(sel_verts))
if self.nearest_vert:
p0 = self.nearest_vert.co
elif self.next_state == 'vert-edge':
p0 = hit_pos
e1, d = self.rfcontext.nearest2D_edge(edges=self.vis_edges)
if e1:
bmv1, bmv2 = e1.verts
if d is not None and d < self.rfcontext.drawing.scale(15):
f = next(iter(e1.link_faces), None)
if f:
lco = []
for v0, v1 in iter_pairs(f.verts, True):
lco.append(v0.co)
if (v0 == bmv1
and v1 == bmv2) or (v0 == bmv2
and v1 == bmv1):
lco.append(p0)
self.draw_lines(lco)
else:
self.draw_lines([bmv1.co, p0])
self.draw_lines([bmv2.co, p0])
elif self.next_state == 'vert-edge-vert':
p0 = hit_pos
else:
return
self.draw_lines([bmv0.co, p0])
elif self.actions.shift and not self.actions.ctrl:
if self.next_state in [
'edge-face', 'edge-quad', 'edge-quad-snap', 'tri-quad'
]:
nearest_vert, _ = self.rfcontext.nearest2D_vert(
verts=self.sel_verts,
max_dist=options['polypen merge dist'])
if nearest_vert:
self.draw_lines([nearest_vert.co, hit_pos])
elif not self.actions.shift and self.actions.ctrl:
if self.next_state == 'edge-face':
e0, _ = self.rfcontext.nearest2D_edge(
edges=self.sel_edges) #next(iter(self.sel_edges))
if not e0: return
e1, d = self.rfcontext.nearest2D_edge(edges=self.vis_edges)
if e1 and d < self.rfcontext.drawing.scale(15) and e0 == e1:
bmv1, bmv2 = e1.verts
p0 = hit_pos
f = next(iter(e1.link_faces), None)
if f:
lco = []
for v0, v1 in iter_pairs(f.verts, True):
lco.append(v0.co)
if (v0 == bmv1 and v1 == bmv2) or (v0 == bmv2
and v1 == bmv1):
lco.append(p0)
self.draw_lines(lco)
else:
self.draw_lines([bmv1.co, hit_pos])
self.draw_lines([bmv2.co, hit_pos])
else:
# self.draw_lines([hit_pos])
bmv1, bmv2 = e0.verts
if self.nearest_vert and not self.nearest_vert.select:
p0 = self.nearest_vert.co
else:
p0 = hit_pos
self.draw_lines([p0, bmv1.co, bmv2.co])
elif self.next_state == 'edge-quad':
# a Desmos construction of how this works: https://www.desmos.com/geometry/bmmx206thi
xy0, xy1, xy2, xy3 = self._get_edge_quad_verts()
if xy0 is None: return
co0 = self.rfcontext.raycast_sources_Point2D(xy0)[0]
co1 = self.rfcontext.raycast_sources_Point2D(xy1)[0]
co2 = self.rfcontext.raycast_sources_Point2D(xy2)[0]
co3 = self.rfcontext.raycast_sources_Point2D(xy3)[0]
self.draw_lines([co1, co2, co3, co0])
elif self.next_state == 'edge-quad-snap':
e0, _ = self.rfcontext.nearest2D_edge(edges=self.sel_edges)
e1 = self.nearest_edge
if not e0 or not e1: return
bmv0, bmv1 = e0.verts
bmv2, bmv3 = e1.verts
p0, p1 = self.rfcontext.Point_to_Point2D(
bmv0.co), self.rfcontext.Point_to_Point2D(bmv1.co)
p2, p3 = self.rfcontext.Point_to_Point2D(
bmv2.co), self.rfcontext.Point_to_Point2D(bmv3.co)
if intersect2d_segment_segment(p1, p2, p3, p0):
bmv2, bmv3 = bmv3, bmv2
# if e0.vector2D(self.rfcontext.Point_to_Point2D).dot(e1.vector2D(self.rfcontext.Point_to_Point2D)) > 0:
# bmv2,bmv3 = bmv3,bmv2
self.draw_lines([bmv0.co, bmv1.co, bmv2.co, bmv3.co])
elif self.next_state == 'tri-quad':
if self.nearest_vert and not self.nearest_vert.select:
p0 = self.nearest_vert.co
else:
p0 = hit_pos
e1, _ = self.rfcontext.nearest2D_edge(edges=self.sel_edges)
if not e1: return
bmv1, bmv2 = e1.verts
f = next(iter(e1.link_faces), None)
if not f: return
lco = []
for v0, v1 in iter_pairs(f.verts, True):
lco.append(v0.co)
if (v0 == bmv1 and v1 == bmv2) or (v0 == bmv2
and v1 == bmv1):
lco.append(p0)
self.draw_lines(lco)
def PS_draw_bgl(self, context):
if context.mode == 'EDIT_MESH': # context.active_object != None and context.active_object.select_get() and
#start_time = time.time()
props = context.preferences.addons[__package__].preferences
settings = context.scene.ps_set_
theme = context.preferences.themes['Default']
vertex_size = theme.view_3d.vertex_size
# Color
VA_Col = props.v_alone_color[0], props.v_alone_color[
1], props.v_alone_color[2], props.v_alone_color[3]
VE_Col = props.VE_color[0], props.VE_color[1], props.VE_color[
2], props.VE_color[3]
F_Col = props.F_color[0], props.F_color[1], props.F_color[
2], props.opacity
sel_Col = props.select_color[0], props.select_color[
1], props.select_color[2], 1.0
bgl.glEnable(bgl.GL_BLEND)
bgl.glLineWidth(props.edge_width)
bgl.glPointSize(vertex_size + props.verts_size)
bgl.glCullFace(bgl.GL_BACK)
if props.xray_ret == False:
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glEnable(bgl.GL_CULL_FACE)
if props.line_smooth:
bgl.glEnable(bgl.GL_LINE_SMOOTH)
#bgl.glDepthRange(0, 0.99999)
#bgl.glDepthFunc(600)
bgl.glDepthMask(False)
is_perspective = context.region_data.is_perspective
if is_perspective:
z_bias = props.z_bias / 350
else:
z_bias = 1.0
tool_retopo = active_tool().idname in tools_ret # Retopology Tools
if tool_retopo:
shader = shader_uni
else:
shader = shader_sm
shader.bind()
view_mat = context.region_data.perspective_matrix
shader.uniform_float("view_mat", view_mat)
shader.uniform_float("Z_Bias", z_bias)
shader.uniform_float("Z_Offset", props.z_offset)
if props.use_mod_ret:
depsgraph = context.evaluated_depsgraph_get()
uniques = context.objects_in_mode_unique_data
#uniques = context.selected_objects
#uniques = context.objects_in_mode
for obj in uniques:
if props.use_mod_ret:
if len(obj.modifiers) > 0:
depsgraph.update()
ob_eval = obj.evaluated_get(depsgraph)
me = ob_eval.to_mesh()
bm = bmesh.new()
bm.from_mesh(me, face_normals=True, use_shape_key=False)
bm.verts.ensure_lookup_table()
bm.edges.ensure_lookup_table()
bm.faces.ensure_lookup_table()
else:
bm = bmesh.from_edit_mesh(obj.data)
if len(bm.verts) <= props.maxP_retop:
# Если выбран инструмент ретопологии
if tool_retopo:
# все вертексы
vCo = [obj.matrix_world @ v.co for v in bm.verts]
vNm = [v.normal for v in bm.verts]
# --- FACES
if settings.draw_faces:
loop_triangles = bm.calc_loop_triangles()
faces_indices = [[
loop.vert.index for loop in looptris
] for looptris in loop_triangles]
FACES = batch_for_shader(shader,
'TRIS', {
"pos": vCo,
'nrm': vNm
},
indices=faces_indices)
shader.uniform_float("color", F_Col)
FACES.draw(shader)
# --- EDGES
if settings.draw_edges:
#edges_indices = [ [e.verts[0].index, e.verts[1].index] for e in bm.edges]
edges_ind = [e.index for e in bm.edges]
edges_cord = [
obj.matrix_world @ v.co for i in edges_ind
for v in bm.edges[i].verts
]
eNm = [
v.normal for i in edges_ind
for v in bm.edges[i].verts
]
EDGES = batch_for_shader(shader, 'LINES', {
"pos": edges_cord,
'nrm': eNm
})
shader.uniform_float("color", VE_Col)
EDGES.draw(shader)
# --- VERTS
# только одиночные вертексы
if settings.draw_verts:
vCo_one = [
obj.matrix_world @ v.co for v in bm.verts
if len(v.link_faces) < 1
] #not v.is_manifold] (not v.is_manifold and v.is_wire)
vCo_one_Nm = [
v.normal for v in bm.verts if len(v.link_faces) < 1
]
VERTS = batch_for_shader(shader, 'POINTS', {
"pos": vCo_one,
'nrm': vCo_one_Nm
})
shader.uniform_float("color", VA_Col)
VERTS.draw(shader)
# Если выбраны обычные инструменты
else:
# --- FACES
vCo = [obj.matrix_world @ v.co for v in bm.verts]
vNm = [v.normal for v in bm.verts]
v_len = len(vCo)
if settings.draw_faces:
loop_triangles = bm.calc_loop_triangles()
faces_indices = [[
loop.vert.index for loop in looptris
] for looptris in loop_triangles]
face_col = [F_Col for i in range(v_len)]
FACES = batch_for_shader(shader,
'TRIS', {
"pos": vCo,
"col": face_col,
'nrm': vNm
},
indices=faces_indices)
FACES.draw(shader)
# --- EDGES
if settings.draw_edges:
edges_ind = [e.index for e in bm.edges]
edges_cord = [
obj.matrix_world @ v.co for i in edges_ind
for v in bm.edges[i].verts
]
eNm = [
v.normal for i in edges_ind
for v in bm.edges[i].verts
]
edge_col = [VE_Col for i in range(len(edges_cord))]
for i, edge in enumerate(
bm.edges): # Окрашивание выделенных элементов
if edge.select:
ind = i * 2
ind2 = ind + 1
edge_col[ind] = sel_Col
edge_col[ind2] = sel_Col
#edges_indices = [ [e.verts[0].index, e.verts[1].index] for e in bm.edges]
EDGES = batch_for_shader(shader, 'LINES', {
"pos": edges_cord,
"col": edge_col,
'nrm': eNm
}) # , indices=edges_indices
EDGES.draw(shader)
# --- VERTS
if settings.draw_verts:
vert_col = [VE_Col for i in range(v_len)]
for i, vert in enumerate(
bm.verts): # Окрашивание выделенных элементов
if len(vert.link_faces) < 1:
vert_col[i] = VA_Col
if vert.select:
#face_col[i] = select_color_f
vert_col[i] = sel_Col
#edge_col[i] = sel_Col
VERTS = batch_for_shader(shader, 'POINTS', {
"pos": vCo,
"col": vert_col,
'nrm': vNm
})
if context.tool_settings.mesh_select_mode[0]:
VERTS.draw(shader)
if props.use_mod_ret:
bm.free()
""" if props.line_smooth:
bgl.glDisable(bgl.GL_LINE_SMOOTH) """
""" bgl.glDisable(bgl.GL_DEPTH_TEST)
def glSwitch(attr, value):
if value:
bgl.glEnable(attr)
else:
bgl.glDisable(attr)
def Draw_map_callback(self, context):
if context.area != Map.view3d_area:
return
elif context.area.type == 'PROPERTIES' and \
context.space_data.context != 'WORLD':
return
# Check if window area has changed for sticky zoom
theMap = Map.object[0]
if Map.region.width < Map.saved_region_width:
diff = Map.saved_region_width - Map.region.width
if theMap.origin.x + theMap.width > Map.saved_region_width:
if theMap.origin.x > 0:
theMap.origin.x -= diff
else:
theMap.width -= diff
else:
if Map.toolProps is not None:
if Map.toolProps.width > Map.toolProps_width:
theMap.origin.x -= diff
Map.toolProps_width = Map.toolProps.width
if theMap.origin.x < 0:
theMap.origin.x += diff
else:
diff = Map.region.width - Map.saved_region_width
if theMap.width > Map.saved_region_width:
theMap.width += diff
else:
if Map.toolProps is not None:
if Map.toolProps.width < Map.toolProps_width:
theMap.origin.x += diff
Map.toolProps_width = Map.toolProps.width
theMap.set_dimensions(theMap.width)
Map.saved_region_width = Map.region.width
# Latitude and longitude are set to an equidistant
# cylindrical projection with lat/long 0/0 exactly
# in the middle of the image.
zLong = theMap.width / 2
longFac = zLong / 180
zLat = theMap.height / 2
latFac = zLat / 90
crossChange = True
if not Map.action == 'PAN':
x = Map.mouse.x
y = Map.mouse.y
if x < theMap.origin.x or x > theMap.origin.x + theMap.width:
crossChange = False
x = 0
else:
testBoundary = theMap.origin.x + theMap.width
if testBoundary < Map.region.width:
rightBoundary = testBoundary
else:
rightBoundary = Map.region.width
if x > rightBoundary:
crossChange = False
x = rightBoundary
cX = x - zLong - theMap.origin.x
if longFac:
newLongitude = cX / longFac
else:
newLongitude = 0.0
if y < theMap.origin.y or y < 0:
crossChange = False
y = 0
elif y > theMap.origin.y + theMap.height:
crossChange = False
y = theMap.origin.y + theMap.height
cY = y - zLat - theMap.origin.y
if latFac:
newLatitude = cY / latFac
else:
newLatitude = 0.0
if newLatitude == Map.latitude and newLongitude == Map.longitude:
crossChange = False
else:
Map.latitude = newLatitude
Map.longitude = newLongitude
else:
if Map.grab.offset.x < Map.grab.spot.x:
off = Map.grab.spot.x - Map.grab.offset.x
theMap.origin.x -= off
else:
off = Map.grab.offset.x - Map.grab.spot.x
theMap.origin.x += off
if Map.grab.offset.y < Map.grab.spot.y:
off = Map.grab.spot.y - Map.grab.offset.y
theMap.origin.y -= off
else:
off = Map.grab.offset.y - Map.grab.spot.y
theMap.origin.y += off
Map.grab.spot.x = Map.mouse.x
Map.grab.spot.y = Map.mouse.y
Lx = theMap.origin.x
Ly = theMap.origin.y
# ---------------------
# Draw a textured quad
# ---------------------
if not Map.textureless:
bgl.glEnable(bgl.GL_BLEND)
if Map.glImage.bindcode == 0:
Map.load_gl_image()
bgl.glBindTexture(bgl.GL_TEXTURE_2D, Map.glImage.bindcode[0])
bgl.glEnable(bgl.GL_TEXTURE_2D)
bgl.glColor4f(1.0, 1.0, 1.0, Map.object[0].opacity)
bgl.glBegin(bgl.GL_QUADS)
bgl.glTexCoord2f(0.0, 0.0)
bgl.glVertex2f(Lx, Ly)
bgl.glTexCoord2f(1.0, 0.0)
bgl.glVertex2f(Lx + theMap.width, Ly)
bgl.glTexCoord2f(1.0, 1.0)
bgl.glVertex2f(Lx + theMap.width, Ly + theMap.height)
bgl.glTexCoord2f(0.0, 1.0)
bgl.glVertex2f(Lx, theMap.height + Ly)
bgl.glEnd()
bgl.glDisable(bgl.GL_TEXTURE_2D)
# -----------------------
# Output text for stats
# -----------------------
if Map.action == 'TIME' or Map.action == 'DAY' or Map.showInfo:
Map.show_text_in_viewport(Map.object[1])
# ---------------------
# draw the crosshair
# ---------------------
x = theMap.width / 2.0
if crossChange and not Map.lockCrosshair:
if Map.action != 'Y':
Sun.SP.Longitude = newLongitude
longitude = (Sun.SP.Longitude * x / 180.0) + x
bgl.glEnable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_LINES)
bgl.glLineWidth(1.0)
alpha = 1.0 if Map.action == 'Y' else 0.5
color = (0.894, 0.741, .510, alpha)
bgl.glColor4f(color[0], color[1], color[2], color[3])
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(Lx + longitude, Ly)
bgl.glVertex2f(Lx + longitude, Ly + theMap.height)
bgl.glEnd()
y = theMap.height / 2.0
if crossChange and not Map.lockCrosshair:
if Map.action != 'X':
Sun.SP.Latitude = newLatitude
latitude = (Sun.SP.Latitude * y / 90.0) + y
alpha = 1.0 if Map.action == 'X' else 0.5
color = (0.894, 0.741, .510, alpha)
bgl.glColor4f(color[0], color[1], color[2], color[3])
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(Lx, Ly + latitude)
bgl.glVertex2f(Lx + theMap.width, Ly + latitude)
bgl.glEnd()
# ---------------------
# draw the border
# ---------------------
bgl.glDisable(bgl.GL_BLEND)
color = (0.6, 0.6, .6, 1.0)
bgl.glColor4f(color[0], color[1], color[2], color[3])
bgl.glBegin(bgl.GL_LINE_LOOP)
bgl.glVertex2f(Lx, Ly)
bgl.glVertex2f(Lx + theMap.width, Ly)
bgl.glVertex2f(Lx + theMap.width, Ly + theMap.height)
bgl.glVertex2f(Lx, theMap.height + Ly)
bgl.glVertex2f(Lx, Ly)
bgl.glEnd()
if not Sun.ShowRiseSet or not Map.lineWidth:
bgl.glDisable(bgl.GL_LINES)
bgl.glFlush()
return
if Map.action == 'G':
draw_text_region()
# ------------------------
# draw the sunrise, sunset
# ------------------------
def draw_angled_line(color, angle, bx, by):
x = math.cos(angle) * radius
y = math.sin(angle) * radius
bgl.glColor4f(color[0], color[1], color[2], color[3])
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(bx, by)
bgl.glVertex2f(bx + x, by + y)
bgl.glEnd()
px = Lx + longitude
py = Ly + latitude
radius = 30 + Map.lineWidth * 10
if Sun.RiseSetOK and Map.lineWidth:
color = (0.2, 0.6, 1.0, 0.9)
angle = -(degToRad(Sun.Sunrise.azimuth) - math.pi / 2)
bgl.glLineWidth(Map.lineWidth)
draw_angled_line(color, angle, px, py)
color = (0.86, 0.18, 0.18, 0.9)
angle = -(degToRad(Sun.Sunset.azimuth) - math.pi / 2)
draw_angled_line(color, angle, px, py)
# ------------------------
# draw current time line
# ------------------------
if Map.textureless:
phi = degToRad(Sun.AzNorth) * -1
else:
phi = degToRad(Sun.Azimuth) * -1
x = math.sin(phi) * math.sin(-Sun.Theta) * (radius + 10)
y = math.sin(Sun.Theta) * math.cos(phi) * (radius + 10)
night = (0.24, 0.29, 0.94, 0.9)
day = (0.85, 0.77, 0.60, 0.9)
if Sun.SolarNoon.elevation < 0.0:
color = night
elif Sun.Elevation >= Sun.Sunrise.elevation:
if Sun.Time >= Sun.Sunset.time and \
Sun.Elevation <= Sun.Sunset.elevation:
color = night
else:
color = day
else:
color = night
bgl.glLineWidth(Map.lineWidth + 1.0)
bgl.glColor4f(color[0], color[1], color[2], color[3])
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(px, py)
bgl.glVertex2f(px + x, py + y)
bgl.glEnd()
bgl.glLineWidth(1.0)
bgl.glDisable(bgl.GL_LINES)
bgl.glFlush()
def draw_target_and_sources(self):
if not self.actions.r3d: return
if not self.loading_done: return
# if self.fps_low_warning: return # skip drawing if low FPS warning is showing
buf_matrix_target = self.rftarget_draw.rfmesh.xform.mx_p # self.rftarget_draw.buf_matrix_model
buf_matrix_target_inv = self.rftarget_draw.rfmesh.xform.imx_p # self.rftarget_draw.buf_matrix_inverse
buf_matrix_view = self.actions.r3d.view_matrix # XForm.to_bglMatrix(self.actions.r3d.view_matrix)
buf_matrix_view_invtrans = matrix_normal(self.actions.r3d.view_matrix) # XForm.to_bglMatrix(matrix_normal(self.actions.r3d.view_matrix))
buf_matrix_proj = self.actions.r3d.window_matrix # XForm.to_bglMatrix(self.actions.r3d.window_matrix)
view_forward = self.Vec_forward() # self.actions.r3d.view_rotation * Vector((0,0,-1))
# bgl.glEnable(bgl.GL_MULTISAMPLE)
# bgl.glEnable(bgl.GL_LINE_SMOOTH)
# bgl.glHint(bgl.GL_LINE_SMOOTH_HINT, bgl.GL_NICEST)
bgl.glEnable(bgl.GL_BLEND)
# bgl.glEnable(bgl.GL_POINT_SMOOTH)
if options['symmetry view'] != 'None' and self.rftarget.mirror_mod.xyz:
if options['symmetry view'] in {'Edge', 'Face'}:
# get frame of target, used for symmetry decorations on sources
ft = self.rftarget.get_frame()
# render sources
for rs,rfs in zip(self.rfsources, self.rfsources_draw):
rfs.draw(
view_forward, self.unit_scaling_factor,
buf_matrix_target, buf_matrix_target_inv,
buf_matrix_view, buf_matrix_view_invtrans, buf_matrix_proj,
1.00, 0.05, False, 0.5,
False,
symmetry=self.rftarget.mirror_mod.xyz,
symmetry_view=options['symmetry view'],
symmetry_effect=options['symmetry effect'],
symmetry_frame=ft,
)
elif options['symmetry view'] == 'Plane':
# draw symmetry planes
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glDepthFunc(bgl.GL_LEQUAL)
bgl.glDisable(bgl.GL_CULL_FACE)
drawing = Globals.drawing
a = pow(options['symmetry effect'], 2.0) # fudge this value, because effect is different with plane than edge/face
r = (1.0, 0.2, 0.2, a)
g = (0.2, 1.0, 0.2, a)
b = (0.2, 0.2, 1.0, a)
w2l = self.rftarget_draw.rfmesh.xform.w2l_point
l2w = self.rftarget_draw.rfmesh.xform.l2w_point
# for rfs in self.rfsources:
# corners = [self.Point_to_Point2D(l2w(p)) for p in rfs.get_local_bbox(w2l).corners]
# drawing.draw2D_lines(corners, (1,1,1,1))
corners = [ c for s in self.rfsources for c in s.get_local_bbox(w2l).corners ]
mx, Mx = min(c.x for c in corners), max(c.x for c in corners)
my, My = min(c.y for c in corners), max(c.y for c in corners)
mz, Mz = min(c.z for c in corners), max(c.z for c in corners)
cx, cy, cz = mx + (Mx - mx) / 2, my + (My - my) / 2, mz + (Mz - mz) / 2
mx, Mx = cx + (mx - cx) * 1.2, cx + (Mx - cx) * 1.2
my, My = cy + (my - cy) * 1.2, cy + (My - cy) * 1.2
mz, Mz = cz + (mz - cz) * 1.2, cz + (Mz - cz) * 1.2
if self.rftarget.mirror_mod.x:
quad = [ l2w(Point((0, my, mz))), l2w(Point((0, my, Mz))), l2w(Point((0, My, Mz))), l2w(Point((0, My, mz))) ]
drawing.draw3D_triangles([quad[0], quad[1], quad[2], quad[0], quad[2], quad[3]], [r, r, r, r, r, r])
if self.rftarget.mirror_mod.y:
quad = [ l2w(Point((mx, 0, mz))), l2w(Point((mx, 0, Mz))), l2w(Point((Mx, 0, Mz))), l2w(Point((Mx, 0, mz))) ]
drawing.draw3D_triangles([quad[0], quad[1], quad[2], quad[0], quad[2], quad[3]], [g, g, g, g, g, g])
if self.rftarget.mirror_mod.z:
quad = [ l2w(Point((mx, my, 0))), l2w(Point((mx, My, 0))), l2w(Point((Mx, My, 0))), l2w(Point((Mx, my, 0))) ]
drawing.draw3D_triangles([quad[0], quad[1], quad[2], quad[0], quad[2], quad[3]], [b, b, b, b, b, b])
# render target
# bgl.glEnable(bgl.GL_MULTISAMPLE)
# bgl.glEnable(bgl.GL_LINE_SMOOTH)
# bgl.glHint(bgl.GL_LINE_SMOOTH_HINT, bgl.GL_NICEST)
bgl.glEnable(bgl.GL_BLEND)
if True:
alpha_above,alpha_below = options['target alpha'],options['target hidden alpha']
cull_backfaces = options['target cull backfaces']
alpha_backface = options['target alpha backface']
self.rftarget_draw.draw(
view_forward, self.unit_scaling_factor,
buf_matrix_target, buf_matrix_target_inv,
buf_matrix_view, buf_matrix_view_invtrans, buf_matrix_proj,
alpha_above, alpha_below, cull_backfaces, alpha_backface,
True
)
def drawCallback():
if bpy.context.mode == 'EDIT_MESH':
obj = bpy.context.object
bl = obj.border_lines
if obj and obj.type == 'MESH' and obj.data:
if bl.borderlines_use:
mesh = obj.data
matrix_world = obj.matrix_world
settings = bpy.context.user_preferences.themes[0].view_3d
transform = settings.transform
edge_select = settings.edge_select
wire_edit = settings.wire_edit
wire = settings.wire
object_active = settings.object_active
glLineWidth(bl.borderlines_width)
draw_with_test = True
if bm_old[0] is None or not bm_old[0].is_valid:
bm = bm_old[0] = bmesh.from_edit_mesh(mesh)
else:
bm = bm_old[0]
no_depth = not bpy.context.space_data.use_occlude_geometry
if no_depth:
glDisable(GL_DEPTH_TEST)
draw_with_test = False
if bl.finer_lines_behind_use:
glLineWidth(bl.borderlines_width / 4.0)
draw_with_test = True
glBegin(GL_LINES)
if bl.custom_color_use:
glColor3f(*bl.custom_color)
for edge in bm.edges:
if edge.is_valid and edge.is_boundary:
coords = [
matrix_world * vert.co
for vert in edge.verts
]
for coord in coords:
glVertex3f(*coord)
else:
active = bm.select_history.active
for edge in bm.edges:
if edge.is_valid and edge.is_boundary and not edge.hide:
coords = [
matrix_world * vert.co
for vert in edge.verts
]
if active == edge:
drawColorSize(coords, transform)
elif edge.select:
drawColorSize(coords, edge_select)
else:
drawColorSize(coords, wire_edit)
glEnd()
glLineWidth(bl.borderlines_width)
glEnable(GL_DEPTH_TEST)
if draw_with_test:
glBegin(GL_LINES)
if bl.custom_color_use:
glColor3f(*bl.custom_color)
for edge in bm.edges:
if edge.is_valid and edge.is_boundary:
coords = [
matrix_world * vert.co
for vert in edge.verts
]
for coord in coords:
glVertex3f(*coord)
else:
active = bm.select_history.active
for edge in bm.edges:
if edge.is_valid and edge.is_boundary:
coords = [
matrix_world * vert.co
for vert in edge.verts
]
if active == edge:
drawColorSize(coords, transform)
elif edge.select:
drawColorSize(coords, edge_select)
else:
drawColorSize(coords, wire_edit)
glEnd()
elif bpy.context.mode == 'OBJECT':
for obj in bpy.context.visible_objects:
if obj and obj.type == 'MESH' and obj.data:
if (obj.show_wire or bpy.context.space_data.viewport_shade
== 'WIREFRAME'):
bl = obj.border_lines
if bl.borderlines_use:
mesh = obj.data
matrix_world = obj.matrix_world
settings = bpy.context.user_preferences.themes[
0].view_3d
wire = settings.wire
object_selected = settings.object_selected
counts = edge_face_count(mesh)
glLineWidth(bl.borderlines_width)
glBegin(GL_LINES)
if bl.custom_color_use:
glColor3f(*bl.custom_color)
elif obj == bpy.context.active_object and obj.select:
glColor3f(*settings.object_active)
elif obj.select:
glColor3f(*settings.object_selected)
else:
glColor3f(*settings.wire)
for edge, count in zip(mesh.edges, counts):
# border edges
if count == 1:
coords = [
matrix_world * Vector(mesh.vertices[i].co)
for i in edge.key
]
for coord in coords:
glVertex3f(*coord)
glEnd()
glLineWidth(1.0)
