def __exit__(self, type, value, traceback): mipmap_state = getattr(self, "_mipmap_state", None) if mipmap_state is not None: bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_GENERATE_MIPMAP, mipmap_state) if self._changed_state: bgl.glBindTexture(bgl.GL_TEXTURE_2D, self._previous_texture)
def h_draw_texture(id, w, h, bounds, coords): bgl.glEnable(bgl.GL_TEXTURE_2D) bgl.glBindTexture(bgl.GL_TEXTURE_2D, id) bgl.glEnable(bgl.GL_BLEND) bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) bgl.glColor4f(*(1,1,1,1)) B = bounds C = coords D = [ (C[0][0]/w, C[0][1]/h), (C[1][0]/w, C[1][1]/h), (C[2][0]/w, C[2][1]/h), (C[3][0]/w, C[3][1]/h), ] #print(D) bgl.glBegin(bgl.GL_QUADS) bgl.glTexCoord2f(D[0][0], D[0][1]) bgl.glVertex2f(B[0], B[1]) bgl.glTexCoord2f(D[1][0], D[1][1]) bgl.glVertex2f(B[0]+B[2], B[1]) bgl.glTexCoord2f(D[2][0], D[2][1]) bgl.glVertex2f(B[0]+B[2], B[1]+B[3]) bgl.glTexCoord2f(D[3][0], D[3][1]) bgl.glVertex2f(B[0], B[1]+B[3]) bgl.glEnd() bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) bgl.glDisable(bgl.GL_TEXTURE_2D)
def draw(): bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, image.bindcode) shader.bind() shader.uniform_int("image", 0) batch.draw(shader)
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 __init__(self, width, height): self.width = width self.height = height textures = bgl.Buffer(bgl.GL_INT, [ 1, ]) bgl.glGenTextures(1, textures) self.texture_id = textures[0] bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture_id) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_S, bgl.GL_REPEAT) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_T, bgl.GL_REPEAT) bgl.glTexImage2D( bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA if platform.system() == 'Darwin' else bgl.GL_RGBA16F, self.width, self.height, 0, bgl.GL_RGBA, bgl.GL_FLOAT, bgl.Buffer(bgl.GL_FLOAT, [self.width, self.height, self.channels]))
def process_draw(self) -> None: width = bge.render.getWindowWidth() height = bge.render.getWindowHeight() self._resolution.on_next(Dimension(width, height)) super().process_draw() data = self.surface.get_data() source = bgl.Buffer(bgl.GL_BYTE, width * height * 4, data) bgl.glEnable(bgl.GL_BLEND) bgl.glActiveTexture(bgl.GL_TEXTURE0) # noinspection PyUnresolvedReferences bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_SRGB_ALPHA, width, height, 0, bgl.GL_BGRA, bgl.GL_UNSIGNED_BYTE, source) 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) self.shader.bind() self.shader.uniform_int("image", 0) self.batch.draw(self.shader) bgl.glDeleteBuffers(1, source)
def load(self, icon_name, file_path): def load_image_to_preview(icon_name, file_path): pcoll = bpy.utils.previews.new() pcoll.load(icon_name, file_path, 'IMAGE') return pcoll def make_rgba_array(image_pixels): rgba = [] for pix in image_pixels: a = (pix >> 24) & 255 r = (pix >> 16) & 255 g = (pix >> 8) & 255 b = pix & 255 rgba.append(r) rgba.append(g) rgba.append(b) rgba.append(a) return rgba texture = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, texture) self.id = texture[0] bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.id) bgl.glPixelStore(bgl.GL_UNPACK_ALIGNMENT, 4) bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA, self.width, self.height, 0, bgl.GL_RGBA, bgl.GL_UNSIGNED_BYTE, rgba) bgl.glTexParametri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEREST) bgl.glTexParametri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_NEREST)
def __dell__(self): if self.id: texture = bgl.Buffer(bgl.GL_INT, 1) texture[0] = self.id bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.id) bgl.glDeleteTextures(1, texture) self.id = None
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 draw(self): bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glBindVertexArray(self.vertex_array[0]) bgl.glDrawArrays(bgl.GL_TRIANGLE_FAN, 0, 4); bgl.glBindVertexArray(0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0)
def draw_textured(self): """ call this draw function only if morphs uses texture """ if self.texture != None: self.texture.gl_load() bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture.bindcode) 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) #GL_LINEAR seems to be used in Blender for background images bgl.glEnable(bgl.GL_TEXTURE_2D) #bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) bgl.glColor4f(*self.color) bgl.glBegin(bgl.GL_QUADS) bgl.glTexCoord2d(0,0) bgl.glVertex2d(self.get_position().x,self.get_position().y) bgl.glTexCoord2d(0,1) bgl.glVertex2d(self.get_position().x,self.get_position().y+self.get_height()) bgl.glTexCoord2d(1,1) bgl.glVertex2d(self.get_position().x+self.get_width(),self.get_position().y+self.get_height()) bgl.glTexCoord2d(1,0) bgl.glVertex2d(self.get_position().x+self.get_width(),self.get_position().y) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_TEXTURE_2D) self.texture.gl_free() return
def render(self): '''Render the scene and return image as buffer. Returns ------- image: HxWxD array where D is 4 when `mode=='RGBA'` else 3. ''' with self.offscreen.bind(): self.offscreen.draw_view3d( bpy.context.scene, bpy.context.view_layer, self.space, #bpy.context.space_data self.region, #bpy.context.region self.camera.view_matrix, self.camera.proj_matrix) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.offscreen.color_texture) # np.asarray seems slow, because bgl.buffer does not support the python buffer protocol # bgl.glGetTexImage(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGB, bgl.GL_UNSIGNED_BYTE, self.buffer) # https://docs.blender.org/api/blender2.8/gpu.html # That's why we use PyOpenGL at this point instead. glGetTexImage(bgl.GL_TEXTURE_2D, 0, self.mode, bgl.GL_UNSIGNED_BYTE, self.buffer) buffer = self.buffer if self.origin == 'upper-left': buffer = np.flipud(buffer) if self.gamma_coeff: buffer = self._color_correct(buffer, self.gamma_coeff) return buffer
def draw(self): bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glBindVertexArray(self.vertex_array[0]) bgl.glDrawArrays(bgl.GL_TRIANGLE_FAN, 0, 4) bgl.glBindVertexArray(0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0)
def __del__(self): self.log.info('[%s] CustomDrawData.__del__() [%s]' % (time.asctime(), self)) bgl.glDeleteBuffers(2, self.vertex_buffer) bgl.glDeleteVertexArrays(1, self.vertex_array) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) bgl.glDeleteTextures(1, self.texture)
def refresh_font_texture(self): # save texture state buf = gl.Buffer(gl.GL_INT, 1) gl.glGetIntegerv(gl.GL_TEXTURE_BINDING_2D, buf) last_texture = buf[0] width, height, pixels = self.io.fonts.get_tex_data_as_rgba32() if self._font_texture is not None: gl.glDeleteTextures([self._font_texture]) gl.glGenTextures(1, buf) self._font_texture = buf[0] gl.glBindTexture(gl.GL_TEXTURE_2D, self._font_texture) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) pixel_buffer = gl.Buffer(gl.GL_BYTE, [4 * width * height]) pixel_buffer[:] = pixels gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, width, height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, pixel_buffer) self.io.fonts.texture_id = self._font_texture gl.glBindTexture(gl.GL_TEXTURE_2D, last_texture) self.io.fonts.clear_tex_data()
def draw_button_icon(self): if self.icon != "": bgl.glEnable(bgl.GL_BLEND) texture = bpy.data.images.load(filepath=self.icon) err = texture.gl_load(filter=bgl.GL_NEAREST, mag=bgl.GL_NEAREST) assert not err, 'OpenGL error: %i' % err bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture.bindcode[0]) 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(self.x_location + ICON_MARGIN_X, self.y_location) bgl.glTexCoord2d(0, 1) bgl.glVertex2d(self.x_location + ICON_MARGIN_X, self.y_location + ICON_HEIGHT) bgl.glTexCoord2d(1, 1) bgl.glVertex2d(self.x_location + ICON_MARGIN_X + ICON_WIDTH, self.y_location + ICON_HEIGHT) bgl.glTexCoord2d(1, 0) bgl.glVertex2d(self.x_location + ICON_MARGIN_X + ICON_WIDTH, self.y_location) bgl.glEnd() bgl.glDisable(bgl.GL_TEXTURE_2D) bgl.glDisable(bgl.GL_BLEND) texture.gl_free()
def __enter__(self): """Loads the image data using OpenGL""" # Set image active in OpenGL ownit = self._blimg.bindcode[0] == 0 if ownit: if self._blimg.gl_load() != 0: raise RuntimeError("failed to load image") previous_texture = self._get_integer(bgl.GL_TEXTURE_BINDING_2D) changed_state = (previous_texture != self._blimg.bindcode[0]) if changed_state: bgl.glBindTexture(bgl.GL_TEXTURE_2D, self._blimg.bindcode[0]) # Grab the image data self._width = self._get_tex_param(bgl.GL_TEXTURE_WIDTH, 0) self._height = self._get_tex_param(bgl.GL_TEXTURE_HEIGHT, 0) size = self._width * self._height * 4 buf = bgl.Buffer(bgl.GL_BYTE, size) fmt = bgl.GL_BGRA if self._bgra else bgl.GL_RGBA bgl.glGetTexImage(bgl.GL_TEXTURE_2D, 0, fmt, bgl.GL_UNSIGNED_BYTE, buf) # OpenGL returns the images upside down, so we're going to rotate it in memory. # ... But only if requested... :) if self._image_inverted: self._image_data = bytes(buf) else: self._image_data = self._invert_image(self._width, self._height, buf) # Restore previous OpenGL state if changed_state: bgl.glBindTexture(bgl.GL_TEXTURE_2D, previous_texture) if ownit: self._blimg.gl_free() return self
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 renderTexture(texture, x, y, width, height): bgl.glEnable(bgl.GL_BLEND) #bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) texture.gl_load() bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture.bindcode[0]) bgl.glEnable(bgl.GL_TEXTURE_2D) 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.glColor4f(1, 1, 1, 1) bgl.glBegin(bgl.GL_QUADS) bgl.glTexCoord2d(0, 0) bgl.glVertex2d(x, y) bgl.glTexCoord2d(0, 1) bgl.glVertex2d(x, y + height) bgl.glTexCoord2d(1, 1) bgl.glVertex2d(x + width, y + height) bgl.glTexCoord2d(1, 0) bgl.glVertex2d(x + width , y) bgl.glEnd() texture.gl_free()
def loadtexture(filepath): """ Loads a texture from an image (tga, jpg...any format supported by FFMPEG) and returns the texture buffer ID. """ id_buf = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, id_buf) id = id_buf.to_list()[0] if hasattr(id_buf, "to_list") else id_buf.list[0] bgl.glBindTexture(bgl.GL_TEXTURE_2D, id) image = texture.ImageFFmpeg(filepath) if not image.image: logger.error( "Error when loading " + filepath + ". File not found? Format not " "supported by FFMPEG? (tga, jpg, png do work)" ) return -1 else: im_buf = image.image bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glTexEnvf(bgl.GL_TEXTURE_ENV, bgl.GL_TEXTURE_ENV_MODE, bgl.GL_MODULATE) bgl.glTexImage2D( bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA, image.size[0], image.size[1], 0, bgl.GL_RGBA, bgl.GL_UNSIGNED_BYTE, im_buf, ) return id
def loadtexture(filepath): """ Loads a texture from an image (tga, jpg...any format supported by FFMPEG) and returns the texture buffer ID. """ id_buf = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, id_buf) id = id_buf.to_list()[0] if hasattr(id_buf, "to_list") else id_buf.list[0] bgl.glBindTexture(bgl.GL_TEXTURE_2D, id) image = texture.ImageFFmpeg(filepath) if not image.image: logger.error("Error when loading " + filepath + ". File not found? Format not " "supported by FFMPEG? (tga, jpg, png do work)") return -1 else: im_buf = image.image bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glTexEnvf(bgl.GL_TEXTURE_ENV, bgl.GL_TEXTURE_ENV_MODE, bgl.GL_MODULATE) bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA, image.size[0], image.size[1], 0, bgl.GL_RGBA, bgl.GL_UNSIGNED_BYTE, im_buf) return id
def renderTexture(texture, x, y, width, height): bgl.glEnable(bgl.GL_BLEND) #bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) texture.gl_load() bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture.bindcode[0]) bgl.glEnable(bgl.GL_TEXTURE_2D) 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.glColor4f(1, 1, 1, 1) bgl.glBegin(bgl.GL_QUADS) bgl.glTexCoord2d(0, 0) bgl.glVertex2d(x, y) bgl.glTexCoord2d(0, 1) bgl.glVertex2d(x, y + height) bgl.glTexCoord2d(1, 1) bgl.glVertex2d(x + width, y + height) bgl.glTexCoord2d(1, 0) bgl.glVertex2d(x + width, y) bgl.glEnd() texture.gl_free()
def __enter__(self): """Sets the Blender Image as the active OpenGL texture""" self._previous_texture = self._get_integer(bgl.GL_TEXTURE_BINDING_2D) self._changed_state = (self._previous_texture != self._blimg.bindcode) if self._changed_state: bgl.glBindTexture(bgl.GL_TEXTURE_2D, self._blimg.bindcode) return self
def _create(self): textures = bgl.Buffer(bgl.GL_INT, [ 1, ]) bgl.glGenTextures(1, textures) self.texture_id = textures[0] bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture_id) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_S, bgl.GL_REPEAT) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_T, bgl.GL_REPEAT) bgl.glTexImage2D( bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA if platform.system() == 'Darwin' else bgl.GL_RGBA16F, self.width, self.height, 0, bgl.GL_RGBA, bgl.GL_FLOAT, bgl.Buffer(bgl.GL_FLOAT, [self.width, self.height, self.channels])) ContextCreateFramebufferFromGLTexture2D(self.context, bgl.GL_TEXTURE_2D, 0, self.texture_id, self)
def __del__(self): log('CustomDrawData.__del__()') bgl.glDeleteBuffers(2, self.vertex_buffer) bgl.glDeleteVertexArrays(1, self.vertex_array) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) bgl.glDeleteTextures(1, self.texture)
def update_brush_texture_bindcode(self, context): scene = context.scene image_paint = scene.tool_settings.image_paint brush = image_paint.brush pixel_width = scene.tool_settings.unified_paint_settings.size # Check curve values for every 10% to check any updates. Its biased, but fast. check_steps = 10 check_tuple = tuple( (n for n in iter_curve_values(brush.curve, check_steps))) + ( pixel_width, ) if self.check_brush_curve_updated(check_tuple): pixels = [ int(n * 255) for n in iter_curve_values(brush.curve, pixel_width) ] id_buff = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, id_buff) bindcode = id_buff.to_list()[0] bgl.glBindTexture(bgl.GL_TEXTURE_2D, bindcode) image_buffer = bgl.Buffer(bgl.GL_INT, len(pixels), pixels) bgl.glTexParameteri( bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER | bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_RED, pixel_width, 1, 0, bgl.GL_RGBA, bgl.GL_UNSIGNED_BYTE, image_buffer) self.brush_texture_bindcode = bindcode
def get_all_mipmaps(image, mm_offset=0): import bgl images = [] image.gl_load() image_id = image.bindcode[0] if image_id == 0: return images level = mm_offset # denetii - change this to shift the largest exported size down bgl.glBindTexture(bgl.GL_TEXTURE_2D, image_id) while level < 16: # LOG.debug('') buf = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetTexLevelParameteriv(bgl.GL_TEXTURE_2D, level, bgl.GL_TEXTURE_WIDTH, buf) width = buf[0] # LOG.debug(width) if width < 8: break bgl.glGetTexLevelParameteriv(bgl.GL_TEXTURE_2D, level, bgl.GL_TEXTURE_HEIGHT, buf) height = buf[0] if height < 8: break del buf buf_size = width * height * 4 # LOG.debug(buf_size) buf = bgl.Buffer(bgl.GL_BYTE, buf_size) bgl.glGetTexImage(bgl.GL_TEXTURE_2D, level, bgl.GL_RGBA, bgl.GL_UNSIGNED_BYTE, buf) images.append((width, height, buf)) if level == 0: pass # LOG.debug(images[0][:16]) # del buf level += 1 return images
def unbind(self): bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) if not self.region is None: bgl.glMatrixMode(bgl.GL_TEXTURE) bgl.glLoadIdentity() bgl.glMatrixMode(bgl.GL_MODELVIEW)
def __init__(self, dimensions): # Generate dummy float image buffer self.dimensions = dimensions width, height = dimensions pixels = [1, 0.2, 0.1, 1.0] * width * height pixels = bgl.Buffer(bgl.GL_FLOAT, width * height * 4, pixels) # Generate texture self.texture = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, self.texture) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA16F, width, height, 0, bgl.GL_RGBA, bgl.GL_FLOAT, pixels) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) # Bind shader that converts from scene linear to display space, # use the scene's color management settings. shader_program = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_CURRENT_PROGRAM, shader_program) # Generate vertex array self.vertex_array = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, self.vertex_array) bgl.glBindVertexArray(self.vertex_array[0]) texturecoord_location = bgl.glGetAttribLocation( shader_program[0], "texCoord") position_location = bgl.glGetAttribLocation(shader_program[0], "pos") bgl.glEnableVertexAttribArray(texturecoord_location) bgl.glEnableVertexAttribArray(position_location) # Generate geometry buffers for drawing textured quad position = [0.0, 0.0, width, 0.0, width, height, 0.0, height] position = bgl.Buffer(bgl.GL_FLOAT, len(position), position) texcoord = [0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0] texcoord = bgl.Buffer(bgl.GL_FLOAT, len(texcoord), texcoord) self.vertex_buffer = bgl.Buffer(bgl.GL_INT, 2) bgl.glGenBuffers(2, self.vertex_buffer) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, position, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(position_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[1]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, texcoord, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(texturecoord_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) bgl.glBindVertexArray(0)
def draw(self): self.log.info('CustomDrawData.draw() [%s]' % self) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glBindVertexArray(self.vertex_array[0]) bgl.glDrawArrays(bgl.GL_TRIANGLE_FAN, 0, 4) bgl.glBindVertexArray(0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0)
def close(self): if not self.initialized: return bgl.glDeleteBuffers(2, self.vertex_buffer) bgl.glDeleteVertexArrays(1, self.vertex_array) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) bgl.glDeleteTextures(1, self.texture)
def draw_texture(cls, _, context): sc = context.scene if not cls.is_running(context): return # no textures are selected if sc.muv_texture_projection_tex_image == "None": return # get texture to be renderred img = bpy.data.images[sc.muv_texture_projection_tex_image] # setup rendering region rect = _get_canvas(context, sc.muv_texture_projection_tex_magnitude) positions = [ [rect.x0, rect.y0], [rect.x0, rect.y1], [rect.x1, rect.y1], [rect.x1, rect.y0] ] tex_coords = [ [0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0] ] # OpenGL configuration if compat.check_version(2, 80, 0) >= 0: bgl.glEnable(bgl.GL_BLEND) bgl.glEnable(bgl.GL_TEXTURE_2D) bgl.glActiveTexture(bgl.GL_TEXTURE0) if img.bindcode: bind = img.bindcode bgl.glBindTexture(bgl.GL_TEXTURE_2D, bind) else: bgl.glEnable(bgl.GL_BLEND) bgl.glEnable(bgl.GL_TEXTURE_2D) if img.bindcode: bind = img.bindcode[0] bgl.glBindTexture(bgl.GL_TEXTURE_2D, bind) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR) bgl.glTexEnvi( bgl.GL_TEXTURE_ENV, bgl.GL_TEXTURE_ENV_MODE, bgl.GL_MODULATE) # render texture bgl.glBegin(bgl.GL_QUADS) bgl.glColor4f(1.0, 1.0, 1.0, sc.muv_texture_projection_tex_transparency) for (v1, v2), (u, v) in zip(positions, tex_coords): bgl.glTexCoord2f(u, v) bgl.glVertex2f(v1, v2) bgl.glEnd()
def preview_bindcode(self): image = self.id_data try: getattr(image, "name") except ReferenceError: del ImageCache.cache[image] return 0 item = ImageCache.cache.get(image, None) if item is None: ImageCache.cache[image] = EvalItemData() assert image in ImageCache.cache item = ImageCache.cache[image] if item.has_icon_generated and item.has_prev_generated and item.preview_bindcode: return item.preview_bindcode image_paint = bpy.context.scene.tool_settings.image_paint skip_buff_free = (image_paint.canvas, image_paint.clone_image) if (not item.has_icon_generated) and image.preview.icon_id and len(image.preview.icon_pixels): ImageCache.icon_flat_arr = np.resize(ImageCache.icon_flat_arr, len(image.preview.icon_pixels)) image.preview.icon_pixels.foreach_get(ImageCache.icon_flat_arr) item.has_icon_generated = np.any(ImageCache.icon_flat_arr) if image.has_data and (image not in ImageCache.gl_load_order) and (image not in skip_buff_free): image.buffers_free() if (not item.has_prev_generated) and len(image.preview.image_pixels): ImageCache.prev_flat_arr = np.resize(ImageCache.prev_flat_arr, len(image.preview.image_pixels)) image.preview.image_pixels.foreach_get(ImageCache.prev_flat_arr) item.has_prev_generated = np.any(ImageCache.prev_flat_arr) if image.has_data and (image not in ImageCache.gl_load_order) and (image not in skip_buff_free): image.buffers_free() if (not item.preview_bindcode) and item.has_prev_generated: id_buff = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, id_buff) item.preview_bindcode = id_buff.to_list()[0] bgl.glBindTexture(bgl.GL_TEXTURE_2D, item.preview_bindcode) image_buffer = bgl.Buffer( bgl.GL_INT, len(ImageCache.prev_flat_arr), ImageCache.prev_flat_arr ) bgl.glTexParameteri( bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER | bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR ) bgl.glTexImage2D( bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA, image.preview.image_size[0], image.preview.image_size[1], 0, bgl.GL_RGBA, bgl.GL_UNSIGNED_BYTE, image_buffer ) return item.preview_bindcode
def draw_callback_px(self, context): nt = bpy.context.scene.world.node_tree.nodes env_tex_node = nt.get(bpy.context.scene.sun_pos_properties.hdr_texture) image = env_tex_node.image if self.area != context.area: return if image.gl_load(): raise Exception() bottom = 0 top = context.area.height right = context.area.width position = Vector((right, top)) / 2 + self.offset scale = Vector((context.area.width, context.area.width / 2)) * self.scale shader = gpu.types.GPUShader(vertex_shader, fragment_shader) coords = ((-0.5, -0.5), (0.5, -0.5), (0.5, 0.5), (-0.5, 0.5)) uv_coords = ((0, 0), (1, 0), (1, 1), (0, 1)) batch = batch_for_shader(shader, 'TRI_FAN', { "pos": coords, "texCoord": uv_coords }) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, image.bindcode) with gpu.matrix.push_pop(): gpu.matrix.translate(position) gpu.matrix.scale(scale) shader.bind() shader.uniform_int("image", 0) shader.uniform_float("exposure", self.exposure) batch.draw(shader) # Crosshair # vertical coords = ((self.mouse_position[0], bottom), (self.mouse_position[0], top)) colors = ((1, ) * 4, ) * 2 shader = gpu.shader.from_builtin('2D_FLAT_COLOR') batch = batch_for_shader(shader, 'LINES', {"pos": coords, "color": colors}) shader.bind() batch.draw(shader) # horizontal if bottom <= self.mouse_position[1] <= top: coords = ((0, self.mouse_position[1]), (context.area.width, self.mouse_position[1])) batch = batch_for_shader(shader, 'LINES', { "pos": coords, "color": colors }) shader.bind() batch.draw(shader)
def __exit__(self, type, value, traceback): mipmap_state = getattr(self, "_mipmap_state", None) if mipmap_state is not None: bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_GENERATE_MIPMAP, mipmap_state) if self._changed_state: bgl.glBindTexture(bgl.GL_TEXTURE_2D, self._previous_texture) if self._ownit: self._blimg.gl_free()
def draw(): bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, offscreen.color_texture) shader.bind() shader.uniform_float("modelMatrix", Matrix.Translation((1, 2, 3)) @ Matrix.Scale(3, 4)) shader.uniform_float("viewProjectionMatrix", bpy.context.region_data.perspective_matrix) shader.uniform_float("image", 0) batch.draw(shader)
def bind(self): bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.glid[0]) if not self.region is None: bgl.glMatrixMode(bgl.GL_TEXTURE) bgl.glLoadIdentity() bgl.glTranslatef(self.region.x, self.region.y, 0) bgl.glScalef(self.region.w, self.region.h, 1) bgl.glMatrixMode(bgl.GL_MODELVIEW)
def __enter__(self): """Sets the Blender Image as the active OpenGL texture""" if self._ownit: if self._blimg.gl_load() != 0: raise RuntimeError("failed to load image") self._previous_texture = self._get_integer(bgl.GL_TEXTURE_BINDING_2D) self._changed_state = (self._previous_texture != self._blimg.bindcode) if self._changed_state: bgl.glBindTexture(bgl.GL_TEXTURE_2D, self._blimg.bindcode) return self
def gen_texture(): textures = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, textures) tex = textures[0] bgl.glBindTexture(bgl.GL_TEXTURE_2D, tex) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) return tex
def draw(self): if self.visible == False: return module.post_draw_step += 1 height = render.getWindowHeight() width = render.getWindowWidth() bgl.glMatrixMode(bgl.GL_PROJECTION) bgl.glLoadIdentity() bgl.gluOrtho2D(0, width, 0, height) bgl.glMatrixMode(bgl.GL_MODELVIEW) bgl.glLoadIdentity() # Enable textures bgl.glEnable(bgl.GL_TEXTURE_2D) # Enable alpha blending bgl.glEnable(bgl.GL_BLEND) bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) bgl.glAlphaFunc(bgl.GL_SRC_ALPHA, 1) # Bind the texture bgl.glBindTexture(bgl.GL_TEXTURE_2D, self._tex_id) # Fix position w, h = self._size bgl.glTranslatef(0, -h, 1) #MipLevel bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_BASE_LEVEL, 0); bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAX_LEVEL, 0); bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR); bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR); # Draw the textured quad bgl.glColor4f(*self.color) bgl.glBegin(bgl.GL_QUADS) self.calculate_glposition() for i in range(4): bgl.glTexCoord2f(self.texco[i][0], self.texco[i][1]) bgl.glVertex2f(self.gl_position[i][0], self.gl_position[i][1]) bgl.glEnd() bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) bgl.glDisable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_TEXTURE_2D) bgl.glMatrixMode(bgl.GL_PROJECTION) bgl.glPopMatrix() bgl.glMatrixMode(bgl.GL_MODELVIEW)
def __init__(self, dimensions): # Generate dummy float image buffer self.dimensions = dimensions width, height = dimensions pixels = [0.1, 0.2, 0.1, 1.0] * width * height pixels = bgl.Buffer(bgl.GL_FLOAT, width * height * 4, pixels) # Generate texture self.texture = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, self.texture) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA16F, width, height, 0, bgl.GL_RGBA, bgl.GL_FLOAT, pixels) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) # Bind shader that converts from scene linear to display space, # use the scene's color management settings. shader_program = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_CURRENT_PROGRAM, shader_program); # Generate vertex array self.vertex_array = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, self.vertex_array) bgl.glBindVertexArray(self.vertex_array[0]) texturecoord_location = bgl.glGetAttribLocation(shader_program[0], "texCoord"); position_location = bgl.glGetAttribLocation(shader_program[0], "pos"); bgl.glEnableVertexAttribArray(texturecoord_location); bgl.glEnableVertexAttribArray(position_location); # Generate geometry buffers for drawing textured quad position = [0.0, 0.0, width, 0.0, width, height, 0.0, height] position = bgl.Buffer(bgl.GL_FLOAT, len(position), position) texcoord = [0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0] texcoord = bgl.Buffer(bgl.GL_FLOAT, len(texcoord), texcoord) self.vertex_buffer = bgl.Buffer(bgl.GL_INT, 2) bgl.glGenBuffers(2, self.vertex_buffer) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, position, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(position_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[1]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, texcoord, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(texturecoord_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) bgl.glBindVertexArray(0)
def drawMenuItem(item, x, y, width, height): global iconWidth global iconHeight iconMarginX = 4 iconMarginY = 4 textMarginX = 6 textHeight = 16 textWidth = 72 bgl.glEnable(bgl.GL_BLEND) if item["highlighted"]: bgl.glColor4f(0.555, 0.555, 0.555, 0.8) else: bgl.glColor4f(0.447, 0.447, 0.447, 0.8) bgl.glRectf(x, y, x + width, y + height) texture = item["icon"] texture.gl_load() bgl.glColor4f(0.0, 0.0, 1.0, 0.5) # bgl.glLineWidth(1.5) # ------ TEXTURE ---------# bgl.glEnable(bgl.GL_BLEND) bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture.bindcode) 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 ) # GL_LINEAR seems to be used in Blender for background images 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(x + iconMarginX, y) bgl.glTexCoord2d(0, 1) bgl.glVertex2d(x + iconMarginX, y + iconHeight) bgl.glTexCoord2d(1, 1) bgl.glVertex2d(x + iconMarginX + iconWidth, y + iconHeight) bgl.glTexCoord2d(1, 0) bgl.glVertex2d(x + iconMarginX + iconWidth, y) bgl.glEnd() texture.gl_free() # draw some text font_id = 0 blf.position(font_id, x + iconMarginX + iconWidth + textMarginX, y + iconHeight * 0.5 - 0.25 * textHeight, 0) blf.size(font_id, textHeight, textWidth) blf.draw(font_id, item["text"])
def draw_callback_mode(self, context): # draw mode_title mode_title(True, "Object Assembler Mode") bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.img.bindcode) 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.glLineWidth(1) # draw frame for icon in self.menu: bgl.glColor3f(0.1, 0.1, 0.1) bgl.glRecti( icon[2][0],icon[2][1],icon[2][2],icon[2][3] ) # icon zeichnen for icon in self.menu: bgl.glEnable(bgl.GL_TEXTURE_2D) bgl.glTexEnvf(bgl.GL_TEXTURE_ENV,bgl.GL_TEXTURE_ENV_MODE, bgl.GL_REPLACE) bgl.glBegin(bgl.GL_QUADS) bgl.glTexCoord2f(icon[4][0][0], icon[4][0][1]) bgl.glVertex2f(icon[1][0], icon[1][1]) bgl.glTexCoord2f(icon[4][1][0], icon[4][1][1]) bgl.glVertex2f(icon[1][0], icon[1][3]) bgl.glTexCoord2f(icon[4][2][0], icon[4][2][1]) bgl.glVertex2f(icon[1][2], icon[1][3]) bgl.glTexCoord2f(icon[4][3][0], icon[4][3][1]) bgl.glVertex2f(icon[1][2], icon[1][1]) bgl.glEnd() bgl.glDisable(bgl.GL_TEXTURE_2D) # draw hover effekt for icon in self.menu: # mouse hover icon if mouse_hover_icon(icon[1], self.mouse): bgl.glColor3f(0.4, 0.4, 0.4) bgl.glLineWidth(2) rect_round_corners(icon[3][0], icon[3][1], icon[3][2], icon[3][3]) # restore opengl defaults bgl.glLineWidth(1) bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
def reload(self): """ Reloads the texture contained in the ``texture`` attribute. Can be used to create animated cursors. """ img = self.texture data = img.image if data == None: raise RuntimeError("Image not loaded correctly!") bgl.glBindTexture(bgl.GL_TEXTURE_2D, self._tex_id) bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA, img.size[0], img.size[1], 0, bgl.GL_RGBA, bgl.GL_UNSIGNED_BYTE, data) self.image_size = img.size[:]
def get_image_buffer(path): img = load_image(path) if not img: return None sx, sy = img.size buf = bgl.Buffer(bgl.GL_FLOAT, 4 * sx * sy) img.gl_load(filter=bgl.GL_LINEAR, mag=bgl.GL_LINEAR) bgl.glBindTexture(bgl.GL_TEXTURE_2D, img.bindcode[0]) bgl.glGetTexImage(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA, bgl.GL_FLOAT, buf) img.gl_free() img.user_clear() bpy.data.images.remove(img) return buf, sx, sy
def init_texture(width, height, texname, texture, clr): # function to init the texture bgl.glPixelStorei(bgl.GL_UNPACK_ALIGNMENT, 1) bgl.glEnable(bgl.GL_TEXTURE_2D) bgl.glBindTexture(bgl.GL_TEXTURE_2D, texname) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glTexParameterf(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_S, bgl.GL_CLAMP) bgl.glTexParameterf(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_T, bgl.GL_CLAMP) bgl.glTexParameterf(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR) bgl.glTexParameterf(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glTexImage2D( bgl.GL_TEXTURE_2D, 0, clr, width, height, 0, clr, bgl.GL_FLOAT, texture )
def _config_textures(self): import ctypes bgl.glBindRenderbuffer(bgl.GL_RENDERBUFFER, self.buf_depth[0]) bgl.glRenderbufferStorage( bgl.GL_RENDERBUFFER, bgl.GL_DEPTH_COMPONENT, self.width, self.height) NULL = bgl.Buffer(bgl.GL_INT, 1, (ctypes.c_int32 * 1).from_address(0)) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.buf_color[0]) bgl.glTexImage2D( bgl.GL_TEXTURE_2D, 0, bgl.GL_R32UI, self.width, self.height, 0, bgl.GL_RED_INTEGER, bgl.GL_UNSIGNED_INT, NULL) del NULL 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)
def draw(self, texture_id, list_verts_co): if list_verts_co: batch = self.batch_create(list_verts_co) # in case someone disabled it before bgl.glEnable(bgl.GL_TEXTURE_2D) # bind texture to image unit 0 bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture_id) self.shader.bind() # tell shader to use the image that is bound to image unit 0 self.shader.uniform_int("image", 0) batch.draw(self.shader) bgl.glDisable(bgl.GL_TEXTURE_2D)
def draw(self,context): global iterations global texture global height global width texture.gl_load() bgl.glEnable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 0.5) bgl.glLineWidth(1.5) #------ TEXTURE ---------# bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture.bindcode) 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) #GL_LINEAR seems to be used in Blender for background images 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(0 + iterations ,100 ) bgl.glTexCoord2d(0,1) bgl.glVertex2d(0+iterations ,100 + height) bgl.glTexCoord2d(1,1) bgl.glVertex2d(0 + iterations + width, 100 + height ) bgl.glTexCoord2d(1,0) bgl.glVertex2d(0 + iterations + width , 100) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_TEXTURE_2D) texture.gl_free() # 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): width = self.region.width height = self.region.height x = self.view_padding_left y = height - self.view_padding_top # Gem map # ----------------------------- if not self.use_navigate: bgl.glEnable(bgl.GL_BLEND) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.offscreen.color_texture) shader_img.bind() shader_img.uniform_int("image", 0) args = { "pos": self.rect_coords(0, 0, width, height), "texCoord": self.rect_coords(0, 0, 1, 1), } batch = batch_for_shader(shader_img, "TRI_FAN", args) batch.draw(shader_img) # Onscreen text # ----------------------------- y = self.onscreen_gem_table(x, y) y -= self.view_margin if self.show_warn: y = self.onscreen_warning(x, y) y -= self.view_margin self.onscreen_options(x, y) # Restore OpenGL defaults # ---------------------------- bgl.glDisable(bgl.GL_BLEND)
def draw_image(x, y, width, height, image, transparency, crop=(0, 0, 1, 1)): # draw_rect(x,y, width, height, (.5,0,0,.5)) coords = [ (x, y), (x + width, y), (x, y + height), (x + width, y + height)] uvs = [(crop[0], crop[1]), (crop[2], crop[1]), (crop[0], crop[3]), (crop[2], crop[3]), ] indices = [(0, 1, 2), (2, 1, 3)] shader = gpu.shader.from_builtin('2D_IMAGE') batch = batch_for_shader(shader, 'TRIS', {"pos": coords, "texCoord": uvs}, indices=indices) # send image to gpu if it isn't there already if image.gl_load(): raise Exception() # texture identifier on gpu texture_id = image.bindcode # in case someone disabled it before bgl.glEnable(bgl.GL_BLEND) # bind texture to image unit 0 bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture_id) shader.bind() # tell shader to use the image that is bound to image unit 0 shader.uniform_int("image", 0) batch.draw(shader) bgl.glDisable(bgl.GL_TEXTURE_2D)
def draw_texture(self, context): wm = context.window_manager sc = context.scene # no texture is selected if sc.tex_image == "None": return # setup rendering region rect = get_canvas(context, sc.tex_magnitude) positions = [ [rect.x0, rect.y0], [rect.x0, rect.y1], [rect.x1, rect.y1], [rect.x1, rect.y0] ] tex_coords = [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]] # get texture to be renderred img = bpy.data.images[sc.tex_image] # OpenGL configuration bgl.glEnable(bgl.GL_BLEND) bgl.glEnable(bgl.GL_TEXTURE_2D) if img.bindcode: bind = img.bindcode bgl.glBindTexture(bgl.GL_TEXTURE_2D, bind) bgl.glTexParameteri( bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri( bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR) bgl.glTexEnvi( bgl.GL_TEXTURE_ENV, bgl.GL_TEXTURE_ENV_MODE, bgl.GL_MODULATE) # render texture bgl.glBegin(bgl.GL_QUADS) bgl.glColor4f(1.0, 1.0, 1.0, sc.tex_transparency) for (v1, v2), (u, v) in zip(positions, tex_coords): bgl.glTexCoord2f(u, v) bgl.glVertex2f(v1, v2) bgl.glEnd()
def render_callback(self, context): if self.bindcode != None: bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glEnable(bgl.GL_BLEND) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.bindcode) bgl.glEnable(bgl.GL_TEXTURE_2D) bgl.glColor4f(1.0, 1.0, 1.0, 1.0) bgl.glBegin(bgl.GL_QUADS) bgl.glTexCoord2f(0.0, 0.0) bgl.glVertex2f(self.x, self.y) bgl.glTexCoord2f(1.0, 0.0) bgl.glVertex2f(self.x + self.width, self.y) bgl.glTexCoord2f(1.0, 1.0) bgl.glVertex2f(self.x + self.width, self.y + self.height) bgl.glTexCoord2f(0.0, 1.0) bgl.glVertex2f(self.x, self.y + self.height) bgl.glEnd() bgl.glDisable(bgl.GL_TEXTURE_2D)
def image_quad(img,color,verts): img.gl_load(bgl.GL_NEAREST, bgl.GL_NEAREST) bgl.glBindTexture(bgl.GL_TEXTURE_2D, img.bindcode) 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.glEnable(bgl.GL_BLEND) #bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) bgl.glColor4f(color[0], color[1], color[2], color[3]) bgl.glBegin(bgl.GL_QUADS) #http://h30097.www3.hp.com/docs/base_doc/DOCUMENTATION/V51B_HTML/MAN/MAN3/2025____.HTM bgl.glTexCoord2f(0,0) bgl.glVertex2f(verts[0][0],verts[0][1]) bgl.glTexCoord2f(0,1) bgl.glVertex2f(verts[1][0],verts[1][1]) bgl.glTexCoord2f(1,1) bgl.glVertex2f(verts[2][0],verts[2][1]) bgl.glTexCoord2f(1,0) bgl.glVertex2f(verts[3][0],verts[3][1]) bgl.glEnd() bgl.glDisable(bgl.GL_BLEND) bgl.glDisable(bgl.GL_TEXTURE_2D)