Upload 9 files

lib/renderer/gl/cam_render.py

@@ -0,0 +1,80 @@
+
+# -*- coding: utf-8 -*-
+
+# Max-Planck-Gesellschaft zur Förderung der Wissenschaften e.V. (MPG) is
+# holder of all proprietary rights on this computer program.
+# You can only use this computer program if you have closed
+# a license agreement with MPG or you get the right to use the computer
+# program from someone who is authorized to grant you that right.
+# Any use of the computer program without a valid license is prohibited and
+# liable to prosecution.
+#
+# Copyright©2019 Max-Planck-Gesellschaft zur Förderung
+# der Wissenschaften e.V. (MPG). acting on behalf of its Max Planck Institute
+# for Intelligent Systems. All rights reserved.
+#
+# Contact: [email protected]
+
+from .render import Render
+
+GLUT = None
+
+
+class CamRender(Render):
+    def __init__(self,
+                 width=1600,
+                 height=1200,
+                 name='Cam Renderer',
+                 program_files=['simple.fs', 'simple.vs'],
+                 color_size=1,
+                 ms_rate=1,
+                 egl=False):
+        Render.__init__(self,
+                        width,
+                        height,
+                        name,
+                        program_files,
+                        color_size,
+                        ms_rate=ms_rate,
+                        egl=egl)
+        self.camera = None
+
+        if not egl:
+            global GLUT
+            import OpenGL.GLUT as GLUT
+            GLUT.glutDisplayFunc(self.display)
+            GLUT.glutKeyboardFunc(self.keyboard)
+
+    def set_camera(self, camera):
+        self.camera = camera
+        self.projection_matrix, self.model_view_matrix = camera.get_gl_matrix()
+
+    def keyboard(self, key, x, y):
+        # up
+        eps = 1
+        # print(key)
+        if key == b'w':
+            self.camera.center += eps * self.camera.direction
+        elif key == b's':
+            self.camera.center -= eps * self.camera.direction
+        if key == b'a':
+            self.camera.center -= eps * self.camera.right
+        elif key == b'd':
+            self.camera.center += eps * self.camera.right
+        if key == b' ':
+            self.camera.center += eps * self.camera.up
+        elif key == b'x':
+            self.camera.center -= eps * self.camera.up
+        elif key == b'i':
+            self.camera.near += 0.1 * eps
+            self.camera.far += 0.1 * eps
+        elif key == b'o':
+            self.camera.near -= 0.1 * eps
+            self.camera.far -= 0.1 * eps
+
+        self.projection_matrix, self.model_view_matrix = self.camera.get_gl_matrix(
+        )
+
+    def show(self):
+        if GLUT is not None:
+            GLUT.glutMainLoop()

lib/renderer/gl/color_render.py

@@ -0,0 +1,162 @@
+'''
+MIT License
+
+Copyright (c) 2019 Shunsuke Saito, Zeng Huang, and Ryota Natsume
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+'''
+import numpy as np
+import random
+
+from .framework import *
+from .cam_render import CamRender
+
+
+class ColorRender(CamRender):
+    def __init__(self, width=1600, height=1200, name='Color Renderer', egl=False):
+        program_files = ['color.vs', 'color.fs']
+        CamRender.__init__(self,
+                           width,
+                           height,
+                           name,
+                           program_files=program_files,
+                           color_size=3, egl=egl)
+
+        # WARNING: this differs from vertex_buffer and vertex_data in Render
+        self.vert_buffer = {}
+        self.vert_data = {}
+
+        # normal
+        self.norm_buffer = {}
+        self.norm_data = {}
+
+        self.color_buffer = {}
+        self.color_data = {}
+
+        self.vertex_dim = {}
+        self.n_vertices = {}
+
+        self.rot_mat_unif = glGetUniformLocation(self.program, 'RotMat')
+        self.rot_matrix = np.eye(3)
+
+        self.norm_mat_unif = glGetUniformLocation(self.program, 'NormMat')
+        self.normalize_matrix = np.eye(4)
+
+    def set_norm_mat(self, scale, center):
+        N = np.eye(4)
+        N[:3, :3] = scale * np.eye(3)
+        N[:3, 3] = -scale * center
+
+        self.normalize_matrix = N
+
+    def set_mesh(self, vertices, faces, color, normals, mat_name='all'):
+
+        self.vert_data[mat_name] = vertices[faces.reshape([-1])]
+        self.n_vertices[mat_name] = self.vert_data[mat_name].shape[0]
+        self.vertex_dim[mat_name] = self.vert_data[mat_name].shape[1]
+        self.color_data[mat_name] = color[faces.reshape([-1])]
+        self.norm_data[mat_name] = normals[faces.reshape([-1])]
+
+        if mat_name not in self.vert_buffer.keys():
+            self.vert_buffer[mat_name] = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, self.vert_buffer[mat_name])
+        glBufferData(GL_ARRAY_BUFFER, self.vert_data[mat_name], GL_STATIC_DRAW)
+
+        if mat_name not in self.color_buffer.keys():
+            self.color_buffer[mat_name] = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, self.color_buffer[mat_name])
+        glBufferData(GL_ARRAY_BUFFER, self.color_data[mat_name],
+                     GL_STATIC_DRAW)
+
+        if mat_name not in self.norm_buffer.keys():
+            self.norm_buffer[mat_name] = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, self.norm_buffer[mat_name])
+        glBufferData(GL_ARRAY_BUFFER, self.norm_data[mat_name], GL_STATIC_DRAW)
+
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+
+    def cleanup(self):
+
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+
+        for key in self.vert_data:
+            glDeleteBuffers(1, [self.vert_buffer[key]])
+            glDeleteBuffers(1, [self.color_buffer[key]])
+            glDeleteBuffers(1, [self.norm_buffer[key]])
+
+        self.norm_buffer = {}
+        self.norm_data = {}
+
+        self.vert_buffer = {}
+        self.vert_data = {}
+
+        self.color_buffer = {}
+        self.color_data = {}
+
+        self.render_texture_mat = {}
+
+        self.vertex_dim = {}
+        self.n_vertices = {}
+
+    def draw(self):
+        self.draw_init()
+
+        glEnable(GL_MULTISAMPLE)
+
+        glUseProgram(self.program)
+        glUniformMatrix4fv(self.norm_mat_unif, 1, GL_FALSE,
+                           self.normalize_matrix.transpose())
+        glUniformMatrix4fv(self.model_mat_unif, 1, GL_FALSE,
+                           self.model_view_matrix.transpose())
+        glUniformMatrix4fv(self.persp_mat_unif, 1, GL_FALSE,
+                           self.projection_matrix.transpose())
+        glUniformMatrix3fv(self.rot_mat_unif, 1, GL_FALSE,
+                           self.rot_matrix.transpose())
+
+        for mat in self.vert_buffer:
+
+            # Handle vertex buffer
+            glBindBuffer(GL_ARRAY_BUFFER, self.vert_buffer[mat])
+            glEnableVertexAttribArray(0)
+            glVertexAttribPointer(0, self.vertex_dim[mat], GL_DOUBLE, GL_FALSE,
+                                  0, None)
+
+            # Handle color buffer
+            glBindBuffer(GL_ARRAY_BUFFER, self.color_buffer[mat])
+            glEnableVertexAttribArray(1)
+            glVertexAttribPointer(1, 3, GL_DOUBLE, GL_FALSE, 0, None)
+
+            # Handle normal buffer
+            glBindBuffer(GL_ARRAY_BUFFER, self.norm_buffer[mat])
+            glEnableVertexAttribArray(2)
+            glVertexAttribPointer(2, 3, GL_DOUBLE, GL_FALSE, 0, None)
+
+            glDrawArrays(GL_TRIANGLES, 0, self.n_vertices[mat])
+
+            glDisableVertexAttribArray(2)
+            glDisableVertexAttribArray(1)
+            glDisableVertexAttribArray(0)
+
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+
+        glUseProgram(0)
+
+        glDisable(GL_MULTISAMPLE)
+
+        self.draw_end()

lib/renderer/gl/framework.py

