def set_background(self, r, g, b, alpha): """Set the Display background. **NB the actual drawing of the background happens during the rendering of the framebuffer by the shader so if no draw() is done by anything during each Display loop the screen will remain black** If you want to see just the background you will have to draw() something out of view (i.e. behind) the Camera. *r, g, b* Color values for the display *alpha* Opacity of the color. An alpha of 0 means a transparent background, an alpha of 1 means full opaque. """ opengles.glClearColor(GLclampf(r), GLclampf(g), GLclampf(b), GLclampf(alpha)) opengles.glColorMask(GLboolean(1), GLboolean(1), GLboolean(1), GLboolean(alpha < 1.0))
def set_background(self, r, g, b, alpha): """Set the Display background. **NB the actual drawing of the background happens during the rendering of the framebuffer by the shader so if no draw() is done by anything during each Display loop the screen will remain black** If you want to see just the background you will have to draw() something out of view (i.e. behind) the Camera. *r, g, b* Color values for the display *alpha* Opacity of the color. An alpha of 0 means a transparent background, an alpha of 1 means full opaque. """ if alpha < 1.0 and (not self.opengl.use_glx) and (not PLATFORM == PLATFORM_PI): LOGGER.warning("create Display with (...use_glx=True) for transparent background on x11 window. libGLX needs to be available") opengles.glClearColor(GLclampf(r), GLclampf(g), GLclampf(b), GLclampf(alpha)) opengles.glColorMask(GLboolean(1), GLboolean(1), GLboolean(1), GLboolean(alpha < 1.0))
def create_display(self, x=0, y=0, w=0, h=0, depth=24, samples=4, layer=0, display_config=DISPLAY_CONFIG_DEFAULT, window_title='', use_glx=False): self.use_glx = use_glx and ( X_WINDOW and hasattr(glx, 'glXChooseFBConfig') ) # only use glx if x11 window and glx available self.display_config = display_config self.window_title = window_title.encode() if not self.use_glx: self.display = openegl.eglGetDisplay(EGL_DEFAULT_DISPLAY) assert self.display != EGL_NO_DISPLAY and self.display is not None for smpl in [ samples, 0 ]: # try with samples first but ANGLE dll can't cope so drop to 0 for windows r = openegl.eglInitialize(self.display, None, None) attribute_list = (EGLint * 19)( EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_DEPTH_SIZE, depth, EGL_ALPHA_SIZE, 8, EGL_BUFFER_SIZE, 32, EGL_SAMPLES, smpl, EGL_STENCIL_SIZE, 8, EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_NONE) numconfig = EGLint(0) poss_configs = (EGLConfig * 5)(*(EGLConfig() for _ in range(5))) r = openegl.eglChooseConfig(self.display, attribute_list, poss_configs, EGLint(len(poss_configs)), byref(numconfig)) context_attribs = (EGLint * 3)(EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE) if numconfig.value > 0: self.config = poss_configs[0] self.context = openegl.eglCreateContext( self.display, self.config, EGL_NO_CONTEXT, context_attribs) if self.context != EGL_NO_CONTEXT: break assert self.context != EGL_NO_CONTEXT and self.context is not None self.create_surface(x, y, w, h, layer) opengles.glDepthRangef(GLfloat(0.0), GLfloat(1.0)) opengles.glClearColor(GLfloat(0.3), GLfloat(0.3), GLfloat(0.7), GLfloat(1.0)) opengles.glBindFramebuffer(GL_FRAMEBUFFER, GLuint(0)) # get GL v GLES and version num for shader translation version = opengles.glGetString(GL_VERSION) version = ctypes.cast(version, c_char_p).value if b"ES" in version: for s in version.split(): if b'.' in s: self.gl_id = b"GLES" + s.split(b'.')[0] break #Setup default hints opengles.glEnable(GL_CULL_FACE) opengles.glCullFace(GL_BACK) opengles.glFrontFace(GL_CW) opengles.glEnable(GL_DEPTH_TEST) if b"GLES" not in self.gl_id: if b"2" in self.gl_id: opengles.glEnable(GL_VERTEX_PROGRAM_POINT_SIZE) else: opengles.glEnable(GL_PROGRAM_POINT_SIZE) # only in > GL3 opengles.glEnable(GL_POINT_SPRITE) opengles.glDepthFunc(GL_LESS) opengles.glDepthMask(GLboolean(True)) opengles.glHint(GL_GENERATE_MIPMAP_HINT, GL_NICEST) opengles.glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, 1, GL_ONE_MINUS_SRC_ALPHA) opengles.glColorMask(GLboolean(True), GLboolean(True), GLboolean(True), GLboolean(False)) #opengles.glEnableClientState(GL_VERTEX_ARRAY) #opengles.glEnableClientState(GL_NORMAL_ARRAY) self.max_texture_size = GLint(0) opengles.glGetIntegerv(GL_MAX_TEXTURE_SIZE, byref(self.max_texture_size)) self.active = True
def draw(self, shape=None, M=None, unif=None, shader=None, textures=None, ntl=None, shny=None, fullset=True): """Draw this Buffer, called by the parent Shape.draw() Keyword arguments: *shape* Shape object this Buffer belongs to, has to be passed at draw to avoid circular reference *shader* Shader object *textures* array of Texture objects *ntl* multiple for tiling normal map which can be less than or greater than 1.0. 0.0 disables the normal mapping, float *shiny* how strong to make the reflection 0.0 to 1.0, float """ self.load_opengl() shader = shader or self.shader or shape.shader or Shader.instance() shader.use() opengles.glUniformMatrix4fv(shader.unif_modelviewmatrix, GLsizei(3), GLboolean(0), M.ctypes.data) opengles.glUniform3fv(shader.unif_unif, GLsizei(20), unif) textures = textures or self.textures if ntl is not None: self.unib[0] = ntl if shny is not None: self.unib[1] = shny self._select() opengles.glVertexAttribPointer(shader.attr_vertex, GLint(3), GL_FLOAT, GLboolean(0), self.N_BYTES, 0) opengles.glEnableVertexAttribArray(shader.attr_vertex) if self.N_BYTES > 12: opengles.glVertexAttribPointer(shader.attr_normal, GLint(3), GL_FLOAT, GLboolean(0), self.N_BYTES, 12) opengles.glEnableVertexAttribArray(shader.attr_normal) if self.N_BYTES > 24: opengles.glVertexAttribPointer(shader.attr_texcoord, GLint(2), GL_FLOAT, GLboolean(0), self.N_BYTES, 24) opengles.glEnableVertexAttribArray(shader.attr_texcoord) opengles.glDisable(GL_BLEND) self.unib[2] = 0.6 for t, texture in enumerate(textures): if (self.disp.last_textures[t] != texture or self.disp.last_shader != shader or self.disp.offscreen_tex): # very slight speed increase for sprites opengles.glActiveTexture(GL_TEXTURE0 + t) assert texture.tex(), 'There was an empty texture in your Buffer.' opengles.glBindTexture(GL_TEXTURE_2D, texture.tex()) opengles.glUniform1i(shader.unif_tex[t], GLint(t)) self.disp.last_textures[t] = texture if texture.blend: # i.e. if any of the textures set to blend then all will for this shader. self.unib[2] = 0.05 if self.unib[2] != 0.6 or shape.unif[13] < 1.0 or shape.unif[14] < 1.0: #use unib[2] as flag to indicate if any Textures to be blended #needs to be done outside for..textures so materials can be transparent opengles.glEnable(GL_BLEND) self.unib[2] = 0.05 self.disp.last_shader = shader opengles.glUniform3fv(shader.unif_unib, GLsizei(5), self.unib) opengles.glEnable(GL_DEPTH_TEST) # TODO find somewhere more efficient to do this opengles.glDrawElements(self.draw_method, GLsizei(self.ntris * 3), GL_UNSIGNED_SHORT, 0)
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("=====")
def _prepare(self) -> None: self.should_prepare = False import numpy as np # pi3d has to be imported in the same thread that it will draw in # Thus, import it here instead of at the top of the file import pi3d from pi3d.util.OffScreenTexture import OffScreenTexture from pi3d.constants import ( opengles, GL_CLAMP_TO_EDGE, GL_ALWAYS, ) # used for reimplementing the draw call with instancing from pi3d.constants import ( GLsizei, GLint, GLboolean, GL_FLOAT, GLuint, GL_ARRAY_BUFFER, GL_STATIC_DRAW, GLfloat, ) from PIL import Image # Setup display and initialise pi3d self.display = pi3d.Display.create( w=self.width, h=self.height, window_title="Raveberry" ) # error 0x500 after Display create # error = opengles.glGetError() # Set a pink background color so mistakes are clearly visible # self.display.set_background(1, 0, 1, 1) self.display.set_background(0, 0, 0, 1) # print OpenGL Version, useful for debugging # import ctypes # def print_char_p(addr): # g = (ctypes.c_char*32).from_address(addr) # i = 0 # while True: # c = g[i] # if c == b'\x00': # break # sys.stdout.write(c.decode()) # i += 1 # sys.stdout.write('\n') # print_char_p(opengles.glGetString(GL_VERSION)) # Visualization is split into five parts: # The background, the particles, the spectrum, the logo and after effects. # * The background is a vertical gradient that cycles through HSV color space, # speeding up with strong bass. # * Particles are multiple sprites that are created at a specified x,y-coordinate # and fly towards the camera. # Due to the projection into screenspace they seem to move away from the center. # * The spectrum is a white circle that represents the fft-transformation of the # currently played audio. It is smoothed to avoid strong spikes. # * The logo is a black circle on top of the spectrum containing the logo. # * After effects add a vignette. # Each of these parts is represented with pi3d Shapes. # They have their own shader and are ordered on the z-axis to ensure correct overlapping. background_shader = pi3d.Shader( os.path.join(settings.BASE_DIR, "core/lights/circle/background") ) self.background = pi3d.Sprite(w=2, h=2) self.background.set_shader(background_shader) self.background.positionZ(0) self.particle_shader = pi3d.Shader( os.path.join(settings.BASE_DIR, "core/lights/circle/particle") ) # create one sprite for all particles self.particle_sprite = pi3d.Sprite(w=self.PARTICLE_SIZE, h=self.PARTICLE_SIZE) self.particle_sprite.set_shader(self.particle_shader) self.particle_sprite.positionZ(0) # this array containes the position and speed for all particles particles = self._initial_particles() # This part was modified from https://learnopengl.com/Advanced-OpenGL/Instancing self.instance_vbo = GLuint() opengles.glGenBuffers(GLsizei(1), ctypes.byref(self.instance_vbo)) opengles.glBindBuffer(GL_ARRAY_BUFFER, self.instance_vbo) particles_raw = particles.ctypes.data_as(ctypes.POINTER(GLfloat)) opengles.glBufferData( GL_ARRAY_BUFFER, particles.nbytes, particles_raw, GL_STATIC_DRAW ) opengles.glBindBuffer(GL_ARRAY_BUFFER, GLuint(0)) attr_particle = opengles.glGetAttribLocation( self.particle_shader.program, b"particle" ) opengles.glEnableVertexAttribArray(attr_particle) opengles.glBindBuffer(GL_ARRAY_BUFFER, self.instance_vbo) opengles.glVertexAttribPointer( attr_particle, GLint(4), GL_FLOAT, GLboolean(0), 0, 0 ) opengles.glBindBuffer(GL_ARRAY_BUFFER, GLuint(0)) opengles.glVertexAttribDivisor(attr_particle, GLuint(1)) spectrum_shader = pi3d.Shader( os.path.join(settings.BASE_DIR, "core/lights/circle/spectrum") ) # use the ratio to compute small sizes for the sprites ratio = self.width / self.height self.spectrum = pi3d.Sprite(w=2 / ratio, h=2) self.spectrum.set_shader(spectrum_shader) self.spectrum.positionZ(0) # initialize the spectogram history with zeroes self.fft = np.zeros( (self.FFT_HIST, self.cava.bars - 2 * self.SPECTRUM_CUT), dtype=np.uint8 ) logo_shader = pi3d.Shader( os.path.join(settings.BASE_DIR, "core/lights/circle/logo") ) self.logo = pi3d.Sprite(w=1.375 / ratio, h=1.375) self.logo.set_shader(logo_shader) self.logo.positionZ(0) logo_image = Image.open( os.path.join(settings.STATIC_ROOT, "graphics/raveberry_square.png") ) self.logo_array = np.frombuffer(logo_image.tobytes(), dtype=np.uint8) self.logo_array = self.logo_array.reshape( (logo_image.size[1], logo_image.size[0], 3) ) # add space for the spectrum self.logo_array = np.concatenate( ( self.logo_array, np.zeros((self.FFT_HIST, logo_image.size[0], 3), dtype=np.uint8), ), axis=0, ) # add alpha channel self.logo_array = np.concatenate( ( self.logo_array, np.ones( (self.logo_array.shape[0], self.logo_array.shape[1], 1), dtype=np.uint8, ), ), axis=2, ) # In order to save memory, the logo and the spectrum share one texture. # The upper 256x256 pixels are the raveberry logo. # Below are 256xFFT_HIST pixels for the spectrum. # The lower part is periodically updated every frame while the logo stays static. self.dynamic_texture = pi3d.Texture(self.logo_array) # Prevent interpolation from opposite edge self.dynamic_texture.m_repeat = GL_CLAMP_TO_EDGE self.spectrum.set_textures([self.dynamic_texture]) self.logo.set_textures([self.dynamic_texture]) after_shader = pi3d.Shader( os.path.join(settings.BASE_DIR, "core/lights/circle/after") ) self.after = pi3d.Sprite(w=2, h=2) self.after.set_shader(after_shader) self.after.positionZ(0) # create an OffscreenTexture to allow scaling. # By first rendering into a smaller Texture a lot of computation is saved. # This OffscreenTexture is then drawn at the end of the draw loop. self.post = OffScreenTexture("scale") self.post_sprite = pi3d.Sprite(w=2, h=2) post_shader = pi3d.Shader( os.path.join(settings.BASE_DIR, "core/lights/circle/scale") ) self.post_sprite.set_shader(post_shader) self.post_sprite.set_textures([self.post]) self.total_bass = 0 self.last_loop = time.time() self.time_elapsed = 0 opengles.glDepthFunc(GL_ALWAYS)