def render():
while True:
for color in (1.,0.,0.,1.), (0.,1.,0.,1.), (0.,0.,1.,1.):
gl.glClearColor(*color)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
yield None
time.sleep(0.2)
def render():
while True:
for color in (1., 0., 0., 1.), (0., 1., 0., 1.), (0., 0., 1., 1.):
gl.glClearColor(*color)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
yield None
time.sleep(0.2)
def __init__(self, width=640, height=480, fullscreen=False, aspect=None):
self.gl = gl
self.bo_next = self.bo_prev = None
self.last_swap = time.time()
self.frame_count = 0
self.disp = egl.eglGetPlatformDisplay(EGL_PLATFORM_SURFACELESS_MESA,
egl.EGL_DEFAULT_DISPLAY, None)
if not self.disp:
raise Exception("Failed to get egl display")
BaseDisplay.__init__(self, width, height, True, aspect)
attribList = arrays.GLintArray.asArray([
egl.EGL_RENDERABLE_TYPE, egl.EGL_OPENGL_ES2_BIT,
egl.EGL_SURFACE_TYPE, egl.EGL_PBUFFER_BIT, egl.EGL_RED_SIZE, 8,
egl.EGL_GREEN_SIZE, 8, egl.EGL_BLUE_SIZE, 8, egl.EGL_ALPHA_SIZE, 8,
egl.EGL_NONE
])
ctxAttrib = arrays.GLintArray.asArray(
[egl.EGL_CONTEXT_CLIENT_VERSION, 2, egl.EGL_NONE])
surfaceAttrib = arrays.GLintArray.asArray(
[egl.EGL_WIDTH, width, egl.EGL_HEIGHT, height, egl.EGL_NONE])
egl.eglInitialize(self.disp, None, None)
config = egl.EGLConfig()
num_configs = ctypes.c_long()
egl.eglChooseConfig(self.disp, attribList, byref(config), 1,
byref(num_configs))
ret = ctypes.c_int()
egl.eglBindAPI(egl.EGL_OPENGL_ES_API)
self.context = egl.eglCreateContext(self.disp, config,
egl.EGL_NO_CONTEXT, ctxAttrib)
self.surface = egl.eglCreatePbufferSurface(self.disp, config,
surfaceAttrib)
assert egl.eglMakeCurrent(self.disp, self.surface, self.surface,
self.context)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glClearColor(0, 0, 0, 0.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
self.win_width = self.width = width
self.win_height = self.height = height
gl.glViewport(0, 0, self.win_width, self.win_height)
self.clear_color = self.TRANSPARENT
self._initialize()
def __init__(self, width=640, height=480, fullscreen=False, aspect=None):
self.gl = gl
self.bo_next = self.bo_prev = None
self.last_swap = time.time()
self.frame_count = 0
self.card = pykms.Card()
print("DRM fd: %d" % self.card.fd)
print("Has atomic: %r" % self.card.has_atomic)
self.render_fd = -1
render_name = libdrm.drmGetRenderDeviceNameFromFd(self.card.fd)
print("Render device name: %r" % render_name)
if render_name:
try:
self.render_fd = os.open(render_name, os.O_RDWR)
except OSError:
print("Render node not available")
print("Render fd: %d" % self.render_fd)
self.gbm_dev = libgbm.gbm_create_device(self.card.fd)
if not self.gbm_dev:
raise Exception("Failed to create GBM device")
print("GBM dev: %x" % self.gbm_dev)
self.res = pykms.ResourceManager(self.card)
self.conn = self.res.reserve_connector()
self.crtc = self.res.reserve_crtc(self.conn)
self.root_plane = self.res.reserve_generic_plane(self.crtc)
if not self.root_plane:
raise Exception("Root plane not available")
self.mode = mode = self.conn.get_default_mode()
BaseDisplay.__init__(self, mode.hdisplay, mode.vdisplay, True, aspect)
self.fps = 1000 * mode.clock / (mode.htotal * mode.vtotal)
print("Creating GBM surface (%dx%d %f Hz)" % (mode.hdisplay, mode.vdisplay, self.fps))
self.gbm_surface = libgbm.gbm_surface_create(
c_void_p(self.gbm_dev), mode.hdisplay, mode.vdisplay,
GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING)
if not self.gbm_surface:
raise Exception("Failed to create GBM surface")
print("GBM surface: %x" % self.gbm_surface)
self.disp = egl.eglGetDisplay(self.gbm_dev)
if not self.disp:
raise Exception("Failed to get egl display")
attribList = arrays.GLintArray.asArray([
egl.EGL_RENDERABLE_TYPE, egl.EGL_OPENGL_ES2_BIT,
egl.EGL_SURFACE_TYPE, egl.EGL_WINDOW_BIT,
#egl.EGL_COLOR_BUFFER_TYPE, egl.EGL_RGB_BUFFER,
egl.EGL_RED_SIZE, 8,
egl.EGL_GREEN_SIZE, 8,
egl.EGL_BLUE_SIZE, 8,
egl.EGL_ALPHA_SIZE, 0,
egl.EGL_NONE
])
ctxAttrib = arrays.GLintArray.asArray([
egl.EGL_CONTEXT_CLIENT_VERSION, 2,
egl.EGL_NONE
])
egl.eglInitialize(self.disp, None, None)
config = egl.EGLConfig()
num_configs = ctypes.c_long()
egl.eglChooseConfig(self.disp, attribList, byref(config), 1, byref(num_configs))
ret = ctypes.c_int()
egl.eglBindAPI(egl.EGL_OPENGL_ES_API)
self.surface = egl.eglCreateWindowSurface(self.disp, config, c_void_p(self.gbm_surface), None)
self.context = egl.eglCreateContext(self.disp, config, egl.EGL_NO_CONTEXT, ctxAttrib)
assert egl.eglMakeCurrent(self.disp, self.surface, self.surface, self.context)
egl.eglSwapInterval(self.disp, 1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glClearColor(0, 0, 0, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
#fb = self.lock_next()
#self.crtc.set_mode(self.conn, fb, mode)
modeb = mode.to_blob(self.card)
req = pykms.AtomicReq(self.card)
req.add(self.conn, "CRTC_ID", self.crtc.id)
req.add(self.crtc, {"ACTIVE": 1,
"MODE_ID": modeb.id})
if req.test(allow_modeset = True):
raise Exception("Atomic test failed")
if req.commit_sync(allow_modeset = True):
raise Exception("Atomic commit failed")
self.win_width = self.width = mode.hdisplay
self.win_height = self.height = mode.vdisplay
gl.glViewport(0, 0, self.win_width, self.win_height)
self.clear_color = self.BLACK
self._initialize()
if req.test():
raise Exception("Atomic test failed")
if req.commit_sync():
raise Exception("Atomic commit failed")
self.free_prev()
self.frame_count += 1
if self.frame_count == 30:
t = time.time()
print("%.02f FPS" % (30.0/(t - self.last_swap)))
self.last_swap = t
self.frame_count = 0
def get_proc_address(self, s):
return egl.eglGetProcAddress(s)
def get_mpv_params(self):
return { "drm_display": {
"fd": self.card.fd,
"render_fd": self.render_fd,
} }
if __name__ == "__main__":
d = Display()
while True:
for color in (1.,0.,0.,1.), (0.,1.,0.,1.), (0.,0.,1.,1.):
gl.glClearColor(*color)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
d.swap_buffers()
gl.glViewport(0, 0, self.win_width, self.win_height)
self.clear_color = self.TRANSPARENT
self._initialize()
def swap_buffers(self):
egl.eglSwapBuffers(self.disp, self.surface)
self.frame_count += 1
def get_proc_address(self, s):
return egl.eglGetProcAddress(s)
def get_mpv_params(self):
return {
"drm_display": {
"fd": -1,
"render_fd": -1,
}
}
if __name__ == "__main__":
d = Display()
while True:
for color in (1., 0., 0., 1.), (0., 1., 0., 1.), (0., 0., 1., 1.):
gl.glClearColor(*color)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
d.swap_buffers()
def __init__(self, width=640, height=480, fullscreen=False, aspect=None):
self.gl = gl
libbcm_host.bcm_host_init()
display = libbcm_host.vc_dispmanx_display_open(0)
mode = DISPMANX_MODEINFO_T()
libbcm_host.vc_dispmanx_display_get_info(display, byref(mode))
print("Display mode: %dx%d" % (mode.width, mode.height))
self.disp = egl.eglGetDisplay(egl.EGL_DEFAULT_DISPLAY)
attribList = arrays.GLintArray.asArray([
egl.EGL_RENDERABLE_TYPE, egl.EGL_OPENGL_ES2_BIT,
egl.EGL_SURFACE_TYPE, egl.EGL_WINDOW_BIT,
#egl.EGL_COLOR_BUFFER_TYPE, egl.EGL_RGB_BUFFER,
egl.EGL_RED_SIZE, 8,
egl.EGL_GREEN_SIZE, 8,
egl.EGL_BLUE_SIZE, 8,
egl.EGL_ALPHA_SIZE, 8,
egl.EGL_NONE
])
ctxAttrib = arrays.GLintArray.asArray([
egl.EGL_CONTEXT_CLIENT_VERSION, 2,
egl.EGL_NONE
])
egl.eglInitialize(self.disp, None, None)
config = egl.EGLConfig()
num_configs = ctypes.c_long()
egl.eglChooseConfig(self.disp, attribList, byref(config), 1, byref(num_configs))
ret = ctypes.c_int()
egl.eglBindAPI(egl.EGL_OPENGL_ES_API)
update = libbcm_host.vc_dispmanx_update_start(0)
rectDst = VC_RECT_T()
rectDst.x = rectDst.y = 0
rectDst.width = mode.width
rectDst.height = mode.height
rectSrc = VC_RECT_T()
rectSrc.x = rectDst.y = 0
rectSrc.width = mode.width << 16
rectSrc.height = mode.height << 16
alpha = VC_DISPMANX_ALPHA_T()
alpha.flags = 1 << 16 # premultiplied alpha
alpha.opacity = 255
alpha.mask = 0
self.nativeWindow = EGL_DISPMANX_WINDOW_T()
self.nativeWindow.width = mode.width
self.nativeWindow.height = mode.height
layer = 0
self.nativeWindow.element = libbcm_host.vc_dispmanx_element_add(
update, display, layer, byref(rectDst), 0, byref(rectSrc),
0, byref(alpha), 0, 0)
libbcm_host.vc_dispmanx_update_submit_sync(update)
libbcm_host.vc_dispmanx_display_close(display)
self.surface = egl.eglCreateWindowSurface(self.disp, config, byref(self.nativeWindow), None)
self.context = egl.eglCreateContext(self.disp, config, egl.EGL_NO_CONTEXT, ctxAttrib)
assert egl.eglMakeCurrent(self.disp, self.surface, self.surface, self.context)
egl.eglSwapInterval(self.disp, 1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
for i in range(5):
gl.glClearColor(0, 0, 0, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
egl.eglSwapBuffers(self.disp, self.surface)
self.win_width = self.width = mode.width
self.win_height = self.height = mode.height
gl.glViewport(0, 0, self.win_width, self.win_height)
BaseDisplay.__init__(self, mode.width, mode.height, True, aspect)
# Transparent layer
self.clear_color = self.TRANSPARENT
self._initialize()
def __init__(self, width=640, height=480, fullscreen=False, aspect=None):
self.gl = gl
libbcm_host.bcm_host_init()
display = libbcm_host.vc_dispmanx_display_open(0)
mode = DISPMANX_MODEINFO_T()
libbcm_host.vc_dispmanx_display_get_info(display, byref(mode))
print("Display mode: %dx%d" % (mode.width, mode.height))
self.disp = egl.eglGetDisplay(egl.EGL_DEFAULT_DISPLAY)
attribList = arrays.GLintArray.asArray([
egl.EGL_RENDERABLE_TYPE, egl.EGL_OPENGL_ES2_BIT,
egl.EGL_SURFACE_TYPE, egl.EGL_WINDOW_BIT,
#egl.EGL_COLOR_BUFFER_TYPE, egl.EGL_RGB_BUFFER,
egl.EGL_RED_SIZE, 8,
egl.EGL_GREEN_SIZE, 8,
egl.EGL_BLUE_SIZE, 8,
egl.EGL_ALPHA_SIZE, 8,
egl.EGL_NONE
])
ctxAttrib = arrays.GLintArray.asArray([
egl.EGL_CONTEXT_CLIENT_VERSION, 2,
egl.EGL_NONE
])
egl.eglInitialize(self.disp, None, None)
config = egl.EGLConfig()
num_configs = ctypes.c_long()
egl.eglChooseConfig(self.disp, attribList, byref(config), 1, byref(num_configs))
ret = ctypes.c_int()
egl.eglBindAPI(egl.EGL_OPENGL_ES_API)
update = libbcm_host.vc_dispmanx_update_start(0)
rectDst = VC_RECT_T()
rectDst.x = rectDst.y = 0
rectDst.width = mode.width
rectDst.height = mode.height
rectSrc = VC_RECT_T()
rectSrc.x = rectDst.y = 0
rectSrc.width = mode.width << 16
rectSrc.height = mode.height << 16
alpha = VC_DISPMANX_ALPHA_T()
alpha.flags = 1 << 16 # premultiplied alpha
alpha.opacity = 255
alpha.mask = 0
self.nativeWindow = EGL_DISPMANX_WINDOW_T()
self.nativeWindow.width = mode.width
self.nativeWindow.height = mode.height
layer = 0
self.nativeWindow.element = libbcm_host.vc_dispmanx_element_add(
update, display, layer, byref(rectDst), 0, byref(rectSrc),
0, byref(alpha), 0, 0)
libbcm_host.vc_dispmanx_update_submit_sync(update)
libbcm_host.vc_dispmanx_display_close(display)
self.surface = egl.eglCreateWindowSurface(self.disp, config, byref(self.nativeWindow), None)
self.context = egl.eglCreateContext(self.disp, config, egl.EGL_NO_CONTEXT, ctxAttrib)
assert egl.eglMakeCurrent(self.disp, self.surface, self.surface, self.context)
egl.eglSwapInterval(self.disp, 1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
for i in range(5):
gl.glClearColor(0, 0, 0, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
egl.eglSwapBuffers(self.disp, self.surface)
self.win_width = self.width = mode.width
self.win_height = self.height = mode.height
gl.glViewport(0, 0, self.win_width, self.win_height)
BaseDisplay.__init__(self, mode.width, mode.height, True, aspect)
# Transparent layer
self.clear_color = self.TRANSPARENT
self._initialize()
def display():
global phi, theta
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
# Filled cube
# gl.glDisable(gl.GL_BLEND)
# gl.glEnable(gl.GL_DEPTH_TEST)
# gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
# gl.glDepthMask(gl.GL_TRUE)
gl.glUniform4f(gpu["uniform"]["u_color"], 0.5, 0.5, 0.5, 1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, gpu["buffer"]["filled"])
gl.glDrawElements(gl.GL_TRIANGLES, len(f_indices), gl.GL_UNSIGNED_INT,
None)
# Outlined cube
# gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
# gl.glEnable(gl.GL_BLEND)
# gl.glDepthMask(gl.GL_FALSE)
gl.glUniform4f(gpu["uniform"]["u_color"], 0, 0, 0, .5)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, gpu["buffer"]["outline"])
gl.glDrawElements(gl.GL_LINES, len(o_indices), gl.GL_UNSIGNED_INT, None)
# Rotate cube
theta += 0.5 # degrees
phi += 0.5 # degrees
model = np.eye(4, dtype=np.float32)
# rotate(model, theta, 0, 0, 1)
# rotate(model, phi, 0, 1, 0)
translate(model, 0, 0, -4)
gl.glUniformMatrix4fv(gpu["uniform"]["u_model"], 1, False, model)
glut.glutSwapBuffers()
def reshape(width, height):
gl.glViewport(0, 0, width, height)
projection = perspective(45.0, width / float(height), 2.0, 100.0)
gl.glUniformMatrix4fv(gpu["uniform"]["u_projection"], 1, False, projection)
# vertices["a_color"] = [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 1], [0, 1, 0, 1],
# [1, 1, 0, 1], [1, 1, 1, 1], [1, 0, 1, 1], [1, 0, 0, 1]]
vertices["a_color"] = [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 1], [0, 0, 0, 1],
[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 1]]
f_indices = np.array([
0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 5, 0, 5, 6, 0, 6, 1, 1, 6, 7, 1, 7, 2, 7,
4, 3, 7, 3, 2, 4, 7, 6, 4, 6, 5
],
dtype=np.uint32)
o_indices = np.array(
[0, 1, 1, 2, 2, 3, 3, 0, 4, 7, 7, 6, 6, 5, 5, 4, 0, 5, 1, 6, 2, 7, 3, 4],
dtype=np.uint32)
# Build & activate program
# --------------------------------------
program = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(vertex, vertex_code)
gl.glCompileShader(vertex)
gl.glAttachShader(program, vertex)
gl.glShaderSource(fragment, fragment_code)
gl.glCompileShader(fragment)
gl.glAttachShader(program, fragment)
gl.glLinkProgram(program)
gl.glDetachShader(program, vertex)
gl.glDetachShader(program, fragment)
gl.glUseProgram(program)
# Build GPU objects
# --------------------------------------