@@ -0,0 +1,95 @@
+# Mario Rosasco, 2016
+# adapted from framework.cpp, Copyright (C) 2010-2012 by Jason L. McKesson
+# This file is licensed under the MIT License.
+#
+# NB: Unlike in the framework.cpp organization, the main loop is contained
+# in the tutorial files, not in this framework file. Additionally, a copy of
+# this module file must exist in the same directory as the tutorial files
+# to be imported properly.
+
+import os
+from OpenGL.GL import *
+
+
+# Function that creates and compiles shaders according to the given type (a GL enum value) and
+# shader program (a file containing a GLSL program).
+def loadShader(shaderType, shaderFile):
+    # check if file exists, get full path name
+    strFilename = findFileOrThrow(shaderFile)
+    shaderData = None
+    with open(strFilename, 'r') as f:
+        shaderData = f.read()
+
+    shader = glCreateShader(shaderType)
+    glShaderSource(
+        shader,
+        shaderData)  # note that this is a simpler function call than in C
+
+    # This shader compilation is more explicit than the one used in
+    # framework.cpp, which relies on a glutil wrapper function.
+    # This is made explicit here mainly to decrease dependence on pyOpenGL
+    # utilities and wrappers, which docs caution may change in future versions.
+    glCompileShader(shader)
+
+    status = glGetShaderiv(shader, GL_COMPILE_STATUS)
+    if status == GL_FALSE:
+        # Note that getting the error log is much simpler in Python than in C/C++
+        # and does not require explicit handling of the string buffer
+        strInfoLog = glGetShaderInfoLog(shader)
+        strShaderType = ""
+        if shaderType is GL_VERTEX_SHADER:
+            strShaderType = "vertex"
+        elif shaderType is GL_GEOMETRY_SHADER:
+            strShaderType = "geometry"
+        elif shaderType is GL_FRAGMENT_SHADER:
+            strShaderType = "fragment"
+
+        print("Compilation failure for " + strShaderType + " shader:\n" +
+              str(strInfoLog))
+
+    return shader
+
+
+# Function that accepts a list of shaders, compiles them, and returns a handle to the compiled program
+def createProgram(shaderList):
+    program = glCreateProgram()
+
+    for shader in shaderList:
+        glAttachShader(program, shader)
+
+    glLinkProgram(program)
+
+    status = glGetProgramiv(program, GL_LINK_STATUS)
+    if status == GL_FALSE:
+        # Note that getting the error log is much simpler in Python than in C/C++
+        # and does not require explicit handling of the string buffer
+        strInfoLog = glGetProgramInfoLog(program)
+        print("Linker failure: \n" + str(strInfoLog))
+
+    for shader in shaderList:
+        glDetachShader(program, shader)
+
+    return program
+
+
+# Helper function to locate and open the target file (passed in as a string).
+# Returns the full path to the file as a string.
+def findFileOrThrow(strBasename):
+    # Keep constant names in C-style convention, for readability
+    # when comparing to C(/C++) code.
+    if os.path.isfile(strBasename):
+        return strBasename
+
+    LOCAL_FILE_DIR = "data" + os.sep
+    GLOBAL_FILE_DIR = os.path.dirname(
+        os.path.abspath(__file__)) + os.sep + "data" + os.sep
+
+    strFilename = LOCAL_FILE_DIR + strBasename
+    if os.path.isfile(strFilename):
+        return strFilename
+
+    strFilename = GLOBAL_FILE_DIR + strBasename
+    if os.path.isfile(strFilename):
+        return strFilename
+
+    raise IOError('Could not find target file ' + strBasename)

lib/renderer/gl/glcontext.py

@@ -0,0 +1,136 @@
+"""Headless GPU-accelerated OpenGL context creation on Google Colaboratory.
+
+Typical usage:
+
+    # Optional PyOpenGL configuratiopn can be done here.
+    # import OpenGL
+    # OpenGL.ERROR_CHECKING = True
+
+    # 'glcontext' must be imported before any OpenGL.* API.
+    from lucid.misc.gl.glcontext import create_opengl_context
+
+    # Now it's safe to import OpenGL and EGL functions
+    import OpenGL.GL as gl
+
+    # create_opengl_context() creates a GL context that is attached to an
+    # offscreen surface of the specified size. Note that rendering to buffers
+    # of other sizes and formats is still possible with OpenGL Framebuffers.
+    #
+    # Users are expected to directly use the EGL API in case more advanced
+    # context management is required.
+    width, height = 640, 480
+    create_opengl_context((width, height))
+
+    # OpenGL context is available here.
+
+"""
+
+from __future__ import print_function
+
+# pylint: disable=unused-import,g-import-not-at-top,g-statement-before-imports
+
+try:
+    import OpenGL
+except:
+    print('This module depends on PyOpenGL.')
+    print('Please run "\033[1m!pip install -q pyopengl\033[0m" '
+          'prior importing this module.')
+    raise
+
+import ctypes
+from ctypes import pointer, util
+import os
+
+os.environ['PYOPENGL_PLATFORM'] = 'egl'
+
+# OpenGL loading workaround.
+#
+# * PyOpenGL tries to load libGL, but we need libOpenGL, see [1,2].
+#   This could have been solved by a symlink libGL->libOpenGL, but:
+#
+# * Python 2.7 can't find libGL and linEGL due to a bug (see [3])
+#   in ctypes.util, that was only wixed in Python 3.6.
+#
+# So, the only solution I've found is to monkeypatch ctypes.util
+# [1] https://devblogs.nvidia.com/egl-eye-opengl-visualization-without-x-server/
+# [2] https://devblogs.nvidia.com/linking-opengl-server-side-rendering/
+# [3] https://bugs.python.org/issue9998
+_find_library_old = ctypes.util.find_library
+try:
+
+    def _find_library_new(name):
+        return {
+            'GL': 'libOpenGL.so',
+            'EGL': 'libEGL.so',
+        }.get(name, _find_library_old(name))
+
+    util.find_library = _find_library_new
+    import OpenGL.GL as gl
+    import OpenGL.EGL as egl
+except:
+    print('Unable to load OpenGL libraries. '
+          'Make sure you use GPU-enabled backend.')
+    print('Press "Runtime->Change runtime type" and set '
+          '"Hardware accelerator" to GPU.')
+    raise
+finally:
+    util.find_library = _find_library_old
+
+
+def create_opengl_context(surface_size=(640, 480)):
+    """Create offscreen OpenGL context and make it current.
+
+  Users are expected to directly use EGL API in case more advanced
+  context management is required.
+
+  Args:
+    surface_size: (width, height), size of the offscreen rendering surface.
+  """
+    egl_display = egl.eglGetDisplay(egl.EGL_DEFAULT_DISPLAY)
+
+    major, minor = egl.EGLint(), egl.EGLint()
+    egl.eglInitialize(egl_display, pointer(major), pointer(minor))
+
+    config_attribs = [
+        egl.EGL_SURFACE_TYPE, egl.EGL_PBUFFER_BIT, egl.EGL_BLUE_SIZE, 8,
+        egl.EGL_GREEN_SIZE, 8, egl.EGL_RED_SIZE, 8, egl.EGL_DEPTH_SIZE, 24,
+        egl.EGL_RENDERABLE_TYPE, egl.EGL_OPENGL_BIT, egl.EGL_NONE
+    ]
+    config_attribs = (egl.EGLint * len(config_attribs))(*config_attribs)
+
+    num_configs = egl.EGLint()
+    egl_cfg = egl.EGLConfig()
+    egl.eglChooseConfig(egl_display, config_attribs, pointer(egl_cfg), 1,
+                        pointer(num_configs))
+
+    width, height = surface_size
+    pbuffer_attribs = [
+        egl.EGL_WIDTH,
+        width,
+        egl.EGL_HEIGHT,
+        height,
+        egl.EGL_NONE,
+    ]
+    pbuffer_attribs = (egl.EGLint * len(pbuffer_attribs))(*pbuffer_attribs)
+    egl_surf = egl.eglCreatePbufferSurface(egl_display, egl_cfg,
+                                           pbuffer_attribs)
+
+    egl.eglBindAPI(egl.EGL_OPENGL_API)
+
+    context_attribs = None
+    # context_attribs = [
+    #     egl.EGL_CONTEXT_MAJOR_VERSION,
+    #     4,
+    #     egl.EGL_CONTEXT_MINOR_VERSION,
+    #     1,
+    #     egl.EGL_NONE,
+    # ]
+
+    egl_context = egl.eglCreateContext(egl_display, egl_cfg,
+                                       egl.EGL_NO_CONTEXT, context_attribs)
+    egl.eglMakeCurrent(egl_display, egl_surf, egl_surf, egl_context)
+
+    buffer_type = egl.EGLint()
+    out = egl.eglQueryContext(egl_display, egl_context,
+                              egl.EGL_CONTEXT_CLIENT_VERSION, buffer_type)
+    # print(buffer_type)

