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 draw_circle_select(m_coords, radius = 16, p_col = (0.7,0.8,1.0,0.6), enabled = False, sub = False):
if(enabled):
f_col = p_col
if sub:
f_col = (1.0, 0.5, 0.4, 0.6)
bgl.glEnable(bgl.GL_BLEND)
bgl.glBegin(bgl.GL_POLYGON)
bgl.glColor4f(f_col[0], f_col[1], f_col[2], f_col[3]/3)
point_x = m_coords[0]
point_y = m_coords[1]
radius = int(radius)
for x in range(0, radius*2):
bgl.glVertex2f(point_x + radius * math.cos(x * (360/(radius*2)) / 180 * 3.14159), point_y + radius * math.sin(x * (360/(radius*2)) / 180 * 3.14159))
bgl.glEnd()
bgl.glBegin(bgl.GL_LINES)
bgl.glColor4f(f_col[0], f_col[1], f_col[2], f_col[3])
for x in range(0, radius*2):
bgl.glVertex2f(point_x + radius * math.cos(x * (360 / (radius * 2)) / 180 * 3.14159),
point_y + radius * math.sin(x * (360 / (radius * 2)) / 180 * 3.14159))
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback_px(self, context):
if init_functions(self, context) == None:
return
region = context.region
rv3d = context.space_data.region_3d
points, guide_verts = init_functions(self, context)
arc_verts = get_arc_from_state(points, guide_verts, context)
# draw bevel, followed by symmetry line, then fillet edge loop
draw_polyline_from_coordinates(context, points, "GL_LINE_STIPPLE")
draw_polyline_from_coordinates(context, guide_verts, "GL_LINE_STIPPLE")
draw_polyline_from_coordinates(context, arc_verts, "GL_BLEND")
# draw arc verts, then radial centre
if DRAW_POINTS:
draw_points(context, arc_verts, 4.2, gl_col1)
draw_points(context, [guide_verts[1]], 5.2, gl_col2)
# draw bottom left, above object name the number of vertices in the fillet
draw_text(context, (65, 30), context.scene.NumVerts)
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
return
def draw_callback_px(self, context):
print("mouse points", len(self.mouse_path))
font_id = 0 # XXX, need to find out how best to get this.
# draw some text
blf.position(font_id, 15, 30, 0)
blf.size(font_id, 20, 72)
blf.draw(font_id, "Hello Word " + str(len(self.mouse_path)))
# 50% alpha, 2 pixel width line
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 0.5)
bgl.glLineWidth(2)
bgl.glBegin(bgl.GL_LINE_STRIP)
for x, y in self.mouse_path:
bgl.glVertex2i(x, y)
bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_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 draw(self, context, render=False):
if self.image is None:
return
bgl.glPushAttrib(bgl.GL_ENABLE_BIT)
p0 = self.pts[0]
p1 = self.pts[1]
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(*self.colour)
bgl.glRectf(p0.x, p0.y, p1.x, p1.y)
self.image.gl_load()
bgl.glEnable(bgl.GL_BLEND)
bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.image.bindcode[0])
bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_NEAREST)
bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST)
bgl.glEnable(bgl.GL_TEXTURE_2D)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
# bgl.glColor4f(1, 1, 1, 1)
bgl.glBegin(bgl.GL_QUADS)
bgl.glTexCoord2d(0, 0)
bgl.glVertex2d(p0.x, p0.y)
bgl.glTexCoord2d(0, 1)
bgl.glVertex2d(p0.x, p1.y)
bgl.glTexCoord2d(1, 1)
bgl.glVertex2d(p1.x, p1.y)
bgl.glTexCoord2d(1, 0)
bgl.glVertex2d(p1.x, p0.y)
bgl.glEnd()
self.image.gl_free()
bgl.glDisable(bgl.GL_TEXTURE_2D)
def draw3d_closed_polylines(context, lpoints, color, thickness, LINE_TYPE, mirror):
#if type(lpoints) is types.GeneratorType:
# lpoints = list(lpoints)
lpoints = [[mirror(pt) for pt in points] for points in lpoints]
if len(lpoints) == 0: return
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.glColor4f(*color)
for points in lpoints:
set_depthrange(0.0, 0.997, points)
bgl.glBegin(bgl.GL_LINE_STRIP)
for coord in chain(points,points[:1]):
bgl.glVertex3f(*coord)
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 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_polyline_from_points(context, points, color, thickness, LINE_TYPE):
'''
a simple way to draw a line
args:
points: a list of tuples representing x,y SCREEN coordinate eg [(10,30),(11,31),...]
color: tuple (r,g,b,a)
thickness: integer? maybe a float
LINE_TYPE: eg...bgl.GL_LINE_STIPPLE or
'''
if LINE_TYPE == "GL_LINE_STIPPLE":
bgl.glLineStipple(4, 0x5555) #play with this later
bgl.glEnable(bgl.GL_LINE_STIPPLE)
bgl.glEnable(bgl.GL_BLEND)
current_width = bgl.GL_LINE_WIDTH
bgl.glColor4f(*color)
bgl.glLineWidth(thickness)
bgl.glBegin(bgl.GL_LINE_STRIP)
for coord in points:
bgl.glVertex2f(*coord)
bgl.glEnd()
bgl.glLineWidth(1)
if LINE_TYPE == "GL_LINE_STIPPLE":
bgl.glDisable(bgl.GL_LINE_STIPPLE)
bgl.glEnable(bgl.GL_BLEND) # back to uninterupted lines
return
def draw_polyline_from_3dpoints(context, points_3d, color, thickness, LINE_TYPE):
'''
a simple way to draw a line
slow...becuase it must convert to screen every time
but allows you to pan and zoom around
args:
points_3d: a list of tuples representing x,y SCREEN coordinate eg [(10,30),(11,31),...]
color: tuple (r,g,b,a)
thickness: integer? maybe a float
LINE_TYPE: eg...bgl.GL_LINE_STIPPLE or
'''
points = [location_3d_to_region_2d(context.region, context.space_data.region_3d, loc) for loc in points_3d]
if LINE_TYPE == "GL_LINE_STIPPLE":
bgl.glLineStipple(4, 0x5555) #play with this later
bgl.glEnable(bgl.GL_LINE_STIPPLE)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(*color)
bgl.glLineWidth(thickness)
bgl.glBegin(bgl.GL_LINE_STRIP)
for coord in points:
bgl.glVertex2f(*coord)
bgl.glEnd()
if LINE_TYPE == "GL_LINE_STIPPLE":
bgl.glDisable(bgl.GL_LINE_STIPPLE)
bgl.glEnable(bgl.GL_BLEND) # back to uninterupted lines
bgl.glLineWidth(1)
return
def 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_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 __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_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 draw_callback_px(self, context):
kha_SystemImpl.frame()
bgl.glUseProgram(0)
bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0)
bgl.glBindBuffer(bgl.GL_ELEMENT_ARRAY_BUFFER, 0)
bgl.glDisable(bgl.GL_DEPTH_TEST)
bgl.glDepthFunc(bgl.GL_ALWAYS)
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 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 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 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 DRAW_RunResize(self, context):
# Restore opengl defaults
bgl.glDisable(bgl.GL_POINTS)
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
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_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_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_postpixel(self):
bgl.glPushAttrib(bgl.GL_ALL_ATTRIB_BITS)
bgl.glEnable(bgl.GL_BLEND)
bgl.glMatrixMode(bgl.GL_MODELVIEW)
bgl.glPushMatrix()
bgl.glLoadIdentity()
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glPushMatrix()
bgl.glLoadIdentity()
bgl.glColor4f(1,0,0,0.2) # TODO: use window background color??
bgl.glEnable(bgl.GL_BLEND)
bgl.glDisable(bgl.GL_DEPTH_TEST)
bgl.glBegin(bgl.GL_QUADS) # TODO: not use immediate mode
bgl.glVertex2f(-1, -1)
bgl.glVertex2f( 1, -1)
bgl.glVertex2f( 1, 1)
bgl.glVertex2f(-1, 1)
bgl.glEnd()
bgl.glPopMatrix()
bgl.glMatrixMode(bgl.GL_MODELVIEW)
bgl.glPopMatrix()
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glPopAttrib()
def draw_callback_px(self, context):
if context.mode == "EDIT_MESH":
en0 = context.scene.dt_custom_props.en0
font_id = 0
font_size = context.scene.dt_custom_props.fs
ob_act = context.active_object
bme = bmesh.from_edit_mesh(ob_act.data)
mtrx = ob_act.matrix_world
list_0 = [v.index for v in bme.verts if v.select]
if len(list_0) != 0:
p = bme.verts[list_0[0]].co.copy()
p_loc_2d = location_3d_to_region_2d(context.region,
context.space_data.region_3d,
p)
q = mtrx * bme.verts[list_0[0]].co.copy()
q_loc_2d = location_3d_to_region_2d(context.region,
context.space_data.region_3d,
q)
# -- -- -- -- distance to adjacent vertices
if context.scene.dt_custom_props.b0 == True:
list_ = [[v.index for v in e.verts]
for e in bme.verts[list_0[0]].link_edges]
for ek in list_:
vi = [i for i in ek if i != list_0[0]][0]
p1 = bme.verts[vi].co.copy()
loc_0_3d = mtrx * ((p + p1) * 0.5)
loc_0_2d = location_3d_to_region_2d(
context.region, context.space_data.region_3d, loc_0_3d)
bgl.glColor4f(1.0, 1.0, 0.0,
context.scene.dt_custom_props.a)
blf.position(font_id, loc_0_2d[0] + 4, loc_0_2d[1] + 4, 0)
blf.size(font_id, font_size,
context.user_preferences.system.dpi)
blf.draw(font_id, str(round((p - p1).length, 4)))
bgl.glLineStipple(4, 0xAAAA)
bgl.glEnable(bgl.GL_LINE_STIPPLE)
# -- -- -- -- distance to axis local global
if context.scene.dt_custom_props.b1 == True:
# -- -- -- -- local
if en0 == 'opt0':
# -- -- -- -- x axis
px = mtrx * Vector((0.0, p[1], p[2]))
px_loc_2d = location_3d_to_region_2d(
context.region, context.space_data.region_3d, px)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 0.0, 0.0,
context.scene.dt_custom_props.a)
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(q_loc_2d[0], q_loc_2d[1])
bgl.glVertex2f(px_loc_2d[0], px_loc_2d[1])
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
if context.scene.dt_custom_props.b2 == False:
lx = (q_loc_2d + px_loc_2d) * 0.5
bgl.glColor4f(1.0, 0.0, 0.0,
context.scene.dt_custom_props.a)
blf.position(font_id, lx[0] + 4, lx[1] + 4, 0)
blf.size(font_id, font_size,
context.user_preferences.system.dpi)
blf.draw(font_id, str(round(p[0], 4)))
# -- -- -- -- y axis
py = mtrx * Vector((p[0], 0.0, p[2]))
py_loc_2d = location_3d_to_region_2d(
context.region, context.space_data.region_3d, py)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 1.0, 0.0,
context.scene.dt_custom_props.a)
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(q_loc_2d[0], q_loc_2d[1])
bgl.glVertex2f(py_loc_2d[0], py_loc_2d[1])
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
if context.scene.dt_custom_props.b2 == False:
ly = (q_loc_2d + py_loc_2d) * 0.5
bgl.glColor4f(0.0, 1.0, 0.0,
context.scene.dt_custom_props.a)
blf.position(font_id, ly[0] + 4, ly[1] + 4, 0)
blf.size(font_id, font_size,
context.user_preferences.system.dpi)
blf.draw(font_id, str(round(p[1], 4)))
# -- -- -- -- z axis
pz = mtrx * Vector((p[0], p[1], 0.0))
pz_loc_2d = location_3d_to_region_2d(
context.region, context.space_data.region_3d, pz)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 1.0,
context.scene.dt_custom_props.a)
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(q_loc_2d[0], q_loc_2d[1])
bgl.glVertex2f(pz_loc_2d[0], pz_loc_2d[1])
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
if context.scene.dt_custom_props.b2 == False:
lz = (q_loc_2d + pz_loc_2d) * 0.5
bgl.glColor4f(0.0, 0.0, 1.0,
context.scene.dt_custom_props.a)
blf.position(font_id, lz[0] + 4, lz[1] + 4, 0)
blf.size(font_id, font_size,
context.user_preferences.system.dpi)
blf.draw(font_id, str(round(p[2], 4)))
# -- -- -- --
if context.scene.dt_custom_props.b2 == True and context.scene.dt_custom_props.b1 == True:
blf.size(font_id, font_size,
context.user_preferences.system.dpi)
bgl.glColor4f(1.0, 0.0, 0.0,
context.scene.dt_custom_props.a)
blf.position(
font_id, q_loc_2d[0] + 4,
q_loc_2d[1] + 4 + font_size + 4 + font_size + 4, 0)
blf.draw(font_id, 'x ' + str(round(p[0], 4)))
bgl.glColor4f(0.0, 1.0, 0.0,
context.scene.dt_custom_props.a)
blf.position(font_id, q_loc_2d[0] + 4,
q_loc_2d[1] + 4 + font_size + 4, 0)
blf.draw(font_id, 'y ' + str(round(p[1], 4)))
bgl.glColor4f(0.0, 0.0, 1.0,
context.scene.dt_custom_props.a)
blf.position(font_id, q_loc_2d[0] + 4, q_loc_2d[1] + 4,
0)
blf.draw(font_id, 'z ' + str(round(p[2], 4)))
# -- -- -- -- global
elif en0 == 'opt1':
# -- -- -- -- x axis
ip_x = intersect_line_plane(
q, q + (Vector((1.0, 0.0, 0.0)) * 0.1),
Vector((0.0, 1.0, 0.0)), Vector((1.0, 0.0, 0.0)))
ip_x_loc_2d = location_3d_to_region_2d(
context.region, context.space_data.region_3d, ip_x)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 0.0, 0.0,
context.scene.dt_custom_props.a)
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(q_loc_2d[0], q_loc_2d[1])
bgl.glVertex2f(ip_x_loc_2d[0], ip_x_loc_2d[1])
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
if context.scene.dt_custom_props.b2 == False:
loc_1_2d = (q_loc_2d + ip_x_loc_2d) * 0.5
bgl.glColor4f(1.0, 0.0, 0.0,
context.scene.dt_custom_props.a)
blf.position(font_id, loc_1_2d[0] + 4, loc_1_2d[1] + 4,
0)
blf.size(font_id, font_size,
context.user_preferences.system.dpi)
blf.draw(font_id, str(round((q - ip_x).length, 4)))
# -- -- -- -- y axis
ip_y = intersect_line_plane(
q, q + (Vector((0.0, 1.0, 0.0)) * 0.1),
Vector((1.0, 0.0, 0.0)), Vector((0.0, 1.0, 0.0)))
ip_y_loc_2d = location_3d_to_region_2d(
context.region, context.space_data.region_3d, ip_y)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 1.0, 0.0,
context.scene.dt_custom_props.a)
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(q_loc_2d[0], q_loc_2d[1])
bgl.glVertex2f(ip_y_loc_2d[0], ip_y_loc_2d[1])
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
if context.scene.dt_custom_props.b2 == False:
loc_2_2d = (q_loc_2d + ip_y_loc_2d) * 0.5
bgl.glColor4f(0.0, 1.0, 0.0,
context.scene.dt_custom_props.a)
blf.position(font_id, loc_2_2d[0] + 4, loc_2_2d[1] + 4,
0)
blf.size(font_id, font_size,
context.user_preferences.system.dpi)
blf.draw(font_id, str(round((q - ip_y).length, 4)))
# -- -- -- -- z axis
ip_z = intersect_line_plane(
q, q + (Vector((0.0, 0.0, 1.0)) * 0.1),
Vector((1.0, 0.0, 0.0)), Vector((0.0, 0.0, 1.0)))
ip_z_loc_2d = location_3d_to_region_2d(
context.region, context.space_data.region_3d, ip_z)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 1.0,
context.scene.dt_custom_props.a)
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(q_loc_2d[0], q_loc_2d[1])
bgl.glVertex2f(ip_z_loc_2d[0], ip_z_loc_2d[1])
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
if context.scene.dt_custom_props.b2 == False:
loc_3_2d = (q_loc_2d + ip_z_loc_2d) * 0.5
bgl.glColor4f(0.0, 0.0, 1.0,
context.scene.dt_custom_props.a)
blf.position(font_id, loc_3_2d[0] + 4, loc_3_2d[1] + 4,
0)
blf.size(font_id, font_size,
context.user_preferences.system.dpi)
blf.draw(font_id, str(round((q - ip_z).length, 4)))
# -- -- -- --
if context.scene.dt_custom_props.b2 == True and context.scene.dt_custom_props.b1 == True:
blf.size(font_id, font_size,
context.user_preferences.system.dpi)
bgl.glColor4f(1.0, 0.0, 0.0,
context.scene.dt_custom_props.a)
blf.position(
font_id, q_loc_2d[0] + 4,
q_loc_2d[1] + 4 + font_size + 4 + font_size + 4, 0)
blf.draw(font_id,
'x ' + str(round((q - ip_x).length, 4)))
bgl.glColor4f(0.0, 1.0, 0.0,
context.scene.dt_custom_props.a)
blf.position(font_id, q_loc_2d[0] + 4,
q_loc_2d[1] + 4 + font_size + 4, 0)
blf.draw(font_id,
'y ' + str(round((q - ip_y).length, 4)))
bgl.glColor4f(0.0, 0.0, 1.0,
context.scene.dt_custom_props.a)
blf.position(font_id, q_loc_2d[0] + 4, q_loc_2d[1] + 4,
0)
blf.draw(font_id,
'z ' + str(round((q - ip_z).length, 4)))
# -- -- -- -- mouse location
if context.scene.dt_custom_props.b4 == True:
rgn = context.region # region
rgn_3d = context.space_data.region_3d # region 3d
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, context.scene.dt_custom_props.a)
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(0, dt_buf.y)
bgl.glVertex2f(dt_buf.x - 15, dt_buf.y)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, context.scene.dt_custom_props.a)
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(rgn.width, dt_buf.y)
bgl.glVertex2f(dt_buf.x + 15, dt_buf.y)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, context.scene.dt_custom_props.a)
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(dt_buf.x, 0)
bgl.glVertex2f(dt_buf.x, dt_buf.y - 15)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, context.scene.dt_custom_props.a)
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(dt_buf.x, rgn.height)
bgl.glVertex2f(dt_buf.x, dt_buf.y + 15)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
bgl.glDisable(bgl.GL_LINE_STIPPLE)
t = str(dt_buf.x) + ', ' + str(dt_buf.y)
lo = region_2d_to_location_3d(context.region,
context.space_data.region_3d,
Vector((dt_buf.x, dt_buf.y)),
Vector((0.0, 0.0, 0.0)))
t1 = '( ' + str(round(lo[0], 4)) + ', ' + str(round(
lo[1], 4)) + ', ' + str(round(lo[2], 4)) + ' )'
bgl.glColor4f(1.0, 1.0, 1.0, context.scene.dt_custom_props.a)
blf.position(font_id, dt_buf.x + 15, dt_buf.y + 15, 0)
blf.size(font_id, 14, context.user_preferences.system.dpi)
blf.draw(font_id,
t1 if context.scene.dt_custom_props.b5 == True else t)
bgl.glDisable(bgl.GL_LINE_STIPPLE)
# -- -- -- -- angles
if context.scene.dt_custom_props.b3 == True:
list_ek = [[v.index for v in e.verts]
for e in bme.verts[list_0[0]].link_edges]
n1 = len(list_ek)
for j in range(n1):
vec1 = p - bme.verts[[
i for i in list_ek[j] if i != list_0[0]
][0]].co.copy()
vec2 = p - bme.verts[[
i for i in list_ek[(j + 1) % n1] if i != list_0[0]
][0]].co.copy()
ang = vec1.angle(vec2)
a_loc_2d = location_3d_to_region_2d(
context.region, context.space_data.region_3d,
mtrx * (((p - (vec1.normalized() * 0.1)) +
(p - (vec2.normalized() * 0.1))) * 0.5))
bgl.glColor4f(0.0, 0.757, 1.0,
context.scene.dt_custom_props.a)
blf.position(font_id, a_loc_2d[0], a_loc_2d[1], 0)
blf.size(font_id, font_size,
context.user_preferences.system.dpi)
blf.draw(
font_id,
str(
round(ang, 4) if context.scene.dt_custom_props.
b6 == True else round(degrees(ang), 2)))
# -- -- -- -- tool on/off
bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
blf.position(font_id, 150, 10, 0)
blf.size(font_id, 20, context.user_preferences.system.dpi)
blf.draw(font_id, 'Ruler On')
def check_draw_bgl(self, context):
objs = context.selected_objects
if len(objs) > 0:
props = context.preferences.addons[__package__].preferences
theme = context.preferences.themes['Default']
vertex_size = theme.view_3d.vertex_size
bgl.glEnable(bgl.GL_BLEND)
bgl.glLineWidth(props.edge_width + 1)
bgl.glPointSize(vertex_size + 5)
bgl.glCullFace(bgl.GL_BACK)
if props.xray_che == 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.9999)
#bgl.glDepthFunc(600)
bgl.glDepthMask(False)
shader.bind()
# COLOR
#opacity_second = props.opacity + 0.1
ngone_col = props.ngone_col[0], props.ngone_col[1], props.ngone_col[
2], props.ngone_col[3]
tris_col = props.tris_col[0], props.tris_col[1], props.tris_col[
2], props.tris_col[3]
e_non_col = props.non_manifold_color[0], props.non_manifold_color[
1], props.non_manifold_color[2], props.non_manifold_color[3]
e_pole_col = props.e_pole_col[0], props.e_pole_col[
1], props.e_pole_col[2], props.e_pole_col[3]
n_pole_col = props.n_pole_col[0], props.n_pole_col[
1], props.n_pole_col[2], props.n_pole_col[3]
f_pole_col = props.f_pole_col[0], props.f_pole_col[
1], props.f_pole_col[2], props.f_pole_col[3]
v_bound_col = props.bound_col[0], props.bound_col[1], props.bound_col[
2], props.bound_col[3]
v_alone_col = props.v_alone_color[0], props.v_alone_color[
1], props.v_alone_color[2], props.v_alone_color[3]
custom_col = props.custom_col[0], props.custom_col[
1], props.custom_col[2], props.custom_col[3]
if props.use_mod_che:
depsgraph = context.evaluated_depsgraph_get()
for obj in objs:
if obj.type == 'MESH':
me = obj.data
if len(me.polygons) < 50000:
if context.mode == 'EDIT_MESH' and props.use_mod_che == False:
bm = bmesh.from_edit_mesh(obj.data)
else:
if props.use_mod_che:
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()
# --- N-Gone
if props.ngone:
ngone = []
for n in bm.faces:
if len(n.verts) > 4:
ngone.append(n.index)
#print("ngone",ngone)
copy = bm.copy()
copy.faces.ensure_lookup_table()
edge_n = [
e for i in ngone for e in copy.faces[i].edges
]
for e in copy.edges:
if not e in edge_n:
e.hide_set(True)
bmesh.ops.triangulate(copy, faces=copy.faces[:])
v_index = []
ngone_co = []
for f in copy.faces:
v_index.extend(
[v.index for v in f.verts if not f.hide])
ngone_co.extend([
obj.matrix_world @ v.co for v in f.verts
if not f.hide
])
copy.free() # TODO может быть удалить ?
ngons_indices = []
ngons_indices.extend(
list(range(0, len(v_index)))[v_i:v_i + 3]
for v_i in range(0, len(v_index), 3))
NGONE = batch_for_shader(shader,
'TRIS', {"pos": ngone_co},
indices=ngons_indices)
shader.uniform_float("color", ngone_col)
NGONE.draw(shader)
# --- Custom
if props.custom_count:
custom_faces = []
for n in bm.faces:
if len(n.verts) == props.custom_count_verts:
custom_faces.append(n.index)
copy = bm.copy()
copy.faces.ensure_lookup_table()
edge_n = [
e for i in custom_faces
for e in copy.faces[i].edges
]
for e in copy.edges:
if not e in edge_n:
e.hide_set(True)
bmesh.ops.triangulate(copy, faces=copy.faces[:])
v_index = []
custom_co = []
for f in copy.faces:
v_index.extend(
[v.index for v in f.verts if not f.hide])
custom_co.extend([
obj.matrix_world @ v.co for v in f.verts
if not f.hide
])
copy.free() # TODO может быть удалить ?
custom_faces_indices = []
custom_faces_indices.extend(
list(range(0, len(v_index)))[v_i:v_i + 3]
for v_i in range(0, len(v_index), 3))
CUSTOM = batch_for_shader(shader,
'TRIS', {"pos": custom_co},
indices=custom_faces_indices)
shader.uniform_float("color", custom_col)
CUSTOM.draw(shader)
if props.tris:
tris_co = [
obj.matrix_world @ v.co for f in bm.faces
for v in f.verts if len(f.verts) == 3
]
TRIS = batch_for_shader(shader, 'TRIS',
{"pos": tris_co})
shader.uniform_float("color", tris_col)
TRIS.draw(shader)
if props.non_manifold_check:
e_non_i = [
e.index for e in bm.edges if not e.is_manifold
]
e_non_co = [
obj.matrix_world @ v.co for i in e_non_i
for v in bm.edges[i].verts
]
EDGES_NON = batch_for_shader(shader, 'LINES',
{"pos": e_non_co})
shader.uniform_float("color", e_non_col)
EDGES_NON.draw(shader)
if props.e_pole:
e_pole_co = [
obj.matrix_world @ v.co for v in bm.verts
if len(v.link_edges) == 5
]
E_POLE = batch_for_shader(shader, 'POINTS',
{"pos": e_pole_co})
shader.uniform_float("color", e_pole_col)
E_POLE.draw(shader)
if props.n_pole:
n_pole_co = [
obj.matrix_world @ v.co for v in bm.verts
if len(v.link_edges) == 3
]
N_POLE = batch_for_shader(shader, 'POINTS',
{"pos": n_pole_co})
shader.uniform_float("color", n_pole_col)
N_POLE.draw(shader)
if props.f_pole:
f_pole_co = [
obj.matrix_world @ v.co for v in bm.verts
if len(v.link_edges) > 5
]
F_POLE = batch_for_shader(shader, 'POINTS',
{"pos": f_pole_co})
shader.uniform_float("color", f_pole_col)
F_POLE.draw(shader)
if props.v_bound:
v_bound_co = [
obj.matrix_world @ v.co for v in bm.verts
if v.is_boundary or not v.is_manifold
]
V_BOUND = batch_for_shader(shader, 'POINTS', {
"pos": v_bound_co,
})
shader.uniform_float("color", v_bound_col)
V_BOUND.draw(shader)
if props.v_alone:
v_alone_co = [
obj.matrix_world @ v.co for v in bm.verts
if len(v.link_edges) < 1
]
V_ALONE = batch_for_shader(shader, 'POINTS',
{"pos": v_alone_co})
shader.uniform_float("color", v_alone_col)
V_ALONE.draw(shader)
if props.use_mod_che:
bm.free()
if props.line_smooth:
bgl.glDisable(bgl.GL_LINE_SMOOTH)
bgl.glDisable(bgl.GL_DEPTH_TEST)
bgl.glDisable(bgl.GL_CULL_FACE)
bgl.glLineWidth(2)
bgl.glPointSize(vertex_size)
bgl.glDisable(bgl.GL_BLEND)
def _draw(self, context):
if (
not context.window_manager.jewelcraft.widget_toggle or
not context.space_data.overlay.show_overlays
):
return
global _font_loc
prefs = context.preferences.addons[var.ADDON_ID].preferences
props = context.scene.jewelcraft
show_all = props.widget_show_all
use_ovrd = props.widget_use_overrides
default_spacing = props.widget_spacing
default_color = prefs.widget_color
default_linewidth = prefs.widget_linewidth
is_df = context.mode == "EDIT_MESH" and context.edit_object.is_instancer
diplay_thold = default_spacing + 0.5
depsgraph = context.evaluated_depsgraph_get()
if is_df:
df = context.edit_object
for ob_act in df.children:
if "gem" in ob_act:
is_gem = True
break
else:
is_gem = False
else:
ob_act = context.object
if ob_act:
is_gem = "gem" in ob_act
if not (show_all or is_gem):
return
if is_gem:
if use_ovrd and "jewelcraft_widget" in ob_act:
ob_act_spacing = ob_act["jewelcraft_widget"].get("spacing", default_spacing)
else:
ob_act_spacing = default_spacing
from_scene_scale = unit.Scale(context).from_scene
if is_df:
df_pass = False
df.update_from_editmode()
if df.modifiers and df.is_deform_modified(context.scene, "PREVIEW"):
df_eval = df.evaluated_get(depsgraph)
polys = df_eval.to_mesh().polygons
poly = polys[polys.active]
ob_act_loc = df.matrix_world @ poly.center
mat_rot = poly.normal.to_track_quat("Z", "Y").to_matrix().to_4x4()
df_eval.to_mesh_clear()
else:
polys = df.data.polygons
poly = polys[polys.active]
ob_act_loc = df.matrix_world @ poly.center
mat_rot = poly.normal.to_track_quat("Z", "Y").to_matrix().to_4x4()
else:
ob_act_loc = ob_act.matrix_world.to_translation()
mat_rot = ob_act.matrix_world.to_quaternion().to_matrix().to_4x4()
ob_act_loc.freeze()
ob_act_rad = max(ob_act.dimensions[:2]) / 2
mat_loc = Matrix.Translation(ob_act_loc)
mat = mat_loc @ mat_rot
mat.freeze()
girdle_act = girdle_coords(ob_act_rad, mat)
shader.bind()
bgl.glEnable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_LINE_SMOOTH)
bgl.glDepthMask(bgl.GL_FALSE)
if props.widget_show_in_front:
bgl.glDisable(bgl.GL_DEPTH_TEST)
for dup in depsgraph.object_instances:
if dup.is_instance:
ob = dup.instance_object.original
else:
ob = dup.object.original
if "gem" not in ob:
continue
ob_rad = max(ob.dimensions[:2]) / 2
ob_loc = dup.matrix_world.translation
spacing_thold = False
if is_gem:
dis_ob = (ob_act_loc - ob_loc).length
dis_gap = from_scene_scale(dis_ob - (ob_act_rad + ob_rad))
dis_thold = dis_gap < diplay_thold
if not (show_all or dis_thold):
continue
if is_df:
if df_pass:
is_act = False
else:
df_pass = is_act = dup.matrix_world.translation == ob_act_loc
else:
if dup.is_instance:
is_act = False
else:
is_act = ob is ob_act
use_diplay_dis = not is_act and dis_thold
else:
use_diplay_dis = False
if show_all or use_diplay_dis:
if use_ovrd and "jewelcraft_widget" in ob:
_color = ob["jewelcraft_widget"].get("color", default_color)
_linewidth = ob["jewelcraft_widget"].get("linewidth", default_linewidth)
_spacing = ob["jewelcraft_widget"].get("spacing", default_spacing)
else:
_color = default_color
_linewidth = default_linewidth
_spacing = default_spacing
bgl.glLineWidth(_linewidth)
shader.uniform_float("color", _color)
if dup.is_instance:
mat = dup.matrix_world.copy()
else:
mat_loc = Matrix.Translation(ob_loc)
mat_rot = dup.matrix_world.to_quaternion().to_matrix().to_4x4()
mat = mat_loc @ mat_rot
mat.freeze()
if use_diplay_dis:
if dis_ob:
girdle_ob = girdle_coords(ob_rad, mat)
dis_gap, start, end = find_nearest(ob_act_loc, ob_act_rad, girdle_act, girdle_ob)
dis_gap = from_scene_scale(dis_gap)
dis_thold = dis_gap < diplay_thold
spacing_thold = dis_gap < (_spacing + 0.3)
if not (show_all or dis_thold):
continue
mid = start.lerp(end, 0.5)
else:
start = end = mid = ob_loc.copy()
if dis_thold:
if dis_gap < 0.1:
shader.uniform_float("color", (1.0, 0.0, 0.0, 1.0))
elif dis_gap < _spacing:
shader.uniform_float("color", (1.0, 0.9, 0.0, 1.0))
_font_loc.append((dis_gap, mid, from_scene_scale(max(ob_act_spacing, _spacing))))
batch = batch_for_shader(shader, "LINES", {"pos": (start, end)})
batch.draw(shader)
if show_all or spacing_thold:
radius = ob_rad + _spacing
coords = girdle_coords(radius, mat)
batch = batch_for_shader(shader, "LINE_LOOP", {"pos": coords})
batch.draw(shader)
# Restore OpenGL defaults
# ----------------------------
bgl.glDisable(bgl.GL_BLEND)
bgl.glDisable(bgl.GL_LINE_SMOOTH)
bgl.glDepthMask(bgl.GL_TRUE)
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glLineWidth(1.0)
def h_mask_end():
bgl.glDisable(bgl.GL_STENCIL_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 DEBUG:
## mesh_drawing._store_current_shader_state(mesh_drawing.PreviousGLState)
## self.screen.Draw(self.sctx._texture)
## mesh_drawing._restore_shader_state(mesh_drawing.PreviousGLState)
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_Overlay(self, context):
np_print('DRAW_Overlay_START',';','NP020PL.flag = ', NP020PL.flag)
flag = NP020PL.flag
helper = NP020PL.helper
region = bpy.context.region
rv3d = bpy.context.region_data
rw = region.width
rh = region.height
co2d = view3d_utils.location_3d_to_region_2d(region, rv3d, helper.location)
frompoints = NP020PL.frompoints
topoints = NP020PL.topoints
col_line_main = (1.0, 1.0, 1.0, 1.0)
col_line_shadow = (0.1, 0.1, 0.1, 0.25)
#greys:
mark_col_A = (0.25, 0.25, 0.25, 1.0)
mark_col_B = (0.5, 0.5, 0.5, 1.0)
mark_col_C = (0.75, 0.75, 0.75, 1.0)
#marins
mark_col_A = (0.25, 0.35, 0.4, 1.0)
mark_col_B = (0.5, 0.6, 0.65, 1.0)
mark_col_C = (0.67, 0.77, 0.82, 1.0)
# writing the dots for recwidget widget at center of scene:
r = 12
angstep = 20
psize = 25
pofsetx = 15
pofsety = 15
fsize = 20
fofsetx = -8
fofsety = -7
widget_circle = construct_circle_2d(r, angstep)
if flag == 'RUNTRANSF0':
instruct = 'place start for point a'
keys_aff = 'LMB - select, CTRL - snap, ENT - change snap'
keys_neg = 'RMB, ESC - quit'
frompoints[0] = helper.location
elif flag == 'RUNTRANST0':
instruct = 'place target for point a'
keys_aff = 'LMB - select, CTRL - snap, ENT - change snap, MMB - lock axis, NUMPAD - value'
keys_neg = 'RMB, ESC - quit'
topoints[0] = helper.location
elif flag == 'RUNTRANSF1':
instruct = 'place start for point b'
keys_aff = 'LMB - select, CTRL - snap, ENT - change snap, MMB - lock axis, NUMPAD - value, RMB - align A (translate)'
keys_neg = 'ESC - quit'
frompoints[1] = helper.location
elif flag == 'RUNTRANST1':
instruct = 'place target for point b'
keys_aff = 'LMB - select, CTRL - snap, ENT - change snap, MMB - lock axis, NUMPAD - value, RMB - align A (translate)'
keys_neg = 'ESC - quit'
topoints[1] = helper.location
elif flag == 'RUNTRANSF2':
instruct = 'place start for point c'
keys_aff = 'LMB - select, CTRL - snap, ENT - change snap, MMB - lock axis, NUMPAD - value, RMB - align AB (translate, rotate)'
keys_neg = 'ESC - quit'
frompoints[2] = helper.location
elif flag == 'RUNTRANST2':
instruct = 'place target for point c'
keys_aff = 'LMB - select, CTRL - snap, ENT - change snap, MMB - lock axis, NUMPAD - value, RMB - align AB (translate, rotate)'
keys_neg = 'ESC - quit'
topoints[2] = helper.location
# ON-SCREEN INSTRUCTIONS:
keys_nav = ''
display_instructions(region, rv3d, instruct, keys_aff, keys_nav, keys_neg)
# LINE:
for i, frompoint in enumerate(frompoints):
topoint = topoints[i]
if frompoint != None and topoint != None:
bgl.glColor4f(*col_line_shadow)
bgl.glLineWidth(1.4)
bgl.glBegin(bgl.GL_LINE_STRIP)
frompoint = view3d_utils.location_3d_to_region_2d(region, rv3d, frompoint)
topoint = view3d_utils.location_3d_to_region_2d(region, rv3d, topoint)
bgl.glVertex2f((frompoint[0] - 1), (frompoint[1] - 1))
bgl.glVertex2f((topoint[0] - 1), (topoint[1] - 1))
bgl.glEnd()
bgl.glColor4f(*col_line_main)
bgl.glLineWidth(1.4)
bgl.glBegin(bgl.GL_LINE_STRIP)
bgl.glVertex2f(*frompoint)
bgl.glVertex2f(*topoint)
bgl.glEnd()
# drawing of markers:
i = 0
for point in frompoints:
if point != None:
point = view3d_utils.location_3d_to_region_2d(region, rv3d, point)
point[0] = point[0] + pofsetx
point[1] = point[1] + pofsety
widget = []
for co in widget_circle:
c = [0.0, 0.0]
c[0] = co[0] + point[0] + pofsetx
c[1] = co[1] + point[1] + pofsety
widget.append(c)
bgl.glEnable(bgl.GL_BLEND)
if i == 0:
bgl.glColor4f(*mark_col_A)
mark = "A"
elif i == 1:
bgl.glColor4f(*mark_col_B)
mark = "B"
elif i == 2:
bgl.glColor4f(*mark_col_C)
mark = "C"
'''
bgl.glLineWidth(1)
bgl.glBegin(bgl.GL_LINE_STRIP)
for co in widget:
bgl.glVertex2f(*co)
bgl.glVertex2f(*widget[len(widget) - 1])
bgl.glEnd()
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
for co in widget:
bgl.glVertex2f(*co)
bgl.glEnd()
'''
font_id = 0
bgl.glEnable(bgl.GL_POINT_SMOOTH)
bgl.glPointSize(psize)
bgl.glBegin(bgl.GL_POINTS)
bgl.glVertex2f(*point)
bgl.glEnd()
bgl.glDisable(bgl.GL_POINT_SMOOTH)
bgl.glColor4f(1.0, 1.0, 1.0, 0.75)
blf.size(font_id, fsize, 72)
blf.position(font_id, point[0] + fofsetx, point[1] + fofsety, 0)
blf.draw(font_id, mark)
i = i + 1
i = 0
for point in topoints:
if point != None:
point = view3d_utils.location_3d_to_region_2d(region, rv3d, point)
point[0] = point[0] + pofsetx
point[1] = point[1] + pofsety
widget = []
for co in widget_circle:
c = [0.0, 0.0]
c[0] = co[0] + point[0] + pofsetx
c[1] = co[1] + point[1] + pofsety
widget.append(c)
bgl.glEnable(bgl.GL_BLEND)
if i == 0:
bgl.glColor4f(*mark_col_A)
mark = "A'"
elif i == 1:
bgl.glColor4f(*mark_col_B)
mark = "B'"
elif i == 2:
bgl.glColor4f(*mark_col_C)
mark = "C'"
'''
bgl.glLineWidth(1)
bgl.glBegin(bgl.GL_LINE_STRIP)
for co in widget:
bgl.glVertex2f(*co)
bgl.glVertex2f(*widget[len(widget) - 1])
bgl.glEnd()
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
for co in widget:
bgl.glVertex2f(*co)
bgl.glEnd()
'''
font_id = 0
bgl.glEnable(bgl.GL_POINT_SMOOTH)
bgl.glPointSize(psize)
bgl.glBegin(bgl.GL_POINTS)
bgl.glVertex2f(*point)
bgl.glEnd()
bgl.glDisable(bgl.GL_POINT_SMOOTH)
bgl.glColor4f(1.0, 1.0, 1.0, 0.75)
blf.size(font_id, fsize, 72)
blf.position(font_id, point[0] + fofsetx, point[1] + fofsety, 0)
blf.draw(font_id, mark)
i = i + 1
#ENDING:
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_geometry(n_id, options, data_vector, data_polygons, data_matrix,
data_edges):
show_verts = options['show_verts']
show_edges = options['show_edges']
show_faces = options['show_faces']
vertex_colors = options['vertex_colors']
edge_colors = options['edge_colors']
edge_width = options['edge_width']
tran = options['transparent']
shade = options['shading']
verlen = options['verlen']
max_verts_ = [len(d) for d in data_vector]
if tran:
polyholy = GL_POLYGON_STIPPLE
edgeholy = GL_LINE_STIPPLE
edgeline = GL_LINE_STRIP
else:
polyholy = GL_POLYGON
edgeholy = GL_LINE
edgeline = GL_LINES
def get_max_k(i, verlen):
k = i
if i > verlen:
k = verlen
return k
''' vertices '''
glEnable(GL_POINT_SIZE)
glEnable(GL_POINT_SMOOTH)
glHint(GL_POINT_SMOOTH_HINT, GL_NICEST)
# glHint(GL_POINT_SMOOTH_HINT, GL_FASTEST)
vsize = options['vertex_size']
if show_verts and data_vector:
glPointSize(vsize)
glColor3f(*vertex_colors)
glBegin(GL_POINTS)
for i, matrix in enumerate(data_matrix):
k = get_max_k(i, verlen)
for vert in data_vector[k]:
vec = data_matrix[i] * vert
glVertex3f(*vec)
glEnd()
glDisable(GL_POINT_SIZE)
glDisable(GL_POINT_SMOOTH)
''' polygons '''
if data_polygons and data_vector:
num_datapolygon_lists = len(data_polygons)
glEnable(polyholy)
for i, matrix in enumerate(data_matrix):
k = get_max_k(i, verlen)
mesh_edges = set()
if k >= num_datapolygon_lists:
k = (num_datapolygon_lists - 1)
#break
for j, pol in enumerate(data_polygons[k]):
if max(pol) >= max_verts_[k]:
continue
if show_faces:
display_face(options, pol, data_vector, data_matrix, k, i)
# collect raw edges, sort by index, use set to prevent dupes.
if show_edges:
er = list(pol) + [pol[0]]
kb = {
tuple(sorted((e, er[i + 1])))
for i, e in enumerate(er[:-1])
}
mesh_edges.update(kb)
if show_edges and mesh_edges:
# glHint(GL_LINE_SMOOTH_HINT, GL_NICEST)
glEnable(edgeholy)
glLineWidth(edge_width)
glColor3f(*edge_colors)
glBegin(GL_LINES)
for edge in mesh_edges:
for p in edge:
vec = data_matrix[i] * data_vector[k][p]
glVertex3f(*vec)
glEnd()
glDisable(edgeholy)
glDisable(polyholy)
''' edges '''
if data_edges and data_vector and show_edges:
glColor3f(*edge_colors)
glLineWidth(edge_width)
glEnable(edgeholy)
for i, matrix in enumerate(data_matrix):
k = get_max_k(i, verlen)
if k >= len(data_edges):
continue
for line in data_edges[k]:
# i think this catches edges which refer to indices not present in
# the accompanying vertex list.
if max(line) >= max_verts_[k]:
continue
glBegin(edgeline)
for p in line:
vec = data_matrix[i] * data_vector[k][p]
glVertex3f(*vec)
glEnd()
glDisable(edgeholy)
''' matrix '''
if data_matrix and not data_vector:
md = MatrixDraw()
for mat in data_matrix:
md.draw_matrix(mat)
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 DRAW_Overlay(self, context):
np_print('DRAW_Overlay_START', ';', 'NP020RM.flag = ', NP020RM.flag)
flag = NP020RM.flag
helper = NP020RM.helper
angstep = NP020RM.angstep
region = bpy.context.region
rv3d = bpy.context.region_data
rw = region.width
rh = region.height
if NP020RM.centerloc == None: centerloc = helper.location
else: centerloc = NP020RM.centerloc
qdef = NP020RM.qdef
ndef = NP020RM.ndef
alpha_0 = NP020RM.alpha_0
alpha_1 = NP020RM.alpha_1
np_print('rw, rh', rw, rh)
rmin = int(min(rw, rh) / 10)
if rmin == 0: rmin = 1
co2d = self.co2d
if flag in ('RUNTRANSCENTER', 'RUNTRANSSTART'):
co2d = view3d_utils.location_3d_to_region_2d(region, rv3d,
helper.location)
if qdef == None:
q = get_ro_normal_from_vertical(region, rv3d, co2d)[1]
n = get_ro_normal_from_vertical(region, rv3d, co2d)[0]
else:
q = qdef
n = ndef
NP020RM.q = q
NP020RM.n = n
#co2d_exp = (event.mouse_region_x, event.mouse_region_y)
#n_exp = get_ro_normal_from_vertical(region, rv3d, co2d_exp)[0]
#np_print('co2d, n, q, n_exp', co2d, n, q)
# writing the dots for circle at center of scene:
radius = 1
ang = 0.0
circle = [(0.0, 0.0, 0.0)]
while ang < 360.0:
circle.append(((cos(radians(ang)) * radius),
(sin(radians(ang)) * radius), (0.0)))
ang += 10
circle.append(
((cos(radians(0.0)) * radius), (sin(radians(0.0)) * radius), (0.0)))
# rotating and translating the circle to user picked angle and place:
circle = rotate_graphic(circle, q)
circle = translate_graphic(circle, centerloc)
rmax = 1
for i, co in enumerate(circle):
co = view3d_utils.location_3d_to_region_2d(region, rv3d, co)
circle[i] = co
for i in range(1, 18):
r = (circle[0] - circle[i]).length
r1 = (circle[0] - circle[i + 18]).length
#if (r + r1) > rmax and abs(r - r1) < min(r, r1)/5: rmax = (r+r1)/2
#if (r + r1) > rmax and abs(r - r1) < min(r, r1)/10: rmax = r + r1
if (r + r1) > rmax and (r + r1) / 2 < rmin: rmax = (r + r1)
elif (r + r1) > rmax and (r + r1) / 2 >= rmin:
rmax = (r + r1) * rmin / (((r + r1) / 2) - ((r + r1) / 2) - rmin)
rmax = abs(rmax)
circle[i] = co
np_print('rmin', rmin)
np_print('rmax', rmax)
if flag not in ('RUNTRANSSTART', 'RUNROTEND'):
fac = (rmin * 2) / rmax
NP020RM.fac = fac
else:
fac = NP020RM.fac
radius = 1 * fac
ang = 0.0
circle = [(0.0, 0.0, 0.0)]
while ang < 360.0:
circle.append(((cos(radians(ang)) * radius),
(sin(radians(ang)) * radius), (0.0)))
ang += 10
circle.append(
((cos(radians(0.0)) * radius), (sin(radians(0.0)) * radius), (0.0)))
if flag == 'RUNTRANSCENTER':
instruct = 'place center point'
keys_aff = 'LMB / ENT / NUMPAD ENT - confirm, CTRL - snap'
keys_nav = ''
keys_neg = 'ESC - quit'
r1 = 1
r2 = 1.5
walpha = construct_roto_widget(alpha_0, alpha_1, fac, r1, r2, angstep)
r1 = 1.5
r2 = 2
wbeta_L = construct_roto_widget(90, 0, fac, r1, r2, angstep)
r1 = 1.5
r2 = 2
wbeta_D = construct_roto_widget(0, 90, fac, r1, r2, angstep)
elif flag == 'BGLPLANE':
instruct = 'choose rotation plane'
keys_aff = 'LMB / ENT / NUMPAD ENT - confirm'
keys_nav = 'MMB / SCROLL - navigate'
keys_neg = 'ESC - quit'
ro_hor, isohipse = get_ro_x_from_iso(region, rv3d, co2d, centerloc)
NP020RM.ro_hor = copy.deepcopy(ro_hor)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 0.0, 0.0, 1.0)
bgl.glLineWidth(2)
bgl.glBegin(bgl.GL_LINE_STRIP)
for co in isohipse:
co = view3d_utils.location_3d_to_region_2d(region, rv3d, co)
bgl.glVertex2f(*co)
bgl.glEnd()
bgl.glEnable(bgl.GL_POINT_SMOOTH)
bgl.glPointSize(4)
bgl.glBegin(bgl.GL_POINTS)
for co in isohipse:
co = view3d_utils.location_3d_to_region_2d(region, rv3d, co)
bgl.glVertex2f(*co)
bgl.glEnd()
r1 = 1
r2 = 1.5
walpha = construct_roto_widget(alpha_0, alpha_1, fac, r1, r2, angstep)
r1 = 1.5
r2 = 2
wbeta_L = construct_roto_widget(90, 0, fac, r1, r2, angstep)
r1 = 1.5
r2 = 2
wbeta_D = construct_roto_widget(0, 90, fac, r1, r2, angstep)
circle = rotate_graphic(circle, ro_hor)
walpha = rotate_graphic(walpha, ro_hor)
wbeta_L = rotate_graphic(wbeta_L, ro_hor)
wbeta_D = rotate_graphic(wbeta_D, ro_hor)
circle = rotate_graphic(circle, q)
walpha = rotate_graphic(walpha, q)
wbeta_L = rotate_graphic(wbeta_L, q)
wbeta_D = rotate_graphic(wbeta_D, q)
elif flag == 'RUNTRANSSTART':
instruct = 'place start point'
keys_aff = 'LMB / ENT / NUMPAD ENT - confirm, CTRL - snap'
keys_nav = ''
keys_neg = 'ESC - quit'
hloc = helper.location
#np_print('hloc', hloc)
hlocb = hloc + n
#np_print('hlocb', hlocb)
#np_print('centerloc, n', centerloc, n)
proj_start = mathutils.geometry.intersect_line_plane(
helper.location, (helper.location + n), centerloc, n)
NP020RM.proj_start = proj_start
if proj_start == centerloc:
proj = centerloc + Vector((0.0, 0.0, 0.001))
#np_print('proj_start' , proj_start)
alpha_0, isohipse = get_angle_from_iso_planar(centerloc, n, proj_start)
alpha_1 = alpha_0
NP020RM.alpha_0 = alpha_0
NP020RM.alpha_1 = alpha_1
np_print('alpha_0', alpha_0)
ro_hor = NP020RM.ro_hor
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 0.0, 0.0, 1.0)
bgl.glLineWidth(2)
bgl.glBegin(bgl.GL_LINE_STRIP)
for co in isohipse:
co = view3d_utils.location_3d_to_region_2d(region, rv3d, co)
bgl.glVertex2f(*co)
bgl.glEnd()
bgl.glEnable(bgl.GL_POINT_SMOOTH)
bgl.glPointSize(4)
bgl.glBegin(bgl.GL_POINTS)
for co in isohipse:
co = view3d_utils.location_3d_to_region_2d(region, rv3d, co)
bgl.glVertex2f(*co)
bgl.glEnd()
r1 = 1
r2 = 1.5
walpha = construct_roto_widget(alpha_0, alpha_1, fac, r1, r2, angstep)
r1 = 1.5
r2 = 2
wbeta_L = construct_roto_widget(alpha_1, 0, fac, r1, r2, angstep)
r1 = 1.5
r2 = 2
wbeta_D = construct_roto_widget(0, alpha_0, fac, r1, r2, angstep)
circle = rotate_graphic(circle, ro_hor)
walpha = rotate_graphic(walpha, ro_hor)
wbeta_L = rotate_graphic(wbeta_L, ro_hor)
wbeta_D = rotate_graphic(wbeta_D, ro_hor)
circle = rotate_graphic(circle, q)
walpha = rotate_graphic(walpha, q)
wbeta_L = rotate_graphic(wbeta_L, q)
wbeta_D = rotate_graphic(wbeta_D, q)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0.5, 0.5, 1.0, 1.0)
bgl.glLineWidth(1)
bgl.glBegin(bgl.GL_LINE_STRIP)
points = (helper.location, proj_start, centerloc)
for co in points:
co = view3d_utils.location_3d_to_region_2d(region, rv3d, co)
bgl.glVertex2f(*co)
bgl.glEnd()
co = view3d_utils.location_3d_to_region_2d(region, rv3d, proj_start)
bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
bgl.glEnable(bgl.GL_POINT_SMOOTH)
bgl.glPointSize(14)
bgl.glEnable(bgl.GL_BLEND)
bgl.glBegin(bgl.GL_POINTS)
bgl.glVertex2f(*co)
bgl.glEnd()
elif flag == 'RUNROTEND':
instruct = 'place end point'
keys_aff = 'LMB / ENT / NUMPAD ENT - confirm, CTRL - snap'
keys_nav = ''
keys_neg = 'ESC - quit'
for k, v in bpy.context.active_operator.properties.items():
np_print(k, v)
alpha_0 = NP020RM.alpha_0_def
hloc = helper.location
startloc = NP020RM.startloc
endloc = helper.location
proj_start = NP020RM.proj_start
#np_print('hloc', hloc)
hlocb = hloc + n
#np_print('hlocb', hlocb)
#np_print('centerloc, n', centerloc, n)
proj_end = mathutils.geometry.intersect_line_plane(
helper.location, (helper.location + n), centerloc, n)
if proj_end == centerloc:
proj_end = centerloc + Vector((0.0, 0.0, 0.001))
#np_print('proj_end' , proj_end)
alpha = get_angle_vector_from_vector(centerloc, proj_start, proj_end)
alpha_1 = alpha_0 + alpha
np_print('alpha_0', alpha_0)
ro_hor = NP020RM.ro_hor
rot_helper_0 = NP020RM.rot_helper_0
np_print('rot_helper_0 =', rot_helper_0)
rot_helper_1 = helper.rotation_euler
np_print('rot_helper_1 =', rot_helper_1)
alpha_real = get_eul_z_angle_diffffff_in_rotated_system(
rot_helper_0, rot_helper_1, ndef)
np_print('alpha_real =', alpha_real)
delta = (abs(alpha_real) - (360 * int(abs(alpha_real) / 360)))
if alpha_real >= 0:
if alpha_0 + delta < 360: alpha_1 = alpha_0 + delta
else: alpha_1 = delta - (360 - alpha_0)
else:
if delta < alpha_0:
alpha_1 = alpha_0
alpha_0 = alpha_1 - delta
else:
alpha_1 = alpha_0
alpha_0 = 360 - (delta - alpha_0)
if alpha_1 == alpha_0: alpha_1 = alpha_0 + 0.001
r1 = 1
r2 = 1.5
walpha = construct_roto_widget(alpha_0, alpha_1, fac, r1, r2, angstep)
r1 = 1.5
r2 = 2
wbeta_L = construct_roto_widget(alpha_1, alpha_0, fac, r1, r2, angstep)
'''
r1 = 1.5
r2 = 2
wbeta_D = construct_roto_widget(0, alpha_0, fac, r1, r2, angstep)
'''
circle = rotate_graphic(circle, ro_hor)
walpha = rotate_graphic(walpha, ro_hor)
wbeta_L = rotate_graphic(wbeta_L, ro_hor)
#wbeta_D = rotate_graphic(wbeta_D, ro_hor)
circle = rotate_graphic(circle, q)
walpha = rotate_graphic(walpha, q)
wbeta_L = rotate_graphic(wbeta_L, q)
#wbeta_D = rotate_graphic(wbeta_D, q)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0.5, 0.5, 1.0, 1.0)
bgl.glLineWidth(1)
bgl.glBegin(bgl.GL_LINE_STRIP)
points = (helper.location, proj_end, centerloc, proj_start)
for co in points:
co = view3d_utils.location_3d_to_region_2d(region, rv3d, co)
bgl.glVertex2f(*co)
bgl.glEnd()
co = view3d_utils.location_3d_to_region_2d(region, rv3d, proj_end)
bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
bgl.glEnable(bgl.GL_POINT_SMOOTH)
bgl.glPointSize(14)
bgl.glEnable(bgl.GL_BLEND)
bgl.glBegin(bgl.GL_POINTS)
bgl.glVertex2f(*co)
bgl.glEnd()
# NUMERICAL ANGLE:
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
font_id = 0
blf.size(font_id, 20, 72)
ang_pos = view3d_utils.location_3d_to_region_2d(
region, rv3d, centerloc)
blf.position(font_id, ang_pos[0] + 2, ang_pos[1] - 2, 0)
blf.draw(font_id, str(round(alpha_real, 2)))
bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
blf.position(font_id, ang_pos[0], ang_pos[1], 0)
blf.draw(font_id, str(round(alpha_real, 2)))
# DRAWING START:
bgl.glEnable(bgl.GL_BLEND)
# ON-SCREEN INSTRUCTIONS:
display_instructions(region, rv3d, instruct, keys_aff, keys_nav, keys_neg)
np_print('centerloc', centerloc)
circle = translate_graphic(circle, centerloc)
walpha = translate_graphic(walpha, centerloc)
wbeta_L = translate_graphic(wbeta_L, centerloc)
if flag is not 'RUNROTEND': wbeta_D = translate_graphic(wbeta_D, centerloc)
np_print('rv3d', rv3d)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, 0.6)
bgl.glLineWidth(1)
bgl.glBegin(bgl.GL_LINE_STRIP)
for i, co in enumerate(circle):
co = view3d_utils.location_3d_to_region_2d(region, rv3d, co)
bgl.glVertex2f(*co)
circle[i] = co
bgl.glEnd()
np_print('centerloc', centerloc)
# drawing of walpha contours:
bgl.glColor4f(1.0, 1.0, 1.0, 0.6)
bgl.glLineWidth(1)
bgl.glBegin(bgl.GL_LINE_STRIP)
for i, co in enumerate(walpha):
co = view3d_utils.location_3d_to_region_2d(region, rv3d, co)
bgl.glVertex2f(*co)
walpha[i] = co
bgl.glEnd()
#np_print('walpha', walpha)
bgl.glColor4f(0.0, 0.0, 0.0, 0.5)
# drawing of walpha fields:
np_print('alpha_0, alpha_1 =', alpha_0, alpha_1)
if alpha_1 >= alpha_0: alpha = alpha_1 - alpha_0
else: alpha = alpha_1 + (360 - alpha_0)
sides = int(alpha / NP020RM.angstep) + 1
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
bgl.glVertex2f(*walpha[0])
bgl.glVertex2f(*walpha[1])
bgl.glVertex2f(*walpha[2])
bgl.glVertex2f(*walpha[(sides * 2) + 1])
bgl.glEnd()
for i in range(1, sides):
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
bgl.glVertex2f(*walpha[((sides * 2) + 2) - i])
bgl.glVertex2f(*walpha[i + 1])
bgl.glVertex2f(*walpha[2 + i])
bgl.glVertex2f(*walpha[((sides * 2) + 2) - (i + 1)])
bgl.glEnd()
# drawing of wbeta_L contours:
bgl.glColor4f(1.0, 1.0, 1.0, 0.6)
bgl.glLineWidth(1)
bgl.glBegin(bgl.GL_LINE_STRIP)
for i, co in enumerate(wbeta_L):
co = view3d_utils.location_3d_to_region_2d(region, rv3d, co)
bgl.glVertex2f(*co)
wbeta_L[i] = co
bgl.glEnd()
#np_print('wbeta_L', wbeta_L)
bgl.glColor4f(0.65, 0.85, 1.0, 0.35)
# drawing of wbeta_L fields:
if flag == 'RUNROTEND':
if alpha_0 >= alpha_1: alpha = alpha_0 - alpha_1
else: alpha = alpha_0 + (360 - alpha_1)
else: alpha = 360 - alpha_1
sides = int(alpha / NP020RM.angstep) + 1
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
bgl.glVertex2f(*wbeta_L[0])
bgl.glVertex2f(*wbeta_L[1])
bgl.glVertex2f(*wbeta_L[2])
bgl.glVertex2f(*wbeta_L[(sides * 2) + 1])
bgl.glEnd()
for i in range(1, sides):
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
bgl.glVertex2f(*wbeta_L[((sides * 2) + 2) - i])
bgl.glVertex2f(*wbeta_L[i + 1])
bgl.glVertex2f(*wbeta_L[2 + i])
bgl.glVertex2f(*wbeta_L[((sides * 2) + 2) - (i + 1)])
bgl.glEnd()
if flag is not 'RUNROTEND':
# drawing of wbeta_D contours:
bgl.glColor4f(1.0, 1.0, 1.0, 0.6)
bgl.glLineWidth(1)
bgl.glBegin(bgl.GL_LINE_STRIP)
for i, co in enumerate(wbeta_D):
co = view3d_utils.location_3d_to_region_2d(region, rv3d, co)
bgl.glVertex2f(*co)
wbeta_D[i] = co
bgl.glEnd()
#np_print('wbeta_D', wbeta_D)
bgl.glColor4f(0.35, 0.6, 0.75, 0.35)
# drawing of wbeta_D fields:
alpha = alpha_0
sides = int(alpha / NP020RM.angstep) + 1
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
bgl.glVertex2f(*wbeta_D[0])
bgl.glVertex2f(*wbeta_D[1])
bgl.glVertex2f(*wbeta_D[2])
bgl.glVertex2f(*wbeta_D[(sides * 2) + 1])
bgl.glEnd()
for i in range(1, sides):
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
bgl.glVertex2f(*wbeta_D[((sides * 2) + 2) - i])
bgl.glVertex2f(*wbeta_D[i + 1])
bgl.glVertex2f(*wbeta_D[2 + i])
bgl.glVertex2f(*wbeta_D[((sides * 2) + 2) - (i + 1)])
bgl.glEnd()
#ENDING
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def h_clip_end():
bgl.glDisable(bgl.GL_SCISSOR_TEST)
def snap_get(self, mval, main_snap_obj=None):
ret = None, None, None
self.mval[:] = mval
snap_vert = self._snap_mode & VERT != 0
snap_edge = self._snap_mode & EDGE != 0
snap_face = self._snap_mode & FACE != 0
_Internal.gpu_Indices_enable_state()
self._offscreen.bind()
#bgl.glDisable(bgl.GL_DITHER) # dithering and AA break color coding, so disable #
#multisample_enabled = bgl.glIsEnabled(bgl.GL_MULTISAMPLE)
#bgl.glDisable(bgl.GL_MULTISAMPLE)
bgl.glEnable(bgl.GL_DEPTH_TEST)
proj_mat = self.rv3d.perspective_matrix.copy()
if self.proj_mat != proj_mat:
self.proj_mat = proj_mat
_Internal.gpu_Indices_set_ProjectionMatrix(self.proj_mat)
self.update_drawing()
ray_dir, ray_orig = self.get_ray(mval)
for i, snap_obj in enumerate(self.snap_objects[self.drawn_count:],
self.drawn_count):
obj = snap_obj.data[0]
try:
bbmin = Vector(obj.bound_box[0])
bbmax = Vector(obj.bound_box[6])
except ReferenceError:
self.snap_objects.remove(snap_obj)
continue
if bbmin != bbmax:
MVP = proj_mat @ snap_obj.mat
mat_inv = snap_obj.mat.inverted()
ray_orig_local = mat_inv @ ray_orig
ray_dir_local = mat_inv.to_3x3() @ ray_dir
in_threshold = _Internal.intersect_boundbox_threshold(
self, MVP, ray_orig_local, ray_dir_local, bbmin, bbmax)
else:
proj_co = _Internal.project_co_v3(self,
snap_obj.mat.translation)
dist = self.mval - proj_co
in_threshold = abs(dist.x) < self._dist_px and abs(
dist.y) < self._dist_px
#snap_obj.data[1] = primitive_point
if in_threshold:
if len(snap_obj.data) == 1:
from .mesh_drawing import GPU_Indices_Mesh
is_bound = obj.display_type == 'BOUNDS'
draw_face = snap_face and not is_bound and obj.display_type != 'WIRE'
draw_edge = snap_edge and not is_bound
draw_vert = snap_vert and not is_bound
snap_obj.data.append(
GPU_Indices_Mesh(obj, draw_face, draw_edge, draw_vert))
snap_obj.data[1].set_draw_mode(snap_face, snap_edge, snap_vert)
snap_obj.data[1].set_ModelViewMatrix(snap_obj.mat)
if snap_obj == main_snap_obj:
snap_obj.data[1].Draw(self._offset_cur, -0.0001)
else:
snap_obj.data[1].Draw(self._offset_cur)
self._offset_cur += snap_obj.data[1].get_tot_elems()
tmp = self.snap_objects[self.drawn_count]
self.snap_objects[self.drawn_count] = self.snap_objects[i]
self.snap_objects[i] = tmp
self.drawn_count += 1
bgl.glReadBuffer(bgl.GL_COLOR_ATTACHMENT0)
bgl.glReadPixels(
int(self.mval[0]) - self._dist_px,
int(self.mval[1]) - self._dist_px, self.threshold, self.threshold,
bgl.GL_RED_INTEGER, bgl.GL_UNSIGNED_INT, self._snap_buffer)
#bgl.glReadBuffer(bgl.GL_BACK)
#import numpy as np
#a = np.array(self._snap_buffer)
#print(a)
snap_obj, index = self._get_nearest_index()
#print("index:", index)
if snap_obj:
ret = self._get_loc(snap_obj, index)
bgl.glDisable(bgl.GL_DEPTH_TEST)
self._offscreen.unbind()
_Internal.gpu_Indices_restore_state()
return (snap_obj, *ret)
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
tile_sel = SprytileGui.loaded_grid.tile_selection
padding = SprytileGui.loaded_grid.padding
margin = SprytileGui.loaded_grid.margin
is_pixel = sprytile_utils.grid_is_single_pixel(SprytileGui.loaded_grid)
# 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,
tile_sel, padding, margin, show_extra,
is_pixel)
# 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_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 view_3d_geom(context, args):
"""
draws the batches
"""
geom, config = args
bgl.glEnable(bgl.GL_BLEND)
if config.draw_polys:
if config.draw_gl_wireframe:
bgl.glPolygonMode(bgl.GL_FRONT_AND_BACK, bgl.GL_LINE)
if config.draw_gl_polygonoffset:
bgl.glEnable(bgl.GL_POLYGON_OFFSET_FILL)
bgl.glPolygonOffset(1.0, 1.0)
if config.shade_mode == 'fragment':
p_batch = batch_for_shader(config.p_shader,
'TRIS', {"position": geom.p_vertices},
indices=geom.p_indices)
config.p_shader.bind()
matrix = context.region_data.perspective_matrix
config.p_shader.uniform_float("viewProjectionMatrix", matrix)
config.p_shader.uniform_float("brightness", 0.5)
else:
if config.uniform_pols:
p_batch = batch_for_shader(config.p_shader,
'TRIS', {"pos": geom.p_vertices},
indices=geom.p_indices)
config.p_shader.bind()
config.p_shader.uniform_float("color", config.poly_color[0][0])
else:
p_batch = batch_for_shader(config.p_shader,
'TRIS', {
"pos": geom.p_vertices,
"color": geom.p_vertex_colors
},
indices=geom.p_indices)
config.p_shader.bind()
p_batch.draw(config.p_shader)
if config.draw_gl_polygonoffset:
bgl.glDisable(bgl.GL_POLYGON_OFFSET_FILL)
if config.draw_gl_wireframe:
bgl.glPolygonMode(bgl.GL_FRONT_AND_BACK, bgl.GL_FILL)
if config.draw_edges:
bgl.glLineWidth(config.line_width)
if config.draw_dashed:
shader = config.dashed_shader
batch = batch_for_shader(shader,
'LINES', {"inPos": geom.e_vertices},
indices=geom.e_indices)
shader.bind()
matrix = context.region_data.perspective_matrix
shader.uniform_float("u_mvp", matrix)
shader.uniform_float("u_resolution", config.u_resolution)
shader.uniform_float("u_dashSize", config.u_dash_size)
shader.uniform_float("u_gapSize", config.u_gap_size)
shader.uniform_float("m_color", geom.e_vertex_colors[0])
batch.draw(shader)
else:
if config.uniform_edges:
e_batch = batch_for_shader(config.e_shader,
'LINES', {"pos": geom.e_vertices},
indices=geom.e_indices)
config.e_shader.bind()
config.e_shader.uniform_float("color", config.edge_color[0][0])
e_batch.draw(config.e_shader)
else:
e_batch = batch_for_shader(config.e_shader,
'LINES', {
"pos": geom.e_vertices,
"color": geom.e_vertex_colors
},
indices=geom.e_indices)
config.e_shader.bind()
e_batch.draw(config.e_shader)
bgl.glLineWidth(1)
if config.draw_verts:
bgl.glPointSize(config.point_size)
if config.uniform_verts:
v_batch = batch_for_shader(config.v_shader, 'POINTS',
{"pos": geom.v_vertices})
config.v_shader.bind()
config.v_shader.uniform_float("color", config.vector_color[0][0])
else:
v_batch = batch_for_shader(config.v_shader, 'POINTS', {
"pos": geom.v_vertices,
"color": geom.points_color
})
config.v_shader.bind()
v_batch.draw(config.v_shader)
bgl.glPointSize(1)
bgl.glEnable(bgl.GL_BLEND)
def Draw_hdr_callback(self, context):
if context.area != Hdr.view3d_area:
return
elif context.area.type == 'PROPERTIES' and \
context.space_data.context != 'WORLD':
return
# Check if window area has changed for sticky zoom
theHdr = Hdr.object[0]
if Hdr.region.width < Hdr.saved_region_width:
diff = Hdr.saved_region_width - Hdr.region.width
if theHdr.origin.x + theHdr.width > Hdr.saved_region_width:
if theHdr.origin.x > 0:
theHdr.origin.x -= diff
else:
theHdr.width -= diff
else:
if Hdr.toolProps is not None:
if Hdr.toolProps.width > Hdr.toolProps_width:
theHdr.origin.x -= diff
Hdr.toolProps_width = Hdr.toolProps.width
if theHdr.origin.x < 0:
theHdr.origin.x += diff
else:
diff = Hdr.region.width - Hdr.saved_region_width
if theHdr.width > Hdr.saved_region_width:
theHdr.width += diff
else:
if Hdr.toolProps is not None:
if Hdr.toolProps.width < Hdr.toolProps_width:
theHdr.origin.x += diff
Hdr.toolProps_width = Hdr.toolProps.width
theHdr.set_dimensions(theHdr.width)
Hdr.saved_region_width = Hdr.region.width
zAzim = theHdr.width / 2
azimFac = zAzim / 180
zElev = theHdr.height / 2
elevFac = zElev / 90
crossChange = True
if not Hdr.action == 'PAN':
x = Hdr.mouse.x
y = Hdr.mouse.y
if x < theHdr.origin.x or x > theHdr.origin.x + theHdr.width:
crossChange = False
x = 0
else:
testBoundary = theHdr.origin.x + theHdr.width
if testBoundary < Hdr.region.width:
rightBoundary = testBoundary
else:
rightBoundary = Hdr.region.width
if x > rightBoundary:
crossChange = False
x = rightBoundary
cX = x - zAzim - theHdr.origin.x
if azimFac:
newAzimuth = cX / azimFac
else:
newAzimuth = 0.0
if y < theHdr.origin.y or y < 0:
crossChange = False
y = 0
elif y > theHdr.origin.y + theHdr.height:
crossChange = False
y = theHdr.origin.y + theHdr.height
cY = y - zElev - theHdr.origin.y
if elevFac:
newElevation = cY / elevFac
else:
newElevation = 0.0
if newElevation == Hdr.elevation and newAzimuth == Hdr.azimuth:
crossChange = False
else:
Hdr.elevation = newElevation
Hdr.azimuth = newAzimuth
else:
if Hdr.grab.offset.x < Hdr.grab.spot.x:
off = Hdr.grab.spot.x - Hdr.grab.offset.x
theHdr.origin.x -= off
else:
off = Hdr.grab.offset.x - Hdr.grab.spot.x
theHdr.origin.x += off
if Hdr.grab.offset.y < Hdr.grab.spot.y:
off = Hdr.grab.spot.y - Hdr.grab.offset.y
theHdr.origin.y -= off
else:
off = Hdr.grab.offset.y - Hdr.grab.spot.y
theHdr.origin.y += off
Hdr.grab.spot.x = Hdr.mouse.x
Hdr.grab.spot.y = Hdr.mouse.y
Lx = theHdr.origin.x
Ly = theHdr.origin.y
# ---------------------
# Draw a textured quad
# ---------------------
bgl.glEnable(bgl.GL_BLEND)
if Hdr.glImage.bindcode == 0:
Hdr.load_gl_image()
bgl.glBindTexture(bgl.GL_TEXTURE_2D, Hdr.glImage.bindcode)
bgl.glEnable(bgl.GL_TEXTURE_2D)
bgl.glColor4f(1.0, 1.0, 1.0, Hdr.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 + theHdr.width, Ly)
bgl.glTexCoord2f(1.0, 1.0)
bgl.glVertex2f(Lx + theHdr.width, Ly + theHdr.height)
bgl.glTexCoord2f(0.0, 1.0)
bgl.glVertex2f(Lx, theHdr.height + Ly)
bgl.glEnd()
bgl.glDisable(bgl.GL_TEXTURE_2D)
# ---------------------
# draw the crosshair
# ---------------------
x = theHdr.width / 2.0
if crossChange and not Hdr.lockCrosshair:
Sun.SP.HDR_azimuth = degToRad(newAzimuth + 180)
azimuth = ((radToDeg(Sun.SP.HDR_azimuth) - 180) * x / 180.0) + x
bgl.glEnable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_LINES)
bgl.glLineWidth(1.0)
alpha = 0.8
color = (0.4, 0.4, 0.4, alpha)
bgl.glColor4f(color[0], color[1], color[2], color[3])
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(Lx + azimuth, Ly)
bgl.glVertex2f(Lx + azimuth, Ly + theHdr.height)
bgl.glEnd()
y = theHdr.height / 2.0
if crossChange and not Hdr.lockCrosshair:
Sun.SP.HDR_elevation = newElevation
elevation = (Sun.SP.HDR_elevation * y / 90.0) + y
bgl.glColor4f(color[0], color[1], color[2], color[3])
bgl.glBegin(bgl.GL_LINES)
bgl.glVertex2f(Lx, Ly + elevation)
bgl.glVertex2f(Lx + theHdr.width, Ly + elevation)
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 + theHdr.width, Ly)
bgl.glVertex2f(Lx + theHdr.width, Ly + theHdr.height)
bgl.glVertex2f(Lx, theHdr.height + Ly)
bgl.glVertex2f(Lx, Ly)
bgl.glEnd()
bgl.glLineWidth(1.0)
bgl.glDisable(bgl.GL_LINES)
bgl.glFlush()
def restore_opengl_defaults():
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
def draw_callback_2d(self, context):
"""Callback function for 2d drawing.
Args:
context:
Returns:
"""
active = context.object
selected = context.selected_objects
if active and selected:
objects = set(selected + [active])
else:
objects = []
wm = context.window_manager
# code that can be used to draw on 2d surface in 3d mode, not used any more
# due to separate handlers for 2d and 3d
# bgl.glMatrixMode(bgl.GL_PROJECTION)
# bgl.glLoadIdentity()
# bgl.gluOrtho2D(0, bpy.context.region.width, 0, bpy.context.region.height)
# bgl.glMatrixMode(bgl.GL_MODELVIEW)
# bgl.glLoadIdentity()
bgl.glEnable(bgl.GL_BLEND)
# submechanisms
if objects and wm.draw_submechanisms:
submechanism_roots = [
obj for obj in bpy.data.objects if 'submechanism/name' in obj
]
# draw spanning trees
for root in submechanism_roots:
if 'submechanism/spanningtree' in root:
if set(root['submechanism/spanningtree']).intersection(
set(bpy.context.selected_objects)):
linecolor = colors['submechanism']
linewidth = 5
else:
linecolor = (*colors['submechanism'][:3], 0.4)
linewidth = 3
draw_path(root['submechanism/spanningtree'],
color=linecolor,
width=linewidth)
# joint['submechanism/independent'],
# joint['submechanism/active'])
avgpos = Vector()
for obj in root['submechanism/spanningtree']:
avgpos += obj.matrix_world.translation
origin = to2d(avgpos / len(root['submechanism/spanningtree']))
draw_textbox(
root['submechanism/name'],
origin,
textsize=8,
textcolor=linecolor,
backgroundcolor=colors['background'],
offset=Vector((-30, 0)),
)
# joints
if objects and wm.draw_jointnames:
for obj in [obj for obj in objects if obj.phobostype == 'link']:
origin = to2d(obj.matrix_world.translation)
draw_textbox(
nUtils.getObjectName(obj, 'joint'),
origin,
textsize=6,
textcolor=colors['dark_grey'],
backgroundcolor=colors['bright_background'],
rightalign=True,
offset=Vector((-16, 0)),
)
if wm.draw_submechanisms and 'submechanism/jointname' in obj:
draw_textbox(
obj['submechanism/jointname'],
origin,
textsize=6,
textcolor=colors['dark_grey'],
backgroundcolor=(*colors['submechanism'][:3], 0.7),
offset=Vector((16, 0)),
)
# interfaces
if selected:
for interface in [
obj for obj in selected if obj.phobostype == 'interface'
]:
color = interface.active_material.diffuse_color
maxc = max(color)
color = [0.6 + c / maxc * 0.4 for c in color]
bgcolor = [
c * 0.4 for c in interface.active_material.diffuse_color
]
draw_textbox(
nUtils.getObjectName(interface),
to2d(interface.matrix_world.translation),
textsize=6,
textcolor=(*color, 1.0 if interface.show_name else 0.4),
backgroundcolor=(*bgcolor, 1.0)
if interface.show_name else colors['background'],
linewidth=3 if interface.show_name else 2,
)
# progress bar
if wm.draw_progress and context.window_manager.progress not in [0, 1]:
draw_progressbar(wm.progress)
# log messages
if wm.draw_messages:
for m in range(wm.phobos_msg_count):
opacity = 1.0
if 1 >= m <= wm.phobos_msg_offset - 1 or m >= wm.phobos_msg_count - 2:
opacity = 0.5
if wm.phobos_msg_offset > 1 > m or m >= wm.phobos_msg_count - 1:
opacity = 0.1
try:
msg = messages[m + wm.phobos_msg_offset]
draw_message(msg['text'],
msg['type'],
m,
opacity,
offset=wm.phobos_msg_offset)
except IndexError:
pass
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw(self, context):
# only draw highlight if no transform are running (mouse moving is False then) and no animation playback
# for performance reasons
if self.current_mesh and not bpy.context.screen.is_animation_playing and self.is_mouse_moving == "True":
if self.current_mesh.name in self.objects_data and self.current_vgroup:
if self.current_vgroup[:
3] == 'fs_' or self.current_vgroup[:
3] == 'fs:':
# start_time1 = time.time()
mesh_evaluation_method = 1
if mesh_evaluation_method == 0:
mesh_baked = self.current_mesh.to_mesh(
preserve_all_data_layers=False,
depsgraph=bpy.context.evaluated_depsgraph_get())
_verts = mesh_baked.vertices
else:
"""
mesh_baked = bmesh.new()
depsg = bpy.context.evaluated_depsgraph_get()
mesh_baked.from_object(self.current_mesh, depsg, deform=True, face_normals=False)
mesh_baked.verts.ensure_lookup_table()
_verts = mesh_baked.verts
"""
deps = bpy.context.evaluated_depsgraph_get()
object_eval = self.current_mesh.evaluated_get(deps)
mesh_baked = object_eval.to_mesh(
preserve_all_data_layers=False,
depsgraph=bpy.context.evaluated_depsgraph_get())
_verts = mesh_baked.vertices
# start_time1 = time.time()
mw = self.current_mesh.matrix_world
object_data = self.objects_data[self.current_mesh.name]
verts_list = object_data["vertex_groups_dict"][
self.current_vgroup]
# verts_co = [mw @ Vector((round(_verts[v].co[0], 2), round(_verts[v].co[1], 2), round(_verts[
# v].co[2], 2))) for v in verts_list]
verts_co = [mw @ _verts[v].co for v in verts_list]
vertex_colors = [
self.highlight_color for _ in range(len(verts_co))
]
if mesh_evaluation_method == 0:
try:
bpy.data.meshes.remove(mesh_baked)
except:
pass
# print('Computed verts in', time.time() - start_time1)
# batch and shader
batch = batch_for_shader(
self.shader,
'TRIS', {
"pos": verts_co,
"color": vertex_colors
},
indices=object_data["indices_groups_dict"][
self.current_vgroup])
# Render
if self.backface_cull:
bgl.glEnable(bgl.GL_CULL_FACE)
bgl.glEnable(bgl.GL_BLEND)
bgl.glDepthMask(bgl.GL_TRUE)
# bgl.glDepthFunc(bgl.GL_LEQUAL)
# bgl.glDepthRange(0.1, 1.0)
# bgl.glClearDepth(1.0)
# bgl.glPolygonMode(bgl.GL_FRONT, bgl.GL_FILL)
# bgl.glClear(bgl.GL_DEPTH_BUFFER_BIT)
batch.draw(self.shader)
bgl.glDisable(bgl.GL_BLEND)
def _draw_browser(self, context):
"""OpenGL drawing code for the BROWSING state."""
window_region = self._window_region(context)
content_width = window_region.width - ITEM_MARGIN_X * 2
content_height = window_region.height - ITEM_MARGIN_Y * 2
content_x = ITEM_MARGIN_X
content_y = context.area.height - ITEM_MARGIN_Y - TARGET_ITEM_HEIGHT
col_count = content_width // TARGET_ITEM_WIDTH
item_width = (content_width - (col_count * ITEM_PADDING_X)) / col_count
item_height = TARGET_ITEM_HEIGHT
block_width = item_width + ITEM_PADDING_X
block_height = item_height + ITEM_MARGIN_Y
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 0.6)
bgl.glRectf(0, 0, window_region.width, window_region.height)
if self.current_display_content:
bottom_y = float('inf')
# The -1 / +2 are for extra rows that are drawn only half at the top/bottom.
first_item_idx = max(
0,
int(-self.scroll_offset // block_height - 1) * col_count)
items_per_page = int(content_height // item_height + 2) * col_count
last_item_idx = first_item_idx + items_per_page
for item_idx, item in enumerate(self.current_display_content):
x = content_x + (item_idx % col_count) * block_width
y = content_y - (item_idx //
col_count) * block_height - self.scroll_offset
item.update_placement(x, y, item_width, item_height)
if first_item_idx <= item_idx < last_item_idx:
# Only draw if the item is actually on screen.
item.draw(
highlighted=item.hits(self.mouse_x, self.mouse_y))
bottom_y = min(y, bottom_y)
self.scroll_offset_space_left = window_region.height - bottom_y
self.scroll_offset_max = (self.scroll_offset -
self.scroll_offset_space_left +
0.25 * block_height)
else:
font_id = 0
text = "Communicating with Blender Cloud"
bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
blf.size(font_id, 20, 72)
text_width, text_height = blf.dimensions(font_id, text)
blf.position(font_id,
content_x + content_width * 0.5 - text_width * 0.5,
content_y - content_height * 0.3 + text_height * 0.5,
0)
blf.draw(font_id, text)
bgl.glDisable(bgl.GL_BLEND)
def DRAW_Overlay(self, context):
np_print('DRAW_Overlay_START', ';', 'NP020FB.flag = ', NP020FB.flag)
'''
addon_prefs = context.preferences.addons[__package__].preferences
badge = addon_prefs.npfb_badge
badge_size = addon_prefs.npfb_badge_size
dist_scale = addon_prefs.npfb_dist_scale
'''
flag = NP020FB.flag
helper = NP020FB.helper
matrix = helper.matrix_world.to_3x3()
region = bpy.context.region
rv3d = bpy.context.region_data
rw = region.width
rh = region.height
qdef = NP020FB.qdef
ndef = NP020FB.ndef
ro_hor_def = NP020FB.ro_hor_def
constrain = NP020FB.constrain
np_print('rw, rh', rw, rh)
rmin = int(min(rw, rh) / 50)
if rmin == 0: rmin = 1
co2d = view3d_utils.location_3d_to_region_2d(region, rv3d, helper.location)
if qdef != None and constrain == False:
q = qdef
n = ndef
pointloc = helper.location
ro_hor = ro_hor_def
elif qdef != None and constrain == True:
q = qdef
n = ndef
pointloc = get_ro_normal_from_vertical(region, rv3d, co2d)[2]
ro_hor = ro_hor_def
else:
q = get_ro_normal_from_vertical(region, rv3d, co2d)[1]
n = get_ro_normal_from_vertical(region, rv3d, co2d)[0]
pointloc = get_ro_normal_from_vertical(region, rv3d, co2d)[2]
ro_hor, isohipse = get_ro_x_from_iso(region, rv3d, co2d,
helper.location)
if pointloc == Vector((0.0, 0.0, 0.0)): pointloc = helper.location
np_print('n / q', n, q)
NP020FB.q = q
NP020FB.n = n
NP020FB.pointloc = pointloc
NP020FB.ro_hor = ro_hor
np_print('co2d, n, q', co2d, n, q)
# Acquiring factor for graphics scaling in order to be space - independent
fac = get_fac_from_view_loc_plane(region, rv3d, rmin, helper.location, q)
NP020FB.fac = fac
symbol = [[18, 37], [21, 37], [23, 33], [26, 33]]
badge_mode = 'RUN'
if qdef != None:
matrix.rotate(ro_hor)
matrix.rotate(qdef)
NP020FB.matrix = matrix
if flag == 'RUNTRANS0':
instruct = 'choose plane / place corner point'
keys_aff = 'LMB - select, CTRL - snap, ENT - lock plane'
keys_nav = ''
keys_neg = 'ESC, RMB - quit'
box = [
helper.location, helper.location, helper.location, helper.location,
helper.location, helper.location, helper.location, helper.location
]
message_main = 'CTRL+SNAP'
message_aux = None
aux_num = None
aux_str = None
elif flag == 'RUNTRANS1':
instruct = 'define the width of the box'
keys_aff = 'LMB - select, CTRL - snap, NUMPAD - value'
keys_nav = ''
keys_neg = 'ESC, RMB - quit'
p0 = NP020FB.p0
box = [
p0, helper.location, helper.location, p0, p0, helper.location,
helper.location, p0
]
message_main = 'CTRL+SNAP'
message_aux = None
aux_num = None
aux_str = None
elif flag == 'RUNTRANS2':
instruct = 'define the length of the box'
keys_aff = 'LMB - select, CTRL - snap, NUMPAD - value'
keys_nav = ''
keys_neg = 'ESC, RMB - quit'
p0 = NP020FB.p0
p1 = NP020FB.p1
box = [
p0, p1, helper.location, p0 + (helper.location - p1), p0, p1,
helper.location, p0 + (helper.location - p1)
]
message_main = 'CTRL+SNAP'
message_aux = None
aux_num = None
aux_str = None
elif flag == 'RUNTRANS3':
instruct = 'define the height of the box'
keys_aff = 'LMB - select, CTRL - snap, NUMPAD - value'
keys_nav = ''
keys_neg = 'ESC, RMB - quit'
p0 = NP020FB.p0
p1 = NP020FB.p1
p2 = NP020FB.p2
p3 = p0 + (p2 - p1)
h = helper.location - p2
box = [p0, p1, p2, p3, p0 + h, p1 + h, p2 + h, p3 + h]
message_main = 'CTRL+SNAP'
message_aux = None
aux_num = None
aux_str = None
NP020FB.box = box
# ON-SCREEN INSTRUCTIONS:
display_instructions(region, rv3d, instruct, keys_aff, keys_nav, keys_neg)
# drawing of box:
box_2d = []
for co in box:
co = view3d_utils.location_3d_to_region_2d(region, rv3d, co)
box_2d.append(co)
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
bgl.glLineWidth(1)
bgl.glBegin(bgl.GL_LINE_STRIP)
for i in range(0, 4):
bgl.glVertex2f(*box_2d[i])
bgl.glVertex2f(*box_2d[0])
bgl.glVertex2f(*box_2d[4])
bgl.glVertex2f(*box_2d[7])
bgl.glVertex2f(*box_2d[3])
bgl.glVertex2f(*box_2d[7])
bgl.glVertex2f(*box_2d[6])
bgl.glVertex2f(*box_2d[2])
bgl.glVertex2f(*box_2d[6])
bgl.glVertex2f(*box_2d[5])
bgl.glVertex2f(*box_2d[1])
bgl.glVertex2f(*box_2d[5])
bgl.glVertex2f(*box_2d[4])
bgl.glEnd()
bgl.glColor4f(1.0, 1.0, 1.0, 0.25)
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
boxfaces = ((0, 1, 2, 3), (0, 1, 5, 4), (1, 2, 6, 5), (2, 3, 7, 6),
(3, 0, 4, 7), (4, 5, 6, 7))
for face in boxfaces:
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
bgl.glVertex2f(*box_2d[face[0]])
bgl.glVertex2f(*box_2d[face[1]])
bgl.glVertex2f(*box_2d[face[2]])
bgl.glVertex2f(*box_2d[face[3]])
bgl.glEnd()
# Drawing the small badge near the cursor with the basic instructions:
display_cursor_badge(co2d, symbol, badge_mode, message_main, message_aux,
aux_num, aux_str)
# writing the dots for boxwidget widget at center of scene:
geowidget_base = [(0.0, 0.0, 0.0), (5.0, 0.0, 0.0), (5.0, -3.0, 0.0),
(0.0, -3.0, 0.0)]
geowidget_top = [(0.0, 0.0, 4.0), (5.0, 0.0, 4.0), (5.0, -3.0, 4.0),
(0.0, -3.0, 4.0)]
geowidget_rest = [(0.0, 0.0, 0.0), (0.0, 0.0, 4.0), (5.0, 0.0, 4.0),
(5.0, 0.0, 0.0), (5.0, -3.0, 0.0), (5.0, -3.0, 4.0),
(0.0, -3.0, 4.0), (0.0, -3.0, 0.0)]
# ON-SCREEN DISPLAY OF GEOWIDGET:
display_geowidget(region, rv3d, fac, ro_hor, q, helper.location, n, qdef,
geowidget_base, geowidget_top, geowidget_rest)
# ON-SCREEN DISTANCES AND OTHERS:
'''
if addon_prefs.npfb_suffix == 'None':
suffix = None
elif addon_prefs.npfb_suffix == 'km':
suffix = ' km'
elif addon_prefs.npfb_suffix == 'm':
suffix = ' m'
elif addon_prefs.npfb_suffix == 'cm':
suffix = ' cm'
elif addon_prefs.npfb_suffix == 'mm':
suffix = ' mm'
elif addon_prefs.npfb_suffix == 'nm':
suffix = ' nm'
elif addon_prefs.npfb_suffix == "'":
suffix = "'"
elif addon_prefs.npfb_suffix == '"':
suffix = '"'
elif addon_prefs.npfb_suffix == 'thou':
suffix = ' thou'
'''
# ON-SCREEN DISTANCES:
display_distance_between_two_points(region, rv3d, box[0], box[1])
display_distance_between_two_points(region, rv3d, box[1], box[2])
display_distance_between_two_points(region, rv3d, box[2], box[6])
#ENDING:
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_polygon_object(mat,
vertices,
faces,
face_color,
draw_faces,
draw_wires,
wire_lines=None,
wire_color=(0, 0, 0),
face_transforms=None,
wire_transforms=None):
"""
Draw a collider polygon object. It takes matrix, vertices (coordinates),
faces (vertex index references), face color (RGB), faces drawing state (bool),
wires drawing state (bool) and optional values wire lines (list of lists
of vertex positions resulting in closed lines), wire color (RGB),
face transformations (list of vertex indices)
and wire transformations (list of vertex indices).
:param mat:
:param vertices:
:param faces:
:param face_color:
:param draw_faces:
:param draw_wires:
:param wire_lines:
:param wire_color:
:param face_transforms:
:param wire_transforms:
:return:
"""
if draw_faces:
for face in faces:
glBegin(GL_POLYGON)
glColor3f(face_color[0], face_color[1], face_color[2])
for vert in face:
if face_transforms:
trans = mat
for transformation in face_transforms:
if vert in transformation[1]:
trans = trans * transformation[0]
glVertex3f(*(trans * Vector(vertices[vert])))
else:
glVertex3f(*(mat * Vector(vertices[vert])))
glEnd()
if draw_wires:
if wire_lines:
# DRAW CUSTOM LINES
vert_i_global = 0
for line in wire_lines:
# glLineWidth(2.0)
glEnable(GL_LINE_STIPPLE)
glBegin(GL_LINES)
glColor3f(wire_color[0], wire_color[1], wire_color[2])
for vert_i, vert1 in enumerate(line):
if vert_i + 1 < len(line):
vert2 = line[vert_i + 1]
else:
continue
# SEPARATE PART TRANSFORMATIONS
if wire_transforms:
trans1 = trans2 = mat
for transformation in wire_transforms:
if vert_i_global in transformation[1]:
trans1 = trans1 * transformation[0]
if vert_i_global + 1 in transformation[1]:
trans2 = trans2 * transformation[0]
glVertex3f(*(trans1 * Vector(vert1)))
glVertex3f(*(trans2 * Vector(vert2)))
else:
glVertex3f(*(mat * Vector(vert1)))
glVertex3f(*(mat * Vector(vert2)))
vert_i_global += 1
vert_i_global += 1
glEnd()
glDisable(GL_LINE_STIPPLE)
# glLineWidth(1.0)
else:
for face in faces:
# glLineWidth(2.0)
glEnable(GL_LINE_STIPPLE)
glBegin(GL_LINES)
glColor3f(wire_color[0], wire_color[1], wire_color[2])
for vert_i, vert1 in enumerate(face):
if vert_i + 1 == len(face):
vert2 = face[0]
else:
vert2 = face[vert_i + 1]
if face_transforms:
trans1 = mat
trans2 = mat
vec1 = Vector(vertices[vert1])
vec2 = Vector(vertices[vert2])
for transformation in face_transforms:
if vert1 in transformation[1]:
trans1 = trans1 * transformation[0]
if vert2 in transformation[1]:
trans2 = trans2 * transformation[0]
glVertex3f(*(trans1 * vec1))
glVertex3f(*(trans2 * vec2))
else:
glVertex3f(*(mat * Vector(vertices[vert1])))
glVertex3f(*(mat * Vector(vertices[vert2])))
glEnd()
glDisable(GL_LINE_STIPPLE)
# glLineWidth(1.0)
if 0: # DEBUG: draw points from faces geometry
glPointSize(3.0)
glBegin(GL_POINTS)
glColor3f(0.5, 0.5, 1)
for vertex_i, vertex in enumerate(vertices):
vec = Vector(vertex)
if face_transforms:
trans = mat
for transformation in face_transforms:
if vertex_i in transformation[1]:
trans = trans * transformation[0]
glVertex3f(*(trans * vec))
else:
glVertex3f(*(mat * vec.to_3d()))
glEnd()
glPointSize(1.0)
if 0: # DEBUG: draw points from lines geometry
if wire_lines:
glPointSize(3.0)
glBegin(GL_POINTS)
glColor3f(1, 0, 0.5)
vert_i_global = 0
for line in wire_lines:
for vert_i, vertex in enumerate(line):
if vert_i + 1 < len(line):
vec = Vector(vertex)
else:
continue
if wire_transforms:
trans = mat
for transformation in wire_transforms:
if vert_i_global in transformation[1]:
trans = trans * transformation[0]
glVertex3f(*(trans * vec.to_3d()))
else:
glVertex3f(*(mat * vec.to_3d()))
vert_i_global += 1
vert_i_global += 1
glEnd()
glPointSize(1.0)
def mesh_check_draw_callback():
obj = bpy.context.object
if obj and obj.type == 'MESH':
if draw_enabled[0]:
mesh = obj.data
matrix_world = obj.matrix_world
glLineWidth(edge_width[0])
if bpy.context.mode == 'EDIT_MESH':
use_occlude = 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)
use_occlude = False
if finer_lines[0]:
glLineWidth(edge_width[0] / 4.0)
use_occlude = True
for face in bm.faces:
if len([verts for verts in face.verts]) == 3:
faces = [
matrix_world * vert.co for vert in face.verts
]
glColor4f(*faces_tri_color[0])
glEnable(GL_BLEND)
glBegin(GL_POLYGON)
draw_poly(faces)
glEnd()
for edge in face.edges:
if edge.is_valid:
edges = [
matrix_world * vert.co
for vert in edge.verts
]
glColor4f(*edges_tri_color[0])
glBegin(GL_LINES)
draw_poly(edges)
glEnd()
elif len([verts for verts in face.verts]) > 4:
new_faces = []
faces = []
coords = [v.co for v in face.verts]
indices = [v.index for v in face.verts]
for pol in tessellate([coords]):
new_faces.append([indices[i] for i in pol])
for f in new_faces:
faces.append([
((matrix_world * bm.verts[i].co)[0] +
face.normal.x * 0.001,
(matrix_world * bm.verts[i].co)[1] +
face.normal.y * 0.001,
(matrix_world * bm.verts[i].co)[2] +
face.normal.z * 0.001) for i in f
])
for f in faces:
glColor4f(*faces_ngons_color[0])
glEnable(GL_BLEND)
glBegin(GL_POLYGON)
draw_poly(f)
glEnd()
for edge in face.edges:
if edge.is_valid:
edges = [
matrix_world * vert.co
for vert in edge.verts
]
glColor4f(*edges_ngons_color[0])
glBegin(GL_LINES)
draw_poly(edges)
glEnd()
glDisable(GL_BLEND)
glColor4f(0.0, 0.0, 0.0, 1.0)
glLineWidth(edge_width[0])
glEnable(GL_DEPTH_TEST)
if use_occlude:
for face in bm.faces:
if len([verts for verts in face.verts]) == 3:
faces = []
for vert in face.verts:
vert_face = matrix_world * vert.co
faces.append(
(vert_face[0] + face.normal.x * 0.001,
vert_face[1] + face.normal.y * 0.001,
vert_face[2] + face.normal.z * 0.001))
glColor4f(*faces_tri_color[0])
glEnable(GL_BLEND)
glBegin(GL_POLYGON)
draw_poly(faces)
glEnd()
for edge in face.edges:
if edge.is_valid:
edges = []
for vert in edge.verts:
vert_edge = matrix_world * vert.co
edges.append((vert_edge[0] +
face.normal.x * 0.001,
vert_edge[1] +
face.normal.y * 0.001,
vert_edge[2] +
face.normal.z * 0.001))
glColor4f(*edges_tri_color[0])
glBegin(GL_LINES)
draw_poly(edges)
glEnd()
elif len([verts for verts in face.verts]) > 4:
new_faces = []
faces = []
coords = [v.co for v in face.verts]
indices = [v.index for v in face.verts]
for pol in tessellate([coords]):
new_faces.append([indices[i] for i in pol])
for f in new_faces:
faces.append([
((matrix_world * bm.verts[i].co)[0] +
face.normal.x * 0.001,
(matrix_world * bm.verts[i].co)[1] +
face.normal.y * 0.001,
(matrix_world * bm.verts[i].co)[2] +
face.normal.z * 0.001) for i in f
])
for f in faces:
glColor4f(*faces_ngons_color[0])
glEnable(GL_BLEND)
glBegin(GL_POLYGON)
draw_poly(f)
glEnd()
for edge in face.edges:
if edge.is_valid:
edges = []
for vert in edge.verts:
vert_edge = matrix_world * vert.co
edges.append((vert_edge[0] +
face.normal.x * 0.001,
vert_edge[1] +
face.normal.y * 0.001,
vert_edge[2] +
face.normal.z * 0.001))
glColor4f(*edges_ngons_color[0])
glBegin(GL_LINES)
draw_poly(edges)
glEnd()
glDisable(GL_BLEND)
glColor4f(0.0, 0.0, 0.0, 1.0)
def draw_callback(self, context):
"""
:type context: bpy.types.Context
"""
prefs = QuickBooleanPreferences.get_instance()
color = prefs.color
snap_color = prefs.snap_color
region = context.region
glsettings = vagl.GLSettings(context)
glsettings.push()
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(*color)
show_reversed = False
if self.reverse:
if self.mode == 'POLYGON':
if len(self.mouse_coords) >= 3:
show_reversed = True
else:
if len(self.mouse_coords) >= 2:
if self.mouse_coords[0] != self.mouse_coords[1]:
show_reversed = True
if show_reversed:
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glClearDepth(1.0)
bgl.glClear(bgl.GL_DEPTH_BUFFER_BIT)
bgl.glDepthMask(1)
bgl.glColorMask(0, 0, 0, 0)
lines = []
if self.mouse_coords:
if self.mode == 'LINE':
w = region.width
h = region.height
p1, p2 = self.mouse_coords
line = (p2 - p1).normalized()
normal = Vector([-line[1], line[0]])
corners = [
Vector([0, 0]),
Vector([w, 0]),
Vector([w, h]),
Vector([0, h])
]
corners_ofs = [v - p1 for v in corners]
dists = [v.project(line).dot(line) for v in corners_ofs]
i = dists.index(min(dists))
line_min = corners_ofs[i].project(line) + p1
i = dists.index(max(dists))
line_max = corners_ofs[i].project(line) + p1
dists = [v.project(normal).dot(normal) for v in corners_ofs]
i = dists.index(max(dists))
normal_max_f = corners_ofs[i].project(normal).dot(normal)
vec = normal * normal_max_f
coords = [line_min, line_max, line_max + vec, line_min + vec]
bgl.glBegin(bgl.GL_QUADS)
for co in coords:
bgl.glVertex2f(*co)
bgl.glEnd()
lines = self.mouse_coords
elif self.mode == 'BOX':
p1, p2 = self.mouse_coords
bgl.glRectf(p1[0], p1[1], p2[0], p2[1])
lines = [
p1,
Vector((p2[0], p1[1])),
Vector((p2[0], p2[1])),
Vector((p1[0], p2[1])), p1
]
elif self.mode == 'CIRCLE':
p1, p2 = self.mouse_coords
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
bgl.glVertex2f(*p1)
r = (p2 - p1).length
coords = calc_circle_coords(p1, r, self.circle_segments,
self.circle_direction)
for co in coords:
bgl.glVertex2f(*co)
bgl.glVertex2f(*coords[0])
bgl.glEnd()
lines = coords + [coords[0]]
elif self.mode == 'POLYGON':
if len(self.mouse_coords) >= 3:
tris = mathutils.geometry.tessellate_polygon(
[[co.to_3d() for co in self.mouse_coords]])
bgl.glBegin(bgl.GL_TRIANGLES)
for tri in tris:
for i in tri:
bgl.glVertex2f(*self.mouse_coords[i])
bgl.glEnd()
if len(self.mouse_coords) > 1:
lines = self.mouse_coords + [self.mouse_coords[0]]
if show_reversed:
bgl.glColorMask(1, 1, 1, 1)
bgl.glBegin(bgl.GL_QUADS)
bgl.glVertex3f(0, 0, -1)
bgl.glVertex3f(region.width, 0, -1)
bgl.glVertex3f(region.width, region.height, -1)
bgl.glVertex3f(0, region.height, -1)
bgl.glEnd()
bgl.glDisable(bgl.GL_DEPTH_TEST)
bgl.glColor4f(*color[:3], 1.0)
bgl.glPointSize(1)
bgl.glLineWidth(1)
if len(lines) > 1:
bgl.glBegin(bgl.GL_LINE_STRIP)
for co in lines:
bgl.glVertex2f(*co)
bgl.glEnd()
if self.mode == 'POLYGON':
if len(self.mouse_coords) == 1:
bgl.glPointSize(5)
bgl.glBegin(bgl.GL_POINTS)
for co in self.mouse_coords:
bgl.glVertex2f(*co)
bgl.glEnd()
bgl.glPointSize(1)
bgl.glLineWidth(1)
if self.mco_ctrl:
SIZE = 12
bgl.glColor4f(*snap_color)
bgl.glBegin(bgl.GL_LINE_LOOP)
v = self.mco_mod
x = v[0] - SIZE / 2
y = v[1] - SIZE / 2
bgl.glVertex2f(x, y)
bgl.glVertex2f(x + SIZE, y)
bgl.glVertex2f(x + SIZE, y + SIZE)
bgl.glVertex2f(x, y + SIZE)
bgl.glEnd()
glsettings.pop()
glsettings.font_size()
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 generate_icon(name, verts=None, faces=None, coll="shape_types"):
pcoll = preview_collections[coll]
if name in pcoll:
thumb = pcoll.get(name)
else:
thumb = pcoll.new(name)
thumb.image_size = (200, 200)
if verts is not None:
import bgl
polygon_color = bpy.context.user_preferences.themes[
0].view_3d.edge_facesel
edge_color = bpy.context.user_preferences.themes[0].view_3d.edge_select
vertex_color = bpy.context.user_preferences.themes[
0].view_3d.vertex_select
clear_color = bpy.context.user_preferences.themes[
0].user_interface.wcol_menu.inner
viewport_info = bgl.Buffer(bgl.GL_INT, 4)
bgl.glGetIntegerv(bgl.GL_VIEWPORT, viewport_info)
buffer = bgl.Buffer(bgl.GL_FLOAT, 200 * 200 * 4)
bgl.glDisable(bgl.GL_SCISSOR_TEST)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
bgl.glEnable(bgl.GL_LINE_SMOOTH)
bgl.glEnable(bgl.GL_POINT_SMOOTH)
bgl.glViewport(0, 0, 200, 200)
bgl.glMatrixMode(bgl.GL_MODELVIEW)
bgl.glPushMatrix()
bgl.glLoadIdentity()
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glPushMatrix()
bgl.glLoadIdentity()
bgl.gluOrtho2D(0, 0, 0, 0)
bgl.glLineWidth(4.0)
bgl.glPointSize(10.0)
bgl.glClearColor(*clear_color)
bgl.glClear(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_DEPTH_BUFFER_BIT)
if faces is None:
bgl.glBegin(bgl.GL_POLYGON)
bgl.glColor3f(*polygon_color)
for vert in verts:
bgl.glVertex2f(*vert)
bgl.glEnd()
else:
bgl.glBegin(bgl.GL_TRIANGLES)
bgl.glColor3f(*polygon_color)
for face in faces:
bgl.glVertex2f(*verts[face[0]])
bgl.glVertex2f(*verts[face[1]])
bgl.glVertex2f(*verts[face[2]])
bgl.glEnd()
bgl.glBegin(bgl.GL_LINE_LOOP)
bgl.glColor3f(*edge_color)
for vert in verts:
bgl.glVertex2f(*vert)
bgl.glEnd()
bgl.glBegin(bgl.GL_POINTS)
bgl.glColor3f(*vertex_color)
for vert in verts:
bgl.glVertex2f(*vert)
bgl.glEnd()
bgl.glReadPixels(0, 0, 200, 200, bgl.GL_RGBA, bgl.GL_FLOAT, buffer)
bgl.glEnable(bgl.GL_SCISSOR_TEST)
bgl.glLineWidth(1.0)
bgl.glPointSize(1.0)
buffer = buffer[:]
for idx in range(0, 200 * 200 * 4, 4):
if buffer[idx] == clear_color[0] and \
buffer[idx + 1] == clear_color[1] and buffer[idx + 2] == clear_color[2]:
buffer[idx + 3] = 0.0
thumb.image_pixels_float = buffer
def disable_depth_test():
glDisable(GL_DEPTH_TEST)
def draw_callback(cls, context):
prefs = compat.get_user_preferences(context).addons[__package__].preferences
if context.window.as_pointer() != cls.origin["window"]:
return # Not match target window.
rect = cls.calc_draw_area_rect(context)
if not rect:
return # No draw target.
draw_area_min_x, draw_area_min_y, draw_area_max_x, draw_area_max_y = rect
_, _, _, origin_x, origin_y = cls.get_origin(context)
width = draw_area_max_x - origin_x
height = draw_area_max_y - origin_y
if width == height == 0:
return
region = context.region
area = context.area
if region.type == 'WINDOW':
region_min_x, region_min_y, region_max_x, region_max_y = get_window_region_rect(area)
else:
region_min_x = region.x
region_min_y = region.y
region_max_x = region.x + region.width - 1
region_max_y = region.y + region.height - 1
if not intersect_aabb(
[region_min_x, region_min_y], [region_max_x, region_max_y],
[draw_area_min_x + 1, draw_area_min_y + 1], [draw_area_max_x - 1, draw_area_max_x - 1]):
# We don't need to draw if draw area is not overlapped with region.
return
current_time = time.time()
region_drawn = False
font_size = prefs.font_size
font_id = 0
dpi = compat.get_user_preferences(context).system.dpi
blf.size(font_id, font_size, dpi)
scissor_box = bgl.Buffer(bgl.GL_INT, 4)
bgl.glGetIntegerv(bgl.GL_SCISSOR_BOX, scissor_box)
# Clip 'TOOLS' and 'UI' region from 'WINDOW' region if need.
# This prevents from drawing multiple time when
# user_preferences.system.use_region_overlap is True.
if context.area.type == 'VIEW_3D' and region.type == 'WINDOW':
x_min, y_min, x_max, y_max = get_region_rect_on_v3d(context)
bgl.glScissor(x_min, y_min, x_max - x_min + 1, y_max - y_min + 1)
# Get string height in draw area.
sh = blf.dimensions(0, string.printable)[1]
x = origin_x - region.x
y = origin_y - region.y
# Draw last operator.
operator_history = cls.removed_old_operator_history()
if prefs.show_last_operator and operator_history:
time_, bl_label, idname_py, _ = operator_history[-1]
if current_time - time_ <= prefs.display_time:
compat.set_blf_font_color(font_id, *prefs.color, 1.0)
# Draw operator text.
text = bpy.app.translations.pgettext_iface(bl_label, "Operator")
text += " ('{}')".format(idname_py)
offset_x = cls.get_text_offset_for_alignment(font_id, text, context)
blf.position(font_id, x + offset_x, y, 0)
if prefs.background:
draw_text_background(text, font_id, x + offset_x, y, prefs.color_background)
draw_text(text, font_id, prefs.color, prefs.shadow, prefs.color_shadow)
y += sh + sh * cls.HEIGHT_RATIO_FOR_SEPARATOR * 0.2
# Draw separator.
sw = blf.dimensions(font_id, "Left Mouse")[0]
offset_x = cls.get_offset_for_alignment(sw, context)
draw_line([x + offset_x, y], [x + sw + offset_x, y], prefs.color, prefs.shadow, prefs.color_shadow)
y += sh * cls.HEIGHT_RATIO_FOR_SEPARATOR * 0.8
region_drawn = True
else:
y += sh + sh * cls.HEIGHT_RATIO_FOR_SEPARATOR
# Draw hold modifier keys.
drawing = False # TODO: Need to check if drawing is now on progress.
compat.set_blf_font_color(font_id, *prefs.color, 1.0)
margin = sh * 0.2
if cls.hold_modifier_keys or drawing:
mod_keys = cls.sorted_modifier_keys(cls.hold_modifier_keys)
if drawing:
text = ""
else:
text = " + ".join(mod_keys)
offset_x = cls.get_text_offset_for_alignment(font_id, text, context)
# Draw rounded box.
box_height = sh + margin * 2
box_width = blf.dimensions(font_id, text)[0] + margin * 2
draw_rounded_box(x - margin + offset_x, y - margin,
box_width, box_height, box_height * 0.2,
prefs.background, prefs.color_background)
# Draw key text.
blf.position(font_id, x + offset_x, y + margin, 0)
draw_text(text, font_id, prefs.color, prefs.shadow, prefs.color_shadow)
bgl.glColor4f(*prefs.color, 1.0)
region_drawn = True
y += sh + margin * 2
# Draw event history.
event_history = cls.removed_old_event_history()
y += sh * cls.HEIGHT_RATIO_FOR_SEPARATOR
for _, event_type, modifiers, repeat_count in event_history[::-1]:
color = prefs.color
compat.set_blf_font_color(font_id, *color, 1.0)
text = get_display_event_text(event_type.name)
if modifiers:
mod_keys = cls.sorted_modifier_keys(modifiers)
text = "{} + {}".format(" + ".join(mod_keys), text)
if repeat_count > 1:
text += " x{}".format(repeat_count)
offset_x = cls.get_text_offset_for_alignment(font_id, text, context)
blf.position(font_id, x + offset_x, y, 0)
if prefs.background:
draw_text_background(text, font_id, x + offset_x, y, prefs.color_background)
draw_text(text, font_id, prefs.color, prefs.shadow, prefs.color_shadow)
y += sh
region_drawn = True
bgl.glDisable(bgl.GL_BLEND)
bgl.glScissor(*scissor_box)
bgl.glLineWidth(1.0)
if region_drawn:
cls.draw_regions_prev.add(region.as_pointer())
def glSwitch(attr, value):
if value:
bgl.glEnable(attr)
else:
bgl.glDisable(attr)
def draw_lw(context, lw, cross_up_dir, draw_faloff):
region = context.region
rv3d = context.region_data
start_2d = view3d_utils.location_3d_to_region_2d(region, rv3d,
lw.start_point.position)
end_2d = view3d_utils.location_3d_to_region_2d(region, rv3d,
lw.end_point.position)
middle_2d = view3d_utils.location_3d_to_region_2d(region, rv3d,
lw.middle_point.position)
dist_ends = ((lw.start_point.position - lw.end_point.position).length *
0.1) * cross_up_dir
end_p1 = view3d_utils.location_3d_to_region_2d(
region, rv3d, lw.end_point.position + dist_ends)
end_p2 = view3d_utils.location_3d_to_region_2d(
region, rv3d, lw.end_point.position - dist_ends)
if start_2d and end_2d and end_p1 and end_p2:
bgl.glEnable(bgl.GL_BLEND)
bgl.glLineWidth(1)
bgl.glPointSize(6)
coords = ((start_2d[0], start_2d[1]), (end_2d[0], end_2d[1]))
batch = batch_for_shader(shader2d, 'LINE_STRIP', {"pos": coords})
shader2d.bind()
shader2d.uniform_float("color", (0.99, 0.5, 0.99, 1.0))
batch.draw(shader2d)
# bgl.glBegin(bgl.GL_LINE_STRIP)
# bgl.glColor4f(0.99, 0.5, 0.99, 1.0)
# bgl.glVertex2f(start_2d[0], start_2d[1])
# bgl.glVertex2f(end_2d[0], end_2d[1])
# bgl.glEnd()
if draw_faloff:
coords = ((start_2d[0], start_2d[1]), (end_p1[0], end_p1[1]),
(end_p2[0], end_p2[1]))
batch = batch_for_shader(shader2d, 'LINE_LOOP', {"pos": coords})
shader2d.bind()
shader2d.uniform_float("color", (0.99, 0.5, 0.99, 1.0))
batch.draw(shader2d)
# bgl.glBegin(bgl.GL_LINE_LOOP)
# bgl.glVertex2f(start_2d[0], start_2d[1])
# bgl.glVertex2f(end_p1[0], end_p1[1])
# bgl.glVertex2f(end_p2[0], end_p2[1])
# bgl.glEnd()
coords = ((start_2d[0], start_2d[1]), (middle_2d[0], middle_2d[1]),
(end_2d[0], end_2d[1]))
batch = batch_for_shader(shader2d, 'POINTS', {"pos": coords})
shader2d.bind()
shader2d.uniform_float("color", (0.99, 0.8, 0.5, 1.0))
batch.draw(shader2d)
# bgl.glBegin(bgl.GL_POINTS)
# bgl.glColor4f(0.99, 0.8, 0.5, 1.0)
# bgl.glVertex2f(start_2d[0], start_2d[1])
# bgl.glVertex2f(middle_2d[0], middle_2d[1])
# bgl.glVertex2f(end_2d[0], end_2d[1])
# bgl.glEnd()
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
def draw_object_axes(args):
context, objs, draw_cursor = args
if context.space_data.overlay.show_overlays:
axes = [(Vector((1, 0, 0)), red), (Vector((0, 1, 0)), green),
(Vector((0, 0, 1)), blue)]
size = context.scene.M3.object_axes_size
alpha = context.scene.M3.object_axes_alpha
for axis, color in axes:
coords = []
# draw object(s)
for obj in objs:
mx = obj.matrix_world
origin = mx.decompose()[0]
# coords.append(origin)
coords.append(origin + mx.to_3x3() @ axis * size * 0.1)
coords.append(origin + mx.to_3x3() @ axis * size)
# cursor
if draw_cursor and context.space_data.overlay.show_cursor:
cmx = context.scene.cursor.matrix
corigin = cmx.decompose()[0]
coords.append(corigin + cmx.to_3x3() @ axis * size * 0.1 * 0.5)
coords.append(corigin + cmx.to_3x3() @ axis * size * 0.5)
"""
# debuging stash + stashtargtmx for object origin changes
for stash in obj.MM.stashes:
if stash.obj:
smx = stash.obj.MM.stashmx
sorigin = smx.decompose()[0]
coords.append(sorigin + smx.to_3x3() @ axis * size * 0.1)
coords.append(sorigin + smx.to_3x3() @ axis * size)
stmx = stash.obj.MM.stashtargetmx
storigin = stmx.decompose()[0]
coords.append(storigin + stmx.to_3x3() @ axis * size * 0.1)
coords.append(storigin + stmx.to_3x3() @ axis * size)
"""
if coords:
indices = [(i, i + 1) for i in range(0, len(coords), 2)]
shader = gpu.shader.from_builtin('3D_UNIFORM_COLOR')
shader.bind()
shader.uniform_float("color", (*color, alpha))
bgl.glEnable(bgl.GL_BLEND)
bgl.glDisable(bgl.GL_DEPTH_TEST)
bgl.glLineWidth(2)
batch = batch_for_shader(shader,
'LINES', {"pos": coords},
indices=indices)
batch.draw(shader)
