def draw_callback_common(self, context, ots):
if Pref.use_alpha_clip:
bgl.glAlphaFunc(bgl.GL_GREATER, 0.1)
bgl.glEnable(bgl.GL_ALPHA_TEST)
orig_is_enabled_depthtest = bgl.glIsEnabled(bgl.GL_DEPTH_TEST)
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
bgl.glEnable(bgl.GL_BLEND)
bgl.glEnable(bgl.GL_TEXTURE_2D)
texcos = [(0.,0.), (1.,0.), (1.,1.), (0.,1.)]
fr = context.scene.frame_current
for l,obj,tex in ots:
ps = [obj.matrix_world*v.co for v in obj.data.vertices[0:4]]
if tex.blendmode == BlendMode.ALPHAOVER:
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
bgl.glBlendEquation(bgl.GL_FUNC_ADD)
elif tex.blendmode == BlendMode.ADDITIVE:
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE)
bgl.glBlendEquation(bgl.GL_FUNC_ADD)
tex.bind()
bgl.glBegin(bgl.GL_QUADS)
for p,t in zip(ps, texcos):
bgl.glTexCoord2f(*t)
bgl.glVertex3f(*p)
bgl.glEnd()
#bgl.glDepthMask(bgl.GL_TRUE)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
bgl.glBlendEquation(bgl.GL_FUNC_ADD)
bgl.glDisable(bgl.GL_TEXTURE_2D)
bgl.glDisable(bgl.GL_BLEND)
if Pref.use_alpha_clip:
bgl.glDisable(bgl.GL_ALPHA_TEST)
if not orig_is_enabled_depthtest:
bgl.glDisable(bgl.GL_DEPTH_TEST)
def draw_callback_3d(self, context):
def draw(ps, cs):
for p, c in zip(ps, cs):
bgl.glColor4f(*c)
bgl.glVertex3f(*p)
bgl.glColor4f(*cs[0])
bgl.glVertex3f(*ps[0])
#bgl.glPushAttrib(bgl.GL_ALL_ATTRIB_BITS) ## #debug - stack context
try:
frcurrent = context.scene.frame_current
for amset in State.data.amsets:
frprevlimit = amset.dissolve_length
for fr in range(frcurrent - frprevlimit, frcurrent + 1):
for aseq in amset.get_ampseqs():
amp = aseq.get(fr)
if not amp:
continue
viewvec = State.current_viewvec if Pref.use_billboard else amp.viewvec
dfr = frcurrent - fr
tfr = 1.0 - dfr / frprevlimit if frprevlimit != 0 else 1.0
##
u0 = viewvec.cross(Vector((
0, 0,
1))).normalized() if abs(viewvec.z) != 1.0 else Vector(
(1, 0, 0))
v0 = u0.cross(viewvec)
size = amp.size
u = u0 * size
v = v0 * size
z_offset = fr / 1000
#z_offset = fr/100
#z_offset = -dfr/50
#z_offset = -dfr/1000
#q = amp.location
q = amp.location - viewvec * z_offset
alpha, quadscale = 1, 1
if amset.dissolve_method == AMDissolveMethod.Opacity:
#alpha = tfr
alpha = tfr**2.0
elif amset.dissolve_method == AMDissolveMethod.Size:
quadscale = tfr**2.0
elif amset.dissolve_method == AMDissolveMethod.OpacitySize:
alpha = tfr**2.0
quadscale = tfr**2.0
elif amset.dissolve_method == AMDissolveMethod.Const:
pass
u *= quadscale
v *= quadscale
cs = [(1, 1, 1, alpha), (1, 1, 1, .0), (1, 1, 1, .0),
(1, 1, 1, .0)]
bgl.glEnable(bgl.GL_BLEND)
bgl.glDepthMask(bgl.GL_FALSE)
if amset.blendmode == AMBlendMode.AlphaOver:
## alpha over
bgl.glBlendFunc(bgl.GL_SRC_ALPHA,
bgl.GL_ONE_MINUS_SRC_ALPHA)
#bgl.glBlendFunc(bgl.GL_ONE, bgl.GL_ONE)
bgl.glBlendEquation(bgl.GL_FUNC_ADD)
elif amset.blendmode == AMBlendMode.Additive:
## additive
bgl.glBlendEquation(bgl.GL_FUNC_ADD)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE)
else:
print('<!> invalid blendmode: ' + amset.blendmode)
if amset.image_texture and amset.image_texture.bindcode[0]:
amset.image_texture.gl_touch(0)
bgl.glEnable(bgl.GL_TEXTURE_2D)
bgl.glColor4f(1.0, 1.0, 1.0, alpha)
bgl.glBindTexture(bgl.GL_TEXTURE_2D,
amset.image_texture.bindcode[0])
bgl.glBegin(bgl.GL_QUADS)
ps = [q - u - v, q + u - v, q + u + v, q - u + v]
bgl.glTexCoord2f(0.0, 0.0)
bgl.glVertex3f(*ps[0])
bgl.glTexCoord2f(1.0, 0.0)
bgl.glVertex3f(*ps[1])
bgl.glTexCoord2f(1.0, 1.0)
bgl.glVertex3f(*ps[2])
bgl.glTexCoord2f(0.0, 1.0)
bgl.glVertex3f(*ps[3])
bgl.glEnd()
bgl.glDisable(bgl.GL_TEXTURE_2D)
else:
bgl.glBegin(bgl.GL_POLYGON)
draw([q, q + u, q + u + v, q + v], cs)
draw([q, q - u, q - u + v, q + v], cs)
draw([q, q + u, q + u - v, q - v], cs)
draw([q, q - u, q - u - v, q - v], cs)
bgl.glEnd()
bgl.glDisable(bgl.GL_BLEND)
bgl.glDepthMask(bgl.GL_TRUE)
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
except Exception as e:
print('error in draw callback')
print(e)
def render(self, draw_data):
io = self.io
shader = self._bl_shader
display_width, display_height = io.display_size
fb_width = int(display_width * io.display_fb_scale[0])
fb_height = int(display_height * io.display_fb_scale[1])
if fb_width == 0 or fb_height == 0:
return
draw_data.scale_clip_rects(*io.display_fb_scale)
# backup GL state
(
last_program,
last_texture,
last_active_texture,
last_array_buffer,
last_element_array_buffer,
last_vertex_array,
last_blend_src,
last_blend_dst,
last_blend_equation_rgb,
last_blend_equation_alpha,
last_viewport,
last_scissor_box,
) = self._backup_integers(
gl.GL_CURRENT_PROGRAM,
1,
gl.GL_TEXTURE_BINDING_2D,
1,
gl.GL_ACTIVE_TEXTURE,
1,
gl.GL_ARRAY_BUFFER_BINDING,
1,
gl.GL_ELEMENT_ARRAY_BUFFER_BINDING,
1,
gl.GL_VERTEX_ARRAY_BINDING,
1,
gl.GL_BLEND_SRC,
1,
gl.GL_BLEND_DST,
1,
gl.GL_BLEND_EQUATION_RGB,
1,
gl.GL_BLEND_EQUATION_ALPHA,
1,
gl.GL_VIEWPORT,
4,
gl.GL_SCISSOR_BOX,
4,
)
last_enable_blend = gl.glIsEnabled(gl.GL_BLEND)
last_enable_cull_face = gl.glIsEnabled(gl.GL_CULL_FACE)
last_enable_depth_test = gl.glIsEnabled(gl.GL_DEPTH_TEST)
last_enable_scissor_test = gl.glIsEnabled(gl.GL_SCISSOR_TEST)
gl.glEnable(gl.GL_BLEND)
gl.glBlendEquation(gl.GL_FUNC_ADD)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glDisable(gl.GL_CULL_FACE)
gl.glDisable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_SCISSOR_TEST)
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glViewport(0, 0, int(fb_width), int(fb_height))
ortho_projection = (2.0 / display_width, 0.0, 0.0, 0.0, 0.0,
2.0 / -display_height, 0.0, 0.0, 0.0, 0.0, -1.0,
0.0, -1.0, 1.0, 0.0, 1.0)
shader.bind()
shader.uniform_float("ProjMtx", ortho_projection)
shader.uniform_int("Texture", 0)
for commands in draw_data.commands_lists:
size = commands.idx_buffer_size * imgui.INDEX_SIZE // 4
address = commands.idx_buffer_data
ptr = C.cast(address, C.POINTER(C.c_int))
idx_buffer_np = np.ctypeslib.as_array(ptr, shape=(size, ))
size = commands.vtx_buffer_size * imgui.VERTEX_SIZE // 4
address = commands.vtx_buffer_data
ptr = C.cast(address, C.POINTER(C.c_float))
vtx_buffer_np = np.ctypeslib.as_array(ptr, shape=(size, ))
vtx_buffer_shaped = vtx_buffer_np.reshape(-1,
imgui.VERTEX_SIZE // 4)
idx_buffer_offset = 0
for command in commands.commands:
x, y, z, w = command.clip_rect
gl.glScissor(int(x), int(fb_height - w), int(z - x),
int(w - y))
vertices = vtx_buffer_shaped[:, :2]
uvs = vtx_buffer_shaped[:, 2:4]
colors = vtx_buffer_shaped.view(np.uint8)[:, 4 * 4:]
colors = colors.astype('f') / 255.0
indices = idx_buffer_np[idx_buffer_offset:idx_buffer_offset +
command.elem_count]
gl.glBindTexture(gl.GL_TEXTURE_2D, command.texture_id)
batch = batch_for_shader(shader,
'TRIS', {
"Position": vertices,
"UV": uvs,
"Color": colors,
},
indices=indices)
batch.draw(shader)
idx_buffer_offset += command.elem_count
# restore modified GL state
gl.glUseProgram(last_program)
gl.glActiveTexture(last_active_texture)
gl.glBindTexture(gl.GL_TEXTURE_2D, last_texture)
gl.glBindVertexArray(last_vertex_array)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, last_array_buffer)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, last_element_array_buffer)
gl.glBlendEquationSeparate(last_blend_equation_rgb,
last_blend_equation_alpha)
gl.glBlendFunc(last_blend_src, last_blend_dst)
if last_enable_blend:
gl.glEnable(gl.GL_BLEND)
else:
gl.glDisable(gl.GL_BLEND)
if last_enable_cull_face:
gl.glEnable(gl.GL_CULL_FACE)
else:
gl.glDisable(gl.GL_CULL_FACE)
if last_enable_depth_test:
gl.glEnable(gl.GL_DEPTH_TEST)
else:
gl.glDisable(gl.GL_DEPTH_TEST)
if last_enable_scissor_test:
gl.glEnable(gl.GL_SCISSOR_TEST)
else:
gl.glDisable(gl.GL_SCISSOR_TEST)
gl.glViewport(last_viewport[0], last_viewport[1], last_viewport[2],
last_viewport[3])
gl.glScissor(last_scissor_box[0], last_scissor_box[1],
last_scissor_box[2], last_scissor_box[3])
def draw_callback(self, context, opt={}):
center = opt.get('center') or get_center_pos(context)
zoom = opt.get('zoom') or get_zoom(context)
back_image_alpha = opt.get('back_image_alpha') or .5
image_size = opt.get('image_size') or (0,0)
width,height = image_size
img = State.img_bake_target
if img and width*height != 0:
if not img.bindcode[0]:
img.gl_load(0, bgl.GL_NEAREST, bgl.GL_NEAREST)
else:
img.gl_touch(0)
bgl.glEnable(bgl.GL_BLEND)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
bgl.glBlendEquation(bgl.GL_FUNC_ADD)
bgl.glEnable(bgl.GL_TEXTURE_2D)
bgl.glColor4f(1,1,1,back_image_alpha)
bgl.glBindTexture(bgl.GL_TEXTURE_2D, img.bindcode[0])
bgl.glBegin(bgl.GL_QUADS)
dw = Vector((width,0)) / 2
dh = Vector((0,height)) / 2
ps = [center+(-dw-dh)*zoom
,center+(dw-dh)*zoom
,center+(dw+dh)*zoom
,center+(-dw+dh)*zoom
]
ts = [(0,0),(1,0),(1,1),(0,1)]
for p,t in zip(ps,ts):
bgl.glTexCoord2f(*t)
bgl.glVertex2f(*p)
bgl.glEnd()
bgl.glDisable(bgl.GL_TEXTURE_2D)
##
#bgl.glEnable(bgl.GL_BLEND)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
bgl.glBlendEquation(bgl.GL_FUNC_ADD)
for line in State.lines:
bgl.glColor4f(*(*line.color,1.0))
ps = line.seq.all()
if len(ps)<2:
continue
ka,kb = ps[0:2]
a = Vector((ka.x,ka.y))
b = Vector((kb.x,kb.y))
t = (b-a).normalized()
n = Vector((t.y, -t.x))
prev_u = a+n*ka.radius
prev_v = a-n*ka.radius
for ka,kb in zip(ps[:-1], ps[1:]):
a = Vector((ka.x,ka.y))
b = Vector((kb.x,kb.y))
t = (b-a).normalized()
n = Vector((t.y, -t.x))
u = b+n*kb.radius
v = b-n*kb.radius
bgl.glBegin(bgl.GL_QUADS)
for p in [prev_u, u, v, prev_v]:
bgl.glVertex2f(*(center+p*zoom))
bgl.glEnd()
prev_u = u
prev_v = v
# restore opengl defaults
bgl.glLineWidth(1)
bgl.glDisable(bgl.GL_BLEND)
bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
bgl.glBlendEquation(bgl.GL_FUNC_ADD)
def glenable(self):
bgl.glEnable(bgl.GL_BLEND)
bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
bgl.glBlendEquation(bgl.GL_FUNC_ADD)
def _set(self, instance, value):
glBlendEquation(blend_equations_k2v[value])