lib/renderer/gl/init_gl.py

@@ -0,0 +1,24 @@
+_glut_window = None
+_context_inited = None
+
+
+def initialize_GL_context(width=512, height=512, egl=False):
+    '''
+    default context uses GLUT
+    '''
+    if not egl:
+        import OpenGL.GLUT as GLUT
+        display_mode = GLUT.GLUT_DOUBLE | GLUT.GLUT_RGB | GLUT.GLUT_DEPTH
+        global _glut_window
+        if _glut_window is None:
+            GLUT.glutInit()
+            GLUT.glutInitDisplayMode(display_mode)
+            GLUT.glutInitWindowSize(width, height)
+            GLUT.glutInitWindowPosition(0, 0)
+            _glut_window = GLUT.glutCreateWindow("My Render.")
+    else:
+        from .glcontext import create_opengl_context
+        global _context_inited
+        if _context_inited is None:
+            create_opengl_context((width, height))
+            _context_inited = True

lib/renderer/gl/norm_render.py

@@ -0,0 +1,79 @@
+'''
+MIT License
+
+Copyright (c) 2019 Shunsuke Saito, Zeng Huang, and Ryota Natsume
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+'''
+from OpenGL.GLUT import *
+
+from .render2 import Render
+
+
+class NormRender(Render):
+    def __init__(self,
+                 width=1600,
+                 height=1200,
+                 name='Cam Renderer',
+                 program_files=['simple.fs', 'simple.vs'],
+                 color_size=1,
+                 ms_rate=1):
+        Render.__init__(self, width, height, name, program_files, color_size,
+                        ms_rate)
+        self.camera = None
+
+        glutDisplayFunc(self.display)
+        glutKeyboardFunc(self.keyboard)
+
+    def set_camera(self, camera):
+        self.camera = camera
+        self.projection_matrix, self.model_view_matrix = camera.get_gl_matrix()
+
+    def set_matrices(self, projection, modelview):
+        self.projection_matrix = projection
+        self.model_view_matrix = modelview
+
+    def keyboard(self, key, x, y):
+        # up
+        eps = 1
+        # print(key)
+        if key == b'w':
+            self.camera.center += eps * self.camera.direction
+        elif key == b's':
+            self.camera.center -= eps * self.camera.direction
+        if key == b'a':
+            self.camera.center -= eps * self.camera.right
+        elif key == b'd':
+            self.camera.center += eps * self.camera.right
+        if key == b' ':
+            self.camera.center += eps * self.camera.up
+        elif key == b'x':
+            self.camera.center -= eps * self.camera.up
+        elif key == b'i':
+            self.camera.near += 0.1 * eps
+            self.camera.far += 0.1 * eps
+        elif key == b'o':
+            self.camera.near -= 0.1 * eps
+            self.camera.far -= 0.1 * eps
+
+        self.projection_matrix, self.model_view_matrix = self.camera.get_gl_matrix(
+        )
+
+    def show(self):
+        glutMainLoop()

lib/renderer/gl/prt_render.py

