def render_planar_update(self, rx, ry, rw, rh, x_scale=1, y_scale=1):
log("%s.render_planar_update%s pixel_format=%s", self, (rx, ry, rw, rh, x_scale, y_scale), self.pixel_format)
if self.pixel_format not in ("YUV420P", "YUV422P", "YUV444P", "GBRP"):
#not ready to render yet
return
if self.pixel_format == "GBRP":
self.set_rgbP_paint_state()
self.gl_marker("painting planar update, format %s", self.pixel_format)
divs = get_subsampling_divs(self.pixel_format)
glEnable(GL_FRAGMENT_PROGRAM_ARB)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
tw, th = self.texture_size
log("%s.render_planar_update(..) texture_size=%s, size=%s", self, self.texture_size, self.size)
glBegin(GL_QUADS)
for x,y in ((0, 0), (0, rh), (rw, rh), (rw, 0)):
ax = min(tw, x)
ay = min(th, y)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glMultiTexCoord2i(texture, ax//div_w, ay//div_h)
glVertex2i(int(rx+ax*x_scale), int(ry+ay*y_scale))
glEnd()
if self.pixel_format == "GBRP":
self.unset_rgbP_paint_state()
def init_back_texture(self, width, height):
if self.fbo is None:
self.fbo = glGenFramebuffers(1)
glActiveTexture(GL_TEXTURE0 + 1)
if self.bfTex is not None:
glDeleteTextures([self.bfTex])
self.bfTex = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, self.bfTex)
glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
w = int(width)
h = int(height)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, w, h, 0,
GL_RGBA, GL_FLOAT, None)
glBindFramebuffer(GL_FRAMEBUFFER, self.fbo)
glFramebufferTexture2D(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
self.bfTex, 0)
glBindFramebuffer(GL_FRAMEBUFFER, 0)
glBindTexture(GL_TEXTURE_2D, 0)
def __prepare_shaders(self,
rotation_matrix=None,
light_matrix=None,
depth=True):
"""Generic shaders preparation method for depth map and final scene."""
self.__sh.add_attribute(0, self.__mean_face, 'mean_position')
self.__sh.bind_buffer()
self.__sh.use_shaders()
self.__sh.bind_uniform_matrix(light_matrix.dot(rotation_matrix),
'light_matrix')
if not depth:
self.__sh.bind_uniform_matrix(rotation_matrix, 'rotation_matrix')
self.__sh.bind_uniform_vector(self.__face.light_cartesian,
'light_vector')
coefficients_amount = len(self.__face.coefficients)
indices = -ones(199, dtype='i')
indices[:coefficients_amount] = array(range(coefficients_amount))
self.__sh.bind_uniform_ints(indices, 'indices')
coefficients = zeros(199, dtype='f')
coefficients[:coefficients_amount] = self.__face.coefficients
self.__sh.bind_uniform_floats(coefficients, 'coefficients')
glActiveTexture(GL_TEXTURE0)
self.__sh.bind_texture(0)
if not depth:
glActiveTexture(GL_TEXTURE1)
self.__sh.bind_texture(1)
def _do_paint_rgb24(self, img_data, x, y, w, h, rowstride, options, callbacks):
log("do_paint_rgb24(%s bytes, %s, %s, %s, %s, %s, %s, %s)", len(img_data), x, y, w, h, rowstride, options, callbacks)
ww, wh = self.size
if x+w>ww or y+h>wh:
log("do_paint_rgb24: ignoring paint which would overflow the backing area")
return
drawable = self.gl_init()
if not drawable:
log("do_paint_rgb24: cannot paint yet..")
return
try:
#cleanup if we were doing yuv previously:
if self.pixel_format!=GLPixmapBacking.RGB24:
self.remove_shader()
self.pixel_format = GLPixmapBacking.RGB24
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstride/3)
for texture in (GL_TEXTURE1, GL_TEXTURE2):
glActiveTexture(texture)
glDisable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, w, h, GL_RGB, GL_UNSIGNED_BYTE, img_data)
glBegin(GL_QUADS)
for rx,ry in ((x, y), (x, y+h), (x+w, y+h), (x+w, y)):
glTexCoord2i(rx, ry)
glVertex2i(rx, ry)
glEnd()
finally:
self.gl_end(drawable)
def render_yuv_update(self, rx, ry, rw, rh):
debug("render_yuv_update %sx%s at %sx%s pixel_format=%s", rw, rh, rx,
ry, self.pixel_format)
if self.pixel_format not in (YUV420P, YUV422P, YUV444P):
#not ready to render yet
return
self.gl_marker("Painting YUV update")
divs = get_subsampling_divs(self.pixel_format)
glEnable(GL_FRAGMENT_PROGRAM_ARB)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv_shader[0])
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1),
(GL_TEXTURE2, 2)):
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
tw, th = self.texture_size
debug("render_yuv_update texture_size=%s, size=%s", self.texture_size,
self.size)
glBegin(GL_QUADS)
for x, y in ((rx, ry), (rx, ry + rh), (rx + rw, ry + rh), (rx + rw,
ry)):
ax = min(tw, x)
ay = min(th, y)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1),
(GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glMultiTexCoord2i(texture, ax / div_w, ay / div_h)
glVertex2i(ax, ay)
glEnd()
def _draw(self, transformation_matrix: numpy.ndarray):
glUseProgram(self._shader)
glUniformMatrix4fv(
self._transform_location,
1,
GL_FALSE,
transformation_matrix.T.astype(numpy.float32),
)
glUniform1i(self._texture_location, 0)
try:
glBindVertexArray(self._vao)
except GLError: # There seems to be errors randomly when binding the VBO
log.debug(
f"Failed binding the OpenGL state for {self}. Trying to reload it."
)
self.unload()
self._setup()
glBindVertexArray(self._vao)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, self._texture)
glDrawArrays(self.draw_mode, self.draw_start, self.draw_count)
glBindVertexArray(0)
glUseProgram(0)
def load_stack(self, stack):
print('stack shape', stack.shape)
s = np.array(stack, dtype=np.uint8, order='F')
print(s.shape)
w, h, d = s.shape
print('shape', s.shape)
stack_texture = glGenTextures(1)
print(stack_texture)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_3D, stack_texture)
glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
# glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
# glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
# glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE)
glTexImage3D(GL_TEXTURE_3D, 0, GL_R8, d, h, w, 0, GL_RED,
GL_UNSIGNED_BYTE, s)
print("made 3D texture")
return stack_texture, s.shape
def render_planar_update(self, rx, ry, rw, rh, x_scale=1, y_scale=1):
log("%s.render_planar_update%s pixel_format=%s", self, (rx, ry, rw, rh, x_scale, y_scale), self.pixel_format)
if self.pixel_format not in ("YUV420P", "YUV422P", "YUV444P", "GBRP"):
#not ready to render yet
return
if self.pixel_format == "GBRP":
self.set_rgbP_paint_state()
self.gl_marker("painting planar update, format %s", self.pixel_format)
divs = get_subsampling_divs(self.pixel_format)
glEnable(GL_FRAGMENT_PROGRAM_ARB)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
tw, th = self.texture_size
log("%s.render_planar_update(..) texture_size=%s, size=%s", self, self.texture_size, self.size)
glBegin(GL_QUADS)
for x,y in ((0, 0), (0, rh), (rw, rh), (rw, 0)):
ax = min(tw, x)
ay = min(th, y)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glMultiTexCoord2i(texture, ax//div_w, ay//div_h)
glVertex2i(int(rx+ax*x_scale), int(ry+ay*y_scale))
glEnd()
if self.pixel_format == "GBRP":
self.unset_rgbP_paint_state()
def update_planar_textures(self,
x,
y,
width,
height,
img,
pixel_format,
scaling=False):
assert self.textures is not None, "no OpenGL textures!"
log("%s.update_planar_textures%s", self,
(x, y, width, height, img, pixel_format))
divs = get_subsampling_divs(pixel_format)
if self.pixel_format is None or self.pixel_format != pixel_format or self.texture_size != (
width, height):
self.pixel_format = pixel_format
self.texture_size = (width, height)
self.gl_marker("Creating new planar textures, pixel format %s" %
pixel_format)
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1),
(GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
mag_filter = GL_NEAREST
if scaling or (div_w > 1 or div_h > 1):
mag_filter = GL_LINEAR
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_MAG_FILTER, mag_filter)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
width / div_w, height / div_h, 0, GL_LUMINANCE,
GL_UNSIGNED_BYTE, None)
self.gl_marker("updating planar textures: %sx%s %s" %
(width, height, pixel_format))
rowstrides = img.get_rowstride()
img_data = img.get_pixels()
assert len(rowstrides) == 3 and len(img_data) == 3
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1),
(GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[index])
pixel_data = img_data[index]
log("texture %s: div=%s, rowstride=%s, %sx%s, data=%s bytes",
index, divs[index], rowstrides[index], width / div_w,
height / div_h, len(pixel_data))
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width / div_w,
height / div_h, GL_LUMINANCE, GL_UNSIGNED_BYTE,
pixel_data)
def update_planar_textures(self, x, y, width, height, img, pixel_format, scaling=False):
assert self.textures is not None, "no OpenGL textures!"
log("%s.update_planar_textures%s", self, (x, y, width, height, img, pixel_format))
divs = get_subsampling_divs(pixel_format)
if self.pixel_format is None or self.pixel_format!=pixel_format or self.texture_size!=(width, height):
self.pixel_format = pixel_format
self.texture_size = (width, height)
self.gl_marker("Creating new planar textures, pixel format %s", pixel_format)
# Create textures of the same size as the window's
empty_buf = b"\0"*(width*height)
pixel_data = self.pixels_for_upload(empty_buf)[1]
for texture, index in ((GL_TEXTURE0, TEX_Y), (GL_TEXTURE1, TEX_U), (GL_TEXTURE2, TEX_V)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
target = GL_TEXTURE_RECTANGLE_ARB
glBindTexture(target, self.textures[index])
mag_filter = GL_NEAREST
if scaling or (div_w > 1 or div_h > 1):
mag_filter = GL_LINEAR
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, mag_filter)
glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
set_texture_level()
glTexImage2D(target, 0, GL_LUMINANCE, width//div_w, height//div_h, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, pixel_data)
#glBindTexture(target, 0) #redundant: we rebind below:
self.gl_marker("updating planar textures: %sx%s %s", width, height, pixel_format)
rowstrides = img.get_rowstride()
img_data = img.get_pixels()
assert len(rowstrides)==3 and len(img_data)==3
for texture, index, tex_name in (
(GL_TEXTURE0, TEX_Y, "Y"),
(GL_TEXTURE1, TEX_U, "U"),
(GL_TEXTURE2, TEX_V, "V"),
):
div_w, div_h = divs[index]
w = width//div_w
h = height//div_h
if w==0 or h==0:
log.error("Error: zero dimension %ix%i for %s planar texture %s", w, h, pixel_format, tex_name)
log.error(" screen update %s dropped", (x, y, width, height))
continue
glActiveTexture(texture)
target = GL_TEXTURE_RECTANGLE_ARB
glBindTexture(target, self.textures[index])
self.set_alignment(w, rowstrides[index], tex_name)
upload, pixel_data = self.pixels_for_upload(img_data[index])
log("texture %s: div=%s, rowstride=%s, %sx%s, data=%s bytes, upload=%s",
index, divs[index], rowstrides[index], w, h, len(pixel_data), upload)
glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 0)
try:
glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, 0)
except:
pass
glTexSubImage2D(target, 0, 0, 0, w, h, GL_LUMINANCE, GL_UNSIGNED_BYTE, pixel_data)
glBindTexture(target, 0)
def update_texture_yuv(self, img_data, x, y, width, height, rowstrides, pixel_format):
assert x==0 and y==0
assert self.textures is not None, "no OpenGL textures!"
if self.pixel_format is None or self.pixel_format!=pixel_format or self.texture_size!=(width, height):
self.pixel_format = pixel_format
self.texture_size = (width, height)
divs = get_subsampling_divs(pixel_format)
debug("GL creating new YUV textures for pixel format %s using divs=%s", pixel_format, divs)
self.gl_marker("Creating new YUV textures")
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
mag_filter = GL_NEAREST
if div_w > 1 or div_h > 1:
mag_filter = GL_LINEAR
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, mag_filter)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width/div_w, height/div_h, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0)
debug("Assigning fragment program")
glEnable(GL_FRAGMENT_PROGRAM_ARB)
if not self.yuv_shader:
self.yuv_shader = [ 1 ]
glGenProgramsARB(1, self.yuv_shader)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv_shader[0])
prog = GL_COLORSPACE_CONVERSIONS
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, len(prog), prog)
err = glGetString(GL_PROGRAM_ERROR_STRING_ARB)
if err:
#FIXME: maybe we should do something else here?
log.error(err)
self.gl_marker("Updating YUV textures")
divs = get_subsampling_divs(pixel_format)
U_width = 0
U_height = 0
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[index])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width/div_w, height/div_h, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[index])
if index == 1:
U_width = width/div_w
U_height = height/div_h
elif index == 2:
if width/div_w != U_width:
log.error("Width of V plane is %d, differs from width of corresponding U plane (%d), pixel_format is %d", width/div_w, U_width, pixel_format)
if height/div_h != U_height:
log.error("Height of V plane is %d, differs from height of corresponding U plane (%d)", height/div_h, U_height)
def finalizar_renderizado(self):
"""Renderiza la textura final, obtenida en el framebuffer 0."""
self.renderizar_por_pasos(True,
(0, self.shader_h, self.fbos[0], self.fbos[1]),
(1, self.shader_v, self.fbos[1], None))
# Pequeño render lateral sin usar el programa (textura del framebuffer)
glActiveTexture(GL_TEXTURE0)
self.renderizar_cuad(self.ventana[0]-160, 0., self.ventana[0], 120.)
glBindTexture(GL_TEXTURE_2D, self.fbos[1].textura)
self.renderizar_cuad(self.ventana[0]-160, 130., self.ventana[0], 250.)
def _set_texture(self, name, value):
from OpenGL.GL import glActiveTexture, glBindTexture, glUniform1i, \
GL_TEXTURE0, GL_TEXTURE_2D
gl_texture_unit = self._assign_texture(name)
glActiveTexture(GL_TEXTURE0 + gl_texture_unit)
glBindTexture(GL_TEXTURE_2D, value._gl_handle)
glUniform1i(self._uniform_handles.get(name), gl_texture_unit)
# it seems that this unit should be activated before using
# the framebuffer
glActiveTexture(GL_TEXTURE0)
def update_stack(self, stack):
s = np.array(stack, dtype=np.uint8, order='F')
w, h, d = s.shape
glActiveTexture(GL_TEXTURE0)
glTexSubImage3D(GL_TEXTURE_3D, # Target
0, # Level
0, 0, 0, # xoffset, yoffset, zoffset
d, h, w, # width, height, depth
GL_RED, # Format of the pixel data
GL_UNSIGNED_BYTE, # Type of the pixel data
s) # Data
def _set_texture(self, name, value):
from OpenGL.GL import glActiveTexture, glBindTexture, glUniform1i, \
GL_TEXTURE0, GL_TEXTURE_2D
gl_texture_unit = self._assign_texture(name)
glActiveTexture(GL_TEXTURE0 + gl_texture_unit)
glBindTexture(GL_TEXTURE_2D, value._gl_handle)
glUniform1i(self._uniform_handles.get(name), gl_texture_unit)
# it seems that this unit should be activated before using
# the framebuffer
glActiveTexture(GL_TEXTURE0)
def set_rgb_paint_state(self):
# Set GL state for RGB painting:
# no fragment program
# only tex unit #0 active
self.gl_marker("Switching to RGB paint state")
glDisable(GL_FRAGMENT_PROGRAM_ARB);
for texture in (GL_TEXTURE1, GL_TEXTURE2):
glActiveTexture(texture)
glDisable(GL_TEXTURE_RECTANGLE_ARB)
glActiveTexture(GL_TEXTURE0);
glEnable(GL_TEXTURE_RECTANGLE_ARB)
def finalizar_renderizado(self):
"""Renderiza la textura final, obtenida en el framebuffer."""
# Desactivar el framebuffer
no_usar_fbos()
# Activar la textura
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, self.fbos[0].textura)
# Renderiza la imagen principal
self.shader.usar() if self.shader else None
self.renderizar_cuad(0., 0., self.tam[0], self.tam[1])
no_usar_shaders() if self.shader else None
def set_rgb_paint_state(self):
# Set GL state for RGB painting:
# no fragment program
# only tex unit #0 active
self.gl_marker("Switching to RGB paint state")
glDisable(GL_FRAGMENT_PROGRAM_ARB);
for texture in (GL_TEXTURE1, GL_TEXTURE2):
glActiveTexture(texture)
glDisable(GL_TEXTURE_RECTANGLE_ARB)
glActiveTexture(GL_TEXTURE0);
glEnable(GL_TEXTURE_RECTANGLE_ARB)
def use(self, tex_unit):
"""Makes the given texture as active in the rendering pipeline.
:param tex_unit: OpenGL texture image unit to make active.
:type tex_unit: int
"""
self.tex_unit = tex_unit
glActiveTexture(GL_TEXTURE0 + self.tex_unit)
glBindTexture(self.tex_type, self.tex_id)
glBindSampler(self.tex_unit, self.sampler)
yield
glBindTexture(self.tex_type, 0)
def update_texture_yuv(self, img_data, x, y, width, height, rowstrides, pixel_format):
window_width, window_height = self.size
assert self.textures is not None, "no OpenGL textures!"
if self.pixel_format is None or self.pixel_format!=pixel_format:
self.pixel_format = pixel_format
divs = self.get_subsampling_divs(pixel_format)
log("GL creating new YUV textures for pixel format %s using divs=%s", pixel_format, divs)
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
div = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
mag_filter = GL_NEAREST
if div>1:
mag_filter = GL_LINEAR
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, mag_filter)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, window_width/div, window_height/div, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0)
log("Assigning fragment program")
glEnable(GL_FRAGMENT_PROGRAM_ARB)
if not self.yuv_shader:
self.yuv_shader = [ 1 ]
glGenProgramsARB(1, self.yuv_shader)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv_shader[0])
prog = GL_COLORSPACE_CONVERSIONS
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, len(prog), prog)
err = glGetString(GL_PROGRAM_ERROR_STRING_ARB)
if err:
#FIXME: maybe we should do something else here?
log.error(err)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv_shader[0])
# Clamp width and height to the actual texture size
if x + width > window_width:
width = window_width - x
if y + height > window_height:
height = window_height - y
divs = self.get_subsampling_divs(pixel_format)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
div = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[index])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width/div, height/div, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[index])
glFlush()
def update_planar_textures(self, x, y, width, height, img, pixel_format, scaling=False):
assert x==0 and y==0
assert self.textures is not None, "no OpenGL textures!"
debug("%s.update_planar_textures%s", self, (x, y, width, height, img, pixel_format))
divs = get_subsampling_divs(pixel_format)
if self.pixel_format is None or self.pixel_format!=pixel_format or self.texture_size!=(width, height):
self.pixel_format = pixel_format
self.texture_size = (width, height)
self.gl_marker("Creating new planar textures, pixel format %s" % pixel_format)
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
mag_filter = GL_NEAREST
if scaling or (div_w > 1 or div_h > 1):
mag_filter = GL_LINEAR
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, mag_filter)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width/div_w, height/div_h, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, None)
self.gl_marker("updating planar textures: %sx%s %s" % (width, height, pixel_format))
U_width = 0
U_height = 0
rowstrides = img.get_rowstride()
img_data = img.get_pixels()
assert len(rowstrides)==3
assert len(img_data)==3
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[index])
pixel_data = img_data[index][:]
debug("texture %s: div=%s, rowstride=%s, %sx%s, data=%s bytes", index, divs[index], rowstrides[index], width/div_w, height/div_h, len(pixel_data))
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width/div_w, height/div_h, GL_LUMINANCE, GL_UNSIGNED_BYTE, pixel_data)
if index == 1:
U_width = width/div_w
U_height = height/div_h
elif index == 2:
if width/div_w != U_width:
log.error("Width of V plane is %d, differs from width of corresponding U plane (%d), pixel_format is %d", width/div_w, U_width, pixel_format)
if height/div_h != U_height:
log.error("Height of V plane is %d, differs from height of corresponding U plane (%d), pixel_format is %d", height/div_h, U_height, pixel_format)
def draw(self, program):
if self.cull_face:
glDisable(GL_CULL_FACE)
program.setInt("diffuseTexture", 0)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, self.texture)
glBindVertexArray(self.VAO)
glDrawArrays(GL_TRIANGLES, 0, self.__indicesLen)
glBindVertexArray(0)
if self.cull_face:
glEnable(GL_CULL_FACE)
def renderizar_por_pasos(self, prueba, *pasos):
"""Automatiza el renderizado, a través de pasos explícitos. La idea es
dar n pasos de renderizado a fbos, y un último paso a la pantalla.
prueba = ¿Renderizar framebuffers?
pasos = (textura, shader, fbo_previo, fbo), donde:
textura = posición de la textura donde renderizar el fbo previo
shader = shader a utilizar durante la renderización al fbo
fbo_previo = fbo que contiene la textura a renderizar
fbo = framebuffer sobre el cual renderizar"""
for paso in pasos:
tex = paso[0]
shader = paso[1]
fbo_prev = paso[2]
fbo = paso[3]
# Si hay que renderizar a un framebuffer
if fbo:
# Usamos el nuevo framebuffer
fbo.usar()
glClear(GL_COLOR_BUFFER_BIT)
# Activamos la textura
glActiveTexture(GL_TEXTURE0 + tex)
# Renderizamos el resultado del framebuffer anterior
glBindTexture(GL_TEXTURE_2D, fbo_prev.textura)
# Usar shaders si corresponde
if shader:
shader.usar()
# Al renderizar a un fbo, lo hacemos en tamaño completo
self.renderizar_cuad(0., 0., self.ventana[0], self.ventana[1])
# Si hay que renderizar a la pantalla
else:
# Dejamos de usar los framebuffers
no_usar_fbos()
glClear(GL_COLOR_BUFFER_BIT)
# Activamos la textura
glActiveTexture(GL_TEXTURE0 + tex)
# Renderizamos el resultado del framebuffer anterior
glBindTexture(GL_TEXTURE_2D, fbo_prev.textura)
# Usar shaders si corresponde
if shader:
shader.usar()
# Tamaño completo a tamaño de zona de renderizado de la cámara
inicio_x = self.zona[0]*self.ventana[0]
inicio_y = self.zona[1]*self.ventana[1]
fin_x = self.zona[2]*self.ventana[0]
fin_y = self.zona[3]*self.ventana[1]
# Renderizamos a la pantalla
self.renderizar_cuad(inicio_x, inicio_y, fin_x, fin_y)
# Terminamos de usar los shaders
no_usar_shaders()
def upload_cursor_texture(self, width, height, pixels):
upload, pixel_data = self.pixels_for_upload(pixels)
rgb_format = "RGBA"
glActiveTexture(GL_TEXTURE0)
target = GL_TEXTURE_RECTANGLE_ARB
glEnable(target)
glBindTexture(target, self.textures[TEX_CURSOR])
self.set_alignment(width, width*4, rgb_format)
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER)
glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER)
glTexImage2D(target, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixel_data)
log("GL cursor %ix%i uploaded %i bytes of %s pixel data using %s",
width, height, len(pixels), rgb_format, upload)
glBindTexture(target, 0)
glDisable(target)
def from_matrix(cls, matrix):
"""Creates a texture from given matrix file.
:param matrix: The matrix.
:type matrix: list
:returns: The texture instance.
:rtype: :class:`renderer.Texture`
"""
w, h = len(matrix[0]), len(matrix)
grid = bytes(chain.from_iterable(reversed(matrix)))
tex = glGenTextures(1)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, tex)
# This code is necessary to handle non-power-of-two textures with small
# sizes.
# TODO: refactor this
param_ids = [
GL_UNPACK_ALIGNMENT,
GL_UNPACK_ROW_LENGTH,
GL_UNPACK_SKIP_ROWS,
GL_UNPACK_SKIP_PIXELS,
]
old_params = {
p: glGetInteger(p)
for p in param_ids
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0)
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0)
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0)
glTexStorage2D(GL_TEXTURE_2D, 1, GL_R8, w, h)
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, GL_RED, GL_UNSIGNED_BYTE, grid)
for p, v in old_params.items():
glPixelStorei(p, v)
glBindTexture(GL_TEXTURE_2D, 0)
return Texture(tex, w, h, GL_TEXTURE_2D)
def render_to_texture(self, text):
"""Renders the given string to a texture object.
:param text: Text to render.
:type text: str
:returns: The resulting texture object.
:rtype: :class:`renderer.Texture`
"""
# render the text to a SDL_Surface structure
surf_ptr = ttf.TTF_RenderText_Solid(
self.font,
text.encode('utf8'),
sdl.SDL_Color())
if not surf_ptr:
raise SDLError('failed to render text to surface: {}'.format(
ttf.TTF_GetError()))
# retrieve a pointer to pixel data
surf = surf_ptr.contents
pixels = ctypes.cast(surf.pixels, ctypes.POINTER(ctypes.c_char))
# create and fill an OpenGL rectangle texture (that is, a texture which
# can have arbitrary non-power-of-two size and is accessed using
# UV coordinates which are linearly mapped to the texture size)
tex = glGenTextures(1)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, tex)
glTexStorage2D(GL_TEXTURE_2D, 1, GL_R8, surf.w, surf.h)
glTexSubImage2D(
GL_TEXTURE_2D,
0,
0,
0,
surf.w,
surf.h,
GL_RED,
GL_UNSIGNED_BYTE,
pixels)
glBindTexture(GL_TEXTURE_2D, 0)
sdl.SDL_FreeSurface(surf_ptr)
return Texture(tex, surf.w, surf.h, GL_TEXTURE_2D)
def from_image(cls, image):
"""Creates a texture from given image file.
:param image: Image.
:type image: :class:`PIL.Image`
:returns: The texture instance.
:rtype: :class:`renderer.Texture`
"""
w, h = image.size
tex = glGenTextures(1)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, tex)
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGB8, w, h)
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, GL_RGB, GL_UNSIGNED_BYTE, image.tobytes())
glBindTexture(GL_TEXTURE_2D, 0)
return Texture(tex, w, h)
def __init__(self, imagefile, points=[], alpha=1.0):
super(ImageActor, self).__init__()
im = Image.open(imagefile)
# Try to open the image file
try:
ix, iy, image = im.size[0], im.size[1], im.tostring("raw", "RGBA", 0, -1)
except SystemError:
ix, iy, image = im.size[0], im.size[1], im.tostring("raw", "RGBX", 0, -1)
# get a texture buffer
glActiveTexture(GL_TEXTURE0)
self.texid = glGenTextures(1)
# Bind the texture
glBindTexture(GL_TEXTURE_2D, self.texid)
glPixelStorei(GL_UNPACK_ALIGNMENT,1)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
# Upload the image
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, ix, iy, 0, GL_RGBA, GL_UNSIGNED_BYTE, image)
# Generate the points for the billboard
if points == []:
points = [Point(0,0), Point(ix,0), Point(ix,-iy), Point(0,-iy)]
if len(points) != 4:
raise Exception("Image needs 4 points, %d provided" % len(points))
# Generate the UV map
uv = [Point(0,1), Point(1,1), Point(1,0), Point(0,0)]
a = []
for i in [0,1,2,0,2,3]:
point = points[i]
tex = uv[i]
a.extend([point.x, point.y, tex.x, tex.y])
# Assign the VBO
super(ImageActor, self)._assignVBO(a)
self.alpha = float(alpha)
def update_planar_textures(self, x, y, width, height, img, pixel_format, scaling=False):
assert self.textures is not None, "no OpenGL textures!"
log("%s.update_planar_textures%s", self, (x, y, width, height, img, pixel_format))
divs = get_subsampling_divs(pixel_format)
if self.pixel_format is None or self.pixel_format!=pixel_format or self.texture_size!=(width, height):
self.pixel_format = pixel_format
self.texture_size = (width, height)
self.gl_marker("Creating new planar textures, pixel format %s", pixel_format)
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
mag_filter = GL_NEAREST
if scaling or (div_w > 1 or div_h > 1):
mag_filter = GL_LINEAR
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, mag_filter)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
set_texture_level()
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width//div_w, height//div_h, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, None)
self.gl_marker("updating planar textures: %sx%s %s", width, height, pixel_format)
rowstrides = img.get_rowstride()
img_data = img.get_pixels()
assert len(rowstrides)==3 and len(img_data)==3
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[index])
upload, pixel_data = self.pixels_for_upload(img_data[index])
log("texture %s: div=%s, rowstride=%s, %sx%s, data=%s bytes, upload=%s", index, divs[index], rowstrides[index], width//div_w, height//div_h, len(pixel_data), upload)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_BASE_LEVEL, 0)
try:
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAX_LEVEL, 0)
except:
pass
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width//div_w, height//div_h, GL_LUMINANCE, GL_UNSIGNED_BYTE, pixel_data)
def __prepare_shaders(self, rotation_matrix=None, light_matrix=None,
depth=True):
"""Generic shaders preparation method for depth map and final scene."""
self.__sh.add_attribute(0, self.__face_vertices, 'face_vertices')
self.__sh.bind_buffer()
self.__sh.use_shaders()
self.__sh.bind_uniform_matrix(light_matrix, 'light_matrix')
if not depth:
face = self.__face_vertices.reshape(self.__mean_face.size // 3, 3)
normals = get_normals(face, View.__triangles.flatten())
self.__sh.add_attribute(1, normals, 'normal_vector')
self.__sh.bind_uniform_matrix(rotation_matrix, 'rotation_matrix')
self.__sh.bind_uniform_vector(self.__face.light_cartesian,
'light_vector')
if not depth:
glActiveTexture(GL_TEXTURE0)
self.__sh.bind_texture(0)
def _do_paint_rgb24(self, img_data, x, y, w, h, rowstride, options,
callbacks):
log("do_paint_rgb24(%s bytes, %s, %s, %s, %s, %s, %s, %s)",
len(img_data), x, y, w, h, rowstride, options, callbacks)
ww, wh = self.size
if x + w > ww or y + h > wh:
log("do_paint_rgb24: ignoring paint which would overflow the backing area"
)
return
drawable = self.gl_init()
if not drawable:
log("do_paint_rgb24: cannot paint yet..")
return
try:
#cleanup if we were doing yuv previously:
if self.pixel_format != GLPixmapBacking.RGB24:
self.remove_shader()
self.pixel_format = GLPixmapBacking.RGB24
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstride / 3)
for texture in (GL_TEXTURE1, GL_TEXTURE2):
glActiveTexture(texture)
glDisable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, w, h, GL_RGB,
GL_UNSIGNED_BYTE, img_data)
glBegin(GL_QUADS)
for rx, ry in ((x, y), (x, y + h), (x + w, y + h), (x + w, y)):
glTexCoord2i(rx, ry)
glVertex2i(rx, ry)
glEnd()
finally:
self.gl_end(drawable)
def render_planar_update(self, rx, ry, rw, rh, x_scale=1, y_scale=1):
log("%s.render_planar_update%s pixel_format=%s", self, (rx, ry, rw, rh, x_scale, y_scale), self.pixel_format)
if self.pixel_format not in ("YUV420P", "YUV422P", "YUV444P", "GBRP"):
#not ready to render yet
return
if self.pixel_format == "GBRP":
# Set GL state for planar RGB: change fragment program
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.shaders[RGBP2RGB_SHADER])
self.gl_marker("painting planar update, format %s", self.pixel_format)
divs = get_subsampling_divs(self.pixel_format)
glEnable(GL_FRAGMENT_PROGRAM_ARB)
for texture, index in ((GL_TEXTURE0, TEX_Y), (GL_TEXTURE1, TEX_U), (GL_TEXTURE2, TEX_V)):
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
tw, th = self.texture_size
log("%s.render_planar_update(..) texture_size=%s, size=%s", self, self.texture_size, self.size)
glBegin(GL_QUADS)
for x,y in ((0, 0), (0, rh), (rw, rh), (rw, 0)):
ax = min(tw, x)
ay = min(th, y)
for texture, index in ((GL_TEXTURE0, TEX_Y), (GL_TEXTURE1, TEX_U), (GL_TEXTURE2, TEX_V)):
(div_w, div_h) = divs[index]
glMultiTexCoord2i(texture, ax//div_w, ay//div_h)
glVertex2i(int(rx+ax*x_scale), int(ry+ay*y_scale))
glEnd()
for texture in (GL_TEXTURE0, GL_TEXTURE1, GL_TEXTURE2):
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0)
glDisable(GL_FRAGMENT_PROGRAM_ARB)
if self.pixel_format == "GBRP":
# Reset state to our default (YUV painting)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.shaders[YUV2RGB_SHADER])
glActiveTexture(GL_TEXTURE0)
def load(file_path):
img = Image.open(file_path, 'r').convert('RGB')
img_data = np.array(img, dtype=np.uint8)
width, height = img.size
texture = glGenTextures(1)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, texture)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB,
GL_UNSIGNED_BYTE, img_data)
return texture
def __prepare_shaders(self,
rotation_matrix=None,
light_matrix=None,
depth=True):
"""Generic shaders preparation method for depth map and final scene."""
self.__sh.add_attribute(0, self.__face_vertices, 'face_vertices')
self.__sh.bind_buffer()
self.__sh.use_shaders()
self.__sh.bind_uniform_matrix(light_matrix, 'light_matrix')
if not depth:
face = self.__face_vertices.reshape(self.__mean_face.size // 3, 3)
normals = get_normals(face, View.__triangles.flatten())
self.__sh.add_attribute(1, normals, 'normal_vector')
self.__sh.bind_uniform_matrix(rotation_matrix, 'rotation_matrix')
self.__sh.bind_uniform_vector(self.__face.light_cartesian,
'light_vector')
if not depth:
glActiveTexture(GL_TEXTURE0)
self.__sh.bind_texture(0)
def __init__(self, stack, spacing):
s = np.array(stack, dtype=np.uint8, order='F')
w, h, d = s.shape
stack_texture = glGenTextures(1)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_3D, stack_texture)
glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE)
glTexImage3D(GL_TEXTURE_3D, 0, GL_R8, d, h, w, 0, GL_RED,
GL_UNSIGNED_BYTE, s)
self.stack_texture = stack_texture
self.shape = s.shape
def render_yuv_update(self, rx, ry, rw, rh):
debug("render_yuv_update %sx%s at %sx%s pixel_format=%s", rw, rh, rx, ry, self.pixel_format)
if self.pixel_format not in (YUV420P, YUV422P, YUV444P):
#not ready to render yet
return
self.gl_marker("Painting YUV update")
divs = get_subsampling_divs(self.pixel_format)
glEnable(GL_FRAGMENT_PROGRAM_ARB)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv_shader[0])
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
tw, th = self.texture_size
debug("render_yuv_update texture_size=%s, size=%s", self.texture_size, self.size)
glBegin(GL_QUADS)
for x,y in ((rx, ry), (rx, ry+rh), (rx+rw, ry+rh), (rx+rw, ry)):
ax = min(tw, x)
ay = min(th, y)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glMultiTexCoord2i(texture, ax/div_w, ay/div_h)
glVertex2i(ax, ay)
glEnd()
texture_id = glGenTextures(1)
glPixelStorei(GL_UNPACK_ALIGNMENT, 4)
glBindTexture(GL_TEXTURE_2D, texture_id)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, img.size[0], img.size[1], 0, GL_RGBA, GL_UNSIGNED_BYTE, img_data)
while running:
glClear(GL_COLOR_BUFFER_BIT)
# Specify shader to be used
glUseProgram(program.program_id)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, texture_id)
sampler_loc = program.attribute_location('texture_sampler')
glUniform1i(sampler_loc, 0)
# Bind VAO - this will automatically
# bind all the vbo's saving us a bunch
# of calls
glBindVertexArray(vao_id)
# Modern GL makes the draw call really simple
# All the complexity has been pushed elsewhere
glDrawArrays(GL_TRIANGLES, 0, 6)
# Lets unbind the shader and vertex array state
glUseProgram(0)
def _render_volume_obj(self, volume_object, width, height, VMatrix, PMatrix):
glBindFramebuffer(GL_FRAMEBUFFER, self.fbo)
glViewport(0, 0, width, height)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_3D, volume_object.stack_object.stack_texture)
glClear(GL_COLOR_BUFFER_BIT) # Clear back buffer.
glEnable(GL_CULL_FACE)
glCullFace(GL_FRONT) # NB flipped
# glValidateProgram(self.b_shader.program)
# logging.debug("b_valid ", glGetProgramiv(self.b_shader.program,
# GL_VALIDATE_STATUS))
# logging.debug(glGetProgramInfoLog(self.b_shader.program).decode())
glUseProgram(self.b_shader.program)
glBindVertexArray(volume_object.vao)
volume_object.elVBO.bind()
mv_matrix = np.dot(VMatrix, volume_object.transform)
glUniformMatrix4fv(self.b_shader.get_uniform("mv_matrix"),
1, True, mv_matrix.astype('float32'))
glUniformMatrix4fv(self.b_shader.get_uniform("p_matrix"),
1, True, PMatrix.astype('float32'))
glDrawElements(GL_TRIANGLES, volume_object.elCount,
GL_UNSIGNED_INT, volume_object.elVBO)
volume_object.elVBO.unbind()
glBindVertexArray(0)
glUseProgram(0)
glBindFramebuffer(GL_FRAMEBUFFER, 0)
glActiveTexture(GL_TEXTURE0 + 1)
glBindTexture(GL_TEXTURE_2D, self.bfTex)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_3D, volume_object.stack_object.stack_texture)
glUseProgram(self.f_shader.program)
glUniform1i(self.f_shader.get_uniform("texture3s"), 0)
glUniform1i(self.f_shader.get_uniform("backfaceTex"), 1)
glEnable(GL_CULL_FACE)
glCullFace(GL_BACK)
glBindVertexArray(volume_object.vao)
volume_object.elVBO.bind()
glUniformMatrix4fv(self.f_shader.get_uniform("mv_matrix"),
1, True, mv_matrix.astype('float32'))
glUniformMatrix4fv(self.f_shader.get_uniform("p_matrix"),
1, True, PMatrix.astype('float32'))
glDrawElements(GL_TRIANGLES, volume_object.elCount,
GL_UNSIGNED_INT, volume_object.elVBO)
glActiveTexture(GL_TEXTURE0+1)
glBindTexture(GL_TEXTURE_2D, 0)
glCullFace(GL_BACK)
volume_object.elVBO.unbind()
glBindVertexArray(0)
glUseProgram(0)
def update_texture_yuv(self, img_data, x, y, width, height, rowstrides,
pixel_format):
window_width, window_height = self.size
assert self.textures is not None, "no OpenGL textures!"
if self.pixel_format is None or self.pixel_format != pixel_format:
self.pixel_format = pixel_format
divs = self.get_subsampling_divs(pixel_format)
log(
"GL creating new YUV textures for pixel format %s using divs=%s",
pixel_format, divs)
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1),
(GL_TEXTURE2, 2)):
div = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
mag_filter = GL_NEAREST
if div > 1:
mag_filter = GL_LINEAR
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_MAG_FILTER, mag_filter)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
window_width / div, window_height / div, 0,
GL_LUMINANCE, GL_UNSIGNED_BYTE, 0)
log("Assigning fragment program")
glEnable(GL_FRAGMENT_PROGRAM_ARB)
if not self.yuv_shader:
self.yuv_shader = [1]
glGenProgramsARB(1, self.yuv_shader)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv_shader[0])
prog = GL_COLORSPACE_CONVERSIONS
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,
GL_PROGRAM_FORMAT_ASCII_ARB, len(prog),
prog)
err = glGetString(GL_PROGRAM_ERROR_STRING_ARB)
if err:
#FIXME: maybe we should do something else here?
log.error(err)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv_shader[0])
# Clamp width and height to the actual texture size
if x + width > window_width:
width = window_width - x
if y + height > window_height:
height = window_height - y
divs = self.get_subsampling_divs(pixel_format)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1),
(GL_TEXTURE2, 2)):
div = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[index])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width / div,
height / div, GL_LUMINANCE, GL_UNSIGNED_BYTE,
img_data[index])
glFlush()
def paint_yuv420(self, img_data, x, y, width, height, rowstrides):
#import time
#before=time.time()
# OpenGL begin
if not self.gldrawable.gl_begin(self.glcontext):
log.error("OUCH")
return False
# Upload texture
if self.textures[0] == 0:
self.textures = glGenTextures(3)
glEnable(GL_FRAGMENT_PROGRAM_ARB)
if not self.yuv420_shader:
self.yuv420_shader = [ 1 ]
glGenProgramsARB(1, self.yuv420_shader)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv420_shader[0])
# The following fragprog is:
# * MIT X11 license, Copyright (c) 2007 by:
# * Michael Dominic K. <*****@*****.**>
#http://www.mdk.org.pl/2007/11/17/gl-colorspace-conversions
prog = """!!ARBfp1.0
# cgc version 3.1.0010, build date Feb 10 2012
# command line args: -profile arbfp1
# source file: yuv.cg
#vendor NVIDIA Corporation
#version 3.1.0.10
#profile arbfp1
#program main
#semantic main.IN
#var float2 IN.texcoord1 : $vin.TEXCOORD0 : TEX0 : 0 : 1
#var float2 IN.texcoord2 : $vin.TEXCOORD1 : TEX1 : 0 : 1
#var float2 IN.texcoord3 : $vin.TEXCOORD2 : TEX2 : 0 : 1
#var samplerRECT IN.texture1 : TEXUNIT0 : texunit 0 : 0 : 1
#var samplerRECT IN.texture2 : TEXUNIT1 : texunit 1 : 0 : 1
#var samplerRECT IN.texture3 : TEXUNIT2 : texunit 2 : 0 : 1
#var float4 IN.color : $vin.COLOR0 : COL0 : 0 : 1
#var float4 main.color : $vout.COLOR0 : COL : -1 : 1
#const c[0] = 1.1643835 2.017231 0 0.5
#const c[1] = 0.0625 1.1643835 -0.3917616 -0.81296802
#const c[2] = 1.1643835 0 1.5960271
PARAM c[3] = { { 1.1643835, 2.017231, 0, 0.5 },
{ 0.0625, 1.1643835, -0.3917616, -0.81296802 },
{ 1.1643835, 0, 1.5960271 } };
TEMP R0;
TEMP R1;
TEX R0.x, fragment.texcoord[2], texture[2], RECT;
ADD R1.z, R0.x, -c[0].w;
TEX R1.x, fragment.texcoord[0], texture[0], RECT;
TEX R0.x, fragment.texcoord[1], texture[1], RECT;
ADD R1.x, R1, -c[1];
ADD R1.y, R0.x, -c[0].w;
DP3 result.color.z, R1, c[0];
DP3 result.color.y, R1, c[1].yzww;
DP3 result.color.x, R1, c[2];
MOV result.color.w, fragment.color.primary;
END
# 10 instructions, 2 R-regs
"""
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, len(prog), prog)
log.error(glGetString(GL_PROGRAM_ERROR_STRING_ARB))
glEnable(GL_FRAGMENT_PROGRAM_ARB)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv420_shader[0])
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[0])
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width, height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[0]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[1])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[1])
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width/2, height/2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[1]);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[2])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[2])
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width/2, height/2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[2]);
vtxarrays=0
if vtxarrays == 1:
texcoords = [ [ 0, 0 ],
[ 0, height],
[ width, height],
[ width, 0] ]
vtxcoords = texcoords
texcoords_half = [ [ 0, 0 ],
[ 0, height/2],
[ width/2, height/2],
[ width/2, 0] ]
glVertexPointeri(vtxcoords)
glActiveTexture(GL_TEXTURE0);
glClientActiveTexture(GL_TEXTURE0)
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointeri(texcoords)
glActiveTexture(GL_TEXTURE1);
glClientActiveTexture(GL_TEXTURE1)
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointeri(texcoords_half)
glActiveTexture(GL_TEXTURE2);
glClientActiveTexture(GL_TEXTURE2)
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointeri(texcoords_half)
glDrawArrays(GL_QUADS, 0, 4);
else:
glBegin(GL_QUADS);
glMultiTexCoord2i(GL_TEXTURE0, 0, 0);
glMultiTexCoord2i(GL_TEXTURE1, 0, 0);
glMultiTexCoord2i(GL_TEXTURE2, 0, 0);
glVertex2i(0, 0);
glMultiTexCoord2i(GL_TEXTURE0, 0, height);
glMultiTexCoord2i(GL_TEXTURE1, 0, height/2);
glMultiTexCoord2i(GL_TEXTURE2, 0, height/2);
glVertex2i(0, height);
glMultiTexCoord2i(GL_TEXTURE0, width, height);
glMultiTexCoord2i(GL_TEXTURE1, width/2, height/2);
glMultiTexCoord2i(GL_TEXTURE2, width/2, height/2);
glVertex2i(width, height);
glMultiTexCoord2i(GL_TEXTURE0, width, 0);
glMultiTexCoord2i(GL_TEXTURE1, width/2, 0);
glMultiTexCoord2i(GL_TEXTURE2, width/2, 0);
glVertex2i(width, 0);
glEnd()
# OpenGL end
#self.gldrawable.swap_buffers()
# self.gldrawable.swap_buffers()
glFinish()
self.gldrawable.gl_end()
def update(self):
for camera in self.__active_camera:
self.__vertices = camera.vertices
self.__indices = camera.indices
self.__data_for_render = camera.get_data_for_render()
glBindBuffer(GL_ARRAY_BUFFER, self.__VBO)
glBufferData(GL_ARRAY_BUFFER, self.__vertices.nbytes,
self.__vertices, GL_STATIC_DRAW)
camera.bind_frame_buffer()
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
for material, data in self.__data_for_render.items():
material.use_program()
num_of_items = sum(
TYPE_TO_LENGTH[type_]
for attrib, type_ in material.attributes_types.items()
if attrib not in material.instanced_attribs)
pointer = 0
glBindBuffer(GL_ARRAY_BUFFER, self.__VBO)
for attrib, index in sorted(material.attributes.items(),
key=lambda x: x[1]):
if attrib not in material.instanced_attribs:
length = TYPE_TO_LENGTH[
material.attributes_types[attrib]]
glEnableVertexAttribArray(index)
glVertexAttribPointer(
index, length, GL_FLOAT, GL_FALSE,
self.__vertices.itemsize * num_of_items,
ctypes.c_void_p(pointer * 4))
pointer += length
if material.view_matrix_name in material.uniforms:
glUniformMatrix4fv(
material.uniforms[material.view_matrix_name], 1,
GL_FALSE, camera.obj.inverse_matrix)
if material.projection_matrix_name in material.uniforms:
glUniformMatrix4fv(
material.uniforms[material.projection_matrix_name], 1,
GL_FALSE, camera.projection)
for dat in data:
sampler_id = 0
for uniform, index in material.uniforms.items():
if material.uniforms_types[uniform] == GL_SAMPLER_2D:
if uniform in dat['object'].components[
'Mesh'].uniform_data:
unif_dat = dat['object'].components[
'Mesh'].uniform_data[uniform]
if callable(unif_dat):
unif_dat = unif_dat()
glUniform1i(index, sampler_id)
glActiveTexture(GL_TEXTURE0 + sampler_id)
unif_dat.bind_texture()
unif_dat.load_settings()
if unif_dat.default_texture == unif_dat.texture:
unif_dat.send_texture()
# if type(unif_dat) == int:
# glUniform1i(index, sampler_id)
# glActiveTexture(GL_TEXTURE0 + sampler_id)
# glBindTexture(GL_TEXTURE_2D, unif_dat)
else:
glUniform1i(index, sampler_id)
glActiveTexture(GL_TEXTURE0 + sampler_id)
unif_dat.bind_texture()
unif_dat.load_settings()
if unif_dat.default_texture == unif_dat.texture:
unif_dat.send_texture()
# glUniform1i(index, sampler_id)
# glActiveTexture(GL_TEXTURE0 + sampler_id)
# glBindTexture(GL_TEXTURE_2D, unif_dat)
elif 'Texture' in dat['object'].components:
# location = material.uniforms[uniform]
texture = dat['object'].components['Texture']
glUniform1i(index, sampler_id)
glActiveTexture(GL_TEXTURE0 + sampler_id)
texture.bind_texture()
texture.load_settings()
if texture.default_texture == texture.texture:
texture.send_texture()
# texture.bind_default_texture()
sampler_id += 1
elif material.model_matrix_name == uniform:
glUniformMatrix4fv(
index, 1, GL_FALSE,
dat['object'].transformation_matrix)
elif material.view_matrix_name == uniform:
pass
elif material.projection_matrix_name == uniform:
pass
elif uniform in dat['object'].components[
'Mesh'].uniform_data:
uniform_data = dat['object'].components[
'Mesh'].uniform_data[uniform]
if callable(uniform_data):
uniform_data = uniform_data()
if type(uniform_data) == int or float:
glUniform1f(index, float(uniform_data))
elif type(uniform_data) == int or float:
glUniform1f(index, float(uniform_data))
# glDrawElements(GL_TRIANGLES, dat['length'], GL_UNSIGNED_INT, ctypes.c_void_p(dat['pointer'] * 0))
flatten_indices = dat['indices']
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.__EBO)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
flatten_indices.nbytes, flatten_indices,
GL_STATIC_DRAW)
# glDrawElements(GL_TRIANGLES, len(flatten_indices), GL_UNSIGNED_INT, None)
mesh = dat['object'].components['Mesh']
if len(mesh.instanced_point_data):
instance_data = mesh.get_instanced_data_positioned_to_material(
material, flattened=False)
instance_cnt = len(instance_data)
instance_data = instance_data.flatten()
glBindBuffer(GL_ARRAY_BUFFER, self.__instanceVBO)
glBufferData(GL_ARRAY_BUFFER, instance_data.nbytes,
instance_data, GL_STATIC_DRAW)
num_of_items = sum(
TYPE_TO_LENGTH[material.attributes_types[attrib]]
for attrib in material.instanced_attribs)
ptr = 0
for attrib, index in sorted(
material.attributes.items(),
key=lambda x: x[1]):
if attrib in material.instanced_attribs:
length = TYPE_TO_LENGTH[
material.attributes_types[attrib]]
glEnableVertexAttribArray(index)
glVertexAttribPointer(
index, length, GL_FLOAT, GL_FALSE,
instance_data.itemsize * num_of_items,
ctypes.c_void_p(ptr * 4))
glVertexAttribDivisor(index, 1)
ptr += length
glDrawElementsInstanced(GL_TRIANGLES,
len(flatten_indices),
GL_UNSIGNED_INT, None,
instance_cnt)
else:
glDrawRangeElements(GL_TRIANGLES, dat['pointer'],
dat['pointer'] + dat['length'],
len(flatten_indices),
GL_UNSIGNED_INT, None)
def Bind(self, slot=0):
glActiveTexture(GL_TEXTURE0 + slot)
glBindTexture(GL_TEXTURE_2D, self.m_RendererID)
def render(
self,
proj: np.ndarray,
view: np.ndarray,
model: np.ndarray,
lights: List[Light],
mode: Optional[int] = None,
) -> None:
"""Render material
This function must be called before rendering the actual object
Args:
proj: Projection materix
view: View matrix
model: Model matrix
lights: Light objects in the scene
mode: Set explicit shader mode (optional - used for vertex colors)
"""
if not self._initialized:
self.build_shader()
if self.display == SOLID:
if self.lights and len(lights) > 0:
if self._texture is not None:
self.shader._mode = Shader.LIGHT_TEXTURE
else:
self.shader._mode = Shader.LIGHT_COLOR
else:
if self._texture is not None:
self.shader._mode = Shader.NO_LIGHT_TEXTURE
else:
self.shader._mode = Shader.NO_LIGHT_COLOR
else:
self.shader._mode = Shader.NO_LIGHT_COLOR
if mode is not None:
self.shader._mode = mode
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
self.shader.use()
self.shader.set_int("material_mode", self.shader._mode)
self.shader.set_matrix4x4_np("model", model)
if view is None:
self.shader.set_int("view_mode", 1)
else:
self.shader.set_matrix4x4_np("view", view)
self.shader.set_int("view_mode", 0)
self.shader.set_matrix4x4_np("projection", proj)
self.shader.set_float("opacity", self.opacity)
if self._texture is not None:
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, self._texture)
self.shader.set_int("tex_unit", 0)
light_array = [light.position for light in lights]
lcolor_array = [light.color for light in lights]
light_array = np.array(light_array, dtype=np.float32)
lcolor_array = np.array(lcolor_array, dtype=np.float32)
self.shader.set_vector3_array_np("light_pos", light_array, len(lights))
self.shader.set_vector3_array_np("light_color", lcolor_array,
len(lights))
self.shader.set_int("LIGHT_COUNT", len(lights))
self.shader.set_vector3_np("object_color",
np.array(self.color, dtype=np.float32))
glPixelStorei(GL_UNPACK_ALIGNMENT, 4)
glBindTexture(GL_TEXTURE_2D, texture_id)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, img.size[0], img.size[1], 0,
GL_RGBA, GL_UNSIGNED_BYTE, img_data)
while running:
glClear(GL_COLOR_BUFFER_BIT)
# Specify shader to be used
glUseProgram(program.program_id)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, texture_id)
sampler_loc = program.attribute_location('texture_sampler')
glUniform1i(sampler_loc, 0)
# Bind VAO - this will automatically
# bind all the vbo's saving us a bunch
# of calls
glBindVertexArray(vao_id)
# Modern GL makes the draw call really simple
# All the complexity has been pushed elsewhere
glDrawArrays(GL_TRIANGLES, 0, 6)
# Lets unbind the shader and vertex array state
glUseProgram(0)
def update_texture_yuv(self, img_data, x, y, width, height, rowstrides,
pixel_format):
assert x == 0 and y == 0
assert self.textures is not None, "no OpenGL textures!"
if self.pixel_format is None or self.pixel_format != pixel_format or self.texture_size != (
width, height):
self.pixel_format = pixel_format
self.texture_size = (width, height)
divs = get_subsampling_divs(pixel_format)
debug(
"GL creating new YUV textures for pixel format %s using divs=%s",
pixel_format, divs)
self.gl_marker("Creating new YUV textures")
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1),
(GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
mag_filter = GL_NEAREST
if div_w > 1 or div_h > 1:
mag_filter = GL_LINEAR
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_MAG_FILTER, mag_filter)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
width / div_w, height / div_h, 0, GL_LUMINANCE,
GL_UNSIGNED_BYTE, 0)
debug("Assigning fragment program")
glEnable(GL_FRAGMENT_PROGRAM_ARB)
if not self.yuv_shader:
self.yuv_shader = [1]
glGenProgramsARB(1, self.yuv_shader)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv_shader[0])
prog = GL_COLORSPACE_CONVERSIONS
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,
GL_PROGRAM_FORMAT_ASCII_ARB, len(prog),
prog)
err = glGetString(GL_PROGRAM_ERROR_STRING_ARB)
if err:
#FIXME: maybe we should do something else here?
log.error(err)
self.gl_marker("Updating YUV textures")
divs = get_subsampling_divs(pixel_format)
U_width = 0
U_height = 0
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1),
(GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[index])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width / div_w,
height / div_h, GL_LUMINANCE, GL_UNSIGNED_BYTE,
img_data[index])
if index == 1:
U_width = width / div_w
U_height = height / div_h
elif index == 2:
if width / div_w != U_width:
log.error(
"Width of V plane is %d, differs from width of corresponding U plane (%d), pixel_format is %d",
width / div_w, U_width, pixel_format)
if height / div_h != U_height:
log.error(
"Height of V plane is %d, differs from height of corresponding U plane (%d)",
height / div_h, U_height)
def update_texture_yuv420(self, img_data, x, y, width, height, rowstrides):
drawable = self.glarea.get_gl_drawable()
context = self.glarea.get_gl_context()
window_width, window_height = self.get_size()
if not drawable.gl_begin(context):
raise Exception("** Cannot create OpenGL rendering context!")
assert self.textures is not None
if self.current_mode == GLClientWindow.MODE_RGB:
raise Exception("** RGB -> YUV mode change unimplemented!")
elif self.current_mode == GLClientWindow.MODE_UNINITIALIZED:
log("Creating new YUV textures")
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
window_width, window_height, 0, GL_LUMINANCE,
GL_UNSIGNED_BYTE, 0)
glActiveTexture(GL_TEXTURE1)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[1])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_LINEAR)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
window_width / 2, window_height / 2, 0, GL_LUMINANCE,
GL_UNSIGNED_BYTE, 0)
glActiveTexture(GL_TEXTURE2)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[2])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_LINEAR)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
window_width / 2, window_height / 2, 0, GL_LUMINANCE,
GL_UNSIGNED_BYTE, 0)
log("Assigning fragment program")
glEnable(GL_FRAGMENT_PROGRAM_ARB)
if not self.yuv420_shader:
self.yuv420_shader = [1]
glGenProgramsARB(1, self.yuv420_shader)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB,
self.yuv420_shader[0])
prog = GL_COLORSPACE_CONVERSIONS
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,
GL_PROGRAM_FORMAT_ASCII_ARB, len(prog),
prog)
log.error(glGetString(GL_PROGRAM_ERROR_STRING_ARB))
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB,
self.yuv420_shader[0])
self.current_mode = GLClientWindow.MODE_YUV
# Clamp width and height to the actual texture size
if x + width > window_width:
width = window_width - x
if y + height > window_height:
height = window_height - y
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[0])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width, height,
GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[0])
glActiveTexture(GL_TEXTURE1)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[1])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[1])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width / 2,
height / 2, GL_LUMINANCE, GL_UNSIGNED_BYTE,
img_data[1])
glActiveTexture(GL_TEXTURE2)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[2])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[2])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width / 2,
height / 2, GL_LUMINANCE, GL_UNSIGNED_BYTE,
img_data[2])
drawable.gl_end()
self.render_image()
def update_texture_yuv420(self, img_data, x, y, width, height, rowstrides):
drawable = self.glarea.get_gl_drawable()
context = self.glarea.get_gl_context()
window_width, window_height = self.get_size()
if not drawable.gl_begin(context):
raise Exception("** Cannot create OpenGL rendering context!")
assert self.textures is not None
if self.current_mode == GLClientWindow.MODE_RGB:
raise Exception("** RGB -> YUV mode change unimplemented!")
elif self.current_mode == GLClientWindow.MODE_UNINITIALIZED:
log("Creating new YUV textures")
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, window_width, window_height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[1])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, window_width/2, window_height/2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[2])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, window_width/2, window_height/2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0);
log("Assigning fragment program")
glEnable(GL_FRAGMENT_PROGRAM_ARB)
if not self.yuv420_shader:
self.yuv420_shader = [ 1 ]
glGenProgramsARB(1, self.yuv420_shader)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv420_shader[0])
prog = GL_COLORSPACE_CONVERSIONS
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, len(prog), prog)
log.error(glGetString(GL_PROGRAM_ERROR_STRING_ARB))
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv420_shader[0])
self.current_mode = GLClientWindow.MODE_YUV
# Clamp width and height to the actual texture size
if x + width > window_width:
width = window_width - x
if y + height > window_height:
height = window_height - y
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[0])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width, height, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[0])
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[1])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[1])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width/2, height/2, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[1])
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[2])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[2])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width/2, height/2, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[2])
drawable.gl_end()
self.render_image()
def bindTexture(unit, textureID):
glActiveTexture(GL_TEXTURE0 + unit)
glBindTexture(GL_TEXTURE_2D, textureID)
def draw_pointer(self):
px, py, _, _, size, start_time = self.pointer_overlay
elapsed = monotonic_time()-start_time
log("pointer_overlay=%s, elapsed=%.1f, timeout=%s, cursor-data=%s",
self.pointer_overlay, elapsed, CURSOR_IDLE_TIMEOUT, (self.cursor_data or [])[:7])
if elapsed>=CURSOR_IDLE_TIMEOUT:
#timeout - stop showing it:
self.pointer_overlay = None
return
x = px
y = py
if not self.cursor_data:
#paint a fake one:
alpha = max(0, (5.0-elapsed)/5.0)
lw = 2
glLineWidth(lw)
glBegin(GL_LINES)
glColor4f(0, 0, 0, alpha)
glVertex2i(x-size, y-lw//2)
glVertex2i(x+size, y-lw//2)
glVertex2i(x, y-size)
glVertex2i(x, y+size)
glEnd()
return
cw = self.cursor_data[3]
ch = self.cursor_data[4]
xhot = self.cursor_data[5]
yhot = self.cursor_data[6]
x = px-xhot
y = py-yhot
if TEXTURE_CURSOR:
#paint the texture containing the cursor:
glActiveTexture(GL_TEXTURE0)
target = GL_TEXTURE_RECTANGLE_ARB
glEnable(target)
glBindTexture(target, self.textures[TEX_CURSOR])
glEnablei(GL_BLEND, self.textures[TEX_CURSOR])
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA)
glBlendFunc(GL_ONE, GL_ONE)
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE)
glBegin(GL_QUADS)
glTexCoord2i(0, 0)
glVertex2i(x, y)
glTexCoord2i(0, ch)
glVertex2i(x, y+ch)
glTexCoord2i(cw, ch)
glVertex2i(x+cw, y+ch)
glTexCoord2i(cw, 0)
glVertex2i(x+cw, y)
glEnd()
glBindTexture(target, 0)
glDisable(target)
else:
#FUGLY: paint each pixel separately..
if not self.validate_cursor():
return
pixels = self.cursor_data[8]
blen = cw*ch*4
p = struct.unpack(b"B"*blen, pixels)
glLineWidth(1)
#TODO: use VBO arrays to make this faster
for cx in range(cw):
for cy in range(ch):
i = cx*4+cy*cw*4
if p[i+3]>=64:
glBegin(GL_POINTS)
glColor4f(p[i]/256.0, p[i+1]/256.0, p[i+2]/256.0, p[i+3]/256.0)
glVertex2i(x+cx, y+cy)
glEnd()
def _render_volume_obj(self, volume_object, width, height, VMatrix, PMatrix):
glBindFramebuffer(GL_FRAMEBUFFER, self.fbo)
glViewport(0, 0, width, height)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_3D, volume_object.stack_object.stack_texture)
glClear(GL_COLOR_BUFFER_BIT) # Clear back buffer.
glEnable(GL_CULL_FACE)
glCullFace(GL_BACK)
glUseProgram(self.b_shader.program)
glBindVertexArray(volume_object.vao)
volume_object.elVBO.bind()
mv_matrix = np.dot(VMatrix, volume_object.transform)
glUniformMatrix4fv(self.b_shader.get_uniform("mv_matrix"),
1, True, mv_matrix.astype('float32'))
glUniformMatrix4fv(self.b_shader.get_uniform("p_matrix"),
1, True, PMatrix.astype('float32'))
glDrawElements(GL_TRIANGLES, volume_object.elCount,
GL_UNSIGNED_INT, volume_object.elVBO)
volume_object.elVBO.unbind()
glBindVertexArray(0)
glUseProgram(0)
glBindFramebuffer(GL_FRAMEBUFFER, 0)
glActiveTexture(GL_TEXTURE0 + 1)
glBindTexture(GL_TEXTURE_2D, self.bfTex)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_3D, volume_object.stack_object.stack_texture)
glUseProgram(self.f_shader.program)
glUniform1i(self.f_shader.get_uniform("texture3s"), 0)
glUniform1i(self.f_shader.get_uniform("backfaceTex"), 1)
tex_inv_matrix = np.dot(PMatrix,
np.dot(mv_matrix,
la.inv(volume_object.tex_transform)))
glUniformMatrix4fv(self.f_shader.get_uniform('tex_inv_matrix'),
1,
True,
tex_inv_matrix.astype('float32'))
glUniform1f(self.f_shader.get_uniform('isolevel'),
volume_object.threshold/255.0)
glEnable(GL_CULL_FACE)
glCullFace(GL_FRONT)
glBindVertexArray(volume_object.vao)
volume_object.elVBO.bind()
glUniformMatrix4fv(self.f_shader.get_uniform("mv_matrix"),
1, True, mv_matrix.astype('float32'))
glUniformMatrix4fv(self.f_shader.get_uniform("p_matrix"),
1, True, PMatrix.astype('float32'))
glDrawElements(GL_TRIANGLES, volume_object.elCount,
GL_UNSIGNED_INT, volume_object.elVBO)
glActiveTexture(GL_TEXTURE0+1)
glBindTexture(GL_TEXTURE_2D, 0)
glCullFace(GL_BACK)
volume_object.elVBO.unbind()
glBindVertexArray(0)
glUseProgram(0)
def paint_yuv420(self, img_data, x, y, width, height, rowstrides):
#import time
#before=time.time()
# OpenGL begin
if not self.gldrawable.gl_begin(self.glcontext):
log.error("OUCH")
return False
# Upload texture
if self.textures[0] == 0:
self.textures = glGenTextures(3)
glEnable(GL_FRAGMENT_PROGRAM_ARB)
if not self.yuv420_shader:
self.yuv420_shader = [1]
glGenProgramsARB(1, self.yuv420_shader)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv420_shader[0])
# The following fragprog is:
# * MIT X11 license, Copyright (c) 2007 by:
# * Michael Dominic K. <*****@*****.**>
#http://www.mdk.org.pl/2007/11/17/gl-colorspace-conversions
prog = """!!ARBfp1.0
# cgc version 3.1.0010, build date Feb 10 2012
# command line args: -profile arbfp1
# source file: yuv.cg
#vendor NVIDIA Corporation
#version 3.1.0.10
#profile arbfp1
#program main
#semantic main.IN
#var float2 IN.texcoord1 : $vin.TEXCOORD0 : TEX0 : 0 : 1
#var float2 IN.texcoord2 : $vin.TEXCOORD1 : TEX1 : 0 : 1
#var float2 IN.texcoord3 : $vin.TEXCOORD2 : TEX2 : 0 : 1
#var samplerRECT IN.texture1 : TEXUNIT0 : texunit 0 : 0 : 1
#var samplerRECT IN.texture2 : TEXUNIT1 : texunit 1 : 0 : 1
#var samplerRECT IN.texture3 : TEXUNIT2 : texunit 2 : 0 : 1
#var float4 IN.color : $vin.COLOR0 : COL0 : 0 : 1
#var float4 main.color : $vout.COLOR0 : COL : -1 : 1
#const c[0] = 1.1643835 2.017231 0 0.5
#const c[1] = 0.0625 1.1643835 -0.3917616 -0.81296802
#const c[2] = 1.1643835 0 1.5960271
PARAM c[3] = { { 1.1643835, 2.017231, 0, 0.5 },
{ 0.0625, 1.1643835, -0.3917616, -0.81296802 },
{ 1.1643835, 0, 1.5960271 } };
TEMP R0;
TEMP R1;
TEX R0.x, fragment.texcoord[2], texture[2], RECT;
ADD R1.z, R0.x, -c[0].w;
TEX R1.x, fragment.texcoord[0], texture[0], RECT;
TEX R0.x, fragment.texcoord[1], texture[1], RECT;
ADD R1.x, R1, -c[1];
ADD R1.y, R0.x, -c[0].w;
DP3 result.color.z, R1, c[0];
DP3 result.color.y, R1, c[1].yzww;
DP3 result.color.x, R1, c[2];
MOV result.color.w, fragment.color.primary;
END
# 10 instructions, 2 R-regs
"""
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,
GL_PROGRAM_FORMAT_ASCII_ARB, len(prog), prog)
log.error(glGetString(GL_PROGRAM_ERROR_STRING_ARB))
glEnable(GL_FRAGMENT_PROGRAM_ARB)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv420_shader[0])
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[0])
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width, height,
0, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[0])
glActiveTexture(GL_TEXTURE1)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[1])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_LINEAR)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[1])
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width / 2,
height / 2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE,
img_data[1])
glActiveTexture(GL_TEXTURE2)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[2])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_LINEAR)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[2])
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width / 2,
height / 2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE,
img_data[2])
vtxarrays = 0
if vtxarrays == 1:
texcoords = [[0, 0], [0, height], [width, height], [width, 0]]
vtxcoords = texcoords
texcoords_half = [[0, 0], [0, height / 2], [width / 2, height / 2],
[width / 2, 0]]
glVertexPointeri(vtxcoords)
glActiveTexture(GL_TEXTURE0)
glClientActiveTexture(GL_TEXTURE0)
glEnableClientState(GL_TEXTURE_COORD_ARRAY)
glTexCoordPointeri(texcoords)
glActiveTexture(GL_TEXTURE1)
glClientActiveTexture(GL_TEXTURE1)
glEnableClientState(GL_TEXTURE_COORD_ARRAY)
glTexCoordPointeri(texcoords_half)
glActiveTexture(GL_TEXTURE2)
glClientActiveTexture(GL_TEXTURE2)
glEnableClientState(GL_TEXTURE_COORD_ARRAY)
glTexCoordPointeri(texcoords_half)
glDrawArrays(GL_QUADS, 0, 4)
else:
glBegin(GL_QUADS)
glMultiTexCoord2i(GL_TEXTURE0, 0, 0)
glMultiTexCoord2i(GL_TEXTURE1, 0, 0)
glMultiTexCoord2i(GL_TEXTURE2, 0, 0)
glVertex2i(0, 0)
glMultiTexCoord2i(GL_TEXTURE0, 0, height)
glMultiTexCoord2i(GL_TEXTURE1, 0, height / 2)
glMultiTexCoord2i(GL_TEXTURE2, 0, height / 2)
glVertex2i(0, height)
glMultiTexCoord2i(GL_TEXTURE0, width, height)
glMultiTexCoord2i(GL_TEXTURE1, width / 2, height / 2)
glMultiTexCoord2i(GL_TEXTURE2, width / 2, height / 2)
glVertex2i(width, height)
glMultiTexCoord2i(GL_TEXTURE0, width, 0)
glMultiTexCoord2i(GL_TEXTURE1, width / 2, 0)
glMultiTexCoord2i(GL_TEXTURE2, width / 2, 0)
glVertex2i(width, 0)
glEnd()
# OpenGL end
#self.gldrawable.swap_buffers()
# self.gldrawable.swap_buffers()
glFinish()
self.gldrawable.gl_end()
def main():
if not glfw.init():
print('Failed to initialize GLFW.')
return
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, GL_TRUE)
glfw.window_hint(glfw.SAMPLES, config['sampling_level'])
if config['fullscreen']:
global width, height
mode = glfw.get_video_mode(glfw.get_primary_monitor())
width, height = mode.size.width, mode.size.height
window = glfw.create_window(mode.size.width, mode.size.height, config['app_name'], glfw.get_primary_monitor(), None)
else:
window = glfw.create_window(width, height, config['app_name'], None, None)
if not window:
print('Failed to create GLFW Window.')
glfw.terminate()
return
# подключаем наши функции для эвентов
#
glfw.make_context_current(window)
glfw.set_framebuffer_size_callback(window, ResizeCallback)
glfw.set_cursor_pos_callback(window, MouseLookCallback)
glfw.set_key_callback(window, KeyInputCallback)
glfw.set_input_mode(window, glfw.CURSOR, glfw.CURSOR_DISABLED)
glEnable(GL_DEPTH_TEST)
glEnable(GL_CULL_FACE)
# подключаем фрагментный и вершинный шейдеры
#
program = Program()
program.attachShader(Shader('resources/shaders/vert.vs', GL_VERTEX_SHADER))
program.attachShader(Shader('resources/shaders/frag.fs', GL_FRAGMENT_SHADER))
program.link()
# подключаем шейдер для создания карты теней
#
depthProgram = Program()
depthProgram.attachShader(Shader('resources/shaders/depth.vs', GL_VERTEX_SHADER))
depthProgram.attachShader(Shader('resources/shaders/depth.fs', GL_FRAGMENT_SHADER))
depthProgram.attachShader(Shader('resources/shaders/depth.gs', GL_GEOMETRY_SHADER))
depthProgram.link()
# создаем depthBuffer и frameBuffer
#
shadow = Shadow(config['near_plane_depth'], config['far_plane_depth'])
shadow.create(config['shadow_width'], config['shadow_height'])
program.use()
program.setInt("diffuseTexture", 0)
program.setInt("depthMap", 1)
# позиция источника света
#
lightPos = glm.vec3(0.0, 2.35, 0.0)
# загрузка всех объектов сцены
#
room = Model('resources/models/dinning_room.json')
# цикл обработки
#
while not glfw.window_should_close(window):
if config['debug_mode']:
print(glGetError())
# обработка нажатий клавиатуры для камеры
#
DoMovement()
# движение источника света
#
if light_movement:
lightPos.z = math.sin(glfw.get_time() * 0.5) * 3.0
glClearColor(0.1, 0.1, 0.1, 1.0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# обработка с помощью depthProgram - карта теней
#
shadow.castShadow(depthProgram, lightPos)
room.draw(depthProgram)
shadow.endCastShadow(program)
glViewport(0, 0, width, height)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# обработка с помощью program - на основе полученной карты теней
#
program.use()
view = cam.get_view_matrix()
viewPos = glm.vec3(cam.camera_pos[0],cam.camera_pos[1],cam.camera_pos[2])
perspective = glm.perspective(45, width / height, config['near_plane'], config['far_plane'])
program.setMat4('projection', perspective)
program.setMat4('view', view)
program.setVec3('lightPos', lightPos)
program.setVec3('viewPos', viewPos)
program.setInt('shadows', True)
program.setFloat("far_plane", config["far_plane_depth"])
glActiveTexture(GL_TEXTURE1)
glBindTexture(GL_TEXTURE_CUBE_MAP, shadow.depthbuffer.texture)
room.draw(program)
glfw.swap_buffers(window)
glfw.poll_events()
glfw.terminate()
def setup(self): ''' Construct the texture atlas for the font ''' face = Face(self.filename) face.set_pixel_sizes(0, self.size) rowh, roww = 0,0 # Determine image size for i in xrange(32,128): face.load_char( chr(i), FT_LOAD_RENDER) bitmap = face.glyph.bitmap if roww + bitmap.width + 1 >= 1024: # max texture width self.w = max(self.w, roww) self.h += rowh roww = 0 rowh = 0 roww += bitmap.width + 1 rowh = max(rowh, bitmap.rows) self.w = max(self.w, roww) self.h += rowh ## Create texture to hold ASCII glyphs # Ensure no texture is currently selected glActiveTexture(GL_TEXTURE0) self.texid = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, self.texid) glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, self.w, self.h, 0, GL_ALPHA, GL_UNSIGNED_BYTE, 0) # We require 1 byte alignment when uploading texture data glPixelStorei(GL_UNPACK_ALIGNMENT, 1) # Clamping to edges is important to prevent artifacts when scaling glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE) # Linear filtering looks better for text glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) # Add glyphs to texture ox = 0 oy = 0 rowh = 0 # class to hold data class CharInfo: pass for i in xrange(32,128): face.load_char( chr(i), FT_LOAD_RENDER) g = face.glyph bitmap = g.bitmap if ox + bitmap.width + 1 >= 1024: # max texture width oy += rowh rowh = 0 ox = 0 glTexSubImage2D(GL_TEXTURE_2D, 0, ox, oy, bitmap.width, bitmap.rows, GL_ALPHA, GL_UNSIGNED_BYTE, bitmap.buffer) ci = CharInfo() ci.ax = float(g.advance.x >> 6) ci.ay = float(g.advance.y >> 6) ci.bw = float(bitmap.width) ci.bh = float(bitmap.rows) ci.bl = float(g.bitmap_left) ci.bt = float(g.bitmap_top) ci.tx = float(ox) / float(self.w) ci.ty = float(oy) / float(self.h) self.c[chr(i)] = ci rowh = max(rowh, bitmap.rows) ox += bitmap.width + 1
