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)
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 _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 _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__(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 check_status(self):
status = gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER)
if status == gl.GL_FRAMEBUFFER_COMPLETE:
return True
else:
print("Render target error: " + str(status))
return False
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 paintEvent(self, event): # On OS X, when using QGLWidget, it is possible that the opengl draw framebuffer is not # completely constructed before entering paint event. # We just omit all paint event before framebuffer is fully initialized. if GL.glCheckFramebufferStatus(GL.GL_DRAW_FRAMEBUFFER) != GL.GL_FRAMEBUFFER_COMPLETE: return # Need this to make sure we are drawing on the correct GL context self.makeCurrent() # Compile and link shaders only when OpenGL draw framebuffer is constructed if not self.programCompiled: self.vertexShader = shaders.compileShader(VERTEX_SHADER, GL.GL_VERTEX_SHADER) self.fragmentShader = shaders.compileShader(FRAGMENT_SHADER, GL.GL_FRAGMENT_SHADER) self.fragmentMarkerShader = shaders.compileShader( FRAGMENT_MARKER_SHADER, GL.GL_FRAGMENT_SHADER) self.shader = shaders.compileProgram(self.vertexShader, self.fragmentShader) self.markerShader = shaders.compileProgram(self.vertexShader, self.fragmentMarkerShader) self.programCompiled = True GL.glShadeModel(GL.GL_FLAT) GL.glEnable(GL.GL_DEPTH_TEST) GL.glEnable(GL.GL_POINT_SMOOTH) GL.glHint(GL.GL_POINT_SMOOTH_HINT, GL.GL_NICEST) GL.glEnable(GL.GL_LINE_SMOOTH) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) tv = math.tan(self.screen.parameterDialog.getVerticalFOV() * 0.5 / 180 * math.pi) th = math.tan(self.screen.parameterDialog.getHorizontalFOV() * 0.5 / 180 * math.pi) viewport_width = self.width() viewport_height = int(viewport_width * (tv / th)) GL.glViewport((self.width() - viewport_width) / 2, (self.height() - viewport_height) / 2, viewport_width, viewport_height) GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) self.updateCamera() self.drawCoords() # self.drawCones() self.drawMarkers() self.drawGroups() GL.glDisable(GL.GL_CULL_FACE) GL.glDisable(GL.GL_DEPTH_TEST) GL.glPointSize(5) self.openGLDraw(self.shader, GL.GL_LINES, self.testVertexBuffer, self.testColorBuffer) painter = QtGui.QPainter(self) if len(self.mouseRect) > 0: painter.setPen(QtGui.QColor(0, 200, 50, 100)) left = min(self.mouseRect[0].x(), self.mouseRect[1].x()) top = min(self.mouseRect[0].y(), self.mouseRect[1].y()) width = max(self.mouseRect[0].x(), self.mouseRect[1].x()) - left height = max(self.mouseRect[0].y(), self.mouseRect[1].y()) - top rect = QtCore.QRect(left, top, width, height) painter.drawRect(rect) painter.end()
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 check_status(self):
status = gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER)
if status == gl.GL_FRAMEBUFFER_COMPLETE:
print("Framebuffer complete")
return True
else:
print("Render target error: " + str(status))
return False
def paintGL(self):
"""Paint the scene."""
# pass if the framebuffer isn't complete yet or if not initialized
if not (gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE
and self.isVisible() and self.initialized):
return
gl.glClearColor(0, 0, 0, 0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
# Set the viewport and clear the framebuffer
# --- Draw the ND in its viewport ----
gl.glViewport(*self.ndviewport)
self.color_shader.use()
self.arcs.draw()
self.ownship.draw()
self.mask.draw()
self.edge.draw()
self.ticks.draw()
# Select the text shader
self.text_shader.use()
self.font.use()
self.font.set_block_size((0, 0))
self.globaldata.set_vertex_modifiers(VERTEX_IS_GLXY, True)
self.ticklbls.draw()
self.globaldata.set_vertex_modifiers(VERTEX_IS_GLXY, False)
self.spdlabel_text.draw()
self.spdlabel_val.draw()
# --- Draw the MCP in its viewport ---
gl.glViewport(*self.mcpviewport)
self.mcp_tex_shader.use()
gl.glActiveTexture(gl.GL_TEXTURE0 + 0)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.mcp_texture)
self.mcp.draw()
gl.glBindTexture(gl.GL_TEXTURE_2D, self.btn_tex)
self.btn_leds.draw()
if self.updownpos is not None:
self.mcp_col_shader.use()
gl.glVertexAttrib2f(2, *self.updownpos)
self.updown.draw()
gl.glVertexAttrib2f(2, 0.0, 0.0)
self.mcp_txt_shader.use()
gl.glActiveTexture(gl.GL_TEXTURE0 + 0)
gl.glBindTexture(gl.GL_TEXTURE_2D_ARRAY, self.lcd_tex)
self.mcp_text.draw()
# Unbind everything
RenderObject.unbind_all()
gl.glUseProgram(0)
def paintGL(self):
if GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER) == 33305:
return
GL.glClear(GL.GL_COLOR_BUFFER_BIT)
if not self.texture:
return
if not self.shader:
self.compileShaders()
if not self.vbo:
self.vbo = GL.glGenBuffers(1)
shaders.glUseProgram(self.shader)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vbo)
vertices = numpy.array(
[-self.scale + self.cx, -self.scale + self.cy ,
self.scale + self.cx, -self.scale + self.cy,
self.scale + self.cx, self.scale + self.cy,
-self.scale + self.cx, self.scale + self.cy,
0,0,1,0,1,1,0,1], dtype = numpy.float32)
GL.glBufferData(GL.GL_ARRAY_BUFFER, 64, vertices, GL.GL_STATIC_DRAW)
loc = GL.glGetAttribLocation(self.shader, "positionIn")
GL.glEnableVertexAttribArray(loc)
GL.glVertexAttribPointer(loc, 2, GL.GL_FLOAT, 0, 8, c_void_p(0))
loc = GL.glGetAttribLocation(self.shader, "texIn")
GL.glEnableVertexAttribArray(loc)
GL.glVertexAttribPointer(loc, 2, GL.GL_FLOAT, 0, 8, c_void_p(32))
def _uniformLoc(name):
return GL.glGetUniformLocation(self.shader,name)
GL.glUniform1f(_uniformLoc("g"), self.gamma);
GL.glUniform1f(_uniformLoc("m"), math.pow(2, self.exposure + 2.47393))
GL.glUniform1f(_uniformLoc("s"), math.pow(2, -3.5 * self.gamma))
GL.glUniform1i(_uniformLoc("hdr_mode"), self.hdr_mode);
GL.glUniform1i(_uniformLoc("texture"), 0);
GL.glActiveTexture(GL.GL_TEXTURE0);
GL.glBindTexture(GL.GL_TEXTURE_2D, self.texture)
GL.glDrawArrays(GL.GL_QUADS, 0, 4);
GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
loc = GL.glGetAttribLocation(self.shader, "positionIn")
GL.glDisableVertexAttribArray(loc)
loc = GL.glGetAttribLocation(self.shader, "texIn")
GL.glDisableVertexAttribArray(loc)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
shaders.glUseProgram(0)
if self.rightBtnDown:
self.renderPixelInfo()
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 paintGL(self):
"""Paint the scene."""
# pass if the framebuffer isn't complete yet or if not initialized
if not (gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE and self.isVisible() and self.initialized):
return
gl.glClearColor(0, 0, 0, 0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
# Set the viewport and clear the framebuffer
# --- Draw the ND in its viewport ----
gl.glViewport(*self.ndviewport)
self.color_shader.use()
self.arcs.draw()
self.ownship.draw()
self.mask.draw()
self.edge.draw()
self.ticks.draw()
# Select the text shader
self.text_shader.use()
self.font.use()
self.font.set_block_size((0, 0))
self.globaldata.set_vertex_modifiers(VERTEX_IS_GLXY, True)
self.ticklbls.draw()
self.globaldata.set_vertex_modifiers(VERTEX_IS_GLXY, False)
self.spdlabel_text.draw()
self.spdlabel_val.draw()
# --- Draw the MCP in its viewport ---
gl.glViewport(*self.mcpviewport)
self.mcp_tex_shader.use()
gl.glActiveTexture(gl.GL_TEXTURE0 + 0)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.mcp_texture)
self.mcp.draw()
gl.glBindTexture(gl.GL_TEXTURE_2D, self.btn_tex)
self.btn_leds.draw()
if self.updownpos is not None:
self.mcp_col_shader.use()
gl.glVertexAttrib2f(2, *self.updownpos)
self.updown.draw()
gl.glVertexAttrib2f(2, 0.0, 0.0)
self.mcp_txt_shader.use()
gl.glActiveTexture(gl.GL_TEXTURE0 + 0)
gl.glBindTexture(gl.GL_TEXTURE_2D_ARRAY, self.lcd_tex)
self.mcp_text.draw()
# Unbind everything
RenderObject.unbind_all()
gl.glUseProgram(0)
def setup_framebuffer(self):
"""
Set up RGB, surface normal, depth and segmentation framebuffers for the renderer
"""
self.fbo = GL.glGenFramebuffers(1)
self.color_tex_rgb = GL.glGenTextures(1)
self.color_tex_normal = GL.glGenTextures(1)
self.color_tex_semantics = GL.glGenTextures(1)
self.color_tex_3d = GL.glGenTextures(1)
self.depth_tex = GL.glGenTextures(1)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.color_tex_rgb)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA, self.width,
self.height, 0, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, None)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.color_tex_normal)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA, self.width,
self.height, 0, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, None)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.color_tex_semantics)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA, self.width,
self.height, 0, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, None)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.color_tex_3d)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA32F, self.width,
self.height, 0, GL.GL_RGBA, GL.GL_FLOAT, None)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.depth_tex)
GL.glTexImage2D.wrappedOperation(GL.GL_TEXTURE_2D, 0,
GL.GL_DEPTH24_STENCIL8, self.width,
self.height, 0, GL.GL_DEPTH_STENCIL,
GL.GL_UNSIGNED_INT_24_8, None)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fbo)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0,
GL.GL_TEXTURE_2D, self.color_tex_rgb, 0)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT1,
GL.GL_TEXTURE_2D, self.color_tex_normal, 0)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT2,
GL.GL_TEXTURE_2D, self.color_tex_semantics,
0)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT3,
GL.GL_TEXTURE_2D, self.color_tex_3d, 0)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER,
GL.GL_DEPTH_STENCIL_ATTACHMENT,
GL.GL_TEXTURE_2D, self.depth_tex, 0)
GL.glViewport(0, 0, self.width, self.height)
GL.glDrawBuffers(4, [
GL.GL_COLOR_ATTACHMENT0, GL.GL_COLOR_ATTACHMENT1,
GL.GL_COLOR_ATTACHMENT2, GL.GL_COLOR_ATTACHMENT3
])
assert GL.glCheckFramebufferStatus(
GL.GL_FRAMEBUFFER) == GL.GL_FRAMEBUFFER_COMPLETE
def paintGL(self):
if 'glCheckFramebufferStatus' in GL.__dict__:
if GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER) != GL.GL_FRAMEBUFFER_COMPLETE:
return
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glLoadIdentity()
GL.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, (1, 1, 1, 0.25))
GL.glTranslated(0.0, 0.0, -10.0)
GL.glRotated(self.xRot / 16.0, 1.0, 0.0, 0.0)
GL.glRotated(self.yRot / 16.0, 0.0, 1.0, 0.0)
GL.glRotated(self.zRot / 16.0, 0.0, 0.0, 1.0)
GL.glCallList(self.objects)
def __init__(self, size):
self.size = size
self.fbo = FBO()
self.color_tex = Texture()
self.depth_tex = Texture()
w, h = size
with self.color_tex:
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA32F, w, h, 0,
gl.GL_RGBA, gl.GL_FLOAT, None)
with self.depth_tex:
gl.glTexImage2D.wrappedOperation(gl.GL_TEXTURE_2D, 0,
gl.GL_DEPTH24_STENCIL8, w, h, 0,
gl.GL_DEPTH_STENCIL,
gl.GL_UNSIGNED_INT_24_8, None)
with self.fbo:
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER,
gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, self.color_tex, 0)
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER,
gl.GL_DEPTH_STENCIL_ATTACHMENT,
gl.GL_TEXTURE_2D, self.depth_tex, 0)
gl.glViewport(0, 0, w, h)
assert gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE
self.shader = Shader(vp_code='''
#version 130
uniform mat4 MVP;
uniform mat4 MV;
in vec4 data;
out vec4 aData;
void main() {
aData = data;
gl_Position = MVP * gl_Vertex;
}
''',
fp_code='''
#version 130
in vec4 aData;
out vec4 fragColor;
void main() {
fragColor = aData;
}
''')
self.fovy = 10.0
self.aspect = 1.0 * w / h
self.znear, self.zfar = 0.01, 100.0
def _checkBoundFramebuffer():
status = gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER)
if status == gl.GL_FRAMEBUFFER_COMPLETE:
return
elif status == gl.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
raise Exception("GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT")
elif status == gl.GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
raise Exception("GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS")
elif status == gl.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
raise Exception("GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT")
elif status == gl.GL_FRAMEBUFFER_UNSUPPORTED:
raise Exception("GL_FRAMEBUFFER_UNSUPPORTED")
else:
raise Exception(status)
def paintGL(self):
if 'glCheckFramebufferStatus' in GL.__dict__:
if GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER) != GL.GL_FRAMEBUFFER_COMPLETE:
return
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glLoadIdentity()
GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, (20, -10, -20, 0))
GL.glLightfv(GL.GL_LIGHT1, GL.GL_DIFFUSE, (0.25, 0.25, 0.25, 1))
GL.glLightfv(GL.GL_LIGHT1, GL.GL_POSITION, (-10, -5, -20, 0))
GL.glTranslated(0.0, 0.0, -10.0)
GL.glRotated(self.xRot / 16.0, 1.0, 0.0, 0.0)
GL.glRotated(self.yRot / 16.0, 0.0, 1.0, 0.0)
GL.glRotated(self.zRot / 16.0, 0.0, 0.0, 1.0)
GL.glCallList(self.objects[self.index])
def __setup(self, width: int, height: int) -> None:
if self.__is_setup:
self.__teardown()
self.__is_setup = True
self.__fbo = GL.glGenFramebuffers(1)
if self.__debug_name is not None:
GL.glObjectLabel(GL.GL_FRAMEBUFFER, self.__fbo, -1,
self.__debug_name)
self.__info_tex = Texture(debug_name=self.__debug_name)
self.__i8_texture(self.__info_tex, GL.GL_RG8UI, GL.GL_RG_INTEGER,
width, height)
with self:
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER,
GL.GL_COLOR_ATTACHMENT0,
GL.GL_TEXTURE_2D, self.__info_tex.v, 0)
GL.glDrawBuffers([GL.GL_COLOR_ATTACHMENT0])
status = GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER)
if status != GL.GL_FRAMEBUFFER_COMPLETE:
lut = [
GL.GL_FRAMEBUFFER_UNDEFINED,
GL.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
GL.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT,
GL.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER,
GL.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER,
GL.GL_FRAMEBUFFER_UNSUPPORTED,
GL.GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE,
GL.GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS
]
# Find the magic constant name
for i in lut:
if status == int(i):
result = i
break
else:
result = "unknown %d" % status
print("Error, could not create framebuffer. Status: %s" %
str(result))
assert False
def __init__(self):
self.__fbo = gl.glGenFramebuffers(1)
self.__depthCubeMap = gl.glGenTextures(1)
self.__width = 1024
self.__height = 1024
gl.glBindTexture(gl.GL_TEXTURE_2D, self.__depthCubeMap)
gl.glActiveTexture(gl.GL_TEXTURE0 + self.__depthCubeMap)
for i in range(6):
gl.glTexImage2D(gl.GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0,
gl.GL_DEPTH_COMPONENT, self.__width, self.__height,
0, gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT, None)
gl.glTexParameteri(gl.GL_TEXTURE_CUBE_MAP, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_CUBE_MAP, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
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.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.__fbo)
gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT,
self.__depthCubeMap, 0)
gl.glDrawBuffer(gl.GL_NONE)
gl.glReadBuffer(gl.GL_NONE)
if gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER) != gl.GL_FRAMEBUFFER_COMPLETE:
raise Exception(
"ERROR::FRAMEBUFFER:: Framebuffer is not complete! -> {:02X}".
format(gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER)))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def resize(self, width, height):
'''Resize to new width and height.
For safety, this actually destroys and recreates the framebuffer and
all attachments.
'''
#Check to make sure we actually changed something.
if self.width == width and self.height == height: return
# print(width, height)
self.delete()
self.width = width
self.height = height
self.id = GL.glGenFramebuffers(1)
self.bind()
self.texture = Texture((self.width, self.height), **self.textureKwargs)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0,
self.texture.target, self.texture.id, 0)
if self.depth:
if self._depthTexture:
self.depthTexture = Texture((self.width, self.height),
**self.depthTextureKwargs)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER,
GL.GL_DEPTH_ATTACHMENT,
self.depthTexture.target,
self.depthTexture.id, 0)
else:
self.depthId = GL.glGenRenderbuffers(1)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, self.depthId)
GL.glRenderbufferStorage(GL.GL_RENDERBUFFER, self.depthType,
self.width, self.height)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, 0)
GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER,
GL.GL_DEPTH_ATTACHMENT,
GL.GL_RENDERBUFFER, self.depthId)
status = GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER)
if status != GL.GL_FRAMEBUFFER_COMPLETE:
errs = dict((int(globals()[item]), item) for item in globals()
if 'GL_FRAMEBUFFER_' in item)
raise RuntimeError("Framebuffer status: %s" %
errs.get(status, status))
self.aspect = self.width / self.height
def create_render_target(self):
render_texture = GL.glGenTextures(1)
GL.glBindTexture(GL.GL_TEXTURE_2D, render_texture)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGB, self.width(), self.height(), 0, GL.GL_RGB, 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)
fbo = GL.glGenFramebuffers(1)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, fbo)
GL.glFramebufferTexture(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0, render_texture, 0)
if GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER) != GL.GL_FRAMEBUFFER_COMPLETE:
raise Exception("Framebuffer creation failed")
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
return fbo, render_texture
def init_img_fb(self):
"""
Create 2 framebuffers to use for swapping image to texture for post
processing shaders
"""
for name in self.fb_ids:
self.fb_ids[name] = gl.glGenFramebuffers(1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fb_ids[name])
gl.glFramebufferTexture2D(
gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D,
self.texture_ids[self.fb_texture_map[name]], 0)
assert (gl.GL_FRAMEBUFFER_COMPLETE == gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER)), (
"Frame buffer %s isn't completely initialized" % (name))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def __init__(self, width, height, attachments, pixel_format=GL.GL_RGBA16F):
""" Initialise an FBO given a width and height. """
# Create and initialise an FBO with colour attachments of
# the appropriate size.
self.__fbo = GL.glGenFramebuffers(1)
self.__textures = {}
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.__fbo)
for attachment in attachments:
texture = Texture.blank(width, height, pixel_format)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER,
attachment,
GL.GL_TEXTURE_2D,
texture.get_texture(),
0)
self.__textures[attachment] = texture
assert GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER) == GL.GL_FRAMEBUFFER_COMPLETE
def check_status(self):
"""
Checks the completeness of the FBO
"""
status = GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER)
incomplete_states = {
GL.GL_FRAMEBUFFER_UNSUPPORTED: "Framebuffer unsupported. Try another format.",
GL.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: "Framebuffer incomplete attachment",
GL.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: "Framebuffer missing attachment",
GL.GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: "Framebuffer unsupported dimension.",
GL.GL_FRAMEBUFFER_INCOMPLETE_FORMATS: "Framebuffer incoplete formats.",
GL.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER: "Framebuffer incomplete draw buffer.",
GL.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER: "Framebuffer incomplete read buffer",
}
if status == GL.GL_FRAMEBUFFER_COMPLETE:
return
s = incomplete_states.get(status, "Unknown error")
raise FBOError(s)
def bind(self, clear=True):
self.viewport = tuple(GL.glGetIntegerv(GL.GL_VIEWPORT))
if not self.initialized:
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fb_id)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, self.rb_id)
GL.glRenderbufferStorage(
GL.GL_RENDERBUFFER,
GL.GL_DEPTH_COMPONENT32F,
self.viewport[2],
self.viewport[3],
)
GL.glFramebufferRenderbuffer(
GL.GL_FRAMEBUFFER,
GL.GL_DEPTH_ATTACHMENT,
GL.GL_RENDERBUFFER,
self.rb_id,
)
GL.glFramebufferTexture2D(
GL.GL_FRAMEBUFFER,
GL.GL_COLOR_ATTACHMENT0,
GL.GL_TEXTURE_2D,
self.fb_tex.texture_name,
0, # mipmap level, normally 0
)
GL.glFramebufferTexture2D(
GL.GL_FRAMEBUFFER,
GL.GL_DEPTH_ATTACHMENT,
GL.GL_TEXTURE_2D,
self.db_tex.texture_name,
0, # mipmap level, normally 0
)
status = GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER)
if status != GL.GL_FRAMEBUFFER_COMPLETE:
raise RuntimeError
self.initialized = True
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fb_id)
if clear:
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
yield
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
def paintGL(self):
"""Paint the scene."""
# pass if the framebuffer isn't complete yet or if not initialized
if not (gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE and self.isVisible()):
return
# Set the viewport and clear the framebuffer
gl.glViewport(*self.viewport)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glVertexAttrib1f(ATTRIB_OFFSETY, 0.0)
self.color_shader.use()
self.fixed.draw()
gl.glEnable(gl.GL_CLIP_DISTANCE0)
gl.glEnable(gl.GL_CLIP_DISTANCE1)
gl.glVertexAttrib1f(ATTRIB_OFFSETY, self.y_offset)
self.scale.draw()
self.text_shader.use()
self.font.use()
self.font.set_char_size(self.scaletxt.char_size)
self.font.set_block_size(self.scaletxt.block_size)
self.scaletxt.draw()
gl.glDisable(gl.GL_CLIP_DISTANCE1)
self.font.set_char_size(self.aclbls.char_size)
self.font.set_block_size(self.aclbls.block_size)
self.aclbls.draw()
gl.glDisable(gl.GL_CLIP_DISTANCE0)
gl.glVertexAttrib1f(ATTRIB_OFFSETY, 0.0)
self.font.set_char_size(self.rwylbl.char_size)
self.font.set_block_size(self.rwylbl.block_size)
self.rwylbl.draw()
self.timelbl.draw()
# Unbind everything
RenderObject.unbind_all()
gl.glUseProgram(0)
def genShadowMap(self) -> None:
self.__depthMapFbo = gl.glGenFramebuffers(1);
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 attach(self, target: int,
attachment: Union[GlTexture2D, GlTextureRectangle,
GlRenderbuffer]):
""" attach Texture or Renderbuffer to given attachment target.
Args:
target: attachment target, e.g., GL_COLOR_ATTACHMENT0, GL_DEPTH_STENCIL_ATTACHMENT, ...
attachment: texture or renderbuffer to attach.
"""
if isinstance(attachment, (GlTexture2D, GlTextureRectangle)):
texture_target = None
if isinstance(attachment, GlTexture2D):
texture_target = gl.GL_TEXTURE_2D
if isinstance(attachment, GlTextureRectangle):
texture_target = gl.GL_TEXTURE_RECTANGLE
gl.glBindFramebuffer(self._target, self._id)
gl.glFramebufferTexture2D(self._target, target, texture_target,
attachment.id, 0)
gl.glBindFramebuffer(self._target, 0)
elif isinstance(attachment, GlRenderbuffer):
gl.glBindFramebuffer(self._target, self._id)
gl.glFramebufferRenderbuffer(self._target, target,
gl.GL_RENDERBUFFER, attachment.id)
gl.glBindFramebuffer(self._target, 0)
else:
raise ValueError(
"texture should be GlTexture2D, GlTextureRectangle or GlRenderbuffer."
)
self._attachments[target] = attachment
gl.glBindFramebuffer(self._target, self._id)
self._valid = gl.glCheckFramebufferStatus(
self._target) == gl.GL_FRAMEBUFFER_COMPLETE
gl.glBindFramebuffer(self._target, 0)
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):
"""Paint the scene."""
# pass if the framebuffer isn't complete yet or if not initialized
if not (gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE
and self.initialized and self.isVisible()):
return
# Set the viewport and clear the framebuffer
gl.glViewport(*self.viewport)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
# Send the (possibly) updated global uniforms to the buffer
self.globaldata.set_vertex_scale_type(VERTEX_IS_LATLON)
# --- DRAW THE MAP AND COASTLINES ---------------------------------------------
# Map and coastlines: don't wrap around in the shader
self.globaldata.enable_wrap(False)
if self.show_map:
# Select the texture shader
self.texture_shader.use()
# Draw map texture
gl.glActiveTexture(gl.GL_TEXTURE0 + 0)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.map_texture)
self.map.draw()
# Select the non-textured shader
self.color_shader.use()
# Draw coastlines
if self.show_coast:
if self.wrapdir == 0:
# Normal case, no wrap around
self.coastlines.draw(first_vertex=0,
vertex_count=self.vcount_coast)
else:
self.coastlines.bind()
wrapindex = np.uint32(self.coastindices[int(self.wraplon) +
180])
if self.wrapdir == 1:
gl.glVertexAttrib1f(ATTRIB_LON, 360.0)
self.coastlines.draw(first_vertex=0,
vertex_count=wrapindex)
gl.glVertexAttrib1f(ATTRIB_LON, 0.0)
self.coastlines.draw(first_vertex=wrapindex,
vertex_count=self.vcount_coast -
wrapindex)
else:
gl.glVertexAttrib1f(ATTRIB_LON, -360.0)
self.coastlines.draw(first_vertex=wrapindex,
vertex_count=self.vcount_coast -
wrapindex)
gl.glVertexAttrib1f(ATTRIB_LON, 0.0)
self.coastlines.draw(first_vertex=0,
vertex_count=wrapindex)
# --- DRAW PREVIEW SHAPE (WHEN AVAILABLE) -----------------------------
self.polyprev.draw()
# --- DRAW CUSTOM SHAPES (WHEN AVAILABLE) -----------------------------
self.allpolys.draw()
# --- DRAW THE SELECTED AIRCRAFT ROUTE (WHEN AVAILABLE) ---------------
if self.show_traf:
self.route.draw()
self.cpalines.draw()
# --- DRAW AIRPORT DETAILS (RUNWAYS, TAXIWAYS, PAVEMENTS) -------------
self.runways.draw()
self.thresholds.draw()
if self.zoom >= 1.0:
for idx in self.apt_inrange:
self.taxiways.draw(first_vertex=idx[0], vertex_count=idx[1])
self.pavement.draw(first_vertex=idx[2], vertex_count=idx[3])
# --- DRAW THE INSTANCED AIRCRAFT SHAPES ------------------------------
# update wrap longitude and direction for the instanced objects
self.globaldata.enable_wrap(True)
# PZ circles only when they are bigger than the A/C symbols
if self.naircraft > 0 and self.show_traf and self.show_pz and self.zoom >= 0.15:
self.globaldata.set_vertex_scale_type(VERTEX_IS_METERS)
self.protectedzone.draw(n_instances=self.naircraft)
self.globaldata.set_vertex_scale_type(VERTEX_IS_SCREEN)
# Draw traffic symbols
if self.naircraft > 0 and self.show_traf:
self.ac_symbol.draw(n_instances=self.naircraft)
if self.zoom >= 0.5:
nairports = self.nairports[2]
elif self.zoom >= 0.25:
nairports = self.nairports[1]
else:
nairports = self.nairports[0]
if self.zoom >= 3:
nwaypoints = self.nwaypoints
else:
nwaypoints = self.nnavaids
# Draw waypoint symbols
if self.show_wpt:
self.waypoints.bind()
gl.glVertexAttrib4Nub(ATTRIB_COLOR, *(lightblue3 + (255, )))
self.waypoints.draw(n_instances=nwaypoints)
# Draw airport symbols
if self.show_apt:
self.airports.bind()
gl.glVertexAttrib4Nub(ATTRIB_COLOR, *(lightblue3 + (255, )))
self.airports.draw(n_instances=nairports)
if self.do_text:
self.text_shader.use()
self.font.use()
if self.show_apt:
self.font.set_char_size(self.aptlabels.char_size)
self.font.set_block_size(self.aptlabels.block_size)
self.aptlabels.bind()
gl.glVertexAttrib4Nub(ATTRIB_COLOR, *(lightblue4 + (255, )))
self.aptlabels.draw(n_instances=nairports)
if self.show_wpt:
self.font.set_char_size(self.wptlabels.char_size)
self.font.set_block_size(self.wptlabels.block_size)
self.wptlabels.bind()
gl.glVertexAttrib4Nub(ATTRIB_COLOR, *(lightblue4 + (255, )))
self.wptlabels.draw(n_instances=nwaypoints)
if self.show_traf and self.route.vertex_count > 1:
gl.glVertexAttrib4Nub(ATTRIB_COLOR, *(magenta + (255, )))
self.font.set_char_size(self.routelbl.char_size)
self.font.set_block_size(self.routelbl.block_size)
self.routelbl.draw()
if self.naircraft > 0 and self.show_traf and self.show_lbl:
self.font.set_char_size(self.aclabels.char_size)
self.font.set_block_size(self.aclabels.block_size)
self.aclabels.draw(n_instances=self.naircraft)
# SSD
if self.ssd_all or len(self.ssd_ownship) > 0:
self.ssd_shader.use()
gl.glUniform3f(self.ssd_shader.loc_vlimits, 4e4, 25e4, 500.0)
gl.glUniform1i(self.ssd_shader.loc_nac, self.naircraft)
if self.ssd_all:
self.ssd.draw(first_vertex=0,
vertex_count=self.naircraft,
n_instances=self.naircraft)
else:
self.ssd.draw(first_vertex=self.ssd_ownship[-1],
vertex_count=1,
n_instances=self.naircraft)
# Unbind everything
RenderObject.unbind_all()
gl.glUseProgram(0)
def paintGL(self):
"""Paint the scene."""
# pass if the framebuffer isn't complete yet or if not initialized
if not (gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE and self.initialized and self.isVisible()):
return
# Set the viewport and clear the framebuffer
gl.glViewport(*self.viewport)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
# Send the (possibly) updated global uniforms to the buffer
self.globaldata.set_vertex_scale_type(VERTEX_IS_LATLON)
# --- DRAW THE MAP AND COASTLINES ---------------------------------------------
# Map and coastlines: don't wrap around in the shader
self.globaldata.enable_wrap(False)
if self.show_map:
# Select the texture shader
self.texture_shader.use()
# Draw map texture
gl.glActiveTexture(gl.GL_TEXTURE0 + 0)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.map_texture)
self.map.draw()
# Select the non-textured shader
self.color_shader.use()
# Draw coastlines
if self.show_coast:
if self.wrapdir == 0:
# Normal case, no wrap around
self.coastlines.draw(first_vertex=0, vertex_count=self.vcount_coast)
else:
self.coastlines.bind()
wrapindex = np.uint32(self.coastindices[int(self.wraplon) + 180])
if self.wrapdir == 1:
gl.glVertexAttrib1f(ATTRIB_LON, 360.0)
self.coastlines.draw(first_vertex=0, vertex_count=wrapindex)
gl.glVertexAttrib1f(ATTRIB_LON, 0.0)
self.coastlines.draw(first_vertex=wrapindex, vertex_count=self.vcount_coast - wrapindex)
else:
gl.glVertexAttrib1f(ATTRIB_LON, -360.0)
self.coastlines.draw(first_vertex=wrapindex, vertex_count=self.vcount_coast - wrapindex)
gl.glVertexAttrib1f(ATTRIB_LON, 0.0)
self.coastlines.draw(first_vertex=0, vertex_count=wrapindex)
# --- DRAW PREVIEW SHAPE (WHEN AVAILABLE) -----------------------------
self.polyprev.draw()
# --- DRAW CUSTOM SHAPES (WHEN AVAILABLE) -----------------------------
self.allpolys.draw()
# --- DRAW THE SELECTED AIRCRAFT ROUTE (WHEN AVAILABLE) ---------------
if self.show_traf:
self.route.draw()
self.cpalines.draw()
# --- DRAW AIRPORT DETAILS (RUNWAYS, TAXIWAYS, PAVEMENTS) -------------
self.runways.draw()
self.thresholds.draw()
if self.zoom >= 1.0:
for idx in self.apt_inrange:
self.taxiways.draw(first_vertex=idx[0], vertex_count=idx[1])
self.pavement.draw(first_vertex=idx[2], vertex_count=idx[3])
# --- DRAW THE INSTANCED AIRCRAFT SHAPES ------------------------------
# update wrap longitude and direction for the instanced objects
self.globaldata.enable_wrap(True)
# PZ circles only when they are bigger than the A/C symbols
if self.naircraft > 0 and self.show_traf and self.show_pz and self.zoom >= 0.15:
self.globaldata.set_vertex_scale_type(VERTEX_IS_METERS)
self.protectedzone.draw(n_instances=self.naircraft)
self.globaldata.set_vertex_scale_type(VERTEX_IS_SCREEN)
# Draw traffic symbols
if self.naircraft > 0 and self.show_traf:
self.ac_symbol.draw(n_instances=self.naircraft)
if self.zoom >= 0.5:
nairports = self.nairports[2]
elif self.zoom >= 0.25:
nairports = self.nairports[1]
else:
nairports = self.nairports[0]
if self.zoom >= 3:
nwaypoints = self.nwaypoints
else:
nwaypoints = self.nnavaids
# Draw waypoint symbols
if self.show_wpt:
self.waypoints.bind()
gl.glVertexAttrib4Nub(ATTRIB_COLOR, *(lightblue3 + (255,)))
self.waypoints.draw(n_instances=nwaypoints)
# Draw airport symbols
if self.show_apt:
self.airports.bind()
gl.glVertexAttrib4Nub(ATTRIB_COLOR, *(lightblue3 + (255,)))
self.airports.draw(n_instances=nairports)
if self.do_text:
self.text_shader.use()
self.font.use()
if self.show_apt:
self.font.set_char_size(self.aptlabels.char_size)
self.font.set_block_size(self.aptlabels.block_size)
self.aptlabels.bind()
gl.glVertexAttrib4Nub(ATTRIB_COLOR, *(lightblue4 + (255,)))
self.aptlabels.draw(n_instances=nairports)
if self.show_wpt:
self.font.set_char_size(self.wptlabels.char_size)
self.font.set_block_size(self.wptlabels.block_size)
self.wptlabels.bind()
gl.glVertexAttrib4Nub(ATTRIB_COLOR, *(lightblue4 + (255,)))
self.wptlabels.draw(n_instances=nwaypoints)
if self.show_traf and self.route.vertex_count > 1:
gl.glVertexAttrib4Nub(ATTRIB_COLOR, *(magenta + (255,)))
self.font.set_char_size(self.routelbl.char_size)
self.font.set_block_size(self.routelbl.block_size)
self.routelbl.draw()
if self.naircraft > 0 and self.show_traf and self.show_lbl:
self.font.set_char_size(self.aclabels.char_size)
self.font.set_block_size(self.aclabels.block_size)
self.aclabels.draw(n_instances=self.naircraft)
# SSD
if self.ssd_all or len(self.ssd_ownship) > 0:
self.ssd_shader.use()
gl.glUniform3f(self.ssd_shader.loc_vlimits, 1e4, 4e4, 200.0)
if self.ssd_all:
self.ssd.draw(first_vertex=0, vertex_count=self.naircraft, n_instances=self.naircraft)
else:
self.ssd.draw(first_vertex=self.ssd_ownship[-1], vertex_count=1, n_instances=self.naircraft)
# Unbind everything
RenderObject.unbind_all()
gl.glUseProgram(0)
def paintGL(self):
"""Paint the scene."""
# pass if the framebuffer isn't complete yet or if not initialized
if not (gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE and self.initialized and self.isVisible()):
return
# Set the viewport and clear the framebuffer
gl.glViewport(*self.viewport)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
# Select the non-textured shader
self.color_shader.use()
self.globaldata.set_vertex_modifiers(VERTEX_IS_GLXY, False)
self.arcs.draw()
self.globaldata.set_vertex_modifiers(VERTEX_IS_METERS, False)
self.protectedzone.draw(n_instances=self.n_aircraft)
self.globaldata.set_vertex_modifiers(VERTEX_IS_SCREEN, True)
self.ac_symbol.draw(n_instances=self.n_aircraft)
self.globaldata.set_vertex_modifiers(VERTEX_IS_SCREEN, False)
self.waypoints.bind()
gl.glVertexAttrib4Nub(ATTRIB_COLOR, *(lightblue2 + (255,)))
self.waypoints.draw()
self.airports.bind()
gl.glVertexAttrib4Nub(ATTRIB_COLOR, *(lightblue2 + (255,)))
self.airports.draw()
self.text_shader.use()
self.font.use()
self.font.set_char_size(self.wptlabels.char_size)
self.font.set_block_size(self.wptlabels.block_size)
self.wptlabels.bind()
gl.glVertexAttrib4Nub(ATTRIB_COLOR, *(lightblue3 + (255,)))
self.wptlabels.draw(n_instances=self.waypoints.n_instances)
self.font.set_char_size(self.aptlabels.char_size)
self.font.set_block_size(self.aptlabels.block_size)
self.aptlabels.bind()
gl.glVertexAttrib4Nub(ATTRIB_COLOR, *(lightblue3 + (255,)))
self.aptlabels.draw(n_instances=self.airports.n_instances)
self.font.set_char_size(self.aclabels.char_size)
self.font.set_block_size(self.aclabels.block_size)
self.aclabels.draw(n_instances=self.n_aircraft)
self.color_shader.use()
self.globaldata.set_vertex_modifiers(VERTEX_IS_GLXY, False)
self.ownship.draw()
self.mask.draw()
self.edge.draw()
self.globaldata.set_vertex_modifiers(VERTEX_IS_GLXY, True)
self.ticks.draw()
# Select the text shader
self.text_shader.use()
self.font.use()
self.font.set_block_size((0, 0))
self.ticklbls.draw()
self.globaldata.set_vertex_modifiers(VERTEX_IS_GLXY, False)
self.spdlabel_text.draw()
self.spdlabel_val.draw()
# Unbind everything
RenderObject.unbind_all()
gl.glUseProgram(0)
def __init__(self, width=512, height=512, gpu_id=0, render_marker=False, robot=''):
self.render_marker = render_marker
self.VAOs = []
self.VBOs = []
self.materials = []
self.textures = []
self.is_textured = []
self.is_materialed = []
self.objects = []
self.texUnitUniform = None
self.width = width
self.height = height
self.vertices = []
self.faces = []
self.poses_trans = []
self.poses_rot = []
self.instances = []
self.extents = []
self.robot = robot
if len(self.robot) > 3:
self._offset_map = self.load_offset()
else:
self._offset_map = None
self.r = CppYCBRenderer.CppYCBRenderer(width, height, get_available_devices()[gpu_id])
self.r.init()
self.glstring = GL.glGetString(GL.GL_VERSION)
from OpenGL.GL import shaders
self.shaders = shaders
self.colors = [[0.9, 0, 0], [0.6, 0, 0], [0.3, 0, 0], [0.3, 0, 0], [0.3, 0, 0], [0.3, 0, 0], [0.3, 0, 0]]
self.lightcolor = [1, 1, 1]
cur_dir = os.path.dirname(os.path.abspath(__file__))
vertexShader = self.shaders.compileShader(
open(os.path.join(cur_dir, 'shaders/vert.shader')).readlines(), GL.GL_VERTEX_SHADER)
fragmentShader = self.shaders.compileShader(
open(os.path.join(cur_dir,'shaders/frag.shader')).readlines(), GL.GL_FRAGMENT_SHADER)
vertexShader_textureMat = self.shaders.compileShader(
open(os.path.join(cur_dir,'shaders/vert_blinnphong.shader')).readlines(), GL.GL_VERTEX_SHADER)
fragmentShader_textureMat = self.shaders.compileShader(
open(os.path.join(cur_dir,'shaders/frag_blinnphong.shader')).readlines(), GL.GL_FRAGMENT_SHADER)
vertexShader_textureless = self.shaders.compileShader(
open(os.path.join(cur_dir,'shaders/vert_textureless.shader')).readlines(), GL.GL_VERTEX_SHADER)
fragmentShader_textureless = self.shaders.compileShader(
open(os.path.join(cur_dir,'shaders/frag_textureless.shader')).readlines(), GL.GL_FRAGMENT_SHADER)
#try with the easiest shader first, and then look at Gl apply material
vertexShader_material = self.shaders.compileShader(
open(os.path.join(cur_dir,'shaders/vert_mat.shader')).readlines(), GL.GL_VERTEX_SHADER)
fragmentShader_material = self.shaders.compileShader(
open(os.path.join(cur_dir,'shaders/frag_mat.shader')).readlines(), GL.GL_FRAGMENT_SHADER)
vertexShader_simple = self.shaders.compileShader(
open(os.path.join(cur_dir,'shaders/vert_simple.shader')).readlines(), GL.GL_VERTEX_SHADER)
fragmentShader_simple = self.shaders.compileShader(
open(os.path.join(cur_dir,'shaders/frag_simple.shader')).readlines(), GL.GL_FRAGMENT_SHADER)
self.shaderProgram = self.shaders.compileProgram(vertexShader, fragmentShader)
self.shaderProgram_textureless = self.shaders.compileProgram(vertexShader_textureless, fragmentShader_textureless)
self.shaderProgram_simple = self.shaders.compileProgram(vertexShader_simple, fragmentShader_simple)
self.shaderProgram_material = self.shaders.compileProgram(vertexShader_material, fragmentShader_material)
self.shaderProgram_textureMat = self.shaders.compileProgram(vertexShader_textureMat, fragmentShader_textureMat)
self.texUnitUniform_textureMat = GL.glGetUniformLocation(self.shaderProgram_textureMat, 'texUnit')
self.lightpos = [0, 0, 0]
self.fbo = GL.glGenFramebuffers(1)
self.color_tex = GL.glGenTextures(1)
self.color_tex_2 = GL.glGenTextures(1)
self.color_tex_3 = GL.glGenTextures(1)
self.color_tex_4 = GL.glGenTextures(1)
self.color_tex_5 = GL.glGenTextures(1)
self.depth_tex = GL.glGenTextures(1)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.color_tex)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA32F, self.width, self.height, 0,
GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, None)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.color_tex_2)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA32F, self.width, self.height, 0,
GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, None)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.color_tex_3)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA32F, self.width, self.height, 0,
GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, None)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.color_tex_4)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA32F, self.width, self.height, 0,
GL.GL_RGBA, GL.GL_FLOAT, None)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.color_tex_5)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA32F, self.width, self.height, 0,
GL.GL_RGBA, GL.GL_FLOAT, None)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.depth_tex)
GL.glTexImage2D.wrappedOperation(
GL.GL_TEXTURE_2D, 0, GL.GL_DEPTH24_STENCIL8, self.width, self.height, 0,
GL.GL_DEPTH_STENCIL, GL.GL_UNSIGNED_INT_24_8, None)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fbo)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0, GL.GL_TEXTURE_2D, self.color_tex, 0)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT1, GL.GL_TEXTURE_2D, self.color_tex_2, 0)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT2, GL.GL_TEXTURE_2D, self.color_tex_3, 0)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT3, GL.GL_TEXTURE_2D, self.color_tex_4, 0)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT4, GL.GL_TEXTURE_2D, self.color_tex_5, 0)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_STENCIL_ATTACHMENT, GL.GL_TEXTURE_2D, self.depth_tex, 0)
GL.glViewport(0, 0, self.width, self.height)
GL.glDrawBuffers(5, [GL.GL_COLOR_ATTACHMENT0, GL.GL_COLOR_ATTACHMENT1,
GL.GL_COLOR_ATTACHMENT2, GL.GL_COLOR_ATTACHMENT3, GL.GL_COLOR_ATTACHMENT4])
assert GL.glCheckFramebufferStatus(
GL.GL_FRAMEBUFFER) == GL.GL_FRAMEBUFFER_COMPLETE
self.fov = 20
self.camera = [1, 0, 0]
self.target = [0, 0, 0]
self.up = [0, 0, 1]
P = perspective(self.fov, float(self.width) /
float(self.height), 0.01, 100)
V = lookat(
self.camera,
self.target, up=self.up)
self.V = np.ascontiguousarray(V, np.float32)
self.P = np.ascontiguousarray(P, np.float32)
self.grid = self.generate_grid()
#added mouse interaction
self.is_rotating = False
def paintGL(self):
"""Paint the scene."""
# clear the color and depth buffer
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# initialize FrameBuffer
fbo = gl.glGenFramebuffers(1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo)
depthbuffer = gl.glGenRenderbuffers(1)
gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, depthbuffer)
gl.glRenderbufferStorage(gl.GL_RENDERBUFFER, gl.GL_DEPTH_COMPONENT24,
self.width, self.height)
gl.glFramebufferRenderbuffer(
gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT, gl.GL_RENDERBUFFER,
depthbuffer
)
# --- end FB init
# generate the texture we render to, and set parameters
renderedTexture = 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, renderedTexture)
# 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_RGBA, self.width,
self.height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_INT, None)
# --- end texture init
# Set "renderedTexture" as our colour attachement #0
gl.glFramebufferTexture2D(
gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D,
renderedTexture,
0 # mipmap level, normally 0
)
status = gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER)
assert status == gl.GL_FRAMEBUFFER_COMPLETE, status
# bind to fb
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo)
# viewport is shared with the main context
gl.glViewport(0, 0, self.width, self.height)
# Clear the screen
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# --- at this point everything should be set, draw away
# THIS IS DRAWING PART
# bind the VBO
self.vbo.bind()
# tell OpenGL that the VBO contains an array of vertices
# prepare the shader
gl.glEnableVertexAttribArray(0)
# these vertices contain 2 single precision coordinates
gl.glVertexAttribPointer(0, 2, gl.GL_FLOAT, gl.GL_FALSE, 0, None)
gl.glUseProgram(self.shaders_program)
# draw "count" points from the VBO
gl.glDrawArrays(gl.GL_LINE_STRIP, 0, len(self.data))
# END OF DRAWING PART
debug_buffer = gl.glReadPixels(0, 0, self.width, self.height, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE)
image = Image.frombytes(mode="RGB", size=(self.width, self.height),
data=debug_buffer)
image = image.transpose(Image.FLIP_TOP_BOTTOM)
image.save("/tmp/foo.jpg")
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) # unbind FB
gl.glBindTexture(gl.GL_TEXTURE_2D, renderedTexture) # bind to result ??
# THIS IS DRAWING PART II
# vertex arrays must be enabled using glEnableClientState
gl.glEnable(gl.GL_TEXTURE_2D) # ???
texId = gl.glGetUniformLocation(self.my_shaders_program, "renderedTexture")
gl.glUseProgram(self.my_shaders_program)
# HOW TO DRAW TEXTURE
gl.glActiveTexture(gl.GL_TEXTURE0);
gl.glBindTexture(gl.GL_TEXTURE_2D, renderedTexture) # bind to result ??
# Set our "renderedTexture" sampler to user Texture Unit 0
gl.glUniform1i(texId, 0);
gl.glBegin(gl.GL_QUADS)
gl.glVertex3f(-1.0,-1.0, 0.0)
gl.glVertex3f( 1.0,-1.0, 0.0)
gl.glVertex3f( 1.0, 1.0, 0.0)
gl.glVertex3f(-1.0, 1.0, 0.0)
gl.glEnd()
def paintGL(self):
"""Paint the scene."""
# pass if the framebuffer isn't complete yet or if not initialized
if not (gl.glCheckFramebufferStatus(
gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE
and self.initialized and self.isVisible()):
return
# Get data for active node
actdata = bs.net.get_nodedata()
# Set the viewport and clear the framebuffer
gl.glViewport(*self.viewport)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
# Send the (possibly) updated global uniforms to the buffer
self.shaderset.set_vertex_scale_type(VERTEX_IS_LATLON)
# --- DRAW THE MAP AND COASTLINES ---------------------------------------------
# Map and coastlines: don't wrap around in the shader
self.shaderset.enable_wrap(False)
if actdata.show_map:
# Select the texture shader
# self.texture_shader.use()
# Draw map texture
# self.map_texture.bind()
self.map.draw()
# Select the non-textured shader
# self.color_shader.use()
# Draw coastlines
if actdata.show_coast:
if self.wrapdir == 0:
# Normal case, no wrap around
self.coastlines.draw(first_vertex=0,
vertex_count=self.vcount_coast)
else:
self.coastlines.bind()
wrapindex = np.uint32(self.coastindices[int(self.wraplon) +
180])
if self.wrapdir == 1:
gl.glVertexAttrib1f(self.coastlines.lon.loc, 360.0)
self.coastlines.draw(first_vertex=0,
vertex_count=wrapindex)
gl.glVertexAttrib1f(self.coastlines.lon.loc, 0.0)
self.coastlines.draw(first_vertex=wrapindex,
vertex_count=self.vcount_coast -
wrapindex)
else:
gl.glVertexAttrib1f(self.coastlines.lon.loc, -360.0)
self.coastlines.draw(first_vertex=wrapindex,
vertex_count=self.vcount_coast -
wrapindex)
gl.glVertexAttrib1f(self.coastlines.lon.loc, 0.0)
self.coastlines.draw(first_vertex=0,
vertex_count=wrapindex)
# --- DRAW PREVIEW SHAPE (WHEN AVAILABLE) -----------------------------
self.polyprev.draw()
# --- DRAW CUSTOM SHAPES (WHEN AVAILABLE) -----------------------------
if actdata.show_poly > 0:
self.allpolys.draw()
if actdata.show_poly > 1:
self.allpfill.draw()
# --- DRAW THE SELECTED AIRCRAFT ROUTE (WHEN AVAILABLE) ---------------
if actdata.show_traf:
self.route.draw()
self.cpalines.draw()
self.traillines.draw()
# --- DRAW AIRPORT DETAILS (RUNWAYS, TAXIWAYS, PAVEMENTS) -------------
self.runways.draw()
self.thresholds.draw()
if self.zoom >= 1.0:
for idx in self.apt_inrange:
self.taxiways.draw(first_vertex=idx[0], vertex_count=idx[1])
self.pavement.draw(first_vertex=idx[2], vertex_count=idx[3])
# --- DRAW THE INSTANCED AIRCRAFT SHAPES ------------------------------
# update wrap longitude and direction for the instanced objects
self.shaderset.enable_wrap(True)
# PZ circles only when they are bigger than the A/C symbols
if self.naircraft > 0 and actdata.show_traf and actdata.show_pz and self.zoom >= 0.15:
self.shaderset.set_vertex_scale_type(VERTEX_IS_METERS)
self.protectedzone.draw(n_instances=self.naircraft)
self.shaderset.set_vertex_scale_type(VERTEX_IS_SCREEN)
# Draw traffic symbols
if self.naircraft > 0 and actdata.show_traf:
if self.routelbl.n_instances:
self.rwaypoints.draw(n_instances=self.routelbl.n_instances)
self.ac_symbol.draw(n_instances=self.naircraft)
if self.zoom >= 0.5 and actdata.show_apt == 1 or actdata.show_apt == 2:
nairports = self.nairports[2]
elif self.zoom >= 0.25 and actdata.show_apt == 1 or actdata.show_apt == 3:
nairports = self.nairports[1]
else:
nairports = self.nairports[0]
if self.zoom >= 3 and actdata.show_wpt == 1 or actdata.show_wpt == 2:
nwaypoints = self.nwaypoints
else:
nwaypoints = self.nnavaids
# Draw waypoint symbols
if actdata.show_wpt:
self.waypoints.draw(n_instances=nwaypoints)
if self.ncustwpts > 0:
self.customwp.draw(n_instances=self.ncustwpts)
# Draw airport symbols
if actdata.show_apt:
self.airports.draw(n_instances=nairports)
# Text rendering
self.text_shader.use()
self.font.use()
if actdata.show_apt:
self.font.set_char_size(self.aptlabels.char_size)
self.font.set_block_size(self.aptlabels.block_size)
self.aptlabels.draw(n_instances=nairports)
if actdata.show_wpt:
self.font.set_char_size(self.wptlabels.char_size)
self.font.set_block_size(self.wptlabels.block_size)
self.wptlabels.draw(n_instances=nwaypoints)
if self.ncustwpts > 0:
self.font.set_char_size(self.customwplbl.char_size)
self.font.set_block_size(self.customwplbl.block_size)
self.customwplbl.draw(n_instances=self.ncustwpts)
if actdata.show_traf and self.route.vertex_count > 1:
self.font.set_char_size(self.routelbl.char_size)
self.font.set_block_size(self.routelbl.block_size)
self.routelbl.draw()
if self.naircraft > 0 and actdata.show_traf and actdata.show_lbl:
self.font.set_char_size(self.aclabels.char_size)
self.font.set_block_size(self.aclabels.block_size)
self.aclabels.draw(n_instances=self.naircraft)
# SSD
if actdata.ssd_all or actdata.ssd_conflicts or len(
actdata.ssd_ownship) > 0:
self.ssd_shader.use()
gl.glUniform3f(self.ssd_shader.Vlimits.loc, self.asas_vmin**2,
self.asas_vmax**2, self.asas_vmax)
gl.glUniform1i(self.ssd_shader.n_ac.loc, self.naircraft)
self.ssd.draw(vertex_count=self.naircraft,
n_instances=self.naircraft)
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, False, color.strides[0], ctypes.c_void_p(0))
position_buffer_small = VertexBufferObject()
with position_buffer_small:
gl.glBufferData(gl.GL_ARRAY_BUFFER, position_small.nbytes, position_small, gl.GL_STATIC_DRAW)
loc = gl.glGetAttribLocation(gl_program, 'position')
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, position_small.strides[0], ctypes.c_void_p(0))
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, indices_buffer_small.handle)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, 0)
framebuffer = Framebuffer()
assert gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE
color_tex = gl.glGenTextures(1)
# gl.glActiveTexture(gl.GL_TEXTURE1)
gl.glBindTexture(gl.GL_TEXTURE_2D, color_tex)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, width_2, height_2, 0, gl.GL_RGBA,
gl.GL_UNSIGNED_BYTE, None)
depth_tex = gl.glGenTextures(1)
# gl.glActiveTexture(gl.GL_TEXTURE2)
gl.glBindTexture(gl.GL_TEXTURE_2D, depth_tex)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_DEPTH_COMPONENT, width_2, height_2, 0, gl.GL_DEPTH_COMPONENT,
gl.GL_FLOAT, None)
# gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBindTexture(gl.GL_TEXTURE_2D, 0)
def init_gl(self):
# Set up framebuffer and render textures
self.fb = GL.glGenFramebuffers(1)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fb)
self.depth_buffer = GL.glGenRenderbuffers(1)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, self.depth_buffer)
if self.multisample > 0:
GL.glRenderbufferStorageMultisample(GL.GL_RENDERBUFFER,
self.multisample,
GL.GL_DEPTH24_STENCIL8,
self.width, self.height)
else:
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.depth_buffer)
self.texture_id = int(GL.glGenTextures(1))
if self.multisample > 0:
GL.glBindTexture(GL.GL_TEXTURE_2D_MULTISAMPLE, self.texture_id)
GL.glTexImage2DMultisample(GL.GL_TEXTURE_2D_MULTISAMPLE,
self.multisample, GL.GL_RGBA8,
self.width, self.height, True)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER,
GL.GL_COLOR_ATTACHMENT0,
GL.GL_TEXTURE_2D_MULTISAMPLE,
self.texture_id, 0)
else:
GL.glBindTexture(GL.GL_TEXTURE_2D, self.texture_id)
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_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_MAX_LEVEL, 0)
GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER,
GL.GL_COLOR_ATTACHMENT0,
GL.GL_TEXTURE_2D, self.texture_id, 0)
status = GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER)
if status != GL.GL_FRAMEBUFFER_COMPLETE:
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
raise Exception("Incomplete framebuffer")
# Resolver framebuffer in case of multisample antialiasing
if self.multisample > 0:
self.resolve_fb = GL.glGenFramebuffers(1)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.resolve_fb)
self.resolve_texture_id = int(GL.glGenTextures(1))
GL.glBindTexture(GL.GL_TEXTURE_2D, self.resolve_texture_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.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_MAX_LEVEL, 0)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA8, self.width,
self.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)
if status != GL.GL_FRAMEBUFFER_COMPLETE:
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
raise Exception("Incomplete framebuffer")
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
# OpenVR texture data
self.texture = openvr.Texture_t()
if self.multisample > 0:
self.texture.handle = self.resolve_texture_id
else:
self.texture.handle = self.texture_id
self.texture.eType = openvr.TextureType_OpenGL
self.texture.eColorSpace = openvr.ColorSpace_Gamma
## 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.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D,renderedTexture, 0);
## Set the list of draw buffers.
## GLenum DrawBuffers[1] = {gl.GL_COLOR_ATTACHMENT0};
DrawBuffers_type = gl.GLenum * 1
DrawBuffers = DrawBuffers_type(gl.GL_COLOR_ATTACHMENT0)
gl.glDrawBuffers(1, DrawBuffers); # "1" is the size of DrawBuffers
# Always check that our framebuffer is ok
if gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) != gl.GL_FRAMEBUFFER_COMPLETE:
raise Exception("framebuffer failed check")
# Render to our framebuffer
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, framebuffer);
gl.glViewport(0,0,w,h); # Render on the whole framebuffer, complete from the lower left corner to the upper right
#-------------------------------------------------------------------------------
# rendering test code
import time
from neurodot_present.common import Quad
q = Quad((0.5,0.5),(0.5,0.75),(0.75,0.5),(0.75,0.75))
#prepare rendering model
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