@@ -0,0 +1,450 @@
+
+# -*- coding: utf-8 -*-
+
+# Max-Planck-Gesellschaft zur Förderung der Wissenschaften e.V. (MPG) is
+# holder of all proprietary rights on this computer program.
+# You can only use this computer program if you have closed
+# a license agreement with MPG or you get the right to use the computer
+# program from someone who is authorized to grant you that right.
+# Any use of the computer program without a valid license is prohibited and
+# liable to prosecution.
+#
+# Copyright©2019 Max-Planck-Gesellschaft zur Förderung
+# der Wissenschaften e.V. (MPG). acting on behalf of its Max Planck Institute
+# for Intelligent Systems. All rights reserved.
+#
+# Contact: [email protected]
+
+import numpy as np
+import random
+
+from .framework import *
+from .cam_render import CamRender
+
+
+class PRTRender(CamRender):
+    def __init__(self,
+                 width=1600,
+                 height=1200,
+                 name='PRT Renderer',
+                 uv_mode=False,
+                 ms_rate=1,
+                 egl=False):
+        program_files = ['prt.vs', 'prt.fs'
+                         ] if not uv_mode else ['prt_uv.vs', 'prt_uv.fs']
+        CamRender.__init__(self,
+                           width,
+                           height,
+                           name,
+                           program_files=program_files,
+                           color_size=8,
+                           ms_rate=ms_rate,
+                           egl=egl)
+
+        # WARNING: this differs from vertex_buffer and vertex_data in Render
+        self.vert_buffer = {}
+        self.vert_data = {}
+
+        self.vert_label_buffer = {}
+        self.vert_label_data = {}
+
+        self.norm_buffer = {}
+        self.norm_data = {}
+
+        self.tan_buffer = {}
+        self.tan_data = {}
+
+        self.btan_buffer = {}
+        self.btan_data = {}
+
+        self.prt1_buffer = {}
+        self.prt1_data = {}
+
+        self.prt2_buffer = {}
+        self.prt2_data = {}
+
+        self.prt3_buffer = {}
+        self.prt3_data = {}
+
+        self.uv_buffer = {}
+        self.uv_data = {}
+
+        self.render_texture_mat = {}
+
+        self.vertex_dim = {}
+        self.n_vertices = {}
+        self.label_dim = {}
+
+        self.norm_mat_unif = glGetUniformLocation(self.program, 'NormMat')
+        self.normalize_matrix = np.eye(4)
+
+        self.shcoeff_unif = glGetUniformLocation(self.program, 'SHCoeffs')
+        self.shcoeffs = np.zeros((9, 3))
+        self.shcoeffs[0, :] = 1.0
+        #self.shcoeffs[1:,:] = np.random.rand(8,3)
+
+        self.hasAlbedoUnif = glGetUniformLocation(self.program, 'hasAlbedoMap')
+        self.hasNormalUnif = glGetUniformLocation(self.program, 'hasNormalMap')
+
+        self.analyticUnif = glGetUniformLocation(self.program, 'analytic')
+        self.analytic = False
+
+        self.rot_mat_unif = glGetUniformLocation(self.program, 'RotMat')
+        self.rot_matrix = np.eye(3)
+
+    def set_texture(self, mat_name, smplr_name, texture):
+        # texture_image: H x W x 3
+        width = texture.shape[1]
+        height = texture.shape[0]
+        texture = np.flip(texture, 0)
+        img_data = np.fromstring(texture.tostring(), np.uint8)
+
+        if mat_name not in self.render_texture_mat:
+            self.render_texture_mat[mat_name] = {}
+        if smplr_name in self.render_texture_mat[mat_name].keys():
+            glDeleteTextures([self.render_texture_mat[mat_name][smplr_name]])
+            del self.render_texture_mat[mat_name][smplr_name]
+
+        self.render_texture_mat[mat_name][smplr_name] = glGenTextures(1)
+        glActiveTexture(GL_TEXTURE0)
+
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
+        glBindTexture(GL_TEXTURE_2D,
+                      self.render_texture_mat[mat_name][smplr_name])
+
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB,
+                     GL_UNSIGNED_BYTE, img_data)
+
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 3)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                        GL_LINEAR_MIPMAP_LINEAR)
+
+        glGenerateMipmap(GL_TEXTURE_2D)
+
+    def set_albedo(self, texture_image, mat_name='all'):
+        self.set_texture(mat_name, 'AlbedoMap', texture_image)
+
+    def set_normal_map(self, texture_image, mat_name='all'):
+        self.set_texture(mat_name, 'NormalMap', texture_image)
+
+    def set_mesh(self,
+                 vertices,
+                 faces,
+                 norms,
+                 faces_nml,
+                 uvs,
+                 faces_uvs,
+                 prt,
+                 faces_prt,
+                 tans,
+                 bitans,
+                 verts_label=None,
+                 mat_name='all'):
+
+        self.vert_data[mat_name] = vertices[faces.reshape([-1])]
+        self.vert_label_data[mat_name] = verts_label[faces.reshape([-1])]
+        self.n_vertices[mat_name] = self.vert_data[mat_name].shape[0]
+        self.vertex_dim[mat_name] = self.vert_data[mat_name].shape[1]
+        self.label_dim[mat_name] = self.vert_label_data[mat_name].shape[1]
+
+        if mat_name not in self.vert_buffer.keys():
+            self.vert_buffer[mat_name] = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, self.vert_buffer[mat_name])
+        glBufferData(GL_ARRAY_BUFFER, self.vert_data[mat_name], GL_STATIC_DRAW)
+
+        if mat_name not in self.vert_label_buffer.keys():
+            self.vert_label_buffer[mat_name] = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, self.vert_label_buffer[mat_name])
+        glBufferData(GL_ARRAY_BUFFER, self.vert_label_data[mat_name],
+                     GL_STATIC_DRAW)
+
+        self.uv_data[mat_name] = uvs[faces_uvs.reshape([-1])]
+        if mat_name not in self.uv_buffer.keys():
+            self.uv_buffer[mat_name] = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, self.uv_buffer[mat_name])
+        glBufferData(GL_ARRAY_BUFFER, self.uv_data[mat_name], GL_STATIC_DRAW)
+
+        self.norm_data[mat_name] = norms[faces_nml.reshape([-1])]
+        if mat_name not in self.norm_buffer.keys():
+            self.norm_buffer[mat_name] = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, self.norm_buffer[mat_name])
+        glBufferData(GL_ARRAY_BUFFER, self.norm_data[mat_name], GL_STATIC_DRAW)
+
+        self.tan_data[mat_name] = tans[faces_nml.reshape([-1])]
+        if mat_name not in self.tan_buffer.keys():
+            self.tan_buffer[mat_name] = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, self.tan_buffer[mat_name])
+        glBufferData(GL_ARRAY_BUFFER, self.tan_data[mat_name], GL_STATIC_DRAW)
+
+        self.btan_data[mat_name] = bitans[faces_nml.reshape([-1])]
+        if mat_name not in self.btan_buffer.keys():
+            self.btan_buffer[mat_name] = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, self.btan_buffer[mat_name])
+        glBufferData(GL_ARRAY_BUFFER, self.btan_data[mat_name], GL_STATIC_DRAW)
+
+        self.prt1_data[mat_name] = prt[faces_prt.reshape([-1])][:, :3]
+        self.prt2_data[mat_name] = prt[faces_prt.reshape([-1])][:, 3:6]
+        self.prt3_data[mat_name] = prt[faces_prt.reshape([-1])][:, 6:]
+
+        if mat_name not in self.prt1_buffer.keys():
+            self.prt1_buffer[mat_name] = glGenBuffers(1)
+        if mat_name not in self.prt2_buffer.keys():
+            self.prt2_buffer[mat_name] = glGenBuffers(1)
+        if mat_name not in self.prt3_buffer.keys():
+            self.prt3_buffer[mat_name] = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, self.prt1_buffer[mat_name])
+        glBufferData(GL_ARRAY_BUFFER, self.prt1_data[mat_name], GL_STATIC_DRAW)
+        glBindBuffer(GL_ARRAY_BUFFER, self.prt2_buffer[mat_name])
+        glBufferData(GL_ARRAY_BUFFER, self.prt2_data[mat_name], GL_STATIC_DRAW)
+        glBindBuffer(GL_ARRAY_BUFFER, self.prt3_buffer[mat_name])
+        glBufferData(GL_ARRAY_BUFFER, self.prt3_data[mat_name], GL_STATIC_DRAW)
+
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+
+    def set_mesh_mtl(self,
+                     vertices,
+                     faces,
+                     norms,
+                     faces_nml,
+                     uvs,
+                     faces_uvs,
+                     tans,
+                     bitans,
+                     prt,
+                     verts_label=None):
+        for key in faces:
+            self.vert_data[key] = vertices[faces[key].reshape([-1])]
+            self.vert_label_data[key] = verts_label[faces[key].reshape([-1])]
+            self.n_vertices[key] = self.vert_data[key].shape[0]
+            self.vertex_dim[key] = self.vert_data[key].shape[1]
+            self.label_dim[key] = self.vert_label_data[key].shape[1]
+
+            if key not in self.vert_buffer.keys():
+                self.vert_buffer[key] = glGenBuffers(1)
+            glBindBuffer(GL_ARRAY_BUFFER, self.vert_buffer[key])
+            glBufferData(GL_ARRAY_BUFFER, self.vert_data[key], GL_STATIC_DRAW)
+
+            if key not in self.vert_label_buffer.keys():
+                self.vert_label_buffer[key] = glGenBuffers(1)
+            glBindBuffer(GL_ARRAY_BUFFER, self.vert_label_buffer[key])
+            glBufferData(GL_ARRAY_BUFFER, self.vert_label_data[key],
+                         GL_STATIC_DRAW)
+
+            self.uv_data[key] = uvs[faces_uvs[key].reshape([-1])]
+            if key not in self.uv_buffer.keys():
+                self.uv_buffer[key] = glGenBuffers(1)
+            glBindBuffer(GL_ARRAY_BUFFER, self.uv_buffer[key])
+            glBufferData(GL_ARRAY_BUFFER, self.uv_data[key], GL_STATIC_DRAW)
+
+            self.norm_data[key] = norms[faces_nml[key].reshape([-1])]
+            if key not in self.norm_buffer.keys():
+                self.norm_buffer[key] = glGenBuffers(1)
+            glBindBuffer(GL_ARRAY_BUFFER, self.norm_buffer[key])
+            glBufferData(GL_ARRAY_BUFFER, self.norm_data[key], GL_STATIC_DRAW)
+
+            self.tan_data[key] = tans[faces_nml[key].reshape([-1])]
+            if key not in self.tan_buffer.keys():
+                self.tan_buffer[key] = glGenBuffers(1)
+            glBindBuffer(GL_ARRAY_BUFFER, self.tan_buffer[key])
+            glBufferData(GL_ARRAY_BUFFER, self.tan_data[key], GL_STATIC_DRAW)
+
+            self.btan_data[key] = bitans[faces_nml[key].reshape([-1])]
+            if key not in self.btan_buffer.keys():
+                self.btan_buffer[key] = glGenBuffers(1)
+            glBindBuffer(GL_ARRAY_BUFFER, self.btan_buffer[key])
+            glBufferData(GL_ARRAY_BUFFER, self.btan_data[key], GL_STATIC_DRAW)
+
+            self.prt1_data[key] = prt[faces[key].reshape([-1])][:, :3]
+            self.prt2_data[key] = prt[faces[key].reshape([-1])][:, 3:6]
+            self.prt3_data[key] = prt[faces[key].reshape([-1])][:, 6:]
+
+            if key not in self.prt1_buffer.keys():
+                self.prt1_buffer[key] = glGenBuffers(1)
+            if key not in self.prt2_buffer.keys():
+                self.prt2_buffer[key] = glGenBuffers(1)
+            if key not in self.prt3_buffer.keys():
+                self.prt3_buffer[key] = glGenBuffers(1)
+            glBindBuffer(GL_ARRAY_BUFFER, self.prt1_buffer[key])
+            glBufferData(GL_ARRAY_BUFFER, self.prt1_data[key], GL_STATIC_DRAW)
+            glBindBuffer(GL_ARRAY_BUFFER, self.prt2_buffer[key])
+            glBufferData(GL_ARRAY_BUFFER, self.prt2_data[key], GL_STATIC_DRAW)
+            glBindBuffer(GL_ARRAY_BUFFER, self.prt3_buffer[key])
+            glBufferData(GL_ARRAY_BUFFER, self.prt3_data[key], GL_STATIC_DRAW)
+
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+
+    def cleanup(self):
+
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+        for key in self.vert_data:
+            glDeleteBuffers(1, [self.vert_buffer[key]])
+            glDeleteBuffers(1, [self.norm_buffer[key]])
+            glDeleteBuffers(1, [self.uv_buffer[key]])
+            glDeleteBuffers(1, [self.vert_label_buffer[key]])
+
+            glDeleteBuffers(1, [self.tan_buffer[key]])
+            glDeleteBuffers(1, [self.btan_buffer[key]])
+            glDeleteBuffers(1, [self.prt1_buffer[key]])
+            glDeleteBuffers(1, [self.prt2_buffer[key]])
+            glDeleteBuffers(1, [self.prt3_buffer[key]])
+
+            glDeleteBuffers(1, [])
+
+            for smplr in self.render_texture_mat[key]:
+                glDeleteTextures([self.render_texture_mat[key][smplr]])
+
+        self.vert_buffer = {}
+        self.vert_data = {}
+
+        self.vert_label_buffer = {}
+        self.vert_label_data = {}
+
+        self.norm_buffer = {}
+        self.norm_data = {}
+
+        self.tan_buffer = {}
+        self.tan_data = {}
+
+        self.btan_buffer = {}
+        self.btan_data = {}
+
+        self.prt1_buffer = {}
+        self.prt1_data = {}
+
+        self.prt2_buffer = {}
+        self.prt2_data = {}
+
+        self.prt3_buffer = {}
+        self.prt3_data = {}
+
+        self.uv_buffer = {}
+        self.uv_data = {}
+
+        self.render_texture_mat = {}
+
+        self.vertex_dim = {}
+        self.n_vertices = {}
+        self.label_dim = {}
+
+    def randomize_sh(self):
+        self.shcoeffs[0, :] = 0.8
+        self.shcoeffs[1:, :] = 1.0 * np.random.rand(8, 3)
+
+    def set_sh(self, sh):
+        self.shcoeffs = sh
+
+    def set_norm_mat(self, scale, center):
+        N = np.eye(4)
+        N[:3, :3] = scale * np.eye(3)
+        N[:3, 3] = -scale * center
+
+        self.normalize_matrix = N
+
+    def draw(self):
+        self.draw_init()
+
+        glDisable(GL_BLEND)
+        #glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+        glEnable(GL_MULTISAMPLE)
+
+        glUseProgram(self.program)
+        glUniformMatrix4fv(self.norm_mat_unif, 1, GL_FALSE,
+                           self.normalize_matrix.transpose())
+        glUniformMatrix4fv(self.model_mat_unif, 1, GL_FALSE,
+                           self.model_view_matrix.transpose())
+        glUniformMatrix4fv(self.persp_mat_unif, 1, GL_FALSE,
+                           self.projection_matrix.transpose())
+
+        if 'AlbedoMap' in self.render_texture_mat['all']:
+            glUniform1ui(self.hasAlbedoUnif, GLuint(1))
+        else:
+            glUniform1ui(self.hasAlbedoUnif, GLuint(0))
+
+        if 'NormalMap' in self.render_texture_mat['all']:
+            glUniform1ui(self.hasNormalUnif, GLuint(1))
+        else:
+            glUniform1ui(self.hasNormalUnif, GLuint(0))
+
+        glUniform1ui(self.analyticUnif,
+                     GLuint(1) if self.analytic else GLuint(0))
+
+        glUniform3fv(self.shcoeff_unif, 9, self.shcoeffs)
+
+        glUniformMatrix3fv(self.rot_mat_unif, 1, GL_FALSE,
+                           self.rot_matrix.transpose())
+
+        for mat in self.vert_buffer:
+            # Handle vertex buffer
+            glBindBuffer(GL_ARRAY_BUFFER, self.vert_buffer[mat])
+            glEnableVertexAttribArray(0)
+            glVertexAttribPointer(0, self.vertex_dim[mat], GL_DOUBLE, GL_FALSE,
+                                  0, None)
+
+            # Handle normal buffer
+            glBindBuffer(GL_ARRAY_BUFFER, self.norm_buffer[mat])
+            glEnableVertexAttribArray(1)
+            glVertexAttribPointer(1, 3, GL_DOUBLE, GL_FALSE, 0, None)
+
+            # Handle uv buffer
+            glBindBuffer(GL_ARRAY_BUFFER, self.uv_buffer[mat])
+            glEnableVertexAttribArray(2)
+            glVertexAttribPointer(2, 2, GL_DOUBLE, GL_FALSE, 0, None)
+
+            # Handle tan buffer
+            glBindBuffer(GL_ARRAY_BUFFER, self.tan_buffer[mat])
+            glEnableVertexAttribArray(3)
+            glVertexAttribPointer(3, 3, GL_DOUBLE, GL_FALSE, 0, None)
+
+            # Handle btan buffer
+            glBindBuffer(GL_ARRAY_BUFFER, self.btan_buffer[mat])
+            glEnableVertexAttribArray(4)
+            glVertexAttribPointer(4, 3, GL_DOUBLE, GL_FALSE, 0, None)
+
+            # Handle PTR buffer
+            glBindBuffer(GL_ARRAY_BUFFER, self.prt1_buffer[mat])
+            glEnableVertexAttribArray(5)
+            glVertexAttribPointer(5, 3, GL_DOUBLE, GL_FALSE, 0, None)
+
+            glBindBuffer(GL_ARRAY_BUFFER, self.prt2_buffer[mat])
+            glEnableVertexAttribArray(6)
+            glVertexAttribPointer(6, 3, GL_DOUBLE, GL_FALSE, 0, None)
+
+            glBindBuffer(GL_ARRAY_BUFFER, self.prt3_buffer[mat])
+            glEnableVertexAttribArray(7)
+            glVertexAttribPointer(7, 3, GL_DOUBLE, GL_FALSE, 0, None)
+
+            # Handle vertex label buffer
+            glBindBuffer(GL_ARRAY_BUFFER, self.vert_label_buffer[mat])
+            glEnableVertexAttribArray(8)
+            glVertexAttribPointer(8, self.label_dim[mat], GL_DOUBLE, GL_FALSE,
+                                  0, None)
+
+            for i, smplr in enumerate(self.render_texture_mat[mat]):
+                glActiveTexture(GL_TEXTURE0 + i)
+                glBindTexture(GL_TEXTURE_2D,
+                              self.render_texture_mat[mat][smplr])
+                glUniform1i(glGetUniformLocation(self.program, smplr), i)
+
+            glDrawArrays(GL_TRIANGLES, 0, self.n_vertices[mat])
+
+            glDisableVertexAttribArray(8)
+            glDisableVertexAttribArray(7)
+            glDisableVertexAttribArray(6)
+            glDisableVertexAttribArray(5)
+            glDisableVertexAttribArray(4)
+            glDisableVertexAttribArray(3)
+            glDisableVertexAttribArray(2)
+            glDisableVertexAttribArray(1)
+            glDisableVertexAttribArray(0)
+
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+
+        glUseProgram(0)
+
+        glDisable(GL_BLEND)
+        glDisable(GL_MULTISAMPLE)
+
+        self.draw_end()

