def _loop_begin(self):
# TODO(rec): check if the window was resized and resize it, removing
# code from MegaStation to here.
if pi3d.USE_PYGAME:
import pygame # although done in __init__ ...python namespaces aarg!!!
if pygame.event.get(pygame.QUIT):
self.destroy()
elif PLATFORM != PLATFORM_PI and PLATFORM != PLATFORM_ANDROID:
n = xlib.XEventsQueued(self.opengl.d, xlib.QueuedAfterFlush)
for _ in range(n):
xlib.XNextEvent(self.opengl.d, self.ev)
if self.ev.type == KeyPress or self.ev.type == KeyRelease:
self.event_list.append(self.ev)
elif self.ev.type == ClientMessage:
if (self.ev.xclient.data.l[0] ==
self.opengl.WM_DELETE_WINDOW.value):
self.destroy()
elif self.ev.type == ResizeRequest:
(self.width, self.height) = (self.ev.xresizerequest.width,
self.ev.xresizerequest.height)
opengles.glViewport(0, 0, self.width, self.height)
self.was_resized = True
self.clear()
with self.lock:
self.sprites_to_load, to_load = set(), self.sprites_to_load
self.sprites.extend(to_load)
self._for_each_sprite(lambda s: s.load_opengl(), to_load)
if MARK_CAMERA_CLEAN_ON_EACH_LOOP:
from pi3d.Camera import Camera
#camera = Camera.instance()
#if camera is not None:
# camera.was_moved = False
cameras = Camera.all_instances()
if cameras is not None:
for camera in cameras:
camera.was_moved = False
if self.tidy_needed:
self._tidy()
def create_surface(self, x=0, y=0, w=0, h=0, layer=0):
#Set the viewport position and size
dst_rect = c_ints((x, y, w, h))
src_rect = c_ints((x, y, w << 16, h << 16))
if PLATFORM == PLATFORM_ANDROID:
self.surface = openegl.eglGetCurrentSurface(EGL_DRAW)
# Get the width and height of the screen - TODO, this system returns 100x100
time.sleep(0.2) #give it a chance to find out the dimensions
w = c_int()
h = c_int()
openegl.eglQuerySurface(self.display, self.surface, EGL_WIDTH,
byref(w))
openegl.eglQuerySurface(self.display, self.surface, EGL_HEIGHT,
byref(h))
self.width, self.height = w.value, h.value
elif PLATFORM == PLATFORM_PI:
self.dispman_display = bcm.vc_dispmanx_display_open(
0) #LCD setting
self.dispman_update = bcm.vc_dispmanx_update_start(0)
alpha = c_ints((DISPMANX_FLAGS_ALPHA_PREMULT, 0, 0))
self.dispman_element = bcm.vc_dispmanx_element_add(
self.dispman_update, self.dispman_display, layer, dst_rect, 0,
src_rect, DISPMANX_PROTECTION_NONE, alpha, 0, 0)
nativewindow = (GLint * 3)(self.dispman_element, w, h + 1)
bcm.vc_dispmanx_update_submit_sync(self.dispman_update)
self.nw_p = ctypes.pointer(nativewindow)
### NB changing the argtypes to allow passing of bcm native window is
### deeply unsatisfactory. But xlib defines Window as c_ulong and ctypes
### isn't happy about a pointer being cast to an int
openegl.eglCreateWindowSurface.argtypes = [
EGLDisplay, EGLConfig,
POINTER((GLint * 3)), EGLint
]
self.surface = openegl.eglCreateWindowSurface(
self.display, self.config, self.nw_p, 0)
elif pi3d.USE_PYGAME:
import pygame
flags = pygame.OPENGL
wsize = (w, h)
if w == self.width and h == self.height: # i.e. full screen
flags = pygame.FULLSCREEN | pygame.OPENGL
wsize = (0, 0)
if self.display_config & DISPLAY_CONFIG_NO_RESIZE:
flags |= pygame.RESIZABLE
if self.display_config & DISPLAY_CONFIG_NO_FRAME:
flags |= pygame.NOFRAME
if self.display_config & DISPLAY_CONFIG_FULLSCREEN:
flags |= pygame.FULLSCREEN
elif self.display_config & DISPLAY_CONFIG_MAXIMIZED:
flags |= pygame.FULLSCREEN
wsize = (0, 0)
self.width, self.height = w, h
self.d = pygame.display.set_mode(wsize, flags)
self.window = pygame.display.get_wm_info()["window"]
self.surface = openegl.eglCreateWindowSurface(
self.display, self.config, self.window, 0)
else: # work on basis it's X11
# Set some WM info
self.root = xlib.XRootWindowOfScreen(self.screen)
if self.use_glx: # For drawing on X window with transparent background
numfbconfigs = c_int()
VisData = c_ints(
(glx.GLX_RENDER_TYPE, glx.GLX_RGBA_BIT,
glx.GLX_DRAWABLE_TYPE, glx.GLX_WINDOW_BIT,
glx.GLX_DOUBLEBUFFER, True, glx.GLX_RED_SIZE, 8,
glx.GLX_GREEN_SIZE, 8, glx.GLX_BLUE_SIZE, 8,
glx.GLX_ALPHA_SIZE, 8, glx.GLX_DEPTH_SIZE, 16, 0))
glx_screen = xlib.XDefaultScreen(self.d)
fbconfigs = glx.glXChooseFBConfig(self.d, glx_screen, VisData,
byref(numfbconfigs))
fbconfig = 0
for i in range(numfbconfigs.value):
visual = glx.glXGetVisualFromFBConfig(
self.d, fbconfigs[i]).contents
if not visual:
continue
pict_format = glx.XRenderFindVisualFormat(
self.d, visual.visual).contents
if not pict_format:
continue
fbconfig = fbconfigs[i]
if pict_format.direct.alphaMask > 0:
break
if not fbconfig:
print("No matching FB config found")
#/* Create a colormap - only needed on some X clients, eg. IRIX */
cmap = xlib.XCreateColormap(self.d, self.root, visual.visual,
AllocNone)
attr = xlib.XSetWindowAttributes()
attr.colormap = cmap
attr.background_pixmap = 0
attr.border_pixmap = 0
attr.border_pixel = 0
attr.event_mask = (StructureNotifyMask | EnterWindowMask
| LeaveWindowMask | ExposureMask
| ButtonPressMask | ButtonReleaseMask
| OwnerGrabButtonMask | KeyPressMask
| KeyReleaseMask)
attr_mask = ( # CWBackPixmap|
CWColormap | CWBorderPixel | CWEventMask)
self.window = xlib.XCreateWindow(self.d, self.root, x, y, w, h,
0, visual.depth, 1,
visual.visual, attr_mask,
byref(attr))
else: # normal EGL created context
self.window = xlib.XCreateSimpleWindow(self.d, self.root, x, y,
w, h, 1, 0, 0)
s = ctypes.create_string_buffer(b'WM_DELETE_WINDOW')
self.WM_DELETE_WINDOW = ctypes.c_ulong(
xlib.XInternAtom(self.d, s, 0))
# set window title
title = ctypes.c_char_p(self.window_title)
title_length = ctypes.c_int(len(self.window_title))
wm_name_atom = ctypes.c_ulong(
xlib.XInternAtom(self.d,
ctypes.create_string_buffer(b'WM_NAME'), 0))
string_atom = ctypes.c_ulong(
xlib.XInternAtom(self.d,
ctypes.create_string_buffer(b'STRING'), 0))
xlib.XChangeProperty(self.d, self.window, wm_name_atom,
string_atom, 8, xlib.PropModeReplace, title,
title_length)
if (w == self.width
and h == self.height) or (self.display_config
& DISPLAY_CONFIG_FULLSCREEN):
# set full-screen. Messy c function calls!
wm_state = ctypes.c_ulong(
xlib.XInternAtom(self.d, b'_NET_WM_STATE', 0))
fullscreen = ctypes.c_ulong(
xlib.XInternAtom(self.d, b'_NET_WM_STATE_FULLSCREEN', 0))
fullscreen = ctypes.cast(ctypes.pointer(fullscreen),
ctypes.c_char_p)
XA_ATOM = 4
xlib.XChangeProperty(self.d, self.window, wm_state, XA_ATOM,
32, xlib.PropModeReplace, fullscreen, 1)
self.width, self.height = w, h
if self.display_config & DISPLAY_CONFIG_HIDE_CURSOR:
black = xlib.XColor()
black.red = 0
black.green = 0
black.blue = 0
noData = ctypes.c_char_p(bytes([0, 0, 0, 0, 0, 0, 0, 0]))
bitmapNoData = xlib.XCreateBitmapFromData(
self.d, self.window, noData, 8, 8)
invisibleCursor = xlib.XCreatePixmapCursor(
self.d, bitmapNoData, bitmapNoData, black, black, 0, 0)
xlib.XDefineCursor(self.d, self.window, invisibleCursor)
#TODO add functions to xlib for these window manager libx11 functions
#self.window.set_wm_name('pi3d xlib window')
#self.window.set_wm_icon_name('pi3d')
#self.window.set_wm_class('draw', 'XlibExample')
xlib.XSetWMProtocols(self.d, self.window, self.WM_DELETE_WINDOW, 1)
#self.window.set_wm_hints(flags = Xutil.StateHint,
# initial_state = Xutil.NormalState)
#self.window.set_wm_normal_hints(flags = (Xutil.PPosition | Xutil.PSize
# | Xutil.PMinSize),
# min_width = 20,
# min_height = 20)
xlib.XSelectInput(
self.d, self.window,
KeyPressMask | KeyReleaseMask | ResizeRedirectMask)
xlib.XMapWindow(self.d, self.window)
#xlib.XMoveWindow(self.d, self.window, x, y) #TODO this has to happen later. Works after rendering first frame. Check when
if self.use_glx:
dummy = c_int()
if not glx.glXQueryExtension(self.d, byref(dummy),
byref(dummy)):
print("OpenGL not supported by X server\n")
dummy_glx_context = ctypes.cast(0, glx.GLXContext)
self.render_context = glx.glXCreateNewContext(
self.d, fbconfig, glx.GLX_RGBA_TYPE, dummy_glx_context,
True)
if not self.render_context:
print("Failed to create a GL context\n")
if not glx.glXMakeContextCurrent(
self.d, self.window, self.window, self.render_context):
print("glXMakeCurrent failed for window\n")
else:
self.surface = openegl.eglCreateWindowSurface(
self.display, self.config, self.window, 0)
if not self.use_glx:
assert self.surface != EGL_NO_SURFACE and self.surface is not None
r = openegl.eglMakeCurrent(self.display, self.surface,
self.surface, self.context)
assert r
#Create viewport
opengles.glViewport(GLint(0), GLint(0), GLsizei(w), GLsizei(h))
def draw(self) -> None:
import numpy as np
from scipy.ndimage.filters import gaussian_filter
from pi3d.Camera import Camera
from pi3d.constants import (
opengles,
GL_SRC_ALPHA,
GL_ONE_MINUS_SRC_ALPHA,
GLsizei,
GLboolean,
GLint,
GL_FLOAT,
GL_ARRAY_BUFFER,
GL_UNSIGNED_SHORT,
GL_TEXTURE_2D,
GL_UNSIGNED_BYTE,
)
time_logging = False
if self.should_prepare:
self._prepare()
if self.lights.alarm_program.factor != -1:
self.alarm_factor = max(0.001, self.lights.alarm_program.factor)
else:
self.alarm_factor = 0
then = time.time()
self.display.loop_running()
now = self.display.time
self.time_delta = now - self.last_loop
self.last_loop = now
self.time_elapsed += self.time_delta
if time_logging:
print(f"{time.time() - then} main loop")
then = time.time()
# use a sliding window to smooth the spectrum with a gauss function
# truncating does not save significant time (~3% for this step)
# new_frame = np.array(self.cava.current_frame, dtype="float32")
new_frame = gaussian_filter(self.cava.current_frame, sigma=1.5, mode="nearest")
new_frame = new_frame[self.SPECTRUM_CUT : -self.SPECTRUM_CUT]
new_frame = -0.5 * new_frame ** 3 + 1.5 * new_frame
new_frame *= 255
current_frame = new_frame
if time_logging:
print(f"{time.time() - then} spectrum smoothing")
then = time.time()
# Value used for circle shake and background color cycle
# select the first few values and compute their average
bass_elements = math.ceil(self.BASS_MAX * self.cava.bars)
self.bass_value = sum(current_frame[0:bass_elements]) / bass_elements / 255
self.bass_value = max(self.bass_value, self.alarm_factor)
self.total_bass = self.total_bass + self.bass_value
# the fraction of time that there was bass
self.bass_fraction = self.total_bass / self.time_elapsed / self.lights.UPS
self.uniform_values = {
48: self.width / self.scale,
49: self.height / self.scale,
50: self.scale,
51: self.FFT_HIST,
52: self.NUM_PARTICLES,
53: self.PARTICLE_SPAWN_Z,
54: self.time_elapsed,
55: self.time_delta,
56: self.alarm_factor,
57: self.bass_value,
58: self.total_bass,
59: self.bass_fraction,
}
# start rendering to the smaller OffscreenTexture
# we decrease the size of the texture so it only allocates that much memory
# otherwise it would use as much as the displays size, negating its positive effect
self.post.ix = int(self.post.ix / self.scale)
self.post.iy = int(self.post.iy / self.scale)
opengles.glViewport(
GLint(0),
GLint(0),
GLsizei(int(self.width / self.scale)),
GLsizei(int(self.height / self.scale)),
)
self.post._start()
self.post.ix = self.width
self.post.iy = self.height
self._set_unif(self.background, [48, 49, 54, 56, 58])
self.background.draw()
if time_logging:
print(f"{time.time() - then} background draw")
then = time.time()
# enable additive blending so the draw order of overlapping particles does not matter
opengles.glBlendFunc(1, 1)
self._set_unif(self.particle_sprite, [53, 54, 59])
# copied code from pi3d.Shape.draw()
# we don't need modelmatrices, normals ord textures and always blend
self.particle_sprite.load_opengl()
camera = Camera.instance()
if not camera.mtrx_made:
camera.make_mtrx()
self.particle_sprite.MRaw = self.particle_sprite.tr1
self.particle_sprite.M[0, :, :] = self.particle_sprite.MRaw[:, :]
self.particle_sprite.M[1, :, :] = np.dot(
self.particle_sprite.MRaw, camera.mtrx
)[:, :]
# Buffer.draw()
buf = self.particle_sprite.buf[0]
buf.load_opengl()
shader = buf.shader
shader.use()
opengles.glUniformMatrix4fv(
shader.unif_modelviewmatrix,
GLsizei(2),
GLboolean(0),
self.particle_sprite.M.ctypes.data,
)
opengles.glUniform3fv(shader.unif_unif, GLsizei(20), self.particle_sprite.unif)
buf._select()
opengles.glVertexAttribPointer(
shader.attr_vertex, GLint(3), GL_FLOAT, GLboolean(0), buf.N_BYTES, 0
)
opengles.glEnableVertexAttribArray(shader.attr_vertex)
opengles.glVertexAttribPointer(
shader.attr_texcoord, GLint(2), GL_FLOAT, GLboolean(0), buf.N_BYTES, 24
)
opengles.glEnableVertexAttribArray(shader.attr_texcoord)
buf.disp.last_shader = shader
opengles.glUniform3fv(shader.unif_unib, GLsizei(5), buf.unib)
opengles.glBindBuffer(GL_ARRAY_BUFFER, self.instance_vbo)
opengles.glDrawElementsInstanced(
buf.draw_method,
GLsizei(buf.ntris * 3),
GL_UNSIGNED_SHORT,
0,
self.NUM_PARTICLES,
)
# restore normal blending
opengles.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
if time_logging:
print(f"{time.time() - then} particle draw")
then = time.time()
# roll the history one further, insert the current one.
# we use a texture with four channels eventhough we only need one, refer to this post:
# https://community.khronos.org/t/updating-textures-per-frame/75020/3
# basically the gpu converts it anyway, so other formats would be slower
history = np.zeros(
(self.FFT_HIST, self.cava.bars - 2 * self.SPECTRUM_CUT, 4), dtype="uint8"
)
self.fft = np.roll(self.fft, 1, 0)
self.fft[0] = current_frame
history[:, :, 0] = self.fft
if time_logging:
print(f"{time.time() - then} spectrum roll")
then = time.time()
# change the spectrum part of the texture (the lower 256xFFT_HIST pixels)
opengles.glBindTexture(GL_TEXTURE_2D, self.dynamic_texture._tex)
iformat = self.dynamic_texture._get_format_from_array(
history, self.dynamic_texture.i_format
)
opengles.glTexSubImage2D(
GL_TEXTURE_2D,
0,
0,
self.dynamic_texture.ix,
history.shape[1],
history.shape[0],
iformat,
GL_UNSIGNED_BYTE,
history.ctypes.data_as(ctypes.POINTER(ctypes.c_ubyte)),
)
if time_logging:
print(f"{time.time() - then} glTexImage2D")
then = time.time()
self._set_unif(self.spectrum, [48, 49, 51, 52, 53, 54, 55, 57, 58])
self.spectrum.draw()
if time_logging:
print(f"{time.time() - then} spectrum draw")
then = time.time()
self._set_unif(self.logo, [48, 49, 51, 54, 57, 58])
self.logo.draw()
if time_logging:
print(f"{time.time() - then} logo draw")
then = time.time()
self._set_unif(self.after, [48, 49, 54, 57])
self.after.draw()
if time_logging:
print(f"{time.time() - then} after draw")
then = time.time()
self.post._end()
opengles.glViewport(
GLint(0), GLint(0), GLsizei(self.width), GLsizei(self.height)
)
self._set_unif(self.post_sprite, [50])
self.post_sprite.draw()
if time_logging:
print(f"{time.time() - then} post draw")
print(f"scale: {self.scale}")
print("=====")