def __init__(self,
shader="post_base",
mipmap=False,
add_tex=None,
scale=1.0,
camera=None,
divide=1):
""" calls Texture.__init__ but doesn't need to set file name as
texture generated from the framebuffer. Keyword Arguments:
*shader*
to use when drawing sprite, defaults to post_base, a simple
3x3 convolution that does basic edge detection. Can be copied to
project directory and modified as required.
*mipmap*
can be set to True with slight cost to speed, or use fxaa shader
*add_tex*
list of textures. If additional textures can be used by the shader
then they can be added here.
*scale*
will only render this proportion of the full screen which will
then be mapped to the full uv of the Sprite. The camera object
passed (below) will need to have the same scale set to avoid
perspective distortion
*camera*
the camera to use for rendering to the offscreen texture
*divide*
allow the sprite to be created with intermediate vertices to allow
interesting vertex shader effects
"""
super(PostProcess, self).__init__("postprocess")
self.scale = scale
# load shader
self.shader = Shader(shader)
if camera is None:
self.viewcam = Camera.instance(
) # in case this is prior to one being created
else:
self.viewcam = camera
self.camera = Camera(is_3d=False)
self.sprite = LodSprite(z=20.0, w=self.ix, h=self.iy, n=divide)
self.sprite.set_2d_size(w=self.ix, h=self.iy)
for b in self.sprite.buf:
b.unib[6] = self.scale # ufact
b.unib[7] = self.scale # vfact
b.unib[9] = (1.0 - self.scale) * 0.5 # uoffset
b.unib[10] = (1.0 - self.scale) * 0.5 # voffset
self.blend = True
self.mipmap = mipmap
self.tex_list = [
self
] # TODO check if this self reference causes graphics memory leaks
if add_tex:
self.tex_list.extend(add_tex)
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 pi3d.PLATFORM != pi3d.PLATFORM_PI and pi3d.PLATFORM != pi3d.PLATFORM_ANDROID:
n = xlib.XEventsQueued(self.opengl.d, xlib.QueuedAfterFlush)
for i in range(n):
if xlib.XCheckMaskEvent(self.opengl.d, KeyPressMask, self.ev):
self.event_list.append(self.ev)
else:
xlib.XNextEvent(self.opengl.d, self.ev)
if self.ev.type == ClientMessage:
if (self.ev.xclient.data.l[0] == self.opengl.WM_DELETE_WINDOW.value):
self.destroy()
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
if self.tidy_needed:
self._tidy()
def __init__(self, shader="post_base", mipmap=False, add_tex=None, divide=1):
""" calls Texture.__init__ but doesn't need to set file name as
texture generated from the framebuffer. Keyword Arguments:
*shader*
to use when drawing sprite, defaults to post_base, a simple
3x3 convolution that does basic edge detection. Can be copied to
project directory and modified as required.
*mipmap*
can be set to True with slight cost to speed, or use fxaa shader
*add_tex*
list of textures. If additional textures can be used by the shader
then they can be added here.
"""
super(PostProcess, self).__init__("postprocess")
# load shader
self.shader = Shader(shader)
dummycam = Camera.instance() # in case this is prior to one being created
self.camera = Camera(is_3d=False)
self.sprite = LodSprite(z=20.0, w=self.ix, h=self.iy, n=divide)
self.sprite.set_2d_size(w=self.ix, h=self.iy)
self.alpha = False
self.blend = True
self.mipmap = mipmap
self.tex_list = [self] # TODO check if this self reference causes graphics memory leaks
if add_tex:
self.tex_list.extend(add_tex)
def _loop_begin(self):
# TODO(rec): check if the window was resized and resize it, removing
# code from MegaStation to here.
if not ON_PI:
n = xlib.XEventsQueued(self.opengl.d, xlib.QueuedAfterFlush)
for i in range(n):
if xlib.XCheckMaskEvent(self.opengl.d, KeyPressMask, self.ev):
self.event_list.append(self.ev)
else:
xlib.XNextEvent(self.opengl.d, self.ev)
if self.ev.type == ClientMessage:
if (self.ev.xclient.data.l[0] == self.opengl.WM_DELETE_WINDOW.value):
self.destroy()
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:
camera.was_moved = False
if self.tidy_needed:
self._tidy()
def _loop_begin(self):
# TODO(rec): check if the window was resized and resize it, removing
# code from MegaStation to here.
if not ON_PI:
n = xlib.XEventsQueued(self.opengl.d, xlib.QueuedAfterFlush)
for i in range(n):
if xlib.XCheckMaskEvent(self.opengl.d, KeyPressMask, self.ev):
self.event_list.append(self.ev)
else:
xlib.XNextEvent(self.opengl.d, self.ev)
if self.ev.type == ClientMessage:
if (self.ev.xclient.data.l[0] ==
self.opengl.WM_DELETE_WINDOW.value):
self.destroy()
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:
camera.was_moved = False
if self.tidy_needed:
self._tidy()
def draw(self, shader=None, txtrs=None, ntl=None, shny=None, camera=None, mlist=[], light_camera=None):
"""If called without parameters, there has to have been a previous call to
set_draw_details() for each Buffer in buf[].
NB there is no facility for setting umult and vmult with draw: they must be
set using set_draw_details or Buffer.set_draw_details.
"""
self.load_opengl() # really just to set the flag so _unload_opengl runs
camera = camera or self._camera or Camera.instance()
if not camera.mtrx_made:
camera.make_mtrx()
if light_camera and not light_camera.mtrx_made:
light_camera.make_mtrx()
if self.MFlg or len(mlist) > 0 or len(self.children) > 0:
# Calculate rotation and translation matrix for this model using numpy.
self.MRaw = self.tr1
if self.rozflg:
self.MRaw = dot(self.roz, self.MRaw)
if self.roxflg:
self.MRaw = dot(self.rox, self.MRaw)
if self.royflg:
self.MRaw = dot(self.roy, self.MRaw)
if self.sclflg:
self.MRaw = dot(self.scl, self.MRaw)
if self.tr2flg:
self.MRaw = dot(self.tr2, self.MRaw)
# child drawing addition #############
newmlist = [m for m in mlist]
newmlist.append(self.MRaw)
if len(self.children) > 0:
for c in self.children:
c.draw(shader, txtrs, ntl, shny, camera, newmlist, light_camera) # TODO issues where child doesn't use same shader
for m in mlist[-1::-1]:
self.MRaw = dot(self.MRaw, m)
######################################
self.M[0,:,:] = self.MRaw[:,:]
#self.M[0:16] = c_floats(self.MRaw.reshape(-1).tolist()) #pypy version
self.M[1,:,:] = dot(self.MRaw, camera.mtrx)[:,:]
#self.M[16:32] = c_floats(dot(self.MRaw, camera.mtrx).reshape(-1).tolist()) #pypy
if light_camera is not None:
self.M[2,:,:] = dot(self.MRaw, light_camera.mtrx)[:,:]
self.MFlg = False
elif camera.was_moved:
# Only do this if it's not done because model moved.
self.M[1,:,:] = dot(self.MRaw, camera.mtrx)[:,:]
if light_camera is not None:
self.M[2,:,:] = dot(self.MRaw, light_camera.mtrx)[:,:]
if camera.was_moved:
self.unif[18:21] = camera.eye[0:3]
for b in self.buf:
# Shape.draw has to be passed either parameter == None or values to pass
# on.
b.draw(self, self.M, self.unif, shader, txtrs, ntl, shny)
def draw(self, shader=None, txtrs=None, ntl=None, shny=None, camera=None, mlist=[], light_camera=None):
"""If called without parameters, there has to have been a previous call to
set_draw_details() for each Buffer in buf[].
NB there is no facility for setting umult and vmult with draw: they must be
set using set_draw_details or Buffer.set_draw_details.
"""
self.load_opengl() # really just to set the flag so _unload_opengl runs
camera = camera or self._camera or Camera.instance()
if not camera.mtrx_made:
camera.make_mtrx()
if light_camera and not light_camera.mtrx_made:
light_camera.make_mtrx()
if self.MFlg or len(mlist) > 0 or len(self.children) > 0:
# Calculate rotation and translation matrix for this model using numpy.
self.MRaw = self.tr1
if self.rozflg:
self.MRaw = np.dot(self.roz, self.MRaw)
if self.roxflg:
self.MRaw = np.dot(self.rox, self.MRaw)
if self.royflg:
self.MRaw = np.dot(self.roy, self.MRaw)
if self.sclflg:
self.MRaw = np.dot(self.scl, self.MRaw)
if self.tr2flg:
self.MRaw = np.dot(self.tr2, self.MRaw)
# child drawing addition #############
newmlist = [m for m in mlist]
newmlist.append(self.MRaw)
if len(self.children) > 0:
for c in self.children:
c.draw(shader, txtrs, ntl, shny, camera, newmlist, light_camera) # TODO issues where child doesn't use same shader
for m in mlist[-1::-1]:
self.MRaw = np.dot(self.MRaw, m)
######################################
self.M[0,:,:] = self.MRaw[:,:]
#self.M[0:16] = c_floats(self.MRaw.reshape(-1).tolist()) #pypy version
self.M[1,:,:] = np.dot(self.MRaw, camera.mtrx)[:,:]
#self.M[16:32] = c_floats(np.dot(self.MRaw, camera.mtrx).reshape(-1).tolist()) #pypy
if light_camera is not None:
self.M[2,:,:] = np.dot(self.MRaw, light_camera.mtrx)[:,:]
self.MFlg = False
elif camera.was_moved:
# Only do this if it's not done because model moved.
self.M[1,:,:] = np.dot(self.MRaw, camera.mtrx)[:,:]
if light_camera is not None:
self.M[2,:,:] = np.dot(self.MRaw, light_camera.mtrx)[:,:]
if camera.was_moved:
self.unif[18:21] = camera.eye[0:3]
for b in self.buf:
# Shape.draw has to be passed either parameter == None or values to pass
# on.
b.draw(self, self.M, self.unif, shader, txtrs, ntl, shny)
def draw(self,
shader=None,
txtrs=None,
ntl=None,
shny=None,
camera=None,
mlist=[]):
"""If called without parameters, there has to have been a previous call to
set_draw_details() for each Buffer in buf[].
NB there is no facility for setting umult and vmult with draw: they must be
set using set_draw_details or Buffer.set_draw_details.
"""
self.load_opengl(
) # really just to set the flag so _unload_opengl runs
from pi3d.Camera import Camera
camera = camera or self._camera or Camera.instance()
shader = shader or self.shader
shader.use()
if self.MFlg == True or len(mlist):
# Calculate rotation and translation matrix for this model using numpy.
self.MRaw = dot(
self.tr2,
dot(self.scl,
dot(self.roy, dot(self.rox, dot(self.roz, self.tr1)))))
# child drawing addition #############
newmlist = [m for m in mlist]
newmlist.append(self.MRaw)
if len(self.children) > 0:
for c in self.children:
c.draw(shader, txtrs, ntl, shny, camera, newmlist)
for m in mlist[-1::-1]:
self.MRaw = dot(self.MRaw, m)
######################################
self.M[0:16] = self.MRaw.ravel()
#self.M[0:16] = c_floats(self.MRaw.reshape(-1).tolist()) #pypy version
self.M[16:32] = dot(self.MRaw, camera.mtrx).ravel()
#self.M[16:32] = c_floats(dot(self.MRaw, camera.mtrx).reshape(-1).tolist()) #pypy
self.MFlg = False
elif camera.was_moved:
# Only do this if it's not done because model moved.
self.M[16:32] = dot(self.MRaw, camera.mtrx).ravel()
if camera.was_moved:
self.unif[18:21] = camera.eye[0:3]
opengles.glUniformMatrix4fv(shader.unif_modelviewmatrix, 2,
ctypes.c_int(0), ctypes.byref(self.M))
opengles.glUniform3fv(shader.unif_unif, 20, ctypes.byref(self.unif))
for b in self.buf:
# Shape.draw has to be passed either parameter == None or values to pass
# on.
b.draw(self, shader, txtrs, ntl, shny)
def __init__(self, shader="post_base", mipmap=False, add_tex=None,
scale=1.0, camera=None, divide=1):
""" calls Texture.__init__ but doesn't need to set file name as
texture generated from the framebuffer. Keyword Arguments:
*shader*
to use when drawing sprite, defaults to post_base, a simple
3x3 convolution that does basic edge detection. Can be copied to
project directory and modified as required.
*mipmap*
can be set to True with slight cost to speed, or use fxaa shader
*add_tex*
list of textures. If additional textures can be used by the shader
then they can be added here.
*scale*
will only render this proportion of the full screen which will
then be mapped to the full uv of the Sprite. The camera object
passed (below) will need to have the same scale set to avoid
perspective distortion
*camera*
the camera to use for rendering to the offscreen texture
*divide*
allow the sprite to be created with intermediate vertices to allow
interesting vertex shader effects
"""
super(PostProcess, self).__init__("postprocess")
self.scale = scale
# load shader
self.shader = Shader(shader)
if camera is None:
self.viewcam = Camera.instance() # in case this is prior to one being created
else:
self.viewcam = camera
self.camera = Camera(is_3d=False)
self.sprite = LodSprite(z=20.0, w=self.ix, h=self.iy, n=divide)
self.sprite.set_2d_size(w=self.ix, h=self.iy)
for b in self.sprite.buf:
b.unib[6] = self.scale # ufact
b.unib[7] = self.scale # vfact
b.unib[9] = (1.0 - self.scale) * 0.5 # uoffset
b.unib[10] = (1.0 - self.scale) * 0.5 # voffset
self.alpha = False
self.blend = True
self.mipmap = mipmap
self.tex_list = [self] # TODO check if this self reference causes graphics memory leaks
if add_tex:
self.tex_list.extend(add_tex)
def draw(self, shader=None, txtrs=None, ntl=None, shny=None, camera=None, mlist=[]):
"""If called without parameters, there has to have been a previous call to
set_draw_details() for each Buffer in buf[].
NB there is no facility for setting umult and vmult with draw: they must be
set using set_draw_details or Buffer.set_draw_details.
"""
self.load_opengl() # really just to set the flag so _unload_opengl runs
from pi3d.Camera import Camera
camera = camera or self._camera or Camera.instance()
shader = shader or self.shader
shader.use()
if self.MFlg == True or len(mlist):
# Calculate rotation and translation matrix for this model using numpy.
self.MRaw = dot(self.tr2,
dot(self.scl,
dot(self.roy,
dot(self.rox,
dot(self.roz, self.tr1)))))
# child drawing addition #############
newmlist = [m for m in mlist]
newmlist.append(self.MRaw)
if len(self.children) > 0:
for c in self.children:
c.draw(shader, txtrs, ntl, shny, camera, newmlist)
for m in mlist[-1::-1]:
self.MRaw = dot(self.MRaw, m)
######################################
self.M[0:16] = self.MRaw.ravel()
#self.M[0:16] = c_floats(self.MRaw.reshape(-1).tolist()) #pypy version
self.M[16:32] = dot(self.MRaw, camera.mtrx).ravel()
#self.M[16:32] = c_floats(dot(self.MRaw, camera.mtrx).reshape(-1).tolist()) #pypy
self.MFlg = False
elif camera.was_moved:
# Only do this if it's not done because model moved.
self.M[16:32] = dot(self.MRaw, camera.mtrx).ravel()
if camera.was_moved:
self.unif[18:21] = camera.eye[0:3]
opengles.glUniformMatrix4fv(shader.unif_modelviewmatrix, 2,
ctypes.c_int(0),
ctypes.byref(self.M))
opengles.glUniform3fv(shader.unif_unif, 20, ctypes.byref(self.unif))
for b in self.buf:
# Shape.draw has to be passed either parameter == None or values to pass
# on.
b.draw(self, shader, txtrs, ntl, shny)
def _loop_begin(self):
# TODO(rec): check if the window was resized and resize it, removing
# code from MegaStation to here.
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:
camera.was_moved = False
def _loop_begin(self):
# TODO(rec): check if the window was resized and resize it, removing
# code from MegaStation to here.
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:
camera.was_moved = False
def rotate_to_direction(self, direction, forward=[0.0, 0.0, 1.0]):
""" works out the XYZ euler rotations to rotate this shape from
forward to direction vectors
Arguments:
*direction*
3vector tuple, array or numpy array
*forward*
3vector, usually +ve z direction
"""
if type(direction) is not np.ndarray:
direction = np.array(direction)
if type(forward) is not np.ndarray:
forward = np.array(forward)
if self._camera is None:
self._camera = Camera.instance() # TODO may be issues doing this not in main thread (otherwise why not in Shape.__init__()?)
rot_mtrix = self._camera.matrix_from_two_vectors(forward, direction)
rot_euler = self._camera.euler_angles(rot_mtrix)
self.rotateToX(-rot_euler[0]) # unclear why x and y need to be -ve
self.rotateToY(-rot_euler[1]) # something to do with sense of rotation of camera
self.rotateToZ(rot_euler[2])
def draw(self, shader=None, txtrs=None, ntl=None, shny=None, camera=None):
"""If called without parameters, there has to have been a previous call to
set_draw_details() for each Buffer in buf[].
NB there is no facility for setting umult and vmult with draw: they must be
set using set_draw_details or Buffer.set_draw_details.
"""
from pi3d.Camera import Camera
camera = camera or self._camera or Camera.instance()
shader = shader or self.shader
shader.use()
if self.MFlg == True:
# Calculate rotation and translation matrix for this model using numpy.
self.MRaw = dot(self.tr2,
dot(self.scl,
dot(self.roy,
dot(self.rox,
dot(self.roz, self.tr1)))))
self.M[0:16] = self.MRaw.ravel()
self.M[16:32] = dot(self.MRaw, camera.mtrx).ravel()
self.MFlg = False
elif camera.was_moved:
# Only do this if it's not done because model moved.
self.M[16:32] = dot(self.MRaw, camera.mtrx).ravel()
if camera.was_moved:
self.unif[18:21] = camera.eye[0:3]
opengles.glUniformMatrix4fv(shader.unif_modelviewmatrix, 2,
ctypes.c_int(0),
ctypes.byref(self.M))
opengles.glUniform3fv(shader.unif_unif, 20, ctypes.byref(self.unif))
for b in self.buf:
# Shape.draw has to be passed either parameter == None or values to pass
# on.
b.draw(shader, txtrs, ntl, shny)
def rotate_to_direction(self, direction, forward=[0.0, 0.0, 1.0]):
""" works out the XYZ euler rotations to rotate this shape from
forward to direction vectors
Arguments:
*direction*
3vector tuple, array or numpy array
*forward*
3vector, usually +ve z direction
"""
if type(direction) is not np.ndarray:
direction = np.array(direction)
if type(forward) is not np.ndarray:
forward = np.array(forward)
if self._camera is None:
self._camera = Camera.instance(
) # TODO may be issues doing this not in main thread (otherwise why not in Shape.__init__()?)
rot_mtrix = self._camera.matrix_from_two_vectors(forward, direction)
rot_euler = self._camera.euler_angles(rot_mtrix)
self.rotateToX(-rot_euler[0]) # unclear why x and y need to be -ve
self.rotateToY(
-rot_euler[1]) # something to do with sense of rotation of camera
self.rotateToZ(rot_euler[2])
def draw(self, shader=None, txtrs=None, ntl=None, shny=None, camera=None):
"""If called without parameters, there has to have been a previous call to
set_draw_details() for each Buffer in buf[].
NB there is no facility for setting umult and vmult with draw: they must be
set using set_draw_details or Buffer.set_draw_details.
"""
from pi3d.Camera import Camera
camera = camera or self._camera or Camera.instance()
shader = shader or self.shader
shader.use()
if self.MFlg == True:
# Calculate rotation and translation matrix for this model using numpy.
self.MRaw = dot(
self.tr2,
dot(self.scl,
dot(self.roy, dot(self.rox, dot(self.roz, self.tr1)))))
self.M[0:16] = self.MRaw.ravel()
self.M[16:32] = dot(self.MRaw, camera.mtrx).ravel()
self.MFlg = False
elif camera.was_moved:
# Only do this if it's not done because model moved.
self.M[16:32] = dot(self.MRaw, camera.mtrx).ravel()
if camera.was_moved:
self.unif[18:21] = camera.eye[0:3]
opengles.glUniformMatrix4fv(shader.unif_modelviewmatrix, 2,
ctypes.c_int(0), ctypes.byref(self.M))
opengles.glUniform3fv(shader.unif_unif, 20, ctypes.byref(self.unif))
for b in self.buf:
# Shape.draw has to be passed either parameter == None or values to pass
# on.
b.draw(shader, txtrs, ntl, shny)
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("=====")
from pi3d.Light import Light
from pi3d.Shader import Shader
from pi3d.util.String import String
from pi3d.util.Ttffont import Ttffont
from pi3d.util.Defocus import Defocus
from pi3d.util.Screenshot import screenshot
from pi3d.shape.MergeShape import MergeShape
from pi3d.shape.Sphere import Sphere
from pi3d.shape.Sprite import Sprite
# Setup display and initialise pi3d
DISPLAY = Display.create(x=10, y=10, w=900, h=600, frames_per_second=25)
DISPLAY.set_background(0.4, 0.6, 0.8, 1.0) # r,g,b,alpha
persp_cam = Camera.instance() # default instance camera perspecive view
ortho_cam = Camera(is_3d=False) # 2d orthographic view camera
#setup textures, light position and initial model position
Light((0, 5, 0))
#create shaders
shader = Shader("shaders/uv_reflect")
flatsh = Shader("shaders/uv_flat")
defocus = Defocus()
#Create textures
shapeimg = Texture("textures/straw1.jpg")
shapebump = Texture("textures/floor_nm.jpg", True)
shapeshine = Texture("textures/pong3.png")
#Create shape
from pi3d.Light import Light
from pi3d.Shader import Shader
from pi3d.util.String import String
from pi3d.util.Ttffont import Ttffont
from pi3d.util.Defocus import Defocus
from pi3d.util.Screenshot import screenshot
from pi3d.shape.MergeShape import MergeShape
from pi3d.shape.Sphere import Sphere
from pi3d.shape.Sprite import Sprite
# Setup display and initialise pi3d
DISPLAY = Display.create(x=10, y=10, w=900, h=600, frames_per_second=25)
DISPLAY.set_background(0.4, 0.6, 0.8, 1.0) # r,g,b,alpha
persp_cam = Camera.instance() # default instance camera perspecive view
ortho_cam = Camera(is_3d=False) # 2d orthographic view camera
#setup textures, light position and initial model position
Light((0, 5, 0))
#create shaders
shader = Shader("shaders/uv_reflect")
flatsh = Shader("shaders/uv_flat")
defocus = Defocus()
#Create textures
shapeimg = Texture("textures/straw1.jpg")
shapebump = Texture("textures/floor_nm.jpg", True)
shapeshine = Texture("textures/pong3.png")
#Create shape
def cameraY(self,y):
self.vrcamyloc = y
from pi3d.Camera import Camera
vrcamera = Camera.instance()
if vrcamera:
vrcamera.position((self.vrcamxloc,self.vrcamyloc,1.0))
tank_turret.rotateToZ(roll)
tank_turret.draw()
tank_gun.position(x, y, z)
# adjust gunangle for tilted plane as turret rotates
tank_gun.rotateToX(pitch + math.cos(math.radians(turret - 180)) * gunangle)
tank_gun.rotateToY(turret-90)
tank_gun.rotateToZ(roll - math.sin(math.radians(turret - 180)) * gunangle)
tank_gun.draw()
# Update display before we begin (user might have moved window)
win.update()
DISPLAY.resize(win.winx, win.winy, win.width, win.height - bord)
is_running = True
CAMERA = Camera.instance()
try:
while DISPLAY.loop_running():
mx, my = mymouse.position()
mouserot -= (mx-omx)*0.2
tilt += (my-omy)*0.2
omx=mx
omy=my
CAMERA.reset()
dot1.set_2d_location(DISPLAY.width - 105.0 + 200.0*xm/mapwidth,
DISPLAY.height - 105.0 - 200.0*zm/mapdepth)
dot2.set_2d_location(DISPLAY.width - 105.0 + 200.0*etx/mapwidth,
DISPLAY.height - 105.0 - 200.0*etz/mapdepth)
dot1.draw()