lib/renderer/gl/render.py

@@ -0,0 +1,380 @@
+
+# -*- coding: utf-8 -*-
+
+# Max-Planck-Gesellschaft zur Förderung der Wissenschaften e.V. (MPG) is
+# holder of all proprietary rights on this computer program.
+# You can only use this computer program if you have closed
+# a license agreement with MPG or you get the right to use the computer
+# program from someone who is authorized to grant you that right.
+# Any use of the computer program without a valid license is prohibited and
+# liable to prosecution.
+#
+# Copyright©2019 Max-Planck-Gesellschaft zur Förderung
+# der Wissenschaften e.V. (MPG). acting on behalf of its Max Planck Institute
+# for Intelligent Systems. All rights reserved.
+#
+# Contact: [email protected]
+
+from ctypes import *
+
+import numpy as np
+from .framework import *
+
+GLUT = None
+
+
+# NOTE: Render class assumes GL context is created already.
+class Render:
+    def __init__(self,
+                 width=1600,
+                 height=1200,
+                 name='GL Renderer',
+                 program_files=['simple.fs', 'simple.vs'],
+                 color_size=1,
+                 ms_rate=1,
+                 egl=False):
+        self.width = width
+        self.height = height
+        self.name = name
+        self.use_inverse_depth = False
+        self.egl = egl
+
+        glEnable(GL_DEPTH_TEST)
+
+        glClampColor(GL_CLAMP_READ_COLOR, GL_FALSE)
+        glClampColor(GL_CLAMP_FRAGMENT_COLOR, GL_FALSE)
+        glClampColor(GL_CLAMP_VERTEX_COLOR, GL_FALSE)
+
+        # init program
+        shader_list = []
+
+        for program_file in program_files:
+            _, ext = os.path.splitext(program_file)
+            if ext == '.vs':
+                shader_list.append(loadShader(GL_VERTEX_SHADER, program_file))
+            elif ext == '.fs':
+                shader_list.append(loadShader(GL_FRAGMENT_SHADER,
+                                              program_file))
+            elif ext == '.gs':
+                shader_list.append(loadShader(GL_GEOMETRY_SHADER,
+                                              program_file))
+
+        self.program = createProgram(shader_list)
+
+        for shader in shader_list:
+            glDeleteShader(shader)
+
+        # Init uniform variables
+        self.model_mat_unif = glGetUniformLocation(self.program, 'ModelMat')
+        self.persp_mat_unif = glGetUniformLocation(self.program, 'PerspMat')
+
+        self.vertex_buffer = glGenBuffers(1)
+
+        # Init screen quad program and buffer
+        self.quad_program, self.quad_buffer = self.init_quad_program()
+
+        # Configure frame buffer
+        self.frame_buffer = glGenFramebuffers(1)
+        glBindFramebuffer(GL_FRAMEBUFFER, self.frame_buffer)
+
+        self.intermediate_fbo = None
+        if ms_rate > 1:
+            # Configure texture buffer to render to
+            self.color_buffer = []
+            for i in range(color_size):
+                color_buffer = glGenTextures(1)
+                multi_sample_rate = ms_rate
+                glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, color_buffer)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
+                                GL_CLAMP_TO_EDGE)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
+                                GL_CLAMP_TO_EDGE)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+                                GL_LINEAR)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                                GL_LINEAR)
+                glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE,
+                                        multi_sample_rate, GL_RGBA32F,
+                                        self.width, self.height, GL_TRUE)
+                glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0)
+                glFramebufferTexture2D(GL_FRAMEBUFFER,
+                                       GL_COLOR_ATTACHMENT0 + i,
+                                       GL_TEXTURE_2D_MULTISAMPLE, color_buffer,
+                                       0)
+                self.color_buffer.append(color_buffer)
+
+            self.render_buffer = glGenRenderbuffers(1)
+            glBindRenderbuffer(GL_RENDERBUFFER, self.render_buffer)
+            glRenderbufferStorageMultisample(GL_RENDERBUFFER,
+                                             multi_sample_rate,
+                                             GL_DEPTH24_STENCIL8, self.width,
+                                             self.height)
+            glBindRenderbuffer(GL_RENDERBUFFER, 0)
+            glFramebufferRenderbuffer(GL_FRAMEBUFFER,
+                                      GL_DEPTH_STENCIL_ATTACHMENT,
+                                      GL_RENDERBUFFER, self.render_buffer)
+
+            attachments = []
+            for i in range(color_size):
+                attachments.append(GL_COLOR_ATTACHMENT0 + i)
+            glDrawBuffers(color_size, attachments)
+            glBindFramebuffer(GL_FRAMEBUFFER, 0)
+
+            self.intermediate_fbo = glGenFramebuffers(1)
+            glBindFramebuffer(GL_FRAMEBUFFER, self.intermediate_fbo)
+
+            self.screen_texture = []
+            for i in range(color_size):
+                screen_texture = glGenTextures(1)
+                glBindTexture(GL_TEXTURE_2D, screen_texture)
+                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, self.width,
+                             self.height, 0, GL_RGBA, GL_FLOAT, None)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                                GL_LINEAR)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+                                GL_LINEAR)
+                glFramebufferTexture2D(GL_FRAMEBUFFER,
+                                       GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D,
+                                       screen_texture, 0)
+                self.screen_texture.append(screen_texture)
+
+            glDrawBuffers(color_size, attachments)
+            glBindFramebuffer(GL_FRAMEBUFFER, 0)
+        else:
+            self.color_buffer = []
+            for i in range(color_size):
+                color_buffer = glGenTextures(1)
+                glBindTexture(GL_TEXTURE_2D, color_buffer)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
+                                GL_CLAMP_TO_EDGE)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
+                                GL_CLAMP_TO_EDGE)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+                                GL_NEAREST)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                                GL_NEAREST)
+                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, self.width,
+                             self.height, 0, GL_RGBA, GL_FLOAT, None)
+                glFramebufferTexture2D(GL_FRAMEBUFFER,
+                                       GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D,
+                                       color_buffer, 0)
+                self.color_buffer.append(color_buffer)
+
+            # Configure depth texture map to render to
+            self.depth_buffer = glGenTextures(1)
+            glBindTexture(GL_TEXTURE_2D, self.depth_buffer)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+            glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE,
+                            GL_COMPARE_R_TO_TEXTURE)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL)
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, self.width,
+                         self.height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, None)
+            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                                   GL_TEXTURE_2D, self.depth_buffer, 0)
+
+            attachments = []
+            for i in range(color_size):
+                attachments.append(GL_COLOR_ATTACHMENT0 + i)
+            glDrawBuffers(color_size, attachments)
+            self.screen_texture = self.color_buffer
+
+            glBindFramebuffer(GL_FRAMEBUFFER, 0)
+
+        # Configure texture buffer if needed
+        self.render_texture = None
+
+        # NOTE: original render_texture only support one input
+        # this is tentative member of this issue
+        self.render_texture_v2 = {}
+
+        # Inner storage for buffer data
+        self.vertex_data = None
+        self.vertex_dim = None
+        self.n_vertices = None
+
+        self.model_view_matrix = None
+        self.projection_matrix = None
+
+        if not egl:
+            global GLUT
+            import OpenGL.GLUT as GLUT
+            GLUT.glutDisplayFunc(self.display)
+
+    def init_quad_program(self):
+        shader_list = []
+
+        shader_list.append(loadShader(GL_VERTEX_SHADER, "quad.vs"))
+        shader_list.append(loadShader(GL_FRAGMENT_SHADER, "quad.fs"))
+
+        the_program = createProgram(shader_list)
+
+        for shader in shader_list:
+            glDeleteShader(shader)
+
+        # vertex attributes for a quad that fills the entire screen in Normalized Device Coordinates.
+        # positions # texCoords
+        quad_vertices = np.array([
+            -1.0, 1.0, 0.0, 1.0, -1.0, -1.0, 0.0, 0.0, 1.0, -1.0, 1.0, 0.0,
+            -1.0, 1.0, 0.0, 1.0, 1.0, -1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0
+        ])
+
+        quad_buffer = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, quad_buffer)
+        glBufferData(GL_ARRAY_BUFFER, quad_vertices, GL_STATIC_DRAW)
+
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+
+        return the_program, quad_buffer
+
+    def set_mesh(self, vertices, faces):
+        self.vertex_data = vertices[faces.reshape([-1])]
+        self.vertex_dim = self.vertex_data.shape[1]
+        self.n_vertices = self.vertex_data.shape[0]
+
+        glBindBuffer(GL_ARRAY_BUFFER, self.vertex_buffer)
+        glBufferData(GL_ARRAY_BUFFER, self.vertex_data, GL_STATIC_DRAW)
+
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+
+    def set_viewpoint(self, projection, model_view):
+        self.projection_matrix = projection
+        self.model_view_matrix = model_view
+
+    def draw_init(self):
+        glBindFramebuffer(GL_FRAMEBUFFER, self.frame_buffer)
+        glEnable(GL_DEPTH_TEST)
+
+        glClearColor(0.0, 0.0, 0.0, 0.0)
+        if self.use_inverse_depth:
+            glDepthFunc(GL_GREATER)
+            glClearDepth(0.0)
+        else:
+            glDepthFunc(GL_LESS)
+            glClearDepth(1.0)
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+
+    def draw_end(self):
+        if self.intermediate_fbo is not None:
+            for i in range(len(self.color_buffer)):
+                glBindFramebuffer(GL_READ_FRAMEBUFFER, self.frame_buffer)
+                glReadBuffer(GL_COLOR_ATTACHMENT0 + i)
+                glBindFramebuffer(GL_DRAW_FRAMEBUFFER, self.intermediate_fbo)
+                glDrawBuffer(GL_COLOR_ATTACHMENT0 + i)
+                glBlitFramebuffer(0, 0, self.width, self.height, 0, 0,
+                                  self.width, self.height, GL_COLOR_BUFFER_BIT,
+                                  GL_NEAREST)
+
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+        glDepthFunc(GL_LESS)
+        glClearDepth(1.0)
+
+    def draw(self):
+        self.draw_init()
+
+        glUseProgram(self.program)
+        glUniformMatrix4fv(self.model_mat_unif, 1, GL_FALSE,
+                           self.model_view_matrix.transpose())
+        glUniformMatrix4fv(self.persp_mat_unif, 1, GL_FALSE,
+                           self.projection_matrix.transpose())
+
+        glBindBuffer(GL_ARRAY_BUFFER, self.vertex_buffer)
+
+        glEnableVertexAttribArray(0)
+        glVertexAttribPointer(0, self.vertex_dim, GL_DOUBLE, GL_FALSE, 0, None)
+
+        glDrawArrays(GL_TRIANGLES, 0, self.n_vertices)
+
+        glDisableVertexAttribArray(0)
+
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+
+        glUseProgram(0)
+
+        self.draw_end()
+
+    def get_color(self, color_id=0):
+        glBindFramebuffer(
+            GL_FRAMEBUFFER, self.intermediate_fbo
+            if self.intermediate_fbo is not None else self.frame_buffer)
+        glReadBuffer(GL_COLOR_ATTACHMENT0 + color_id)
+        data = glReadPixels(0,
+                            0,
+                            self.width,
+                            self.height,
+                            GL_RGBA,
+                            GL_FLOAT,
+                            outputType=None)
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+        rgb = data.reshape(self.height, self.width, -1)
+        rgb = np.flip(rgb, 0)
+        return rgb
+
+    def get_z_value(self):
+        glBindFramebuffer(GL_FRAMEBUFFER, self.frame_buffer)
+        data = glReadPixels(0,
+                            0,
+                            self.width,
+                            self.height,
+                            GL_DEPTH_COMPONENT,
+                            GL_FLOAT,
+                            outputType=None)
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+        z = data.reshape(self.height, self.width)
+        z = np.flip(z, 0)
+        return z
+
+    def display(self):
+        self.draw()
+
+        if not self.egl:
+            # First we draw a scene.
+            # Notice the result is stored in the texture buffer.
+
+            # Then we return to the default frame buffer since we will display on the screen.
+            glBindFramebuffer(GL_FRAMEBUFFER, 0)
+
+            # Do the clean-up.
+            glClearColor(0.0, 0.0, 0.0, 0.0)
+            glClear(GL_COLOR_BUFFER_BIT)
+
+            # We draw a rectangle which covers the whole screen.
+            glUseProgram(self.quad_program)
+            glBindBuffer(GL_ARRAY_BUFFER, self.quad_buffer)
+
+            size_of_double = 8
+            glEnableVertexAttribArray(0)
+            glVertexAttribPointer(0, 2, GL_DOUBLE, GL_FALSE,
+                                  4 * size_of_double, None)
+            glEnableVertexAttribArray(1)
+            glVertexAttribPointer(1, 2, GL_DOUBLE, GL_FALSE,
+                                  4 * size_of_double,
+                                  c_void_p(2 * size_of_double))
+
+            glDisable(GL_DEPTH_TEST)
+
+            # The stored texture is then mapped to this rectangle.
+            # properly assing color buffer texture
+            glActiveTexture(GL_TEXTURE0)
+            glBindTexture(GL_TEXTURE_2D, self.screen_texture[0])
+            glUniform1i(
+                glGetUniformLocation(self.quad_program, 'screenTexture'), 0)
+
+            glDrawArrays(GL_TRIANGLES, 0, 6)
+
+            glDisableVertexAttribArray(1)
+            glDisableVertexAttribArray(0)
+
+            glEnable(GL_DEPTH_TEST)
+            glBindBuffer(GL_ARRAY_BUFFER, 0)
+            glUseProgram(0)
+
+            GLUT.glutSwapBuffers()
+            GLUT.glutPostRedisplay()
+
+    def show(self):
+        if not self.egl:
+            GLUT.glutMainLoop()

