def copy_texture_to_screen():
# select the target to draw into
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glViewport(0, 0, window.width, window.height)
# clear the destination
gl.glClearColor(0.4, 0.4, 0.4, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# select the program for drawing
gl.glUseProgram(copy_program)
# send the vertex data
data = (TEXTURE_VERTEX * 8)(
((-0.9, -0.9), (0.0, 0.0)),
((0.5, -0.9), (1.0, 0.0)),
((0.5, 0.5), (1.0, 1.0)),
((-0.9, 0.5), (0.0, 1.0)),
((0.6, 0.6), (0.0, 1.0)),
((1.0, 0.6), (1.0, 1.0)),
((1.0, 1.0), (1.0, 0.0)),
((0.6, 1.0), (0.0, 0.0)),
)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, copy_vertexbuffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(data), data,
gl.GL_DYNAMIC_DRAW)
# draw
gl.glBindVertexArray(copy_vao)
gl.glDrawArrays(gl.GL_QUADS, 0, 8)
gl.glBindVertexArray(0)
def setup_framebuffer():
gl.glGenFramebuffers(1, ctypes.byref(framebuffer))
gl.glGenTextures(1, ctypes.byref(input_texture))
gl.glGenTextures(1, ctypes.byref(rendered_texture))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, framebuffer)
# Set up the input texture
gl.glBindTexture(gl.GL_TEXTURE_3D, input_texture)
gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_WRAP_S,
gl.GL_CLAMP_TO_EDGE)
gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_WRAP_T,
gl.GL_CLAMP_TO_EDGE)
gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_WRAP_R,
gl.GL_CLAMP_TO_EDGE)
# Set up the render target texture
gl.glBindTexture(gl.GL_TEXTURE_3D, rendered_texture)
gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
def render(self):
gl.glUseProgram(self.programA)
for i in range(args["resolution"]):
gl.glUniform1i(self.slice_pos, i)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebufferA0[i])
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)
def build_buffer():
buffer = gl.GLuint(0)
gl.glGenFramebuffers(1, ctypes.byref(buffer))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, buffer)
texture = gl.GLuint(0)
gl.glGenTextures(1, ctypes.byref(texture))
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, BUF_WIDTH, BUF_HEIGHT, 0,
gl.GL_RGBA, gl.GL_FLOAT, 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.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, texture, 0)
if (gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) !=
gl.GL_FRAMEBUFFER_COMPLETE):
raise RuntimeError('Framebuffer incomplete !')
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glBindTexture(gl.GL_TEXTURE_2D, 0)
gl.glDisable(gl.GL_TEXTURE_2D)
return buffer, texture
def own_render(environment, img):
if environment.window is None:
config = gl.Config(double_buffer=False)
environment.window = window.Window(width=WINDOW_WIDTH,
height=WINDOW_HEIGHT,
resizable=False,
config=config)
environment.window.clear()
environment.window.switch_to()
environment.window.dispatch_events()
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
gl.glOrtho(0, WINDOW_WIDTH, 0, WINDOW_HEIGHT, 0, 10)
width = img.shape[1]
height = img.shape[0]
img = np.ascontiguousarray(np.flip(img, axis=0))
img_data = image.ImageData(
width,
height,
'RGB',
img.ctypes.data_as(POINTER(gl.GLubyte)),
pitch=width * 3,
)
img_data.blit(0, 0, 0, width=WINDOW_WIDTH, height=WINDOW_HEIGHT)
x, y, z = environment.cur_pos
environment.text_label.text = "pos: (%.2f, %.2f, %.2f), angle: %d, steps: %d, speed: %.2f m/s" % (
x, y, z, int(environment.cur_angle * 180 / math.pi),
environment.step_count, environment.speed)
environment.text_label.draw()
gl.glFlush()
def render_to_texture():
# select the target to draw into
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, framebuffer)
draw_buffers = (gl.GLenum * 1)(gl.GL_COLOR_ATTACHMENT0)
gl.glDrawBuffers(1, draw_buffers)
gl.glViewport(0, 0, FB_WIDTH, FB_HEIGHT)
# clear the destination
gl.glClearColor(0.5, 0.6, 0.7, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# prepare the rendering
gl.glUseProgram(render_program)
# send the vertex data
data = (COLOR_VERTEX * 3)(((-0.6, -0.5), (1.0, 0.0, 0.0, 1.0)),
((0.6, -0.5), (0.0, 1.0, 0.0, 1.0)),
((0.0, 0.5), (0.0, 0.0, 1.0, 1.0)))
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, render_vertexbuffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(data), data, gl.GL_DYNAMIC_DRAW)
# draw using the vertex array for vertex information
gl.glBindVertexArray(render_vao)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3)
gl.glBindVertexArray(0)
def copy_texture_to_screen():
# select the target to draw into
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glViewport(0, 0, window.width, window.height)
# clear the destination
gl.glClearColor(0.4, 0.4, 0.4, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# select the program for drawing
gl.glUseProgram(copy_program)
# send the vertex data
data = (TEXTURE_VERTEX * 8)(((-0.9, -0.9), (0.0, 0.0)),
((0.5, -0.9), (1.0, 0.0)),
((0.5, 0.5), (1.0, 1.0)),
((-0.9, 0.5), (0.0, 1.0)),
((0.6, 0.6), (0.0, 1.0)),
((1.0, 0.6), (1.0, 1.0)),
((1.0, 1.0), (1.0, 0.0)),
((0.6, 1.0), (0.0, 0.0)),
)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, copy_vertexbuffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(data), data, gl.GL_DYNAMIC_DRAW)
# draw
gl.glBindVertexArray(copy_vao)
gl.glDrawArrays(gl.GL_QUADS, 0, 8)
gl.glBindVertexArray(0)
def __init__(self, width, height, wwidth, wheight):
self.width = width
self.height = height
self.windowwidth = wwidth
self.windowheight = wheight
self.framebuffer = gl.GLuint(0)
self.rendered_texture = Texture()
gl.glGenFramebuffers(1, ctypes.byref(self.framebuffer))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebuffer)
# Set up the texture as the target for color output
with self.rendered_texture:
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA32F, self.width,
self.height, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, 0)
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.glFramebufferTexture2D(gl.GL_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D,
self.rendered_texture.name, 0)
if gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER) != gl.GL_FRAMEBUFFER_COMPLETE:
raise ValueError('Framebuffer not set up completely')
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def setupFBOandTextures(self):
self.framebufferA0 = (gl.GLuint * args["resolution"])()
self.A0_tex = gl.GLuint(0)
self.draw_buffersA0 = (gl.GLenum * args["resolution"])(
gl.GL_COLOR_ATTACHMENT0)
gl.glGenFramebuffers(args["resolution"], self.framebufferA0)
gl.glGenTextures(1, ctypes.byref(self.A0_tex))
#create textures
#A
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBindTexture(gl.GL_TEXTURE_3D, self.A0_tex)
gl.glTexImage3D(gl.GL_TEXTURE_3D, 0, gl.GL_RED, args["resolution"],
args["resolution"], args["resolution"], 0,
gl.GL_RED, gl.GL_FLOAT, 0)
gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_LINEAR)
gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_LINEAR)
#A
for i in range(args["resolution"]):
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebufferA0[i])
gl.glFramebufferTexture3D(gl.GL_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_3D, self.A0_tex, 0, i)
assert (gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE)
def render_to_texture():
# select the target to draw into
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, framebuffer)
draw_buffers = (gl.GLenum * 1)(gl.GL_COLOR_ATTACHMENT0)
gl.glDrawBuffers(1, draw_buffers)
gl.glViewport(0, 0, FB_WIDTH, FB_HEIGHT)
# clear the destination
gl.glClearColor(0.5, 0.6, 0.7, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# prepare the rendering
gl.glUseProgram(render_program)
# send the vertex data
data = (COLOR_VERTEX * 3)(((-0.6, -0.5), (1.0, 0.0, 0.0, 1.0)),
((0.6, -0.5), (0.0, 1.0, 0.0, 1.0)),
((0.0, 0.5), (0.0, 0.0, 1.0, 1.0)))
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, render_vertexbuffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(data), data,
gl.GL_DYNAMIC_DRAW)
# draw using the vertex array for vertex information
gl.glBindVertexArray(render_vao)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3)
gl.glBindVertexArray(0)
def __init__(self):
self.fbo = gl.GLuint(0)
self.rendered_texture = gl.GLuint(0)
self.depthrenderbuffer = gl.GLuint(0)
self.pickingbuffer = gl.GLuint(0)
self.vertex_buffer = gl.GLuint(0)
self.program = GlProgram(shaders.vertex_copy, shaders.fragment_copy)
gl.glGenBuffers(1, pointer(self.vertex_buffer))
data = (gl.GLfloat * 16)(-1, -1, 0, 0,
- 1, 1, 0, 1,
1, 1, 1, 1,
1, -1, 1, 0)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vertex_buffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, sizeof(data), data, gl.GL_STATIC_DRAW)
gl.glGenFramebuffers(1, pointer(self.fbo))
if not self.fbo:
logging.error('failed fbo')
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbo)
gl.glGenTextures(1, pointer(self.rendered_texture))
if not self.rendered_texture:
logging.error('failed rendered_texture')
gl.glGenRenderbuffers(1, pointer(self.depthrenderbuffer))
gl.glGenRenderbuffers(1, pointer(self.pickingbuffer))
self.resize(1, 1)
def render(self):
gl.glUseProgram(self.programA)
gl.glUniform1i(self.tex_pos_A, 0)
for i in range(self.dimz):
gl.glUniform1i(self.slice_pos_A, i)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebufferA0[i])
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)
def __init__(self,
width,
height,
window,
num_color_attachments=1,
mapping_mode=None,
provide_depth=False,
provide_stencil=False):
""""Create an arbitrary layer framebuffer, I'll add stencil and depthbuffers if I ever package this for resuse, in pyweek, those args are pretty much placeholders"""
if mapping_mode is None:
mapping_mode = gl.GL_NEAREST
assert not provide_stencil, 'stencil buffer not implemented'
assert not provide_depth, 'depth buffer not implemented'
self.window = window
self.width = width
self.height = height
self.bufferId = gl.GLuint(0)
self.textureIds = []
self.buffer_args = []
#create the vram objects?
gl.glGenFramebuffers(1, rf(self.bufferId))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.bufferId)
for bufferIndex in range(num_color_attachments):
newTex = gl.GLuint(0)
gl.glGenTextures(1, rf(newTex))
self.textureIds.append(newTex)
gl.glBindTexture(gl.GL_TEXTURE_2D, newTex)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, width, height, 0,
gl.GL_RGB, gl.GL_UNSIGNED_INT, 0)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
mapping_mode)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
mapping_mode)
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0 + bufferIndex,
gl.GL_TEXTURE_2D, newTex, 0)
self.buffer_args.append(gl.GL_COLOR_ATTACHMENT0 + bufferIndex)
#assign one of the vram objects to the framebuffer cache?
if provide_depth:
self.buffer_args.append(gl.GL_DEPTH_ATTACHMENT)
if provide_stencil:
self.buffer_args.append(gl.GL_STENCIL_ATTACHMENT)
self.buffers_provided = (gl.GLenum *
len(self.buffer_args))(*self.buffer_args)
gl.glDrawBuffers(len(self.buffer_args), self.buffers_provided)
self.textures = [
Texture(self.width, self.height, gl.GL_TEXTURE_2D, texId.value)
for texId in self.textureIds
]
assert gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER
) == gl.GL_FRAMEBUFFER_COMPLETE, "I don't know why this happened, but at least I can find out"
def blit_fbo(width, height, src_id, target_id, target_image=gl.GL_BACK):
# For drawing a multisampled FBO to a non-multisampled FBO or to the
# screen. See
# https://www.khronos.org/opengl/wiki/Multisampling#Allocating_a_Multisample_Render_Target
gl.glBindFramebuffer(gl.GL_READ_FRAMEBUFFER, src_id)
gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, target_id)
gl.glDrawBuffer(target_image)
gl.glBlitFramebuffer(0, 0, width, height, 0, 0, width, height,
gl.GL_COLOR_BUFFER_BIT, gl.GL_NEAREST)
def draw_to_buffer():
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, buffer)
set_viewport(BUF_WIDTH, BUF_HEIGHT)
clear(1, 0, 0)
pyglet.graphics.draw_indexed(4, gl.GL_TRIANGLES, [0, 1, 2, 2, 1, 3],
('v2i', (0, 25, 25, 50, 25, 0, 50, 25)),
('c3f', (0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1)))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def createFramebuffer(width, height):
"""Function for setting up additional buffer"""
# create a new framebuffer
fboId = GL.GLuint()
GL.glGenFramebuffers(1, ctypes.byref(fboId))
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, fboId)
# create a texture to render to, required for warping
texId = GL.GLuint()
GL.glGenTextures(1, ctypes.byref(texId))
GL.glBindTexture(GL.GL_TEXTURE_2D, texId)
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_RGBA32F_ARB,
int(width), int(height), 0,
GL.GL_RGBA, GL.GL_FLOAT, None)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER,
GL.GL_COLOR_ATTACHMENT0,
GL.GL_TEXTURE_2D,
texId,
0)
# create a render buffer
rbId = GL.GLuint()
GL.glGenRenderbuffers(1, ctypes.byref(rbId))
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, rbId)
GL.glRenderbufferStorage(
GL.GL_RENDERBUFFER,
GL.GL_DEPTH24_STENCIL8,
int(width),
int(height))
GL.glFramebufferRenderbuffer(
GL.GL_FRAMEBUFFER,
GL.GL_DEPTH_ATTACHMENT,
GL.GL_RENDERBUFFER,
rbId)
GL.glFramebufferRenderbuffer(
GL.GL_FRAMEBUFFER,
GL.GL_STENCIL_ATTACHMENT,
GL.GL_RENDERBUFFER,
rbId)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, 0)
# clear the buffer
GL.glClear(GL.GL_COLOR_BUFFER_BIT)
GL.glClear(GL.GL_STENCIL_BUFFER_BIT)
GL.glClear(GL.GL_DEPTH_BUFFER_BIT)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
return fboId, texId, rbId
def copy(self):
''' copy the contents of the texture to full window '''
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
self.program.use()
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.rendered_texture)
self.program.uniform1i(b"tex", 0)
self.program.vertex_attrib_pointer(self.vertex_buffer, b"position", 4, stride=4 * sizeof(gl.GLfloat))
gl.glDrawArrays(gl.GL_QUADS, 0, 4)
def _use(self):
"""Internal use that do not change the global active framebuffer"""
if self.ctx.active_framebuffer == self:
return
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self._glo)
# NOTE: gl.glDrawBuffer(GL_NONE) if no texture attachments (future)
# NOTE: Default framebuffer currently has this set to None
if self._draw_buffers:
gl.glDrawBuffers(len(self._draw_buffers), self._draw_buffers)
gl.glDepthMask(self._depth_mask)
gl.glViewport(*self._viewport)
def cleanUP(self):
a = (gl.GLfloat * (args["resolution"]**3))()
gl.glBindTexture(gl.GL_TEXTURE_3D, self.A0_tex)
gl.glGetTexImage(gl.GL_TEXTURE_3D, 0, gl.GL_RED, gl.GL_FLOAT, a)
#self.flip() # This updates the screen, very much important.
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
bufA = np.frombuffer(a, dtype=np.float32)
bufA = bufA.reshape(
(args["resolution"], args["resolution"], args["resolution"]))
#consider casting to float64
args["Aout"] = bufA
def __init__(self, width, height):
self.fbo = gl.GLuint(0)
gl.glGenFramebuffers(1, ctypes.byref(self.fbo))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbo)
self.texture = pyglet.image.Texture.create(width, height)
gl.glBindTexture(self.texture.target, 0)
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, self.texture.id, 0)
draw_buffers = (gl.GLenum * 1)(gl.GL_COLOR_ATTACHMENT0)
gl.glDrawBuffers(1, draw_buffers)
assert gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def render(self, mode='human', close=False):
if close:
if self.window:
self.window.close()
return
if mode == 'rgb_array':
return self.img
import pyglet
from pyglet import gl
if self.window is None:
context = pyglet.gl.get_current_context()
self.window = pyglet.window.Window(
width=WINDOW_WIDTH,
height=WINDOW_HEIGHT
)
self.window.switch_to()
self.window.dispatch_events()
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT)
self.window.clear()
# Setup orghogonal projection
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
gl.glOrtho(0, WINDOW_WIDTH, 0, WINDOW_HEIGHT, 0, 10)
# Draw the image to the rendering window
width = self.img.shape[1]
height = self.img.shape[0]
imgData = pyglet.image.ImageData(
width,
height,
'RGB',
self.img.tobytes(),
pitch = width * 3,
)
imgData.blit(0, 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT)
if mode == 'human':
self.window.flip()
def setup_framebuffer():
gl.glGenFramebuffers(1, ctypes.byref(framebuffer))
gl.glGenTextures(1, ctypes.byref(rendered_texture))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, framebuffer)
# Set up the texture as the target for color output
gl.glBindTexture(gl.GL_TEXTURE_2D, rendered_texture)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, FB_WIDTH, FB_HEIGHT, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, 0)
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.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, rendered_texture, 0)
draw_buffers = (gl.GLenum * 1)(gl.GL_COLOR_ATTACHMENT0)
gl.glDrawBuffers(1, draw_buffers)
assert gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE
def useFBO(fbo):
"""Context manager for Framebuffer Object bindings. This function yields
the framebuffer name as an integer.
Parameters
----------
fbo :obj:`int` or :obj:`Framebuffer`
OpenGL Framebuffer Object name/ID or descriptor.
Yields
-------
int
OpenGL name of the framebuffer bound in the context.
Returns
-------
None
Examples
--------
# FBO bound somewhere deep in our code
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, someOtherFBO)
...
# create a new FBO, but we have no idea what the currently bound FBO is
fbo = createFBO()
# use a context to bind attachments
with bindFBO(fbo):
attach(GL.GL_COLOR_ATTACHMENT0, colorTex)
attach(GL.GL_DEPTH_ATTACHMENT, depthRb)
attach(GL.GL_STENCIL_ATTACHMENT, depthRb)
isComplete = gltools.isComplete()
# someOtherFBO is still bound!
"""
prevFBO = GL.GLint()
GL.glGetIntegerv(GL.GL_FRAMEBUFFER_BINDING, ctypes.byref(prevFBO))
toBind = fbo.id if isinstance(fbo, Framebuffer) else int(fbo)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, toBind)
try:
yield toBind
finally:
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, prevFBO.value)
def __init__(self, width, height):
self.fbo = gl.GLuint(0)
gl.glGenFramebuffers(1, ctypes.byref(self.fbo))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbo)
self.texture = pyglet.image.Texture.create(width, height)
gl.glBindTexture(self.texture.target, 0)
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, self.texture.id, 0)
draw_buffers = (gl.GLenum * 1)(gl.GL_COLOR_ATTACHMENT0)
gl.glDrawBuffers(1, draw_buffers)
assert gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def cleanUP(self):
a = (gl.GLfloat * (self.dimx * self.dimy * self.dimz))()
#need a new way to read out pixels
#gl.glReadPixels(0, 0, self.dimx, self.dimy , gl.GL_RGBA, gl.GL_FLOAT, b)
#gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebufferA1);
#gl.glReadPixels(0, 0, self.dimx, self.dimy , gl.GL_RGBA, gl.GL_FLOAT, a)
gl.glBindTexture(gl.GL_TEXTURE_3D, self.A1_tex)
gl.glGetTexImage(gl.GL_TEXTURE_3D, 0, gl.GL_RED, gl.GL_FLOAT, a)
#self.flip() # This updates the screen, very much important.
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
bufA = np.frombuffer(a, dtype=np.float32)
bufA = bufA.reshape(args["A"].shape)
#consider casting to float64
args["Aout"] = bufA
def __init__(self,
size: Tuple[int, int],
textures: Dict[str, Texture] = {},
depth_unit: int = None,
autoclear: bool = False,
set_viewport: bool = False):
self.name = gl.GLuint()
self.size = w, h = size
self.autoclear = autoclear
self.set_viewport = set_viewport
gl.glCreateFramebuffers(1, byref(self.name))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.name)
# Create textures that we can use to read the results.
self.textures = {}
draw_attachments = []
max_unit = 0
for name, texture in textures.items():
self.textures[name] = texture
attachment = gl.GL_COLOR_ATTACHMENT0 + texture.unit
gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, attachment,
texture.name, 0)
draw_attachments.append(attachment)
max_unit = max(max_unit, texture.unit)
# Setup a depth buffer (presumably we always want that)
depth_unit = depth_unit if depth_unit is not None else max_unit + 1
self.textures["depth"] = depth_texture = DepthTexture(self.size,
unit=depth_unit)
gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT,
depth_texture.name, 0)
# Setup draw buffers and connect them to the textures.
self.draw_buffers = (gl.GLenum * len(textures))(*draw_attachments)
gl.glDrawBuffers(len(self.draw_buffers), self.draw_buffers)
# Check that it all went smoothly
assert (gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE
), "Could not setup framebuffer!"
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def _setup(self):
self.name = gl.GLuint()
gl.glCreateFramebuffers(1, byref(self.name))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.name)
self.cubemap_texture = gl.GLuint()
gl.glGenTextures(gl.GL_TEXTURE_CUBE_MAP, byref(self.name))
gl.glBindTexture(gl.GL_TEXTURE_CUBE_MAP, self.cubemap_texture)
w, h = self.size
# initialize the texture (IMPORTANT!!!)
for i in range(6):
gl.glTexImage2D(gl.GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0,
gl.GL_DEPTH_COMPONENT, w, h, 0,
gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT, 0)
gl.glFramebufferTexture2D(gl.GL_DRAW_FRAMEBUFFER,
gl.GL_DEPTH_ATTACHMENT,
gl.GL_TEXTURE_CUBE_MAP_POSITIVE_X,
self.cubemap_texture, 0)
gl.glTexParameteri(gl.GL_TEXTURE_CUBE_MAP, gl.GL_TEXTURE_BASE_LEVEL, 0)
gl.glTexParameteri(gl.GL_TEXTURE_CUBE_MAP, gl.GL_TEXTURE_MAX_LEVEL, 0)
gl.glTexParameteri(gl.GL_TEXTURE_CUBE_MAP, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_LINEAR)
gl.glTexParameteri(gl.GL_TEXTURE_CUBE_MAP, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_LINEAR)
gl.glTexParameteri(gl.GL_TEXTURE_CUBE_MAP, gl.GL_TEXTURE_WRAP_S,
gl.GL_CLAMP_TO_EDGE)
gl.glTexParameteri(gl.GL_TEXTURE_CUBE_MAP, gl.GL_TEXTURE_WRAP_T,
gl.GL_CLAMP_TO_EDGE)
gl.glTexParameteri(gl.GL_TEXTURE_CUBE_MAP, gl.GL_TEXTURE_WRAP_R,
gl.GL_CLAMP_TO_EDGE)
gl.glTexParameteri(gl.GL_TEXTURE_CUBE_MAP, gl.GL_DEPTH_TEXTURE_MODE,
gl.GL_LUMINANCE)
gl.glBindTexture(gl.GL_TEXTURE_CUBE_MAP, 0)
status = gl.glCheckFramebufferStatus(gl.GL_DRAW_FRAMEBUFFER)
assert status == gl.GL_FRAMEBUFFER_COMPLETE, f"Could not setup framebuffer! {status}"
def cleanUP(self):
a = (gl.GLint * (self.dimx * self.dimy * 4))()
b = (gl.GLint * (self.dimx * self.dimy * 4))()
gl.glReadPixels(0, 0, self.dimx, self.dimy, gl.GL_RGBA,
gl.GL_FLOAT, b)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebufferA1)
gl.glReadPixels(0, 0, self.dimx, self.dimy, gl.GL_RGBA,
gl.GL_FLOAT, a)
#self.flip() # This updates the screen, very much important.
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
bufA = np.frombuffer(b, dtype=np.float32)
bufB = np.frombuffer(b, dtype=np.float32)
bufA = bufA.reshape(args["A"].shape)
bufB = bufB.reshape(args["B"].shape)
#consider casting to float64
args["Bout"] = bufB
args["Aout"] = bufA
def render_to_texture(in_size, out_size, view_z=None):
z0, z1 = (0, in_size[2]) if view_z == None else view_z
vertices = (VERTEX * 6)(((-1, -1), (0, 0)), ((1, -1), (1, 0)),
((1, 1), (1, 1)), ((1, 1), (1, 1)),
((-1, 1), (0, 1)), ((-1, -1), (0, 0)))
gl.glBindTexture(gl.GL_TEXTURE_3D, rendered_texture)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, framebuffer)
draw_buffers = (gl.GLenum * 1)(gl.GL_COLOR_ATTACHMENT0)
gl.glDrawBuffers(1, draw_buffers)
gl.glViewport(0, 0, out_size[0], out_size[1])
gl.glUseProgram(render_program)
loc_depth = gl.glGetUniformLocation(render_program,
ctypes.create_string_buffer(b'depth'))
loc_texelSize = gl.glGetUniformLocation(
render_program, ctypes.create_string_buffer(b'texelSize'))
gl.glUniform3f(loc_texelSize, 1 / in_size[0], 1 / in_size[1],
1 / in_size[2])
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, render_vertexbuffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(vertices), vertices,
gl.GL_DYNAMIC_DRAW)
gl.glBindVertexArray(render_vao)
gl.glClearColor(0.0, 0.0, 0.0, 0.0)
for z in range(out_size[2]):
gl.glFramebufferTexture3D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_3D, rendered_texture, 0, z)
fbs = gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER)
assert fbs == gl.GL_FRAMEBUFFER_COMPLETE, 'FramebufferStatus is {}'.format(
fbs)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glUniform1f(loc_depth,
(z0 + z * (z1 - z0)) / in_size[2] / out_size[2])
gl.glBindTexture(gl.GL_TEXTURE_3D, input_texture)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)
if z % 10 == 0:
gl.glFinish()
print('\033[K{}/{}'.format(z, out_size[2] - 1), end='\r')
gl.glFinish()
gl.glBindVertexArray(0)
def resize(self, width, height):
''' resizes the framebuffer to the given dimensions '''
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbo)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.rendered_texture)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, width, height, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, 0)
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.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, self.rendered_texture, 0)
gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, self.depthrenderbuffer)
gl.glRenderbufferStorage(gl.GL_RENDERBUFFER, gl.GL_DEPTH_COMPONENT, width, height)
gl.glFramebufferRenderbuffer(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT, gl.GL_RENDERBUFFER, self.depthrenderbuffer)
gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, self.pickingbuffer)
gl.glRenderbufferStorage(gl.GL_RENDERBUFFER, gl.GL_R16UI, width, height)
gl.glFramebufferRenderbuffer(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT1, gl.GL_RENDERBUFFER, self.pickingbuffer)
draw_buffers = (gl.GLenum * 2)(gl.GL_COLOR_ATTACHMENT0, gl.GL_COLOR_ATTACHMENT1)
gl.glDrawBuffers(2, draw_buffers)
if gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) != gl.GL_FRAMEBUFFER_COMPLETE:
logging.error('setting up fbo failed')
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def setBuffer(self, buffer, clear=True):
"""Set the eye buffer to draw to. Subsequent draw calls will be diverted
to the specified eye.
Parameters
----------
buffer : str
Eye buffer to draw to. Values can either be 'left' or 'right'.
clear : bool
Clear the buffer prior to drawing.
"""
# check if the buffer name is valid
if buffer not in ('left', 'right', 'back'):
raise RuntimeError("Invalid buffer name specified.")
# don't change the buffer if same, but allow clearing
if buffer != self.buffer:
if not self._directDraw:
# handle when the back buffer is selected
if buffer == 'back':
if self.useFBO:
GL.glBindFramebuffer(
GL.GL_FRAMEBUFFER,
self._eyeBuffers[buffer]['frameBuffer'])
else:
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
else:
GL.glBindFramebuffer(
GL.GL_FRAMEBUFFER, self._eyeBuffers[buffer]['frameBuffer'])
self.viewport = self.scissor = self._bufferViewports[buffer]
GL.glEnable(GL.GL_SCISSOR_TEST)
self.buffer = buffer # set buffer string
if clear:
self.setColor(self.color) # clear the buffer to the window color
GL.glClearDepth(1.0)
GL.glDepthMask(GL.GL_TRUE)
GL.glClear(
GL.GL_COLOR_BUFFER_BIT |
GL.GL_DEPTH_BUFFER_BIT |
GL.GL_STENCIL_BUFFER_BIT)
GL.glDisable(GL.GL_TEXTURE_2D)
GL.glEnable(GL.GL_BLEND)
def render(self):
gl.glUseProgram(self.programA)
gl.glUniform1i(self.tex_pos_A_A, 1)
gl.glUniform1i(self.tex_pos_A_B, 3)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebufferA0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)
gl.glUseProgram(self.programB)
gl.glUniform1i(self.tex_pos_B_A, 1)
gl.glUniform1i(self.tex_pos_B_B, 3)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebufferB0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)
gl.glUseProgram(self.programA)
gl.glUniform1i(self.tex_pos_A_A, 0)
gl.glUniform1i(self.tex_pos_A_B, 2)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebufferA1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)
gl.glUseProgram(self.programB)
gl.glUniform1i(self.tex_pos_B_A, 0)
gl.glUniform1i(self.tex_pos_B_B, 2)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebufferB1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)
def setupFBOandTextures(self):
self.framebufferA0 = gl.GLuint(0)
self.framebufferA1 = gl.GLuint(0)
self.framebufferB0 = gl.GLuint(0)
self.framebufferB1 = gl.GLuint(0)
self.A0_tex = gl.GLuint(0)
self.A1_tex = gl.GLuint(0)
self.B0_tex = gl.GLuint(0)
self.B1_tex = gl.GLuint(0)
self.draw_buffersA0 = (gl.GLenum * 1)(gl.GL_COLOR_ATTACHMENT0)
self.draw_buffersA1 = (gl.GLenum * 1)(gl.GL_COLOR_ATTACHMENT0)
self.draw_buffersB0 = (gl.GLenum * 1)(gl.GL_COLOR_ATTACHMENT0)
self.draw_buffersB1 = (gl.GLenum * 1)(gl.GL_COLOR_ATTACHMENT0)
gl.glGenFramebuffers(1, ctypes.byref(self.framebufferA0))
gl.glGenFramebuffers(1, ctypes.byref(self.framebufferA1))
gl.glGenFramebuffers(1, ctypes.byref(self.framebufferB0))
gl.glGenFramebuffers(1, ctypes.byref(self.framebufferB1))
gl.glGenTextures(1, ctypes.byref(self.A0_tex))
gl.glGenTextures(1, ctypes.byref(self.A1_tex))
gl.glGenTextures(1, ctypes.byref(self.B0_tex))
gl.glGenTextures(1, ctypes.byref(self.B1_tex))
#A
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebufferA0)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.A0_tex)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, self.dimx,
self.dimy, 0, gl.GL_RGBA, gl.GL_FLOAT, self.Ap)
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.glFramebufferTexture2D(gl.GL_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, self.A0_tex, 0)
gl.glDrawBuffers(1, self.draw_buffersA0)
assert gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE
gl.glActiveTexture(gl.GL_TEXTURE1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebufferA1)
# Set up the texture as the target for color output
gl.glBindTexture(gl.GL_TEXTURE_2D, self.A1_tex)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, self.dimx,
self.dimy, 0, gl.GL_RGBA, gl.GL_FLOAT, self.Ap)
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.glFramebufferTexture2D(gl.GL_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, self.A1_tex, 0)
gl.glDrawBuffers(1, self.draw_buffersA1)
assert gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE
#B
gl.glActiveTexture(gl.GL_TEXTURE2)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebufferB0)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.B0_tex)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, self.dimx,
self.dimy, 0, gl.GL_RGBA, gl.GL_FLOAT, self.Bp)
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.glFramebufferTexture2D(gl.GL_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, self.B0_tex, 0)
gl.glDrawBuffers(1, self.draw_buffersB0)
assert gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE
gl.glActiveTexture(gl.GL_TEXTURE3)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebufferB1)
# Set up the texture as the target for color output
gl.glBindTexture(gl.GL_TEXTURE_2D, self.B1_tex)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, self.dimx,
self.dimy, 0, gl.GL_RGBA, gl.GL_FLOAT, self.Bp)
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.glFramebufferTexture2D(gl.GL_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, self.B1_tex, 0)
gl.glDrawBuffers(1, self.draw_buffersB1)
assert gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE
def __exit__(self, *unused):
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER,
gl.GLuint(self.current_fbo.value))
def __enter__(self):
self.current_fbo = (gl.GLint)()
gl.glGetIntegerv(gl.GL_FRAMEBUFFER_BINDING, self.current_fbo)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbo)
gl.glViewport(0, 0, self.texture.width, self.texture.height)
def __enter__(self):
self.current_fbo = (gl.GLint)()
gl.glGetIntegerv(gl.GL_FRAMEBUFFER_BINDING, self.current_fbo);
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbo)
gl.glViewport(0, 0, self.texture.width, self.texture.height)
def __exit__(self, *unused):
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, gl.GLuint(self.current_fbo.value))
def __init__(self,
ctx: "Context",
*,
color_attachments=None,
depth_attachment=None):
"""
:param Context ctx: The context this framebuffer belongs to
:param List[arcade.gl.Texture] color_attachments: List of color attachments.
:param arcade.gl.Texture depth_attachment: A depth attachment (optional)
"""
if not color_attachments:
raise ValueError(
"Framebuffer must at least have one color attachment")
self._ctx = ctx
self._color_attachments = (color_attachments if isinstance(
color_attachments, list) else [color_attachments])
self._depth_attachment = depth_attachment
self._glo = fbo_id = gl.GLuint() # The OpenGL alias/name
self._samples = 0 # Leaving this at 0 for future sample support
self._depth_mask = True # Determines if the depth buffer should be affected
self._prev_fbo = None
# Create the framebuffer object
gl.glGenFramebuffers(1, self._glo)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self._glo)
# Ensure all attachments have the same size.
# OpenGL do actually support different sizes,
# but let's keep this simple with high compatibility.
expected_size = (self._color_attachments[0] if self._color_attachments
else self._depth_attachment).size
for layer in [*self._color_attachments, self._depth_attachment]:
if layer and layer.size != expected_size:
raise ValueError(
"All framebuffer attachments should have the same size")
self._width, self._height = expected_size
self._viewport = 0, 0, self._width, self._height
# Attach textures to it
for i, tex in enumerate(self._color_attachments):
# TODO: Possibly support attaching a specific mipmap level
# but we can read from specific mip levels from shaders.
gl.glFramebufferTexture2D(
gl.GL_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0 + i,
gl.GL_TEXTURE_2D,
tex.glo,
0, # Level 0
)
if self.depth_attachment:
gl.glFramebufferTexture2D(
gl.GL_FRAMEBUFFER,
gl.GL_DEPTH_ATTACHMENT,
self.depth_attachment._target,
self.depth_attachment.glo,
0,
)
# Ensure the framebuffer is sane!
self._check_completeness()
# Set up draw buffers. This is simply a prepared list of attachments enums
# we use in the use() method to activate the different color attachment layers
layers = [
gl.GL_COLOR_ATTACHMENT0 + i
for i, _ in enumerate(self._color_attachments)
]
# pyglet wants this as a ctypes thingy, so let's prepare it
self._draw_buffers = (gl.GLuint * len(layers))(*layers)
# Restore the original bound framebuffer to avoid confusion
self.ctx.active_framebuffer.use(force=True)
self.ctx.stats.incr("framebuffer")
weakref.finalize(self, Framebuffer.release, ctx, fbo_id)
def bind(self):
''' binds the framebuffer '''
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbo)
