def __init__(self) -> None:
self._fbo = GL.glGenFramebuffers(1)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self._fbo)
if GL.glCheckFramebufferStatus(
GL.GL_FRAMEBUFFER) != GL.GL_FRAMEBUFFER_COMPLETE:
print('Framebuffer not complete')
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
self._texture_color = GL.glGenTextures(1)
GL.glBindTexture(GL.GL_TEXTURE_2D, self._texture_color)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER,
GL.GL_LINEAR)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER,
GL.GL_LINEAR)
self._texture_depth = GL.glGenTextures(1)
GL.glBindTexture(GL.GL_TEXTURE_2D, self._texture_depth)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER,
GL.GL_LINEAR)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER,
GL.GL_LINEAR)
GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
def renderGL(w, h, func, data):
# TODO store original GL context and restore it afterwards?
startGL()
fbid = GL.glGenFramebuffers(1)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, fbid)
dbid = GL.glGenRenderbuffers(1)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, dbid)
GL.glRenderbufferStorage(GL.GL_RENDERBUFFER, GL.GL_DEPTH_COMPONENT, w, h)
tid = GL.glGenTextures(1)
GL.glBindTexture(GL.GL_TEXTURE_2D, tid)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER,
GL.GL_LINEAR)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER,
GL.GL_LINEAR)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGB, w, h, 0, GL.GL_RGB,
GL.GL_UNSIGNED_BYTE, None)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0,
GL.GL_TEXTURE_2D, tid, 0)
GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT,
GL.GL_RENDERBUFFER, dbid)
assert GL.glCheckFramebufferStatus(
GL.GL_FRAMEBUFFER) == GL.GL_FRAMEBUFFER_COMPLETE, 'GL error'
GL.glViewport(0, 0, w, h)
if isinstance(data, tuple): func(*data)
else: func(data)
data = GL.glReadPixels(0, 0, w, h, GL.GL_RGB, GL.GL_UNSIGNED_BYTE)
GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, 0)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
GL.glDeleteTextures([tid])
GL.glDeleteFramebuffers(1, [fbid])
GL.glDeleteRenderbuffers(1, [dbid])
return np.fromstring(data, dtype=np.uint8).reshape(h, w, 3)
async def async_main(window, config):
await asyncjob.start_worker()
imgui_impl = GlfwRenderer(window)
renderer = WorldRenderer()
app = StarboundMap(renderer)
frame_size = np.ones(2)
while not glfw.window_should_close(window):
glfw.poll_events()
if G.minimized: # do not render zero sized frame
continue
imgui_impl.process_inputs()
frame_size = np.array(glfw.get_framebuffer_size(window))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glViewport(0, 0, frame_size[0], frame_size[1])
gl.glClearColor(0.1, 0.1, 0.2, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
app.gui()
glfw.swap_buffers(window)
await asyncio.sleep(0)
config[CONFIG_WIDTH] = str(int(frame_size[0]))
config[CONFIG_HEIGHT] = str(int(frame_size[1]))
imgui_impl.shutdown()
imgui.shutdown()
def _on_start_env(self, env):
# create framebuffer object to render into
fbo = gl.glGenFramebuffers(1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo)
# create texture
texture = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA,
get_config().window_px_width,
get_config().window_px_height, 0, gl.GL_RGBA,
gl.GL_UNSIGNED_BYTE, None)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_LINEAR)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_LINEAR)
# bind texture to FBO
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, texture, 0)
# Check FBO status
if gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER) != gl.GL_FRAMEBUFFER_COMPLETE:
raise "FBO error"
# Bind default FBO
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
env_info = EnvInfo(env, fbo=fbo, texture=texture)
self._envs[env.id] = env_info
def _create_framebuffer(self):
"""
Make sure opengl context is bound before calling this method
"""
fb = GL.glGenFramebuffers(1)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, fb)
self.texture = GL.glGenTextures(1)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.texture)
GL.glTexImage2D(
GL.GL_TEXTURE_2D, # target
0,
GL.GL_RGBA,
self.fb_size[0],
self.fb_size[1],
0,
GL.GL_RGBA,
GL.GL_UNSIGNED_BYTE,
None,
)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST)
GL.glFramebufferTexture(
GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0, self.texture, 0
)
GL.glDrawBuffers(1, [GL.GL_COLOR_ATTACHMENT0])
if GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER) != GL.GL_FRAMEBUFFER_COMPLETE:
raise Exception("Incomplete framebuffer")
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
return fb
def draw(self, view, renderer):
# gl.glDepthMask(False)
gl.glUseProgram(self.program)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, renderer.fbo_id)
gl.glViewport(0, 0, renderer.cube_res, renderer.cube_res)
# Select skybox VAO
gl.glBindVertexArray(self.vao_id)
rot_mat = self.eyes_up @ view
gl.glUniformMatrix4fv(self.skybox_view_handle, 1, gl.GL_FALSE, rot_mat)
# # Bind to the active texture
# gl.glBindTexture(gl.GL_TEXTURE_CUBE_MAP, renderer.texobj_colour_id)
#
# gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, renderer.texobj_colour_id, 0)
# gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT, renderer.texobj_depth_id, 0)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, self.vao_len)
# Release VAO, FBO and program
gl.glBindVertexArray(0)
gl.glBindTexture(gl.GL_TEXTURE_CUBE_MAP, 0)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glUseProgram(0)
def __init__(self):
self.depthMapFbo = gl.glGenFramebuffers(1)
self.shadowW_i = 1024*4
self.shadowH_i = 1024*4
self.program = self._getProgram()
self.depthMapTex = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.depthMapTex)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_DEPTH_COMPONENT, self.shadowW_i, self.shadowH_i, 0, gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT, None)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_BORDER)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_BORDER)
#gl.glTexParameterfv(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_BORDER_COLOR, (1.0, 1.0, 1.0, 1.0))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.depthMapFbo)
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT, gl.GL_TEXTURE_2D, self.depthMapTex, 0)
gl.glDrawBuffer(gl.GL_NONE)
gl.glReadBuffer(gl.GL_NONE)
if gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) != gl.GL_FRAMEBUFFER_COMPLETE:
print( "ERROR::FRAMEBUFFER:: Framebuffer is not complete!" )
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def renderTranslucent(self): try: GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.translucentFBO) GL.glClearBufferfv(GL.GL_DEPTH, 0, 1) GL_shaders.glUseProgram(self.shaderTranslucent) self.tex1.bind(0) self.model2.bind() GL.glUniformMatrix4fv( self.UNIFORMSTranslucent['my_ModelMatrix'],1, GL.GL_TRUE, self.ModelMatrix.get()) GL.glUniformMatrix4fv( self.UNIFORMSTranslucent['my_ViewMatrix'],1, GL.GL_TRUE, self.ViewMatrix.get()) GL.glUniformMatrix4fv( self.UNIFORMSTranslucent['my_ProjectionMatrix'],1, GL.GL_TRUE, self.ProjectionMatrix.get()) GL.glUniform1i(self.UNIFORMSTranslucent['tex0'], 0) finally: self.model2.unbind() self.tex1.unbind() GL_shaders.glUseProgram(0) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
def initialize(self):
if self.handle:
self.finalize()
self.handle = gl.glGenFramebuffers(1)
self.color_attachment_handle = color_attachment_handle = gl.glCreateTextures(
gl.GL_TEXTURE_2D, 1)
gl.glBindTexture(gl.GL_TEXTURE_2D, color_attachment_handle)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA8, self.width,
self.height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, None)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_LINEAR)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_LINEAR)
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, color_attachment_handle, 0)
self.depth_attachment_handle = depth_attachment_handle = gl.glCreateTextures(
gl.GL_TEXTURE_2D, 1)
gl.glBindTexture(gl.GL_TEXTURE_2D, depth_attachment_handle)
gl.glTexStorage2D(gl.GL_TEXTURE_2D, 1, gl.GL_DEPTH24_STENCIL8,
self.width, self.height)
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER,
gl.GL_DEPTH_STENCIL_ATTACHMENT,
gl.GL_TEXTURE_2D, depth_attachment_handle, 0)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def paintGL(self):
# fade out the sparkle plot
self.fader.swap_frame_buffer()
self.fader.paint_faded(decay=decay_rate)
data = np.random.randint(sparkle_width * sparkle_height,
size=spikes_per_frame)
# generate spike data
self.spike_count += len(data)
# paint the spikes onto the sparkle plot
self.spiker.paint_spikes(data)
# switch to rendering on the screen
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glViewport(0, 0, self.width, self.height)
# draw the sparkle plot on the screen
self.draw_texture.paint(self.fader.get_current_texture())
# print out spike rate
now = time.time()
if now > self.t_last_msg + 1:
dt = now - self.t_last_msg
rate = self.spike_count * 0.000001 / dt
print 'Mspikes per second = %g' % rate
self.spike_count = 0
self.t_last_msg = now
def _init_framebuffer_object(self):
"""
returns a Framebuffer Object to support offscreen rendering.
http://learnopengl.com/#!Advanced-OpenGL/Framebuffers
"""
fbo = gl.glGenFramebuffers(1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo)
rbo = gl.glGenRenderbuffers(1)
gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, rbo)
gl.glRenderbufferStorage(
gl.GL_RENDERBUFFER,
gl.GL_RGBA,
self.init_width,
self.init_height
)
gl.glFramebufferRenderbuffer(
gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_RENDERBUFFER, rbo)
gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, 0)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
fbo_status = gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER)
if fbo_status != gl.GL_FRAMEBUFFER_COMPLETE:
gl.glDeleteFramebuffers([fbo])
glfw.terminate()
raise Exception('Framebuffer failed status check: %s' % fbo_status)
self._fbo = fbo
self._rbo = rbo
def _init_shadow(self):
"""
Initializes a texture to which we render the depth-map for calculating
shadows and creates a framebuffer object that renders the scene's depth
component to this texture.
"""
self.shadow_size = 2048
# configure depth map
self.depth_texture_buffer = gl.glGenFramebuffers(1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.depth_texture_buffer)
# create depth texture
self.depth_map = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.depth_map)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_DEPTH_COMPONENT,
self.shadow_size, self.shadow_size, 0,
gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT, None)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S,
gl.GL_CLAMP_TO_BORDER)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T,
gl.GL_CLAMP_TO_BORDER)
border_color = [1.0, 1.0, 1.0, 1.0]
gl.glTexParameterfv(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_BORDER_COLOR,
border_color)
# attach depth texture as FBO's depth buffer
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT,
gl.GL_TEXTURE_2D, self.depth_map, 0)
gl.glDrawBuffer(gl.GL_NONE)
gl.glReadBuffer(gl.GL_NONE)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def __init__(self, window_width, window_height):
self._framebuf = GL.glGenFramebuffers(1)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self._framebuf)
self._picktex = GL.glGenTextures(1)
GL.glBindTexture(GL.GL_TEXTURE_2D, self._picktex)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA32F, window_width,
window_height, 0, GL.GL_RGB, GL.GL_FLOAT, None)
GL.glFramebufferTexture2D(GL.GL_DRAW_FRAMEBUFFER,
GL.GL_COLOR_ATTACHMENT0, GL.GL_TEXTURE_2D,
self._picktex, 0)
self._depthtex = GL.glGenTextures(1)
GL.glBindTexture(GL.GL_TEXTURE_2D, self._depthtex)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_DEPTH_COMPONENT,
window_width, window_height, 0, GL.GL_DEPTH_COMPONENT,
GL.GL_FLOAT, None)
GL.glFramebufferTexture2D(GL.GL_DRAW_FRAMEBUFFER,
GL.GL_DEPTH_ATTACHMENT, GL.GL_TEXTURE_2D,
self._depthtex, 0)
GL.glReadBuffer(GL.GL_NONE)
GL.glDrawBuffer(GL.GL_COLOR_ATTACHMENT0)
# Restore the default framebuffer
GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
def draw_to_texture(self, view):
gl.glUseProgram(self.program)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbo_id)
gl.glViewport(0, 0, self.cube_res, self.cube_res)
gl.glUniformMatrix4fv(self.view_handle, 1, gl.GL_FALSE, view)
# gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, self.texobj_colour_id, 0)
# gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT, self.texobj_depth_id, 0)
for i in range(6):
rot_mat = self.eyes_up @ view @ self.matrices[i]
gl.glUniformMatrix4fv(self.view_handle, 1, gl.GL_FALSE, rot_mat)
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_CUBE_MAP_POSITIVE_X + i,
self.texobj_colour_id, 0)
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER,
gl.GL_DEPTH_ATTACHMENT,
gl.GL_TEXTURE_CUBE_MAP_POSITIVE_X + i,
self.texobj_depth_id, 0)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glUseProgram(0)
def v_render():
''' render to vr and window '''
global hmd, ctx, window
# resolve multi-sample offscreen buffer
gl.glBindFramebuffer(gl.GL_READ_FRAMEBUFFER, ctx.con.offFBO)
gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT0)
gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, ctx.con.offFBO_r)
gl.glDrawBuffer(gl.GL_COLOR_ATTACHMENT0)
gl.glBlitFramebuffer(0, 0, 2 * hmd.width, hmd.height, 0, 0, 2 * hmd.width,
hmd.height, gl.GL_COLOR_BUFFER_BIT, gl.GL_NEAREST)
# blit to window, left only, window is half-size
gl.glBindFramebuffer(gl.GL_READ_FRAMEBUFFER, ctx.con.offFBO_r)
gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT0)
gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, 0)
gl.glDrawBuffer(gl.GL_BACK if ctx.con.windowDoublebuffer else gl.GL_FRONT)
gl.glBlitFramebuffer(0, 0, hmd.width, hmd.height, 0, 0, hmd.width // 2,
hmd.height // 2, gl.GL_COLOR_BUFFER_BIT,
gl.GL_NEAREST)
# blit to vr texture
gl.glActiveTexture(gl.GL_TEXTURE2)
gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, ctx.con.offFBO_r)
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT1,
gl.GL_TEXTURE_2D, hmd.idtex, 0)
gl.glDrawBuffer(gl.GL_COLOR_ATTACHMENT1)
gl.glBlitFramebuffer(0, 0, 2 * hmd.width, hmd.height, 0, 0, 2 * hmd.width,
hmd.height, gl.GL_COLOR_BUFFER_BIT, gl.GL_NEAREST)
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT1,
gl.GL_TEXTURE_2D, 0, 0)
gl.glDrawBuffer(gl.GL_COLOR_ATTACHMENT0)
openvr.VRCompositor().submit(openvr.Eye_Left, hmd.vTex, hmd.boundLeft)
openvr.VRCompositor().submit(openvr.Eye_Right, hmd.vTex, hmd.boundRight)
# swap if window is double-buffered, flush just in case
if ctx.con.windowDoublebuffer:
glfw.swap_buffers(window)
gl.glFlush()
def draw(self, view, renderer):
gl.glUseProgram(renderer.program)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, renderer.fbo_id)
gl.glViewport(0, 0, renderer.cube_res, renderer.cube_res)
gl.glUniformMatrix4fv(renderer.view_handle, 1, gl.GL_FALSE, view)
# Select mesh VAO
gl.glBindVertexArray(self.vao_id)
# Bind to the active texture
gl.glBindTexture(gl.GL_TEXTURE_CUBE_MAP, renderer.texobj_colour_id)
gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
renderer.texobj_colour_id, 0)
gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT,
renderer.texobj_depth_id, 0)
gl.glDrawElements(
gl.GL_TRIANGLES, # Mode
self.nb_faces * 3, # Count
gl.GL_UNSIGNED_INT, # Type
ctypes.c_void_p(0)) # Element array buffer offset (None)
# Release VAO, FBO and program
gl.glBindVertexArray(0)
gl.glBindTexture(gl.GL_TEXTURE_CUBE_MAP, 0)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glUseProgram(0)
def captureRGBD(self):
'''
XXX DO NOT USE THIS METHOD. Use the capture() instead.
This method is called from the GLUT thread.
Captures a RGBD frame.
'''
try:
if self.useFBO:
res = []
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER,self.fbo)
for att in self.renderBufferAt:
# Read depth from the OpenGL buffer
GL.glReadBuffer(att)
glBuffer = GL.glReadPixels(0, 0, self.fboWidth, self.fboHeight, GL.GL_RGBA, GL.GL_FLOAT)
img = np.flipud(np.array(glBuffer, np.float32).reshape(self.fboHeight,self.fboWidth,4))
res.append(img)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER,0)
return res
# no fbo, just return RGBA from default frame buffer.
glBuffer = GL.glReadPixels(0, 0, self.width, self.height, GL.GL_RGBA, GL.GL_FLOAT)
img = np.flipud(np.array(glBuffer, np.float32).reshape(self.height,self.width,4))
return [img,None,None]
except NoContext:
print "No OpenGL Context found. If you are calling from a different thread use the capture() method instead."
print sys.exc_info()
def __init__(self, width: int = 128, height: int = 128):
self.__fbo = gl.glGenFramebuffers(1)
self.__width: int = int(width)
self.__height: int = int(height)
self.__tex = gl.glGenTextures(1)
gl.glActiveTexture(gl.GL_TEXTURE0 + self.__tex)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.__tex)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_DEPTH_COMPONENT,
self.__width, self.__height, 0, gl.GL_DEPTH_COMPONENT,
gl.GL_FLOAT, None)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S,
gl.GL_CLAMP_TO_BORDER)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T,
gl.GL_CLAMP_TO_BORDER)
gl.glTexParameterfv(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_BORDER_COLOR,
(1.0, 1.0, 1.0, 1.0))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.__fbo)
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT,
gl.GL_TEXTURE_2D, self.__tex, 0)
gl.glDrawBuffer(gl.GL_NONE)
gl.glReadBuffer(gl.GL_NONE)
_checkBoundFramebuffer()
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def v_render():
''' render to vr and window '''
global hmd, ctx, window
# resolve multi-sample offscreen buffer
gl.glBindFramebuffer(gl.GL_READ_FRAMEBUFFER, ctx.con.offFBO)
gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT0)
gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, ctx.con.offFBO_r)
gl.glDrawBuffer(gl.GL_COLOR_ATTACHMENT0)
gl.glBlitFramebuffer(0, 0, 2 * hmd.width, hmd.height,
0, 0, 2 * hmd.width, hmd.height,
gl.GL_COLOR_BUFFER_BIT, gl.GL_NEAREST)
# blit to window, left only, window is half-size
gl.glBindFramebuffer(gl.GL_READ_FRAMEBUFFER, ctx.con.offFBO_r)
gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT0)
gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, 0)
gl.glDrawBuffer(gl.GL_BACK if ctx.con.windowDoublebuffer else gl.GL_FRONT)
gl.glBlitFramebuffer(0, 0, hmd.width, hmd.height,
0, 0, hmd.width // 2, hmd.height // 2,
gl.GL_COLOR_BUFFER_BIT, gl.GL_NEAREST)
# blit to vr texture
gl.glActiveTexture(gl.GL_TEXTURE2)
gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, ctx.con.offFBO_r)
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT1, gl.GL_TEXTURE_2D, hmd.idtex, 0)
gl.glDrawBuffer(gl.GL_COLOR_ATTACHMENT1)
gl.glBlitFramebuffer(0, 0, 2 * hmd.width, hmd.height,
0, 0, 2 * hmd.width, hmd.height,
gl.GL_COLOR_BUFFER_BIT, gl.GL_NEAREST)
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT1, gl.GL_TEXTURE_2D, 0, 0)
gl.glDrawBuffer(gl.GL_COLOR_ATTACHMENT0)
openvr.VRCompositor().submit(openvr.Eye_Left, hmd.vTex, hmd.boundLeft)
openvr.VRCompositor().submit(openvr.Eye_Right, hmd.vTex, hmd.boundRight)
# swap if window is double-buffered, flush just in case
if ctx.con.windowDoublebuffer:
glfw.swap_buffers(window)
gl.glFlush()
def __del__(self):
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
if hasattr(self, "FBORENDER"):
GL.glDeleteTextures(self.TARGET)
GL.glDeleteRenderbuffers(6, self.DEPTH)
GL.glDeleteFramebuffers(1, [self.FBORENDER])
report_GL_error()
if hasattr(self, "FBOACCUM"):
GL.glDeleteTextures([self.ACCUM])
GL.glDeleteTextures([self.AREA])
GL.glDeleteFramebuffers(1, [self.FBOACCUM])
del self.prog
report_GL_error()
if hasattr(self, "SANGLE"):
GL.glDeleteTextures([self.SANGLE])
report_GL_error()
if self.mesh is not None:
del self.mesh
report_GL_error()
if hasattr(self, "wnd"):
glfw.destroy_window(self.wnd)
glfw.terminate()
def __init__(self, width, height):
# Create the frame buffer.
self.fbo_ = GL.glGenFramebuffers(1)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fbo_)
# Create the textures of the frame buffer.
self.texture_ = GL.glGenTextures(1)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.texture_)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER,
GL.GL_LINEAR)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER,
GL.GL_LINEAR)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S,
GL.GL_CLAMP_TO_EDGE)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T,
GL.GL_CLAMP_TO_EDGE)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_COMPARE_MODE,
GL.GL_COMPARE_REF_TO_TEXTURE)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_DEPTH_COMPONENT32F, width,
height, 0, GL.GL_DEPTH_COMPONENT, GL.GL_FLOAT, None)
GL.glFramebufferTexture(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT,
self.texture_, 0)
GL.glDrawBuffer(GL.GL_NONE)
# Check if the frame buffer was created properly.
if not GL.glCheckFramebufferStatus(
GL.GL_FRAMEBUFFER) == GL.GL_FRAMEBUFFER_COMPLETE:
raise RuntimeError("Bind frame buffer failed")
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
def __init__(self, width, height):
self.render_framebuffer_id = GL.glGenFramebuffers(1)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.render_framebuffer_id)
#
self.depth_buffer_id = GL.glGenRenderbuffers(1)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, self.depth_buffer_id)
GL.glRenderbufferStorageMultisample(GL.GL_RENDERBUFFER, 4,
GL.GL_DEPTH_COMPONENT, width,
height)
GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT,
GL.GL_RENDERBUFFER, self.depth_buffer_id)
#
self.render_texture_id = GL.glGenTextures(1)
GL.glBindTexture(GL.GL_TEXTURE_2D_MULTISAMPLE, self.render_texture_id)
GL.glTexImage2DMultisample(GL.GL_TEXTURE_2D_MULTISAMPLE, 4,
GL.GL_RGBA8, width, height, True)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0,
GL.GL_TEXTURE_2D_MULTISAMPLE,
self.render_texture_id, 0)
#
self.resolve_framebuffer_id = GL.glGenFramebuffers(1)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.resolve_framebuffer_id)
#
self.resolve_texture_id = GL.glGenTextures(1)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.resolve_texture_id)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER,
GL.GL_LINEAR)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAX_LEVEL, 0)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA8, width, height, 0,
GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, None)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0,
GL.GL_TEXTURE_2D, self.resolve_texture_id, 0)
status = GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER)
assert status == GL.GL_FRAMEBUFFER_COMPLETE
def setup_fbo(self):
self.ctx.makeCurrent(self.offscreen_surface)
self.tex = GL.glGenTextures(1)
self.fbo = GL.glGenFramebuffers(1)
self.rbuf = GL.glGenRenderbuffers(1)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.tex)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER,
GL.GL_NEAREST)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER,
GL.GL_NEAREST)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA,
OffscreenModelRendererThread.TEX_SIZE,
OffscreenModelRendererThread.TEX_SIZE, 0, GL.GL_RGBA,
GL.GL_UNSIGNED_BYTE, None)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, self.rbuf)
GL.glRenderbufferStorage(GL.GL_RENDERBUFFER, GL.GL_DEPTH_COMPONENT24,
OffscreenModelRendererThread.TEX_SIZE,
OffscreenModelRendererThread.TEX_SIZE)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fbo)
GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT,
GL.GL_RENDERBUFFER, self.rbuf)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0,
GL.GL_TEXTURE_2D, self.tex, 0)
if GL.glCheckFramebufferStatus(
GL.GL_FRAMEBUFFER) != GL.GL_FRAMEBUFFER_COMPLETE:
raise RuntimeError("Framebuffer is not complete!")
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, 0)
def release(self, stack=True):
"""
Bind FBO popping it from the stack
:param stack: (bool) If the bind should be popped form the FBO stack.
"""
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
if not stack:
return
# Are we trying to release an FBO that is not bound?
if not FBO.stack:
raise FBOError("FBO stack is already empty. You are probably releasing a FBO twice or forgot to bind.")
fbo_out = FBO.stack.pop()
# Make sure we released this FBO and not some other random one
if fbo_out != self:
raise FBOError("Incorrect FBO release order")
# Find the parent fbo
if FBO.stack:
parent = FBO.stack[-1]
else:
parent = WINDOW_FBO
# Bind the parent FBO
if parent:
parent.bind()
def paintGL(self):
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fbo)
self.paint_quad()
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.defaultFramebufferObject())
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
self.paint_to_screen()
def bind_frame_buffer(self, width, height):
frame_buffer_name = gl.glGenFramebuffers(1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, frame_buffer_name)
fbo_texture = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, fbo_texture)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, width, height, 0,
gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, None)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S,
gl.GL_CLAMP_TO_EDGE)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T,
gl.GL_CLAMP_TO_EDGE)
depth_render_buffer = gl.glGenRenderbuffers(1)
gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, depth_render_buffer)
gl.glRenderbufferStorage(gl.GL_RENDERBUFFER, gl.GL_DEPTH_COMPONENT,
width, height)
gl.glFramebufferRenderbuffer(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT,
gl.GL_RENDERBUFFER, depth_render_buffer)
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, fbo_texture, 0)
drawbuffers = [gl.GL_COLOR_ATTACHMENT0]
gl.glDrawBuffers(1, drawbuffers)
if gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER) != gl.GL_FRAMEBUFFER_COMPLETE:
return False
return True
def render(self, gltf, nodes, window_size=(800, 600)):
self.vr_compositor.waitGetPoses(self.poses, openvr.k_unMaxTrackedDeviceCount, None, 0)
hmd_pose = self.poses[openvr.k_unTrackedDeviceIndex_Hmd]
if not hmd_pose.bPoseIsValid:
return
hmd_34 = np.ctypeslib.as_array(cast(hmd_pose.mDeviceToAbsoluteTracking.m, c_float_p),
shape=(3,4))
self.view[:3,:] = hmd_34
view = np.linalg.inv(self.view.T)
view.dot(self.eye_transforms[0], out=self.view_matrices[0])
view.dot(self.eye_transforms[1], out=self.view_matrices[1])
gl.glViewport(0, 0, self.vr_framebuffers[0].width, self.vr_framebuffers[0].height)
for eye in (0, 1):
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.vr_framebuffers[eye].fb)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gltfu.set_material_state.current_material = None
gltfu.set_technique_state.current_technique = None
for node in nodes:
gltfu.draw_node(node, gltf,
projection_matrix=self.projection_matrices[eye],
view_matrix=self.view_matrices[eye])
self.controllers.display_gl(self.view_matrices[eye], self.projection_matrices[eye])
self.vr_compositor.submit(openvr.Eye_Left, self.vr_framebuffers[0].texture)
self.vr_compositor.submit(openvr.Eye_Right, self.vr_framebuffers[1].texture)
# mirror left eye framebuffer to screen:
gl.glBlitNamedFramebuffer(self.vr_framebuffers[0].fb, 0,
0, 0, self.vr_framebuffers[0].width, self.vr_framebuffers[0].height,
0, 0, window_size[0], window_size[1],
gl.GL_COLOR_BUFFER_BIT, gl.GL_NEAREST)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def _init_shadow(self):
"""
Initializes a texture to which we render the depth-map for calculating
shadows and creates a framebuffer object that renders the scene's depth
component to this texture.
"""
self.shadow_size = 2048
# configure depth map
self.depth_texture_buffer = gl.glGenFramebuffers(1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.depth_texture_buffer)
# create depth texture
self.depth_map = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.depth_map)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_DEPTH_COMPONENT,
self.shadow_size, self.shadow_size, 0,
gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT, None)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S,
gl.GL_CLAMP_TO_BORDER)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T,
gl.GL_CLAMP_TO_BORDER)
border_color = [1.0, 1.0, 1.0, 1.0]
gl.glTexParameterfv(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_BORDER_COLOR,
border_color)
# attach depth texture as FBO's depth buffer
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT,
gl.GL_TEXTURE_2D, self.depth_map, 0)
gl.glDrawBuffer(gl.GL_NONE)
gl.glReadBuffer(gl.GL_NONE)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def _init_framebuffer_object(self):
"""
returns a Framebuffer Object to support offscreen rendering.
http://learnopengl.com/#!Advanced-OpenGL/Framebuffers
"""
fbo = gl.glGenFramebuffers(1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo)
rbo = gl.glGenRenderbuffers(1)
gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, rbo)
gl.glRenderbufferStorage(gl.GL_RENDERBUFFER, gl.GL_RGBA,
self.init_width, self.init_height)
gl.glFramebufferRenderbuffer(gl.GL_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0,
gl.GL_RENDERBUFFER, rbo)
gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, 0)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
fbo_status = gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER)
if fbo_status != gl.GL_FRAMEBUFFER_COMPLETE:
gl.glDeleteFramebuffers([fbo])
glfw.terminate()
raise Exception('Framebuffer failed status check: %s' % fbo_status)
self._fbo = fbo
self._rbo = rbo
def _on_render(self, env):
env_info = self._envs[env.id]
if self._hidden:
glfw.show_window(self._window)
self._hidden = False
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glBindTexture(gl.GL_TEXTURE_2D, env_info.texture)
# http://stackoverflow.com/questions/27712437/opengl-how-do-i-affect-the-lighting-on-a-textured-plane
gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_REPLACE)
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glBegin(gl.GL_QUADS)
gl.glTexCoord2f(0.0, 0.0)
gl.glVertex3f(0.0, 0.0, 0)
gl.glTexCoord2f(0.0, 1.0)
gl.glVertex3f(0.0, 1.0, 0)
gl.glTexCoord2f(1.0, 1.0)
gl.glVertex3f(1.0, 1.0, 0)
gl.glTexCoord2f(1.0, 0.0)
gl.glVertex3f(1.0, 0.0, 0)
gl.glEnd()
gl.glDisable(gl.GL_TEXTURE_2D)
# Swap front and back buffers
glfw.swap_buffers(self._window)
def __init__(self, bufferFormats, width, height):
if len(bufferFormats) > 6:
raise RuntimeError("Number of attachement to buffer too high: " +
str(len(bufferFormats)))
# Create the frame buffer.
self.textures_ = []
self.fbo_ = GL.glGenFramebuffers(1)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fbo_)
self.colorAttList_ = [
GL.GL_COLOR_ATTACHMENT0, GL.GL_COLOR_ATTACHMENT1,
GL.GL_COLOR_ATTACHMENT2, GL.GL_COLOR_ATTACHMENT3,
GL.GL_COLOR_ATTACHMENT4, GL.GL_COLOR_ATTACHMENT5,
GL.GL_COLOR_ATTACHMENT6
]
self.formatDict_ = {
GL.GL_RGBA32F: (GL.GL_RGBA, GL.GL_FLOAT),
GL.GL_RGBA: (GL.GL_RGBA, GL.GL_UNSIGNED_BYTE),
GL.GL_R32I: (GL.GL_RED_INTEGER, GL.GL_INT),
GL.GL_RGBA32I: (GL.GL_RGBA_INTEGER, GL.GL_INT)
}
# Create the textures of the frame buffer.
for it, currFormat in enumerate(bufferFormats):
if not (currFormat in self.formatDict_):
raise RuntimeError(
"The texture format is not in the dictionary: " +
str(currFormat))
myFormat = self.formatDict_[currFormat]
texture = GL.glGenTextures(1)
GL.glBindTexture(GL.GL_TEXTURE_2D, texture)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER,
GL.GL_NEAREST)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER,
GL.GL_NEAREST)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, currFormat, width, height, 0,
myFormat[0], myFormat[1], None)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER,
self.colorAttList_[it], GL.GL_TEXTURE_2D,
texture, 0)
self.textures_.append(texture)
# Creaet the render buffer.
self.rbo_ = GL.glGenRenderbuffers(1)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, self.rbo_)
GL.glRenderbufferStorage(GL.GL_RENDERBUFFER, GL.GL_DEPTH24_STENCIL8,
width, height)
GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER,
GL.GL_DEPTH_STENCIL_ATTACHMENT,
GL.GL_RENDERBUFFER, self.rbo_)
# Check if the frame buffer was created properly.
if not GL.glCheckFramebufferStatus(
GL.GL_FRAMEBUFFER) == GL.GL_FRAMEBUFFER_COMPLETE:
raise RuntimeError("Bind frame buffer failed")
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, 0)
def _configure_screen_frame_buffer(texture_object):
frame_buffer_object = GL.glGenFramebuffers(1)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, frame_buffer_object)
GL.glFramebufferTexture(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0, texture_object, 0)
GL.glDrawBuffers(1, [GL.GL_COLOR_ATTACHMENT0])
assert GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER) == GL.GL_FRAMEBUFFER_COMPLETE
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
return frame_buffer_object
def read(self, x, y):
GL.glBindFramebuffer(GL.GL_READ_FRAMEBUFFER, self._framebuf)
with self.enable():
GL.glReadBuffer(GL.GL_COLOR_ATTACHMENT0)
pixel = GL.glReadPixels(x, y, 1, 1, GL.GL_RGB, GL.GL_FLOAT)
GL.glReadBuffer(GL.GL_NONE)
return pixel[0][0]
def startRenderOn(self, lightProjection, lightView):
gl.glDisable(gl.GL_CULL_FACE)
gl.glUseProgram(self.__program)
gl.glViewport(0, 0, self.__shadowW_i, self.__shadowH_i)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.__depthMapFbo)
gl.glClear(gl.GL_DEPTH_BUFFER_BIT)
gl.glUniformMatrix4fv(1, 1, gl.GL_FALSE, lightView * lightProjection)
def render(self, scene, camera, light=(1.0, 1.0, 1.0)):
# tr = tracker.SummaryTracker()
self.ctx.clear()
# create a C-style binary buffer for the scene data
scene_packed = scene.pack()
vbo = self.ctx.buffer(scene_packed)
# merge the textures and load them into a buffer
scene.pack_textures()
# load the scene data (vertices, colors, etc.) into the renderer
vao = self.ctx.simple_vertex_array(self.prog, vbo,
*self.shader["params"])
# get the camera parameters and feed them into the renderer
proj, lookat = camera.get_view_model()
self.prog['model'].write((proj * lookat).astype('f4').tobytes())
self.prog['Light'].value = light
# prog['Color'].value = (1.0, 1.0, 1.0, 0.25)
# render out the current
vao.render(moderngl.TRIANGLES)
if self.msaa > 0:
gl.glBindFramebuffer(gl.GL_READ_FRAMEBUFFER, self.fbo_msaa.glo)
gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, self.fbo.glo)
gl.glBlitFramebuffer(0, 0, self.size[0], self.size[1], 0, 0,
self.size[0], self.size[1],
gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT, gl.GL_NEAREST)
# gl.glBindFramebuffer(gl.GL_READ_FRAMEBUFFER, self.fbo_msaa.glo)
# gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, self.fbo.glo)
# gl.glBlitFramebuffer(0, 0, self.size[0], self.size[1], 0, 0,
# self.size[0], self.size[1],
# , gl.GL_LINEAR)
# get the RGB data and convert to numpy array
raw = self.fbo.read(components=4, dtype='f4') # RGBA, floats
img = np.frombuffer(
raw, dtype='f4').reshape((camera.height, camera.width, 4))
# the y axis is flipped during rendering, so we have to unflip this.
# and the image has 4 channels: RGB+Alpha, but we don't care about alpha.
# note that the image will be numpy.float32 in range [0,1]
img = img[::-1, :, :3]
# get the depth buffer and conver to numpy
depth = np.frombuffer(
self.dbo_smol.read(alignment=1),
dtype=np.dtype('f4')).reshape(camera.size())
# similar to the RGB, the dept is flipped upside-down as well so we need to unflip.
depth = depth[::-1, :]
# tr.print_diff()
return img, depth
def setup_fb(self, width, height):
'''Sets up FrameBuffer that will be used as container
for 1 pass of rendering'''
# Clean up old FB and Texture
if self.fb_texture is not None and \
GL.glIsTexture(self.fb_texture):
GL.glDeleteTextures([self.fb_texture])
if self.fbo is not None and GL.glIsFramebuffer(self.fbo):
GL.glDeleteFramebuffers(1, [self.fbo])
# initialize FrameBuffer
self.fbo = GL.glGenFramebuffers(1)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fbo)
depthbuffer = GL.glGenRenderbuffers(1)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, depthbuffer)
GL.glRenderbufferStorage(GL.GL_RENDERBUFFER, GL.GL_DEPTH_COMPONENT32F,
width, height)
GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT,
GL.GL_RENDERBUFFER, depthbuffer)
# end of FrameBuffer initialization
# generate the texture we render to, and set parameters
self.fb_texture = GL.glGenTextures(1) # create target texture
# bind to new texture, all future texture functions will modify this
# particular one
GL.glBindTexture(GL.GL_TEXTURE_2D, self.fb_texture)
# set how our texture behaves on x,y boundaries
GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S,
GL.GL_REPEAT)
GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T,
GL.GL_REPEAT)
# set how our texture is filtered
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER,
GL.GL_LINEAR)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER,
GL.GL_LINEAR)
# occupy width x height texture memory, (None at the end == empty
# image)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA32F, width, height, 0,
GL.GL_RGBA, GL.GL_FLOAT, None)
# --- end texture init
# Set "fb_texture" as our colour attachement #0
GL.glFramebufferTexture2D(
GL.GL_FRAMEBUFFER,
GL.GL_COLOR_ATTACHMENT0,
GL.GL_TEXTURE_2D,
self.fb_texture,
0 # mipmap level, normally 0
)
# verify that everything went well
status = GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER)
assert status == GL.GL_FRAMEBUFFER_COMPLETE, status
def draw(self):
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.framebuffer)
self.shader_program.bind()
GL.glBindVertexArray(self.vertex_attribute_object)
GL.glActiveTexture(GL.GL_TEXTURE0)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.texture)
GL.glDrawArrays(GL.GL_TRIANGLES, 0, 6)
GL.glBindVertexArray(0)
self.shader_program.release()
def mySetup(self):
# Create two shaders:
self.shader_1 = self.loadShader("vs_1.glsl", "fs_1.glsl")
self.UNIFORMS_1 = {
'tex0':GL.glGetUniformLocation(self.shader_1, 'tex0')}
self.shader_2 = self.loadShader("vs_2.glsl", "fs_2.glsl")
self.UNIFORMS_2 = {
'col_tex':GL.glGetUniformLocation(self.shader_2, 'col_tex')}
#Define geometry:
self.vbo = GL_vbo.VBO(
np.array([
[-1.0,-1.0, 0.0, 0.0, 0.0],
[ 1.0,-1.0, 0.0, 1.0, 0.0],
[ 1.0, 1.0, 0.0, 1.0, 1.0],
[-1.0, 1.0, 0.0, 0.0, 1.0],
], dtype=np.float32), target=GL.GL_ARRAY_BUFFER)
self.ibo = GL_vbo.VBO(
np.array([
[0, 1, 3],
[1, 2, 3]
], dtype=np.uint32), target=GL.GL_ELEMENT_ARRAY_BUFFER)
file = PIL_Image.open("tex0.png")
file = file.convert('RGBA')
file_stream = file.tostring('raw', 'RGBA', 0, -1)
# Assign an ID to this texture:
self.tex0_ID = 0;
ID = GL.glGenTextures(1)
GL.glActiveTexture(GL.GL_TEXTURE0 + self.tex0_ID)
GL.glBindTexture(GL.GL_TEXTURE_2D, ID)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR)
GL.glTexImage2D(
GL.GL_TEXTURE_2D, 0, GL_s3tc.GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
file.size[0],
file.size[1],
0, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, file_stream)
del file, file_stream
self.fbo = GL.glGenFramebuffers(1) ## Look into ctypes and pointers!
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fbo)
self.col_tex_ID = 1
self.col_tex = GL.glGenTextures(1)
GL.glActiveTexture(GL.GL_TEXTURE0 + self.col_tex_ID)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.col_tex)
GL.glTexStorage2D(GL.GL_TEXTURE_2D, 1, GL.GL_DEPTH_COMPONENT32F, 512, 512)
# "GL.GL_DEPTH_COMPONENT32F" for depth testing
# "GL.GL_RGBA8" for color testing
GL.glFramebufferTexture(
GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT,
self.col_tex, 0)
def display():
gl.glStencilMask(255)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT |
gl.GL_STENCIL_BUFFER_BIT)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo)
shadowProgram.draw(gl.GL_TRIANGLES, indices)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
# Filled cube
# gl.glDisable(gl.GL_BLEND)
# gl.glEnable(gl.GL_DEPTH_TEST)
# gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
program['u_color'] = 1,1,1,1
program['u_scale'] = 1,1,1
program['draw_shadow'] = 1
program.draw(gl.GL_TRIANGLES, indices)
gl.glEnable(gl.GL_STENCIL_TEST)
gl.glStencilFunc(gl.GL_ALWAYS, 1, 255)
gl.glStencilOp(gl.GL_KEEP, gl.GL_KEEP, gl.GL_REPLACE)
# gl.glStencilFunc(gl.GL_NEVER, 1, 255)
# gl.glStencilOp(gl.GL_REPLACE, gl.GL_REPLACE, gl.GL_REPLACE)
gl.glStencilMask(255)
gl.glDepthMask(gl.GL_FALSE)
program2['u_color'] = 1,1,1,1
program2['u_scale'] = 1,1,1
program2.draw(gl.GL_TRIANGLE_STRIP)
gl.glStencilFunc(gl.GL_EQUAL, 1, 255);
#gl.glStencilOp(gl.GL_KEEP, gl.GL_KEEP, gl.GL_REPLACE)
gl.glStencilMask(0)
gl.glDepthMask(gl.GL_TRUE)
model = np.eye(4, dtype=np.float32)
translate(model, 0, -2, 0)
rotate(model, phi, 0,1,0)
program['model'] = model
program['u_color'] = 0.5, 0.5, 0.5, 1
program['u_scale'] = 1,-1,1
program['draw_shadow'] = 0
program.draw(gl.GL_TRIANGLES, indices)
gl.glDisable(gl.GL_STENCIL_TEST)
# Outlined cube
# gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
# gl.glEnable(gl.GL_BLEND)
# gl.glDepthMask(gl.GL_FALSE)
# program['u_color'] = 0,0,0,1
# program.draw(gl.GL_LINES, outline)
# gl.glDepthMask(gl.GL_TRUE)
glut.glutSwapBuffers()
def doShader(self, program, sources, uniform2f=[], uniform1f=[], uniform2i=[], uniform1i=[], render_target=None, position=(0,0), size=(100,100), readback=False):
if render_target == None:
#resize the screen if necessary
if position[0] + size[0] > self.width:
self.resizefunc(50,50,position[0]+size[0],self.height+1)
if position[1] + size[1] > self.height:
self.resizefunc(50,50,self.width,position[1]+size[1]+1)
#do opengl stuff
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glViewport(position[0],position[1],size[0],size[1])
else:
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, render_target.fb)
gl.glViewport(0,0,render_target.width,render_target.height)
#tell OpenGL which shader program to use for this render
gl.glUseProgram(program.program)
#set any uniform variables we got as arguments
for x in uniform1i: #tuple ("name", value)
gl.glUniform1i(gl.glGetUniformLocation(program.program, x[0]),x[1])
for x in uniform2i: #tuple ("name", value1, value2)
gl.glUniform2i(gl.glGetUniformLocation(program.program, x[0]),x[1],x[2])
for x in uniform1f: #tuple ("name", value)
gl.glUniform1f(gl.glGetUniformLocation(program.program, x[0]),x[1])
for x in uniform2f: #tuple ("name", value1, value2)
gl.glUniform2f(gl.glGetUniformLocation(program.program, x[0]),x[1],x[2])
#bind vertex buffer
self.vbo.bind()
#bind textures
texunits = [gl.GL_TEXTURE0, gl.GL_TEXTURE1, gl.GL_TEXTURE2, gl.GL_TEXTURE3]
for (i,x) in enumerate(sources):
gl.glActiveTexture(texunits[i])
if not program.ferror:
gl.glBindTexture(gl.GL_TEXTURE_2D, x.tex)
else:
gl.glBindTexture(gl.GL_TEXTURE_2D, error_image.tex)
gl.glActiveTexture(texunits[0])
#do the actual drawing
loc = gl.glGetAttribLocation(self.input_program.program, "vertex")
gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, gl.GL_FALSE, 16, None)
gl.glEnableVertexAttribArray(loc)
gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4)
#readback
if readback:
if render_target == None:
# Capture image from the OpenGL buffer
buffer = ( gl.GLubyte * (4*size[0]*size[1]) )(0)
gl.glReadPixels(0, 0, size[0], size[1], gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, buffer)
return buffer
else:
# Capture image from the OpenGL buffer
buffer = ( gl.GLubyte * (4*render_target.width*render_target.height) )(0)
gl.glReadPixels(0, 0, render_target.width, render_target.height, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, buffer)
return buffer
return
def paintGL(self):
now = time.time()
if self.last_time is None:
decay = 0.0
self.dt = None
else:
dt = now - self.last_time
if self.dt is None:
self.dt = dt
else:
#self.dt = dt
self.dt = (0.9) * self.dt + (0.1) * dt
self.last_time = now
if self.dt is not None:
self.slider.swap_frame_buffer(int(self.dt/0.001))
self.slider.paint_slid()
#data = self.data
data = np.random.randint(raster_n_neurons,
size=spikes_per_frame).astype('int32')
# generate spike data
self.spike_count += len(data)
# paint the spikes onto the sparkle plot
self.slider.swap_frame_buffer(0, False)
self.raster.paint_spikes(data)
# switch to rendering on the screen
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glViewport(0, 0, self.width, self.height)
# draw the sparkle plot on the screen
self.draw_texture.paint(self.slider.get_current_texture())
# print out spike rate
now = time.time()
if now > self.t_last_msg + 1:
dt = now - self.t_last_msg
rate = self.spike_count * 0.000001 / dt
print 'Mspikes per second = %g' % rate
self.spike_count = 0
self.t_last_msg = now
# flag a redraw
self.update()
def paint(self):
# fade out the sparkle plot
self.fader.swap_frame_buffer()
self.fader.paint_faded(decay=self.decay_rate)
spikes_per_frame = 100
data = np.random.randint(self.grid_width * self.grid_height,
size=spikes_per_frame)
# paint the spikes onto the sparkle plot
self.spiker.paint_spikes(data)
# switch to rendering on the screen
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glViewport(0, 0, self.width, self.height)
# draw the sparkle plot on the screen
self.draw_texture.paint(self.fader.get_current_texture())
def setupOpaque(self): self.opaqueFBO = GL.glGenFramebuffers(1) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.opaqueFBO) self.opaqueDEPTHtex = GL.glGenTextures(1) GL.glBindTexture(GL.GL_TEXTURE_2D, self.opaqueDEPTHtex) GL.glTexStorage2D( GL.GL_TEXTURE_2D, 1, GL.GL_DEPTH_COMPONENT32F, self.screen_size[0], self.screen_size[1]) GL.glFramebufferTexture( GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT, self.opaqueDEPTHtex, 0) GL.glBindTexture(GL.GL_TEXTURE_2D, 0) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
def swap_frame_buffer(self, slide=1, swap=True):
"""Switch buffers so we alternate which one we're rendering to."""
if swap:
self.usingA = not self.usingA
if self.usingA:
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbA);
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, self.textureA, 0);
else:
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbB);
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, self.textureB, 0);
# reset the geometry so we render to the whole image
gl.glViewport(-slide, 0, self.width, self.height)
def initializeGL(self):
"""Initialize OpenGL, VBOs, upload data on the GPU, etc."""
# background color
gl.glClearColor(0, 0, 0, 0)
vs = glhelpers.compile_vertex_shader(VS)
fs = glhelpers.compile_fragment_shader(FS)
self.shaders_program = glhelpers.link_shader_program(vs, fs)
vs_texture = glhelpers.compile_vertex_shader(VS_texture)
fs_texture = glhelpers.compile_fragment_shader(FS_texture)
self.shaders_program_texture = glhelpers.link_shader_program(vs_texture, fs_texture)
# create the texture
self.texture = gl.glGenTextures(1, ['sparkle'])
gl.glBindTexture(gl.GL_TEXTURE_2D, self.texture)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_LINEAR)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_LINEAR)
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S,
gl.GL_CLAMP_TO_EDGE)
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T,
gl.GL_CLAMP_TO_EDGE)
data = np.tile([255,0,255,0],(256, 256)).flatten()
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, 256, 256, 0,
gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, data)
self.fb = gl.glGenFramebuffers(1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fb);
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, self.texture, 0);
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0); # unbind the framebuffer
self.square = glvbo.VBO(
np.array( [
[ -2,-2, 0 ],
[ 2,-2, 0 ],
[ 2, 2, 0 ],
[ -2,-2, 0 ],
[ 2, 2, 0 ],
[ -2, 2, 0 ],
],'f') * 0.25
)
def toTexture(self, width=None, height=None): if width is None: width = self.width if height is None: height = self.height self.tex = gl.glGenTextures(1) gl.glBindTexture(gl.GL_TEXTURE_2D, self.tex) if self.empty: #create empty texture gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, width, height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, None) else: #use data buffer gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, width, height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, self.data) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glBindTexture(gl.GL_TEXTURE_2D, 0) #generate a frame-buffer as well self.fb = gl.glGenFramebuffers(1) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER,self.fb) gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER,gl.GL_COLOR_ATTACHMENT0,gl.GL_TEXTURE_2D,self.tex,0) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER,0)
def with_opengl_texture(cls,
debug = SETTINGS['debug'],
):
# see http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-14-render-to-texture/
# The framebuffer, which regroups 0, 1, or more textures, and 0 or 1 depth buffer.
FramebufferName = gl.GLuint(0)
gl.glGenFramebuffers(1, ctypes.byref(FramebufferName))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, FramebufferName)
# The texture we're going to render to
renderedTexture = gl.GLuint(0)
gl.glGenTextures(1, ctypes.byref(renderedTexture))
# "Bind" the newly created texture : all future texture functions will modify this texture
gl.glBindTexture(gl.GL_TEXTURE_2D, renderedTexture)
# Give an empty image to OpenGL ( the last "0" )
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, 1024, 768, 0,gl.GL_RGB, gl.GL_UNSIGNED_BYTE, 0)
# Poor filtering. Needed !
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST)
# Set "renderedTexture" as our colour attachement #0
gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, renderedTexture, 0);
# Set the list of draw buffers.
DrawBuffers = gl.GLenum * 1 #gl.GLenum DrawBuffers[1]
DrawBuffers[0] = gl.GL_COLOR_ATTACHMENT0 # = {gl.GL_COLOR_ATTACHMENT0};
gl.glDrawBuffers(1, DrawBuffers); # "1" is the size of DrawBuffers
return cls(width = w,
height = h,
constrain_aspect = constrain_aspect,
display_surface = surf,
run_mode = 'open_gltexture',
)
def _initFBO(self):
self.fboWidth = self.width
self.fboHeight = self.height
# Create three Render buffers. One for color one for XYZW one for depth_component
self.renderBuffers = GL.glGenRenderbuffers(3)
# initialize storage for the render buffers
for i in range(2):
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER,self.renderBuffers[i])
GL.glRenderbufferStorage(GL.GL_RENDERBUFFER,GL.GL_RGBA32F,self.fboWidth,self.fboHeight)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER,0)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER,self.renderBuffers[2])
GL.glRenderbufferStorage(GL.GL_RENDERBUFFER,GL.GL_DEPTH_COMPONENT,self.fboWidth,self.fboHeight)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER,0)
self.fbo = GL.glGenFramebuffers(1)
# bind buffer and populate with RenderBuffers
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER,self.fbo)
self.renderBufferAt = [GL.GL_COLOR_ATTACHMENT0,GL.GL_COLOR_ATTACHMENT1]
GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER,self.renderBufferAt[0],GL.GL_RENDERBUFFER,self.renderBuffers[0])
GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER,self.renderBufferAt[1],GL.GL_RENDERBUFFER,self.renderBuffers[1])
GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER,GL.GL_DEPTH_ATTACHMENT,GL.GL_RENDERBUFFER,self.renderBuffers[2])
# make sure that the new FBO is complete
status = GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER)
if status != GL.GL_FRAMEBUFFER_COMPLETE:
raise StandardError("Failed to properly setup FBO. OpenGL returned FBO status: ",status)
#unbind FBO
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER,0)
print "FBO initialized correctly."
def paintGL(self):
now = time.time()
if self.last_time is None:
decay = 1.0
else:
decay = np.exp((self.last_time - now) / self.decay_time)
decay = 0.9
self.last_time = now
# fade out the sparkle plot
self.fader.swap_frame_buffer()
self.fader.paint_faded(decay=decay)
while len(self.data) > 0:
data = self.data.pop()
self.spike_count += len(data)
# paint the spikes onto the sparkle plot
self.spiker.paint_spikes(data, scale=1)
# switch to rendering on the screen
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glViewport(0, 0, self.width, self.height)
# draw the sparkle plot on the screen
self.draw_texture.paint(self.fader.get_current_texture())
# print out spike rate
if now > self.t_last_msg + 1:
dt = now - self.t_last_msg
rate = self.spike_count * 0.000001 / dt
print 'Mspikes per second = %g' % rate
self.spike_count = 0
self.t_last_msg = now
# flag a redraw
self.update()
def _init_render(self):
"""
Initialize framebuffers to render offscreen, i.e. without displaying a
window
"""
# Framebuffer
self.fbo = gl.glGenFramebuffers(1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbo)
# Color renderbuffer
self.rbo_color = gl.glGenRenderbuffers(1)
gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, self.rbo_color)
gl.glRenderbufferStorage(gl.GL_RENDERBUFFER, gl.GL_RGBA8, self.width,
self.height)
gl.glFramebufferRenderbuffer(gl.GL_DRAW_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0,
gl.GL_RENDERBUFFER, self.rbo_color)
# Depth and stencil renderbuffer.
self.rbo_depth_stencil = gl.glGenRenderbuffers(1)
gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, self.rbo_depth_stencil)
gl.glRenderbufferStorage(gl.GL_RENDERBUFFER, gl.GL_DEPTH24_STENCIL8,
self.width, self.height)
gl.glFramebufferRenderbuffer(gl.GL_FRAMEBUFFER,
gl.GL_DEPTH_STENCIL_ATTACHMENT,
gl.GL_RENDERBUFFER,
self.rbo_depth_stencil)
gl.glDrawBuffer(gl.GL_COLOR_ATTACHMENT0)
gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT0)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbo)
# Sanity check
assert fbos.glCheckFramebufferStatusEXT(gl.GL_FRAMEBUFFER)
gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
def render_to_texture(texture):
fbo = GL.glGenFramebuffers(1)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, fbo)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0,
GL.GL_TEXTURE_2D, texture, 0)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, fbo)
yield
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
GL.glDeleteFramebuffers(1, numpy.array(fbo))
def unbind(self):
if len(RenderTarget.id_stack):
del RenderTarget.id_stack[-1]
if len(RenderTarget.id_stack) >= 1:
id = RenderTarget.id_stack[-1]
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, id)
else:
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def on_draw(self):
if self.started is False:
return
view = self.controller.getViewM()
self.shader.uniform_matrixf("viewM", view)
red,green,blue,alpha = 1,1,1,1
GL.glClearColor(red,green,blue,alpha)
if self.useFBO is True:
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER,self.fbo)
GL.glDrawBuffers(2,self.renderBufferAt)
self._draw() # Draw on the FBO
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER,0)
GL.glBindFramebuffer(GL.GL_READ_FRAMEBUFFER, self.fbo);
GL.glReadBuffer(GL.GL_COLOR_ATTACHMENT0); # read from FBO color0
GL.glBindFramebuffer(GL.GL_DRAW_FRAMEBUFFER, 0);
GL.glDrawBuffers((GL.GL_BACK,)) # write to window frame buffer color0
GL.glBlitFramebuffer(0,0,self.fboWidth,self.fboHeight,0,0,self.width,self.height,GL.GL_COLOR_BUFFER_BIT,GL.GL_LINEAR)
else:
self._draw()
def render():
global image
# Draw to the offscreen FBO
gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, fbo)
gl.glDrawBuffer(gl.GL_COLOR_ATTACHMENT0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4)
# Start to copy off to the pixel buffer; this will continue
# asynchronously with frame delay
gl.glBindBuffer(gl.GL_PIXEL_PACK_BUFFER, pb)
# Yes, you have to do glBufferData every time
gl.glBufferData(gl.GL_PIXEL_PACK_BUFFER, WINDOW_WIDTH * WINDOW_HEIGHT * 4,
ctypes.c_void_p(0), gl.GL_DYNAMIC_READ)
gl.glReadPixels(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, gl.GL_RGBA,
gl.GL_UNSIGNED_BYTE, ctypes.c_void_p(0))
# Copy from offscreen framebuffer to display framebuffer
gl.glBindFramebuffer(gl.GL_READ_FRAMEBUFFER, fbo)
gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, 0)
gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT0)
gl.glDrawBuffer(gl.GL_BACK_LEFT)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glBlitFramebuffer(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, 0, 0, WINDOW_WIDTH,
WINDOW_HEIGHT, gl.GL_COLOR_BUFFER_BIT, gl.GL_NEAREST)
# Now actually map to the pixel buffer and copy image data
image_data_p = ctypes.c_void_p(gl.glMapBuffer(gl.GL_PIXEL_PACK_BUFFER,
gl.GL_READ_ONLY))
image_data_ubyte_p = ctypes.cast(image_data_p,
ctypes.POINTER(ctypes.c_ubyte))
image = np.ctypeslib.as_array(image_data_ubyte_p, shape=(WINDOW_WIDTH,
WINDOW_HEIGHT, 4))
gl.glUnmapBuffer(gl.GL_PIXEL_PACK_BUFFER)
def gl_get_configuration():
"""
Read gl configuration independently of backends.
"""
import ctypes
import OpenGL.GL as gl
configuration = Configuration()
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
value = ctypes.c_int()
try:
gl.glGetFramebufferAttachmentParameteriv(
gl.GL_FRAMEBUFFER, gl.GL_FRONT_LEFT,
gl.GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE, value )
configuration._red_size = value.value
except:
log.warn("Cannot read RED channel size from the framebuffer")
configuration._red_size = 0
try:
gl.glGetFramebufferAttachmentParameteriv(
gl.GL_FRAMEBUFFER, gl.GL_FRONT_LEFT,
gl.GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE, value )
configuration._green_size = value.value
except:
log.warn("Cannot read GREEN channel size from the framebuffer")
configuration._green_size = 0
try:
gl.glGetFramebufferAttachmentParameteriv(
gl.GL_FRAMEBUFFER, gl.GL_FRONT_LEFT,
gl.GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE, value )
configuration._blue_size = value.value
except:
log.warn("Cannot read BLUE channel size from the framebuffer")
configuration._blue_size = 0
try:
gl.glGetFramebufferAttachmentParameteriv(
gl.GL_FRAMEBUFFER, gl.GL_FRONT_LEFT,
gl.GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, value )
configuration._alpha_size = value.value
except:
log.warn("Cannot read ALPHA channel size from the framebuffer")
configuration._alpha_size = 0
try:
gl.glGetFramebufferAttachmentParameteriv(
gl.GL_FRAMEBUFFER, gl.GL_DEPTH,
gl.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, value )
configuration._depth_size = value.value
except:
log.warn("Cannot read DEPTH size from the framebuffer")
configuration._depth_size = 0
try:
gl.glGetFramebufferAttachmentParameteriv(
gl.GL_FRAMEBUFFER, gl.GL_STENCIL,
gl.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, value )
configuration._stencil_size = value.value
except:
log.warn("Cannot read STENCIL size from the framebuffer")
configuration._stencil_size = 0
try:
gl.glGetFramebufferAttachmentParameteriv(
gl.GL_FRAMEBUFFER, gl.GL_FRONT_LEFT,
gl.GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, value )
if value.value == gl.GL_LINEAR:
configuration._srgb = False
elif value.value == gl.GL_SRGB:
configuration._srgb = True
except:
log.warn("Cannot read sRGB value from the framebuffer")
configuration._srgb = False
configuration._stereo = gl.glGetInteger(gl.GL_STEREO)
configuration._double_buffer = gl.glGetInteger(gl.GL_DOUBLEBUFFER)
configuration._samples = gl.glGetInteger(gl.GL_SAMPLES)
# Dumb parsing of the GL_VERSION string
version = gl.glGetString(gl.GL_VERSION)
version = version.split(" ")[0]
major,minor = version.split('.')[:2]
configuration._version = version
configuration._major_version = int(major)
configuration._minor_version = int(minor)
configuration._profile = "unknown"
return configuration
createBufferTexture(textureID[1], texw, texh)
createBufferTexture(textureID[2], texw, texh)
fboID = gl.glGenFramebuffers(1)
programObj0 = createShader("vertex.glsl", "fragment_seed.glsl")
programObj1 = createShader("vertex.glsl", "fragment_flood.glsl")
programObj2 = createShader("vertex.glsl", "fragment_display.glsl")
glfw.glfwSwapInterval(0)
running = True
while running:
showFPS(texw, texh)
if not useShaders:
gl.glBindTexture(gl.GL_TEXTURE_2D, textureID[0]) # Pass-through
else:
setUniformVariables(programObj0, 0, texw, texh, 0)
gl.glBindTexture(gl.GL_TEXTURE_2D, textureID[0])
gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, fboID)
lastRendered = 1
gl.glFramebufferTexture2D(gl.GL_DRAW_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D,
textureID[lastRendered], 0)
renderScene(programObj0, texw, texh)
stepsize = texw//2 if texw > texh else texh//2
while stepsize > 0:
setUniformVariables(programObj1, 0, texw, texh, stepsize)
gl.glBindTexture(gl.GL_TEXTURE_2D, textureID[lastRendered])
lastRendered = 1 if lastRendered == 2 else 2
gl.glFramebufferTexture2D(gl.GL_DRAW_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D,
textureID[lastRendered], 0)
def initializeGL(self):
"""Initialize OpenGL, VBOs, upload data on the GPU, etc."""
# background color
gl.glClearColor(0, 0, 0, 0)
vs = glhelpers.compile_vertex_shader(VS)
fs = glhelpers.compile_fragment_shader(FS)
self.shaders_program = glhelpers.link_shader_program(vs, fs)
vs_fade = glhelpers.compile_vertex_shader(VS_fade)
fs_fade = glhelpers.compile_fragment_shader(FS_fade)
self.shaders_program_fade = glhelpers.link_shader_program(vs_fade, fs_fade)
self.fade_texture1 = gl.glGetUniformLocation(self.shaders_program_fade, 'texture1')
self.fade_decay = gl.glGetUniformLocation(self.shaders_program_fade, 'decay')
# create the texture
self.textureA = gl.glGenTextures(1, ['sparkleA'])
gl.glBindTexture(gl.GL_TEXTURE_2D, self.textureA)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S,
gl.GL_CLAMP_TO_EDGE)
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T,
gl.GL_CLAMP_TO_EDGE)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, sparkle_width, sparkle_height, 0,
gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, None)
self.fbA = gl.glGenFramebuffers(1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbA);
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, self.textureA, 0);
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0); # unbind the framebuffer
# create the texture
self.textureB = gl.glGenTextures(1, ['sparkleB'])
gl.glBindTexture(gl.GL_TEXTURE_2D, self.textureB)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S,
gl.GL_CLAMP_TO_EDGE)
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T,
gl.GL_CLAMP_TO_EDGE)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, sparkle_width, sparkle_height, 0,
gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, None)
self.fbB = gl.glGenFramebuffers(1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbB);
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, self.textureA, 0);
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0); # unbind the framebuffer
self.square = glvbo.VBO(
np.array( [
[ -1,-1, 0, 0, 0 ],
[ 1,-1, 0, 1, 0 ],
[ 1, 1, 0, 1, 1 ],
[ -1,-1, 0, 0, 0 ],
[ 1, 1, 0, 1, 1 ],
[ -1, 1, 0, 0, 1 ],
],'f')
)
def paintGL(self):
"""Paint the scene."""
if self.usingA:
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbA);
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, self.textureA, 0);
else:
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbB);
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, self.textureB, 0);
gl.glViewport(0, 0, sparkle_width, sparkle_height)
# clear the buffer
#gl.glClearColor(255, 0, 0, 0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT + gl.GL_DEPTH_BUFFER_BIT)
gl.glEnableVertexAttribArray(0)
gl.glUseProgram(self.shaders_program_fade)
gl.glUniform1i(self.fade_texture1, 0) # use GL_TEXTURE0
gl.glUniform1f(self.fade_decay, decay_rate)
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glActiveTexture(gl.GL_TEXTURE0)
if self.usingA:
gl.glBindTexture(gl.GL_TEXTURE_2D, self.textureB)
else:
gl.glBindTexture(gl.GL_TEXTURE_2D, self.textureA)
self.square.bind()
gl.glEnableClientState(gl.GL_VERTEX_ARRAY);
gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY);
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT,
gl.GL_FALSE, 5*4, None)
gl.glTexCoordPointer(2, gl.GL_FLOAT, 5*4, self.square + 3*4)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)
data = np.random.randint(sparkle_width * sparkle_height, size=spikes_per_frame)
vbo = glvbo.VBO(data)
vbo.bind()
self.spike_count += len(data)
# tell OpenGL that the VBO contains an array of vertices
# prepare the shader
gl.glEnableVertexAttribArray(0)
# identify what's in the array
gl.glVertexAttribPointer(0, 1, gl.GL_UNSIGNED_INT,
gl.GL_FALSE, 0, None)
gl.glUseProgram(self.shaders_program)
# draw "count" points from the VBO
gl.glDrawArrays(gl.GL_POINTS, 0, len(data))
gl.glUseProgram(0)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) # unbind the framebuffer
gl.glViewport(0, 0, self.width, self.height)
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glActiveTexture(gl.GL_TEXTURE0)
if self.usingA:
gl.glBindTexture(gl.GL_TEXTURE_2D, self.textureA)
else:
gl.glBindTexture(gl.GL_TEXTURE_2D, self.textureB)
self.square.bind()
gl.glEnableClientState(gl.GL_VERTEX_ARRAY);
gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY);
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT,
gl.GL_FALSE, 5*4, None)
gl.glTexCoordPointer(2, gl.GL_FLOAT, 5*4, self.square + 3*4)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)
self.usingA = not self.usingA
now = time.time()
if now > self.t_last_msg + 1:
dt = now - self.t_last_msg
print 'Mspikes per second = %1.1f' % (self.spike_count*0.000001/dt)
self.spike_count = 0
self.t_last_msg = now
# flag a redraw
self.update()
def unbind(self):
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def gl_init_routine():
global program
global fbo
global rb
global pb
global image
# Compile and link shaders
vert_shader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
frag_shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
with open('surface_vert.glsl') as f:
vert_shader_text = f.read()
with open('surface_frag.glsl') as f:
frag_shader_text = f.read()
gl.glShaderSource(vert_shader, vert_shader_text)
gl.glShaderSource(frag_shader, frag_shader_text)
gl.glCompileShader(vert_shader)
gl.glCompileShader(frag_shader)
if not gl.glGetShaderiv(vert_shader, gl.GL_COMPILE_STATUS):
print("Vertex shader did not compile")
return False
if not gl.glGetShaderiv(frag_shader, gl.GL_COMPILE_STATUS):
print("Fragment shader did not compile")
return False
program = gl.glCreateProgram()
gl.glAttachShader(program, vert_shader)
gl.glAttachShader(program, frag_shader)
gl.glLinkProgram(program)
gl.glDetachShader(program, vert_shader)
gl.glDetachShader(program, frag_shader)
gl.glUseProgram(program)
if not gl.glGetProgramiv(program, gl.GL_LINK_STATUS):
print("Shader not linked")
return False
# Create and bind buffers
# Vertex data buffer
vert_dtype = np.dtype([('position', np.float32, 2)])
data = np.zeros(4, dtype=vert_dtype)
data['position'] = [(-1, -1), (-1, 1), (1, -1), (1, 1)]
stride = data.strides[0]
# vb is the vertex buffer
vb, pb = gl.glGenBuffers(2)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vb)
gl.glBufferData(gl.GL_ARRAY_BUFFER, data.nbytes, data, gl.GL_DYNAMIC_DRAW)
offset = ctypes.c_void_p(0)
loc = gl.glGetAttribLocation(program, 'position')
gl.glEnableVertexAttribArray(loc)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vb)
gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, stride, offset)
# Offscreen framebuffer for OpenCV
fbo = gl.glGenFramebuffers(1)
rb = gl.glGenRenderbuffers(1)
gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, rb)
gl.glRenderbufferStorage(gl.GL_RENDERBUFFER, gl.GL_RGBA8, WINDOW_WIDTH,
WINDOW_HEIGHT)
gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, fbo)
gl.glFramebufferRenderbuffer(gl.GL_DRAW_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0, gl.GL_RENDERBUFFER, rb)
return True