lib/renderer/gl/render2.py

@@ -0,0 +1,388 @@
+'''
+MIT License
+
+Copyright (c) 2019 Shunsuke Saito, Zeng Huang, and Ryota Natsume
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+'''
+import numpy as np
+from OpenGL.GLUT import *
+from .framework import *
+
+_glut_window = None
+
+
+class Render:
+    def __init__(self,
+                 width=1600,
+                 height=1200,
+                 name='GL Renderer',
+                 program_files=['simple.fs', 'simple.vs'],
+                 color_size=1,
+                 ms_rate=1):
+        self.width = width
+        self.height = height
+        self.name = name
+        self.display_mode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH
+        self.use_inverse_depth = False
+
+        global _glut_window
+        if _glut_window is None:
+            glutInit()
+            glutInitDisplayMode(self.display_mode)
+            glutInitWindowSize(self.width, self.height)
+            glutInitWindowPosition(0, 0)
+            _glut_window = glutCreateWindow("My Render.")
+
+            # glEnable(GL_DEPTH_CLAMP)
+            glEnable(GL_DEPTH_TEST)
+
+            glClampColor(GL_CLAMP_READ_COLOR, GL_FALSE)
+            glClampColor(GL_CLAMP_FRAGMENT_COLOR, GL_FALSE)
+            glClampColor(GL_CLAMP_VERTEX_COLOR, GL_FALSE)
+
+        # init program
+        shader_list = []
+
+        for program_file in program_files:
+            _, ext = os.path.splitext(program_file)
+            if ext == '.vs':
+                shader_list.append(loadShader(GL_VERTEX_SHADER, program_file))
+            elif ext == '.fs':
+                shader_list.append(loadShader(GL_FRAGMENT_SHADER,
+                                              program_file))
+            elif ext == '.gs':
+                shader_list.append(loadShader(GL_GEOMETRY_SHADER,
+                                              program_file))
+
+        self.program = createProgram(shader_list)
+
+        for shader in shader_list:
+            glDeleteShader(shader)
+
+        # Init uniform variables
+        self.model_mat_unif = glGetUniformLocation(self.program, 'ModelMat')
+        self.persp_mat_unif = glGetUniformLocation(self.program, 'PerspMat')
+
+        self.vertex_buffer = glGenBuffers(1)
+
+        # Init screen quad program and buffer
+        self.quad_program, self.quad_buffer = self.init_quad_program()
+
+        # Configure frame buffer
+        self.frame_buffer = glGenFramebuffers(1)
+        glBindFramebuffer(GL_FRAMEBUFFER, self.frame_buffer)
+
+        self.intermediate_fbo = None
+        if ms_rate > 1:
+            # Configure texture buffer to render to
+            self.color_buffer = []
+            for i in range(color_size):
+                color_buffer = glGenTextures(1)
+                multi_sample_rate = ms_rate
+                glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, color_buffer)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
+                                GL_CLAMP_TO_EDGE)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
+                                GL_CLAMP_TO_EDGE)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+                                GL_LINEAR)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                                GL_LINEAR)
+                glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE,
+                                        multi_sample_rate, GL_RGBA32F,
+                                        self.width, self.height, GL_TRUE)
+                glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0)
+                glFramebufferTexture2D(GL_FRAMEBUFFER,
+                                       GL_COLOR_ATTACHMENT0 + i,
+                                       GL_TEXTURE_2D_MULTISAMPLE, color_buffer,
+                                       0)
+                self.color_buffer.append(color_buffer)
+
+            self.render_buffer = glGenRenderbuffers(1)
+            glBindRenderbuffer(GL_RENDERBUFFER, self.render_buffer)
+            glRenderbufferStorageMultisample(GL_RENDERBUFFER,
+                                             multi_sample_rate,
+                                             GL_DEPTH24_STENCIL8, self.width,
+                                             self.height)
+            glBindRenderbuffer(GL_RENDERBUFFER, 0)
+            glFramebufferRenderbuffer(GL_FRAMEBUFFER,
+                                      GL_DEPTH_STENCIL_ATTACHMENT,
+                                      GL_RENDERBUFFER, self.render_buffer)
+
+            attachments = []
+            for i in range(color_size):
+                attachments.append(GL_COLOR_ATTACHMENT0 + i)
+            glDrawBuffers(color_size, attachments)
+            glBindFramebuffer(GL_FRAMEBUFFER, 0)
+
+            self.intermediate_fbo = glGenFramebuffers(1)
+            glBindFramebuffer(GL_FRAMEBUFFER, self.intermediate_fbo)
+
+            self.screen_texture = []
+            for i in range(color_size):
+                screen_texture = glGenTextures(1)
+                glBindTexture(GL_TEXTURE_2D, screen_texture)
+                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, self.width,
+                             self.height, 0, GL_RGBA, GL_FLOAT, None)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                                GL_LINEAR)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+                                GL_LINEAR)
+                glFramebufferTexture2D(GL_FRAMEBUFFER,
+                                       GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D,
+                                       screen_texture, 0)
+                self.screen_texture.append(screen_texture)
+
+            glDrawBuffers(color_size, attachments)
+            glBindFramebuffer(GL_FRAMEBUFFER, 0)
+        else:
+            self.color_buffer = []
+            for i in range(color_size):
+                color_buffer = glGenTextures(1)
+                glBindTexture(GL_TEXTURE_2D, color_buffer)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
+                                GL_CLAMP_TO_EDGE)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
+                                GL_CLAMP_TO_EDGE)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+                                GL_NEAREST)
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                                GL_NEAREST)
+                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, self.width,
+                             self.height, 0, GL_RGBA, GL_FLOAT, None)
+                glFramebufferTexture2D(GL_FRAMEBUFFER,
+                                       GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D,
+                                       color_buffer, 0)
+                self.color_buffer.append(color_buffer)
+
+            # Configure depth texture map to render to
+            self.depth_buffer = glGenTextures(1)
+            glBindTexture(GL_TEXTURE_2D, self.depth_buffer)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+            glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE,
+                            GL_COMPARE_R_TO_TEXTURE)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL)
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, self.width,
+                         self.height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, None)
+            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                                   GL_TEXTURE_2D, self.depth_buffer, 0)
+
+            attachments = []
+            for i in range(color_size):
+                attachments.append(GL_COLOR_ATTACHMENT0 + i)
+            glDrawBuffers(color_size, attachments)
+            self.screen_texture = self.color_buffer
+
+            glBindFramebuffer(GL_FRAMEBUFFER, 0)
+
+        # Configure texture buffer if needed
+        self.render_texture = None
+
+        # NOTE: original render_texture only support one input
+        # this is tentative member of this issue
+        self.render_texture_v2 = {}
+
+        # Inner storage for buffer data
+        self.vertex_data = None
+        self.vertex_dim = None
+        self.n_vertices = None
+
+        self.model_view_matrix = None
+        self.projection_matrix = None
+
+        glutDisplayFunc(self.display)
+
+    def init_quad_program(self):
+        shader_list = []
+
+        shader_list.append(loadShader(GL_VERTEX_SHADER, "quad.vs"))
+        shader_list.append(loadShader(GL_FRAGMENT_SHADER, "quad.fs"))
+
+        the_program = createProgram(shader_list)
+
+        for shader in shader_list:
+            glDeleteShader(shader)
+
+        # vertex attributes for a quad that fills the entire screen in Normalized Device Coordinates.
+        # positions # texCoords
+        quad_vertices = np.array([
+            -1.0, 1.0, 0.0, 1.0, -1.0, -1.0, 0.0, 0.0, 1.0, -1.0, 1.0, 0.0,
+            -1.0, 1.0, 0.0, 1.0, 1.0, -1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0
+        ])
+
+        quad_buffer = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, quad_buffer)
+        glBufferData(GL_ARRAY_BUFFER, quad_vertices, GL_STATIC_DRAW)
+
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+
+        return the_program, quad_buffer
+
+    def set_mesh(self, vertices, faces):
+        self.vertex_data = vertices[faces.reshape([-1])]
+        self.vertex_dim = self.vertex_data.shape[1]
+        self.n_vertices = self.vertex_data.shape[0]
+
+        glBindBuffer(GL_ARRAY_BUFFER, self.vertex_buffer)
+        glBufferData(GL_ARRAY_BUFFER, self.vertex_data, GL_STATIC_DRAW)
+
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+
+    def set_viewpoint(self, projection, model_view):
+        self.projection_matrix = projection
+        self.model_view_matrix = model_view
+
+    def draw_init(self):
+        glBindFramebuffer(GL_FRAMEBUFFER, self.frame_buffer)
+        glEnable(GL_DEPTH_TEST)
+
+        # glClearColor(0.0, 0.0, 0.0, 0.0)
+        glClearColor(1.0, 1.0, 1.0, 0.0)  # Black background
+
+        if self.use_inverse_depth:
+            glDepthFunc(GL_GREATER)
+            glClearDepth(0.0)
+        else:
+            glDepthFunc(GL_LESS)
+            glClearDepth(1.0)
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+
+    def draw_end(self):
+        if self.intermediate_fbo is not None:
+            for i in range(len(self.color_buffer)):
+                glBindFramebuffer(GL_READ_FRAMEBUFFER, self.frame_buffer)
+                glReadBuffer(GL_COLOR_ATTACHMENT0 + i)
+                glBindFramebuffer(GL_DRAW_FRAMEBUFFER, self.intermediate_fbo)
+                glDrawBuffer(GL_COLOR_ATTACHMENT0 + i)
+                glBlitFramebuffer(0, 0, self.width, self.height, 0, 0,
+                                  self.width, self.height, GL_COLOR_BUFFER_BIT,
+                                  GL_NEAREST)
+
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+        glDepthFunc(GL_LESS)
+        glClearDepth(1.0)
+
+    def draw(self):
+        self.draw_init()
+
+        glUseProgram(self.program)
+        glUniformMatrix4fv(self.model_mat_unif, 1, GL_FALSE,
+                           self.model_view_matrix.transpose())
+        glUniformMatrix4fv(self.persp_mat_unif, 1, GL_FALSE,
+                           self.projection_matrix.transpose())
+
+        glBindBuffer(GL_ARRAY_BUFFER, self.vertex_buffer)
+
+        glEnableVertexAttribArray(0)
+        glVertexAttribPointer(0, self.vertex_dim, GL_DOUBLE, GL_FALSE, 0, None)
+
+        glDrawArrays(GL_TRIANGLES, 0, self.n_vertices)
+
+        glDisableVertexAttribArray(0)
+
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+
+        glUseProgram(0)
+
+        self.draw_end()
+
+    def get_color(self, color_id=0):
+        glBindFramebuffer(
+            GL_FRAMEBUFFER, self.intermediate_fbo
+            if self.intermediate_fbo is not None else self.frame_buffer)
+        glReadBuffer(GL_COLOR_ATTACHMENT0 + color_id)
+        data = glReadPixels(0,
+                            0,
+                            self.width,
+                            self.height,
+                            GL_RGBA,
+                            GL_FLOAT,
+                            outputType=None)
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+        rgb = data.reshape(self.height, self.width, -1)
+        rgb = np.flip(rgb, 0)
+        return rgb
+
+    def get_z_value(self):
+        glBindFramebuffer(GL_FRAMEBUFFER, self.frame_buffer)
+        data = glReadPixels(0,
+                            0,
+                            self.width,
+                            self.height,
+                            GL_DEPTH_COMPONENT,
+                            GL_FLOAT,
+                            outputType=None)
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+        z = data.reshape(self.height, self.width)
+        z = np.flip(z, 0)
+        return z
+
+    def display(self):
+        # First we draw a scene.
+        # Notice the result is stored in the texture buffer.
+        self.draw()
+
+        # Then we return to the default frame buffer since we will display on the screen.
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+
+        # Do the clean-up.
+        # glClearColor(0.0, 0.0, 0.0, 0.0)        #Black background
+        glClearColor(1.0, 1.0, 1.0, 0.0)  # Black background
+        glClear(GL_COLOR_BUFFER_BIT)
+
+        # We draw a rectangle which covers the whole screen.
+        glUseProgram(self.quad_program)
+        glBindBuffer(GL_ARRAY_BUFFER, self.quad_buffer)
+
+        size_of_double = 8
+        glEnableVertexAttribArray(0)
+        glVertexAttribPointer(0, 2, GL_DOUBLE, GL_FALSE, 4 * size_of_double,
+                              None)
+        glEnableVertexAttribArray(1)
+        glVertexAttribPointer(1, 2, GL_DOUBLE, GL_FALSE, 4 * size_of_double,
+                              c_void_p(2 * size_of_double))
+
+        glDisable(GL_DEPTH_TEST)
+
+        # The stored texture is then mapped to this rectangle.
+        # properly assing color buffer texture
+        glActiveTexture(GL_TEXTURE0)
+        glBindTexture(GL_TEXTURE_2D, self.screen_texture[0])
+        glUniform1i(glGetUniformLocation(self.quad_program, 'screenTexture'),
+                    0)
+
+        glDrawArrays(GL_TRIANGLES, 0, 6)
+
+        glDisableVertexAttribArray(1)
+        glDisableVertexAttribArray(0)
+
+        glEnable(GL_DEPTH_TEST)
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+        glUseProgram(0)
+
+        glutSwapBuffers()
+        glutPostRedisplay()
+
+    def show(self):
+        glutMainLoop()