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_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(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 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 _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 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 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 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)
