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])