コード例 #1
0
ファイル: exmp1.py プロジェクト: chxzh/shadyn
    def run(self):
        # initializer timer
        glfw.set_time(0.0)
        t = 0.0
        while not glfw.window_should_close(self.win) and not self.exitNow:
            # update every x seconds
            currT = glfw.get_time()
            if currT - t > 0.1:
                # update time
                t = currT
                # clear
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

                # build projection matrix
                pMatrix = glutils.perspective(45.0, self.aspect, 0.1, 100.0)

                mvMatrix = glutils.lookAt([0.0, 0.0, -2.0], [0.0, 0.0, 0.0],
                                          [0.0, 1.0, 0.0])
                # render
                self.scene.render(pMatrix, mvMatrix)
                # step 
                self.scene.step()

                glfw.swap_buffers(self.win)
                # Poll for and process events
                glfw.poll_events()
        # end
        glfw.terminate()
コード例 #2
0
ファイル: mjviewer.py プロジェクト: TungTNguyen/deeprlhw2
    def handle_mouse_button(self, window, button, act, mods):
        # update button state
        self._button_left_pressed = \
                glfw.get_mouse_button(window, glfw.MOUSE_BUTTON_LEFT) == glfw.PRESS
        self._button_middle_pressed = \
                glfw.get_mouse_button(window, glfw.MOUSE_BUTTON_MIDDLE) == glfw.PRESS
        self._button_right_pressed = \
                glfw.get_mouse_button(window, glfw.MOUSE_BUTTON_RIGHT) == glfw.PRESS

        # update mouse position
        x, y = glfw.get_cursor_pos(window)
        self._last_mouse_x = int(self._scale * x)
        self._last_mouse_y = int(self._scale * y)

        if not self.model:
            return

        self.gui_lock.acquire()

        # save info
        if act == glfw.PRESS:
            self._last_button = button
            self._last_click_time = glfw.get_time()

        self.gui_lock.release()
コード例 #3
0
def render(shader, vao, tex, tex2):
    gl.glClearColor(0.2, 0.3, 0.3, 0.4)
    gl.glClear(gl.GL_COLOR_BUFFER_BIT|gl.GL_DEPTH_BUFFER_BIT)

    gl.glBindTexture(gl.GL_TEXTURE_2D, tex)
    gl.glUseProgram(shader)
    gl.glActiveTexture(gl.GL_TEXTURE0)
    gl.glBindTexture(gl.GL_TEXTURE_2D, tex)
    gl.glUniform1i(gl.glGetUniformLocation(shader, "ourTexture1"), 0)
    gl.glActiveTexture(gl.GL_TEXTURE1)
    gl.glBindTexture(gl.GL_TEXTURE_2D, tex2)
    gl.glUniform1i(gl.glGetUniformLocation(shader, "ourTexture2"), 1)

    view = gl.glGetUniformLocation(shader, "view")
    view_matrix = array([
        [0.8, 0, 0, 0],
        [0, 0.8, 0, 0],
        [0, 0, 0.8, -4],
        [0, 0, 0, 1],
        ])
    gl.glUniformMatrix4fv(view, 1, gl.GL_TRUE, view_matrix)
    projection = gl.glGetUniformLocation(shader, "projection")
    projection_matrix = get_projection_matrix(45, WINDOW_WIDTH/WINDOW_HEIGHT, 0.1, 100)
    gl.glUniformMatrix4fv(projection, 1, gl.GL_FALSE, projection_matrix)
    gl.glBindVertexArray(vao)
    for idx in range(0, len(CUBEPOSITIONS)):
        model = gl.glGetUniformLocation(shader, "model")
        angel = glfw.get_time()%360
        model_matrix = get_model_matrix(idx, angel)
        gl.glUniformMatrix4fv(model, 1, gl.GL_TRUE, model_matrix)
        gl.glDrawArrays(gl.GL_TRIANGLES, 0, VERTEXS.size)
    gl.glBindVertexArray(0)
    gl.glUseProgram(0)
コード例 #4
0
ファイル: window.py プロジェクト: aiv01/aiv-python
 def __init__(self, width=800, height=600, title="aiv"):
     glfw.init()
     glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
     glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
     glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, 1)
     glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
     self.window = glfw.create_window(width, height, title, None, None)
     glfw.make_context_current(self.window)
     glfw.swap_interval(1)
     self.time = glfw.get_time()
     self.delta_time = 0
     self.aspect_ratio = float(width) / float(height)
コード例 #5
0
ファイル: 007-textureloader.py プロジェクト: lhl/vrdev
    def render(self):
        rendertime = time.time()

        GL.glClearColor(0, 0, 0, 1)
        GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)

        # active shader program
        GL.glUseProgram(self.window.shader)

        # Bind Texture
        GL.glBindTexture(GL.GL_TEXTURE_2D, self.window.texture);

        # Create transformations
        # transform = pyrr.Matrix44().identity()
        rad = numpy.radians(glfw.get_time() * 50.0)
        tr_translate = pyrr.matrix44.create_from_translation([0.5, -0.5, 0.0])
        tr_scale     = pyrr.Matrix44().from_scale([1.5, 1.5, 0.5])
        tr_rotation  = pyrr.matrix44.create_from_axis_rotation([0.0, 0.0, 1.0], rad)

        # Applies right to left
        transform = tr_scale * tr_rotation * tr_translate


        loc = GL.glGetUniformLocation(self.window.shader, 'transform')
        GL.glUniformMatrix4fv(loc, 1, GL.GL_FALSE, transform)


        try:
            GL.glBindVertexArray(self.VAO)
           
            # Draw a triangle
            # GL.glDrawArrays(GL.GL_TRIANGLES, 0, 3)

            # draw triangle, starting index of the vertex array, # of vertices (6 = indexData.size), 
            # EBO indexes remain the same (accounts for stride of extra data
            GL.glDrawElements(GL.GL_TRIANGLES, self.index_size, GL.GL_UNSIGNED_INT, None)
        finally:
            # Unbind when we finish
            GL.glBindVertexArray(0)
            GL.glUseProgram(0)

        self.rendertime = 1000 * (time.time() - rendertime)
コード例 #6
0
ファイル: glfw_triangle_test.py プロジェクト: philetus/pyeezl
def main():

    glfw.init()

    window = glfw.create_window( 640, 480, "glfw triangle", None, None )
    
    glfw.make_context_current( window )
    glfw.swap_interval( 1 )
    glfw.set_key_callback( window, on_key )

    while not glfw.window_should_close( window ):

        # set up model view
        width, height = glfw.get_framebuffer_size( window )
        ratio = width / float(height)
        gl.glViewport( 0, 0, width, height )
        gl.glClear( gl.GL_COLOR_BUFFER_BIT )
        gl.glMatrixMode( gl.GL_PROJECTION )
        gl.glLoadIdentity()
        gl.glOrtho( -ratio, ratio, -1.0, 1.0, 1.0, -1.0 )
        gl.glMatrixMode( gl.GL_MODELVIEW )
        gl.glLoadIdentity()
        gl.glRotatef( float(glfw.get_time()) * 50.0, 0.0, 0.0, 1.0 )

        # draw triangle
        gl.glBegin(gl.GL_TRIANGLES);
        gl.glColor3f( 1.0, 0.0, 0.0 )
        gl.glVertex3f( -0.6, -0.4, 0.0 )
        gl.glColor3f( 0.0, 1.0, 0.0 )
        gl.glVertex3f( 0.6, -0.4, 0.0 )
        gl.glColor3f( 0.0, 0.0, 1.0 )
        gl.glVertex3f( 0.0, 0.6, 0.0 )
        gl.glEnd()

        # swap buffers
        glfw.swap_buffers(window)

        # poll for events
        glfw.poll_events()
    
    glfw.destroy_window(window)
    glfw.terminate()
コード例 #7
0
def animate():

    np.matrix('1,0,0,0; 0,1,0,0; 0,0,1,0;0,0,0,1', np.float32)

    time.actual_time = glfw.get_time()

    delta = time.actual_time - time.prev_time
    x_trans = 0
    y_trans = 0

    if(delta > 0.01):
        time.prev_time=time.actual_time
        cartesian.angle+=1
        x_trans = cartesian.radius * np.cos(cartesian.angle*np.pi/180.0)
        y_trans = cartesian.radius * np.sin(cartesian.angle*np.pi/180.0)

    trans = tr.translate(x_trans,y_trans,0.0)
    trans = tr.rotate(0,cartesian.angle,0,trans,True)

    return trans
コード例 #8
0
ファイル: engine.py プロジェクト: DrLuke/PyreeEngine
    async def startmainloop(self) -> None:
        newtime = glfw.get_time()
        self.layercontext.dt = newtime - self.layercontext.time
        self.layercontext.time = newtime

        self.layermanager: LayerManager = LayerManager(self.programconfig,
                                                       self.layercontext)

        ## Async Loop
        self.asyncloop = asyncio.get_running_loop()
        self.asyncloop.set_debug(True)

        ## OSC setup
        self.oscserver = pythonosc.osc_server.AsyncIOOSCUDPServer(
            (self.programconfig.oscserveraddress,
             self.programconfig.oscserverport), self.oscdispatcher,
            self.asyncloop)

        self.transport, protocol = await self.oscserver.create_serve_endpoint()
        while (not glfw.window_should_close(self.window)):
            self.mainLoop()
            await asyncio.sleep(0)  # Give other tasks a chance
        self.transport.close()
コード例 #9
0
ファイル: 2015005078-03-1.py プロジェクト: jinkyo422/HYU
def main():
    if not glfw.init():
        return
    window = glfw.create_window(480, 480, "2015005078-3-1", None, None)
    if not window:
        glfw.terminate()
        return
    glfw.make_context_current(window)

    while not glfw.window_should_close(window):
        glfw.poll_events()

        th = glfw.get_time()
        R = np.array([[np.cos(th), -np.sin(th), 0.],
                      [np.sin(th), np.cos(th), 0.], [0., 0., 1.]])

        T = np.array([[1., 0., .5], [0., 1., 0.], [0., 0., 1.]])

        render(R @ T)

        glfw.swap_buffers(window)

    glfw.terminate()
コード例 #10
0
ファイル: 2.py プロジェクト: SunghunChoi-HYU/2021_cse4020
def main():
    global gVertexArrayIndexed, gIndexArray
    if not glfw.init():
        return
    window = glfw.create_window(640,640,'2019061721', None,None)
    if not window:
        glfw.terminate()
        return
    glfw.make_context_current(window)
    glfw.set_key_callback(window, key_callback)
    glfw.swap_interval(1)

    gVertexArrayIndexed, gIndexArray = createVertexAndIndexArrayIndexed()

    while not glfw.window_should_close(window):
        glfw.poll_events()
        
        t = glfw.get_time()
        render(t*50)

        glfw.swap_buffers(window)

    glfw.terminate()
コード例 #11
0
def actualizar(window):
    global tiempo_anterior
    global carrito
    global obstaculos
    global obstaculos1

    tiempo_actual = glfw.get_time()
    tiempo_delta = tiempo_actual - tiempo_anterior

    carrito.actualizar(window, tiempo_delta)

    for obstaculo in obstaculos:
        if obstaculo.vivo:
            carrito.checar_colisiones(obstaculo)
            if carrito.colisionando:
                break
    for obstaculo1 in obstaculos1:
        if obstaculo1.vivo:
            carrito.checar_colisiones1(obstaculo1)
            if carrito.colisionando:
                break
    
    tiempo_anterior = tiempo_actual
コード例 #12
0
    def run(self):
        # initializer timer
        glfw.set_time(0.0)
        time = 0.0

        while not glfw.window_should_close(self.window) and not self.exit_now:
            # update every x seconds
            now = glfw.get_time()
            if now - time > 1.0 / self.frame_rate:
                # update time
                time = now

                # clear
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

                self.scene.render()

                glfw.swap_buffers(self.window)

                # Poll for and process events
                glfw.poll_events()
        # end
        glfw.terminate()
コード例 #13
0
def main():
    if not glfw.init():
        return
    window = glfw.create_window(480, 480, "2019061721", None, None)
    if not window:
        glfw.terminate()
        return
    glfw.make_context_current(window)

    glfw.swap_interval(1)

    while not glfw.window_should_close(window):
        glfw.poll_events()
        t = glfw.get_time()
        T = np.array([[np.cos(t), -np.sin(t), 0], [np.sin(t),
                                                   np.cos(t), 0], [0, 0, 1]])

        S = np.array([[np.cos(0.5), -np.sin(0.5), .4],
                      [np.sin(0.5), np.cos(0.5), .4], [0., 0., 0.]])
        render(T @ S)
        glfw.swap_buffers(window)

    glfw.terminate()
コード例 #14
0
ファイル: OpenGLViewer.py プロジェクト: Flojan/OpenGLViewer
    def run(self):
        # initializer timer
        glfw.set_time(0.0)
        t = 0.0
        self.scene.readObject()

        while not glfw.window_should_close(self.window) and not self.exitNow:
            # update every x seconds
            currT = glfw.get_time()
            if currT - t > 1.0 / self.frame_rate:
                # update time
                t = currT
                # clear
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

                # render scene
                self.scene.render()

                glfw.swap_buffers(self.window)
                # Poll for and process events
                glfw.poll_events()
        # end
        glfw.terminate()
コード例 #15
0
def main():
    global gComposedM
    if not glfw.init():
        return

    window = glfw.create_window(480, 480, "2018008395", None, None)

    if not window:
        glfw.terminate()
        return

    glfw.make_context_current(window)
    glfw.swap_interval(1)

    while not glfw.window_should_close(window):
        glfw.poll_events()
        th = glfw.get_time()
        R = np.array([[np.cos(th), -np.sin(th), 0.],
                      [np.sin(th), np.cos(th), 0.], [0., 0., 1.]])
        render(R)
        glfw.swap_buffers(window)

    glfw.terminate()
コード例 #16
0
def main():
    if not glfw.init():
        return
    window = glfw.create_window(800, 800, 'my_dog', None, None)
    if not window:
        glfw.terminate()
        return

    glfw.set_key_callback(window, key_callback)
    glfw.set_mouse_button_callback(window, button_callback)
    glfw.make_context_current(window)
    glfw.set_scroll_callback(window, scroll_callback)

    global time, speed
    glfw.swap_interval(1)

    while not glfw.window_should_close(window):
        time = glfw.get_time() * 3 * speed
        glfw.poll_events()
        render()
        glfw.swap_buffers(window)

    glfw.terminate()
コード例 #17
0
def main():
    if not glfw.init():
        return

    window = glfw.create_window(640, 640, "2D Trans", None, None)

    if not window:
        glfw.terminate()
        return

    glfw.make_context_current(window)

    glfw.swap_interval(1)

    while not glfw.window_should_close(window):
        glfw.poll_events()
        t = glfw.get_time()
        # non uniform scale
        s = np.sin(t)
        US = np.array([[s, 0.], [0., s]])

        # rotate
        th = t
        R = np.array([[np.cos(th), -np.sin(th)], [np.sin(th), np.cos(th)]])

        # shear
        a = np.sin(t)
        S = np.array([[1., a], [0., 1.]])

        # identity matrix
        I = np.identity(2)

        # render(R @ S)
        render(S @ R)
        glfw.swap_buffers(window)

    glfw.terminate()
コード例 #18
0
ファイル: app.py プロジェクト: chxzh/shadyn
    def poll_event(self, window):
        flag = False
        cur_time = glfw.get_time()
        del_time = cur_time - self.last_time
        march = sidle = dive = 0.
        if glfw.get_key(window, glfw.KEY_W) == glfw.PRESS:            
            march = self.speed * del_time
        elif glfw.get_key(window, glfw.KEY_S) == glfw.PRESS:            
            march = - self.speed * del_time
        if glfw.get_key(window, glfw.KEY_D) == glfw.PRESS:            
            sidle = self.speed * del_time
        elif glfw.get_key(window, glfw.KEY_A) == glfw.PRESS:            
            sidle = - self.speed * del_time
        if glfw.get_key(window, glfw.KEY_SPACE) == glfw.PRESS:            
            dive = self.speed * del_time
        elif glfw.get_key(window, glfw.KEY_V) == glfw.PRESS:            
            dive = - self.speed * del_time
        if march or sidle or dive:
            self.translate(march, sidle, dive)
            flag = True
        cur_mx, cur_my = glfw.get_cursor_pos(window)
        if glfw.get_mouse_button(window, glfw.MOUSE_BUTTON_RIGHT) == glfw.PRESS:
            del_mx, del_my = cur_mx - self.last_mx, cur_my - self.last_my
            spin = tilt = 0.
            if del_mx:
                spin = self.rev * del_mx * del_time
#                 self.spin += self.rev * del_mx
            if del_my:
                tilt = self.rev * del_my * del_time
            if spin or tilt:
                self.rotate(spin, tilt)
                flag = True
        self.last_mx, self.last_my = cur_mx, cur_my
        self.last_time = cur_time
        if flag:
            self._update_orientation()
            self._update_view_mat()
コード例 #19
0
ファイル: opg_wrapper.py プロジェクト: PitterL/PyOpenglSample
    def run(self):
        # Enable depth test
        glEnable(GL_DEPTH_TEST)
        # Accept fragment if it closer to the camera than the former one
        #glDepthFunc(GL_LESS)
        # Cull triangles which normal is not towards the camera
        #glEnable(GL_CULL_FACE)

        lastFrame = 0
        while not glfw.window_should_close(self.window):
            # Render here, e.g. using pyOpenGL
            glClearColor(0, 0, 0, 1.0)
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

            for shader in self._shaders:
                self.render(shader)

            # Swap front and back buffers
            glfw.swap_buffers(self.window)

            # Poll for and process events
            #glfw.poll_events()
            if self.event:
                currentFrame = glfw.get_time()
                deltaTime = currentFrame - lastFrame
                lastFrame = currentFrame

                # Poll for and process events
                glfw.poll_events()
                self.event.do_movement(deltaTime)
            else:
                glfw.poll_events()

            glBindVertexArray(0)
            glUseProgram(0)

        glfw.terminate()
コード例 #20
0
def main():
    if not glfw.init():
        return

    window = glfw.create_window(640, 640, "2D Trans", None, None)

    if not window:
        glfw.terminate()
        return

    glfw.make_context_current(window)

    glfw.swap_interval(1)

    while not glfw.window_should_close(window):
        glfw.poll_events()
        t = glfw.get_time()
        s = np.sin(t)
        T = np.array([[s, 0.], [0., s]])

        render(T)
        glfw.swap_buffers(window)

    glfw.terminate()
コード例 #21
0
def main():
    if not glfw.init():
        return
    window = glfw.create_window(480, 480, "2016025105", None, None)
    if not window:
        glfw.terminate()
        return
    glfw.make_context_current(window)
    glfw.swap_interval(1)

    while not glfw.window_should_close(window):
        glfw.poll_events()

        t = glfw.get_time()
        s = np.sin(t)
        c = np.cos(t)

        M = np.array([[c, -s, 0.], [s, c, 0.], [0., 0., 1.]])
        S = np.array([[1., 0., 0.5], [0., 1., 0.], [0., 0., 1.]])

        render(M @ S)

        glfw.swap_buffers(window)
    glfw.terminate()
コード例 #22
0
def main():
    if not glfw.init():
        return
    window = glfw.create_window(480, 480, "학번-5-1", None, None)
    if not window:
        glfw.terminate()
        return
    glfw.make_context_current(window)
    glfw.swap_interval(1)

    while not glfw.window_should_close(window):
        glfw.poll_events()

        t = glfw.get_time()
        th = t
        T = np.array([[np.cos(th), -np.sin(th), 0.],
                      [np.sin(th), np.cos(th), 0.], [0., 0., 1.]])

        R = np.array([[1, 0., 0.5], [0., 1., 0], [0., 0., 1]])

        render(T @ R)
        glfw.swap_buffers(window)

    glfw.terminate()
コード例 #23
0
ファイル: window.py プロジェクト: Hukeqing/PyOpenGL-Template
    def window_main_loop(self):
        glClearColor(*self.background_color.get_value())
        # glClearDepth(1.0)
        # glPointSize(5)

        if self.depth_mode:
            glEnable(GL_DEPTH_TEST)
        if self.alpha_mode:
            glEnable(GL_BLEND)  # 使透明生效
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)  # 使透明生效
        if self.stencil_mode:
            glEnable(GL_STENCIL_TEST)

        self.last_time = glfw.get_time()
        self.mouse_scroll_value = 0
        for function_name in self.start:
            if not function_name():
                raise RuntimeError('Start Function: ' +
                                   function_name.__name__ + ' runtime error')
        while not glfw.window_should_close(self.window):
            self.draw()
            glfw.swap_buffers(self.window)
            glfw.poll_events()
        glfw.terminate()  # 终止 glfw
コード例 #24
0
ファイル: 6.8.2-Shaders.py プロジェクト: juliahread/OpenGL
    def draw():
        gl.glClearColor(0.2, 0.3, 0.3, 1.0)
        gl.glClear(gl.GL_COLOR_BUFFER_BIT)

        shaderProgram.use()

        vao.bind()

        # update shader uniform
        timeValue = glfw.get_time()
        greenValue = np.sin(timeValue) / 2.0 + 0.5
        vertexColorLocation = gl.glGetUniformLocation(shaderProgram.Program,
                                                      "ourColor")
        vertexOffsetLocation = gl.glGetUniformLocation(shaderProgram.Program,
                                                       "offset")
        gl.glUniform4f(vertexColorLocation, 0.0, greenValue, 0.0, 1.0)
        gl.glUniform1f(vertexOffsetLocation, 0.3)

        gl.glDrawElements(gl.GL_TRIANGLES, 3 * indices.shape[0],
                          gl.GL_UNSIGNED_INT, None)

        vao.unbind()

        glfw.swap_buffers(window)
コード例 #25
0
def main():

    if not glfw.init():
        return
    window = glfw.create_window(480, 480, "2017029570-5-1", None, None)
    if not window:
        glfw.terminate()
        return
    glfw.make_context_current(window)

    glfw.swap_interval(1)

    while not glfw.window_should_close(window):

        glfw.poll_events()
        t = glfw.get_time()

        M = np.array([[np.cos(t), -np.sin(t)], [np.sin(t), np.cos(t)]])

        render(M)

        glfw.swap_buffers(window)

    glfw.terminate()
コード例 #26
0
ファイル: 2017029807-3-2.py プロジェクト: oknkc8/CSE4020
def main():
    if not glfw.init():
        return
    window = glfw.create_window(480, 480, "2017029807-3-2", None, None)
    if not window:
        glfw.terminate()
        return
    glfw.make_context_current(window)
    glfw.set_key_callback(window, key_callback)

    # set the number of screen refresh to wait before calling glfw.swap_buffer().
    # if your monitor refresh rate is 60Hz, the while loop is repeated every 1/60 sec
    glfw.swap_interval(1)

    while not glfw.window_should_close(window):
        glfw.poll_events()

        # get the current time, in seconds
        t = glfw.get_time()

        render(gComposedM)

        glfw.swap_buffers(window)
    glfw.terminate()
コード例 #27
0
def key_callback(window, key, scancode, action, mods):
    last_frame_time = glfw.get_time()
    if key == glfw.KEY_W:
        acceleration_input = 2
        lateral_friction_factor = 10
        backwards_friction_factor = 10

        rightVector = pyrr.vector3.cross(car.headVector, car.upVector)
        lateral_velocity = rightVector * pyrr.vector3.dot(car.velocityVector, rightVector)
        lateral_friction = -lateral_velocity * lateral_friction_factor
        backwards_friction = -car.velocityVector * backwards_friction_factor
        car.velocityVector = car.velocityVector + (backwards_friction + lateral_friction) * (glfw.get_time() - last_frame_time)

        car.accelerationVector = car.headVector * acceleration_input
        car.velocityVector = car.velocityVector + car.accelerationVector * (glfw.get_time() - last_frame_time)
        car.positionVector = car.positionVector + car.velocityVector + (glfw.get_time() - last_frame_time)

    if key == glfw.KEY_S:
        acceleration_input = -2
        lateral_friction_factor = 1000
        backwards_friction_factor = 1000

        rightVector = pyrr.vector3.cross(car.headVector, car.upVector)
        lateral_velocity = rightVector * pyrr.vector3.dot(car.velocityVector, rightVector)
        lateral_friction = -lateral_velocity * lateral_friction_factor
        backwards_friction = -car.velocityVector * backwards_friction_factor
        car.velocityVector = car.velocityVector + (backwards_friction + lateral_friction) * (
                    glfw.get_time() - last_frame_time)

        car.accelerationVector = car.headVector * acceleration_input
        car.velocityVector = car.velocityVector + car.accelerationVector * (glfw.get_time() - last_frame_time)
        car.positionVector = car.positionVector + car.velocityVector + (glfw.get_time() - last_frame_time)
    if key == glfw.KEY_D:
        car.turn_right()
    if key == glfw.KEY_A:
        car.turn_left()
コード例 #28
0
ファイル: view.py プロジェクト: yoyonel/axuy
    def __init__(self, address, camera, space, width, height, lock):
        # Create GLFW window
        if not glfw.init(): raise RuntimeError('Failed to initialize GLFW!')
        glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
        glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
        glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
        glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
        self.window = glfw.create_window(width, height, 'Axuy', None, None)
        if not self.window:
            glfw.terminate()
            raise RuntimeError('Failed to create GLFW window!')

        self.camera = camera
        self.picos = {address: camera}
        self.colors = {address: choice(COLOR_NAMES)}
        self.last_time = glfw.get_time()
        self.lock = lock

        # Window's rendering and event-handling configuration
        glfw.set_window_icon(self.window, 1, Image.open(abspath('icon.png')))
        glfw.make_context_current(self.window)
        glfw.swap_interval(1)
        glfw.set_input_mode(self.window, glfw.CURSOR, glfw.CURSOR_DISABLED)
        glfw.set_input_mode(self.window, glfw.STICKY_KEYS, True)
        glfw.set_cursor_pos_callback(self.window, self.camera.look)
        self.fov = FOV_INIT
        glfw.set_scroll_callback(self.window, self.zoom)
        glfw.set_mouse_button_callback(self.window, self.shoot)

        # Create OpenGL context
        self.context = context = moderngl.create_context()
        context.enable(moderngl.BLEND)
        context.enable(moderngl.DEPTH_TEST)

        self.space, vertices = space, []
        for (x, y, z), occupied in np.ndenumerate(self.space):
            if self.space[x][y][z - 1] ^ occupied:
                vertices.extend(i + j
                                for i, j in product(neighbors(x, y, z), OXY))
            if self.space[x - 1][y][z] ^ occupied:
                vertices.extend(i + j
                                for i, j in product(neighbors(x, y, z), OYZ))
            if self.space[x][y - 1][z] ^ occupied:
                vertices.extend(i + j
                                for i, j in product(neighbors(x, y, z), OZX))

        self.maprog = context.program(vertex_shader=MAP_VERTEX,
                                      fragment_shader=MAP_FRAGMENT)
        self.maprog['bg'].write(color('Background').tobytes())
        self.maprog['color'].write(color('Aluminium').tobytes())
        mapvb = context.buffer(np.stack(vertices).astype(np.float32).tobytes())
        self.mapva = context.simple_vertex_array(self.maprog, mapvb, 'in_vert')

        self.prog = context.program(vertex_shader=PICO_VERTEX,
                                    fragment_shader=PICO_FRAGMENT)
        pvb = [(context.buffer(TETRAVERTICES.tobytes()), '3f', 'in_vert')]
        pib = context.buffer(TETRAINDECIES.tobytes())
        self.pva = context.vertex_array(self.prog, pvb, pib)
        svb = [(context.buffer(OCTOVERTICES.tobytes()), '3f', 'in_vert')]
        sib = context.buffer(OCTOINDECIES.tobytes())
        self.sva = context.vertex_array(self.prog, svb, sib)
コード例 #29
0
g_shadowShader = shadow.buildShadowShader()
treeSample = random.sample(g_terrain.treeLocations, 25)
rockSample = random.sample(g_terrain.rockLocations, 25)

g_racer = Racer()
g_racer.load("data/racer_02.obj", g_terrain, g_renderingSystem)

propManager = PropManager(g_terrain)
for t in treeSample:
    g_props.append(propManager.createTreeProp(g_terrain, g_renderingSystem, t))
for r in rockSample:
    g_props.append(propManager.createRockProp(g_terrain, g_renderingSystem, r))
# here we'll implement the grass texture loading//etc..
# I may place this code in a helper function in the future

currentTime = glfw.get_time()
prevMouseX, prevMouseY = glfw.get_cursor_pos(window)

while not glfw.window_should_close(window):
    prevTime = currentTime
    currentTime = glfw.get_time()
    dt = currentTime - prevTime

    keyStateMap = {}
    for name, id in g_glfwKeymap.items():
        keyStateMap[name] = glfw.get_key(window, id) == glfw.PRESS

    for name, id in g_glfwMouseMap.items():
        keyStateMap[name] = glfw.get_mouse_button(window, id) == glfw.PRESS

    imgui.new_frame()
コード例 #30
0
ファイル: modern_cube.py プロジェクト: radu/arucube
def main():

    # initialize glfw
    if not glfw.init():
        return

    window = glfw.create_window(1000, 1000, "My OpenGL window", None, None)
    #window.visible = False

    if not window:
        glfw.terminate()
        return

    glfw.make_context_current(window)

    #        positions         colors          texture coords
    cube = [
        -0.5, -0.5, 0.5, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.5, -0.5, 0.5, 1.0,
        1.0, 1.0, 1.0, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0,
        -0.5, 0.5, 0.5, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, -0.5, -0.5, -0.5, 1.0,
        1.0, 1.0, 0.0, 0.0, 1.0, 0.5, -0.5, -0.5, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0,
        0.5, 0.5, -0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, -0.5, 0.5, -0.5, 1.0,
        1.0, 1.0, 0.0, 1.0, 1.0, 0.5, -0.5, -0.5, 1.0, 1.0, 1.0, 0.0, 0.0, 2.0,
        0.5, 0.5, -0.5, 1.0, 1.0, 1.0, 1.0, 0.0, 2.0, 0.5, 0.5, 0.5, 1.0, 1.0,
        1.0, 1.0, 1.0, 2.0, 0.5, -0.5, 0.5, 1.0, 1.0, 1.0, 0.0, 1.0, 2.0, -0.5,
        0.5, -0.5, 1.0, 1.0, 1.0, 0.0, 0.0, 3.0, -0.5, -0.5, -0.5, 1.0, 1.0,
        1.0, 1.0, 0.0, 3.0, -0.5, -0.5, 0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 3.0,
        -0.5, 0.5, 0.5, 1.0, 1.0, 1.0, 0.0, 1.0, 3.0, -0.5, -0.5, -0.5, 1.0,
        1.0, 1.0, 0.0, 0.0, 4.0, 0.5, -0.5, -0.5, 1.0, 1.0, 1.0, 1.0, 0.0, 4.0,
        0.5, -0.5, 0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 4.0, -0.5, -0.5, 0.5, 1.0,
        1.0, 1.0, 0.0, 1.0, 4.0, 0.5, 0.5, -0.5, 1.0, 1.0, 1.0, 0.0, 0.0, 5.0,
        -0.5, 0.5, -0.5, 1.0, 1.0, 1.0, 1.0, 0.0, 5.0, -0.5, 0.5, 0.5, 1.0,
        1.0, 1.0, 1.0, 1.0, 5.0, 0.5, 0.5, 0.5, 1.0, 1.0, 1.0, 0.0, 1.0, 5.0
    ]

    cube = numpy.array(cube, dtype=numpy.float32)

    indices = [
        0, 1, 2, 2, 3, 0, 4, 5, 6, 6, 7, 4, 8, 9, 10, 10, 11, 8, 12, 13, 14,
        14, 15, 12, 16, 17, 18, 18, 19, 16, 20, 21, 22, 22, 23, 20
    ]

    indices = numpy.array(indices, dtype=numpy.uint32)

    vertex_shader = """
    #version 330
    in layout(location = 0) vec3 position;
    in layout(location = 1) vec3 color;
    in layout(location = 2) vec2 textureCoords;
    in layout(location = 3) float textureid;
    uniform mat4 transform;
    uniform mat4 proj;
    out vec3 newColor;
    out vec2 newTexture;
    out float newtextureid;

    void main()
    {
        gl_Position = proj * transform * vec4(position, 1.0f);
        newColor = color;
        newTexture = textureCoords;
        newtextureid = textureid;
    }
    """

    fragment_shader = """
    #version 330
    #extension GL_EXT_texture_array : enable
    in vec3 newColor;
    in vec2 newTexture;
    in float newtextureid;

    uniform sampler2DArray samplerTexture;

    out vec3 outColor;

    void main()
    {
        outColor = (texture(samplerTexture, vec3(newTexture, newtextureid))  * vec4(newColor, 1.0f)).rgb;
        //outColor = texture(samplerTexture, newTexture)  * vec4(newColor, 1.0f);
    }
    """
    shader = OpenGL.GL.shaders.compileProgram(
        OpenGL.GL.shaders.compileShader(vertex_shader, GL_VERTEX_SHADER),
        OpenGL.GL.shaders.compileShader(fragment_shader, GL_FRAGMENT_SHADER))

    VBO = glGenBuffers(1)
    glBindBuffer(GL_ARRAY_BUFFER, VBO)
    glBufferData(GL_ARRAY_BUFFER, cube.itemsize * len(cube), cube,
                 GL_STATIC_DRAW)

    EBO = glGenBuffers(1)
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO)
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.itemsize * len(indices),
                 indices, GL_STATIC_DRAW)

    #position
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, cube.itemsize * 9,
                          ctypes.c_void_p(0))
    glEnableVertexAttribArray(0)
    #color
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, cube.itemsize * 9,
                          ctypes.c_void_p(12))
    glEnableVertexAttribArray(1)
    #texture
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, cube.itemsize * 9,
                          ctypes.c_void_p(24))
    glEnableVertexAttribArray(2)
    #textureid
    glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, cube.itemsize * 9,
                          ctypes.c_void_p(32))
    glEnableVertexAttribArray(3)

    loadTextures()
    """
    texture = glGenTextures(1)
    glBindTexture(GL_TEXTURE_2D, texture)
    # Set the texture wrapping parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
    # Set texture filtering parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
    # load image
    image = Image.open("res/crate.jpg")
    img_data = numpy.array(list(image.getdata()), numpy.uint8)
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, image.width, image.height, 0, GL_RGB, GL_UNSIGNED_BYTE, img_data)
    """

    glUseProgram(shader)

    glClearColor(0.2, 0.2, 0.2, 1.0)

    glShadeModel(GL_SMOOTH)
    glEnable(GL_DEPTH_TEST)

    LightAmbient = [0.5, 0.5, 0.5, 1.0]
    LightDiffuse = [0.5, 0.5, 0.5, 1.0]
    LightPosition = [5.0, 25.0, 15.0, 1.0]

    glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient)
    glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse)
    glLightfv(GL_LIGHT1, GL_POSITION, LightPosition)
    glEnable(GL_LIGHTING)
    glEnable(GL_LIGHT1)

    #glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)

    (xa, ya, za) = (0, 0, 0)

    while not glfw.window_should_close(window):

        (w, h) = glfw.get_window_size(window)

        glfw.poll_events()
        #time.sleep(0.2)

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        #(xa,ya,za) = (12,45,77)
        #(xa,ya,za) = numpy.random.uniform(size=3)*360.0

        (xa, ya, za) = numpy.array([0.8, 0.3, 0.2]) * glfw.get_time()
        (xa, ya, za) = (xa % 2 * math.pi, ya % 2 * math.pi, za % 2 * math.pi)

        rot_x = pyrr.Matrix44.from_x_rotation(xa)
        rot_y = pyrr.Matrix44.from_y_rotation(ya)
        rot_z = pyrr.Matrix44.from_z_rotation(za)
        rot = rot_x * rot_y * rot_z

        (dx, dy, dz) = (0.0, 0.0, -2.0)
        #(dx,dy,dz) =  numpy.random.uniform(-0.5,0.5,size=3)
        trans = pyrr.matrix44.create_from_translation([dx, dy, dz])

        proj = pyrr.matrix44.create_perspective_projection_matrix(
            80.0, 1.0, 0.01, 1000.0)

        transf = numpy.array(rot.dot(trans))

        transformLoc = glGetUniformLocation(shader, "transform")
        projLoc = glGetUniformLocation(shader, "proj")

        glUniformMatrix4fv(transformLoc, 1, GL_FALSE, transf)
        glUniformMatrix4fv(projLoc, 1, GL_FALSE, proj)

        glDrawElements(GL_TRIANGLES, len(indices), GL_UNSIGNED_INT, None)

        glfw.swap_buffers(window)

        pixels = glReadPixelsui(0, 0, w, h, GL_RGB, GL_UNSIGNED_BYTE)
        im = numpy.frombuffer(pixels, dtype='uint8').reshape(h, w, 3)
        im = cv2.flip(im, 0)

        pm = numpy.array([[w, 0, w / 2], [0, h, h / 2], [0, 0, 1]])

        dist = numpy.array([0.0, 0.0, 0.0, 0.0]).reshape(4, 1)

        ra = numpy.array([xa, ya, za]) * 360.0 / math.pi
        detectTag(im, pm, dist, ra)

    glfw.terminate()
コード例 #31
0
 def draw(self, projection, view, model, **param):
     """ When redraw requested, interpolate our node transform from keys """
     self.transform = self.keyframes.value(glfw.get_time())
     super().draw(projection, view, model, **param)
コード例 #32
0
def main():

    # comenzar glfw
    if not glfw.init():
        return

    aspect_ratio = wwidth / wheight
    #creamos la ventana
    window = glfw.create_window(wwidth, wheight, "ProyectoGraficas", None,
                                None)

    #terminar ventana
    if not window:
        glfw.terminate()
        return

    glfw.make_context_current(window)

    glfw.set_window_size_callback(window, window_resize)

    glfw.set_key_callback(window, key_callback)

    glfw.set_cursor_pos_callback(window, mouse_callback)

    glfw.set_input_mode(window, glfw.CURSOR, glfw.CURSOR_DISABLED)

    #carbamos el primer ObjLoader
    casa = ObjLoader()
    #buscamos el objeto en nuestras carpetas
    casa.load_model("obj/casa2.obj")
    #buscamos la textura en nuestras carpetas
    casa_tex = TextureLoader.load_texture("obj/pared.jpg")
    #calculamos
    casa_texture_offset = len(casa.vertex_index) * 12

    #cargamos el segundo objeto
    monster = ObjLoader()
    #buscamos el obj en nuestras carpetas
    monster.load_model("obj/monster.obj")
    #buscamos la textura en nuestras carpetas
    monster_tex = TextureLoader.load_texture("obj/monster.jpg")
    #calculamos
    monster_texture_offset = len(monster.vertex_index) * 12

    #obtenemos los shaders de nuestras carpetas.
    generic_shader = ShaderLoader.compile_shader(
        "shaders/generic_vertex_shader.vs",
        "shaders/generic_fragment_shader.fs")

    #------------------------------------casa--------------------------------------------------------------------------#
    #generamos nestras variaml
    casavao = glGenVertexArrays(1)

    glBindVertexArray(casavao)

    casavbo = glGenBuffers(1)

    glBindBuffer(GL_ARRAY_BUFFER, casavbo)

    glBufferData(GL_ARRAY_BUFFER, casa.model.itemsize * len(casa.model),
                 casa.model, GL_STATIC_DRAW)

    #posicion
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, casa.model.itemsize * 3,
                          ctypes.c_void_p(0))
    glEnableVertexAttribArray(0)

    #Texturas
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, casa.model.itemsize * 2,
                          ctypes.c_void_p(casa_texture_offset))
    glEnableVertexAttribArray(1)
    glBindVertexArray(0)

    #--------------------------------------------------------------------------------------------------------------------

    #-------------------------------------------------------monstruo------------------------------------------------------#
    monster_vao = glGenVertexArrays(1)

    glBindVertexArray(monster_vao)

    monster_vbo = glGenBuffers(1)

    glBindBuffer(GL_ARRAY_BUFFER, monster_vbo)

    glBufferData(GL_ARRAY_BUFFER, monster.model.itemsize * len(monster.model),
                 monster.model, GL_STATIC_DRAW)

    #position
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, monster.model.itemsize * 3,
                          ctypes.c_void_p(0))

    glEnableVertexAttribArray(0)
    #textures
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, monster.model.itemsize * 2,
                          ctypes.c_void_p(monster_texture_offset))
    glEnableVertexAttribArray(1)
    glBindVertexArray(0)
    #-----------------------------------------------------------------------------------------------------------------------#

    #colocamos el color negro

    glClearColor(0, 0, 0, 0)
    glEnable(GL_DEPTH_TEST)

    projection = matrix44.create_perspective_projection_matrix(
        45.0, aspect_ratio, 0.1, 100.0)

    #traslacion del vector a la casa2
    #colocar en el lugar
    casaModelo = matrix44.create_from_translation(Vector3([0.0, 0.0, -3.0]))

    #traslacion en el vectro3 al monstruo
    #colocar en el lugar
    monster_model = matrix44.create_from_translation(Vector3([0.0, 0.0,
                                                              -10.0]))

    #shaders
    glUseProgram(generic_shader)

    model_loc = glGetUniformLocation(generic_shader, "model")

    view_loc = glGetUniformLocation(generic_shader, "view")

    proj_loc = glGetUniformLocation(generic_shader, "proj")

    glUniformMatrix4fv(proj_loc, 1, GL_FALSE, projection)

    #mientras la ventana
    while not glfw.window_should_close(window):

        glfw.poll_events()

        do_movement()
        #colocar la ventada de un color especifico
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        view = cam.get_view_matrix()

        glUniformMatrix4fv(view_loc, 1, GL_FALSE, view)

        #rotaciones
        rot_y = Matrix44.from_y_rotation(glfw.get_time() * 0.5)

        #--------------------------------------casa--------------------------------------#
        glBindVertexArray(casavao)
        glBindTexture(GL_TEXTURE_2D, casa_tex)
        glUniformMatrix4fv(model_loc, 1, GL_FALSE, casaModelo)
        glDrawArrays(GL_TRIANGLES, 0, len(casa.vertex_index))
        glBindVertexArray(0)
        #--------------------------------------------------------------------------------#

        #---------------------------------------monstruo----------------------------------#
        glBindVertexArray(monster_vao)
        glBindTexture(GL_TEXTURE_2D, monster_tex)
        glUniformMatrix4fv(model_loc, 1, GL_FALSE, monster_model)
        glDrawArrays(GL_TRIANGLES, 0, len(monster.vertex_index))
        glBindVertexArray(0)
        #--------------------------------------------------------------------------------------

        #buffer de la ventana
        glfw.swap_buffers(window)

    #finalizamos
    glfw.terminate()
コード例 #33
0
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, image.height, 0, GL_RGBA,
             GL_UNSIGNED_BYTE, img_data)

glUseProgram(shader)
glClearColor(0, 0.2, 0.2, 1)
glEnable(GL_DEPTH_TEST)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

#(field of view, aspect ratio,near,far)
projection = pyrr.matrix44.create_perspective_projection_matrix(
    45, 1280 / 720, 0.1, 100)
glUniformMatrix4fv(proj_loc, 1, GL_FALSE, projection)
translation = pyrr.matrix44.create_from_translation(pyrr.Vector3([0, 0, -3]))

while not glfw.window_should_close(window):
    glfw.poll_events()
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    #make rotation matrix
    rot_x = pyrr.Matrix44.from_x_rotation(0.5 * glfw.get_time())
    rot_y = pyrr.Matrix44.from_y_rotation(0.8 * glfw.get_time())
    rotation = pyrr.matrix44.multiply(rot_x, rot_y)
    model = pyrr.matrix44.multiply(rotation, translation)
    #(handle to load to, no. of matrices, transposed
    # matrix)
    glUniformMatrix4fv(model_loc, 1, GL_FALSE, model)
    #(mode,no of indices,data_type,offset)
    glDrawElements(GL_TRIANGLES, len(indices), GL_UNSIGNED_INT, None)
    glfw.swap_buffers(window)

glfw.terminate()
コード例 #34
0
ファイル: app.py プロジェクト: chxzh/shadyn
 def init_input(self, window):
     self.last_mx, self.last_my = glfw.get_cursor_pos(window)
     self.last_time = glfw.get_time()
     self.activate_mouse = False
コード例 #35
0
ファイル: window.py プロジェクト: aiv01/aiv-python
 def update(self):
     glfw.swap_buffers(self.window)
     glfw.poll_events()
     time = glfw.get_time()
     self.delta_time = time - self.time
     self.time = time
コード例 #36
0
def computeMatricesFromInputs(window):
    global lastTime
    global position
    global horizontalAngle
    global verticalAngle
    global initialFoV
    global ViewMatrix
    global ProjectionMatrix

    # glfwGetTime is called only once, the first time this function is called
    if lastTime == None:
        lastTime = glfw.get_time()

    # Compute time difference between current and last frame
    currentTime = glfw.get_time()
    deltaTime = currentTime - lastTime

    # Get mouse position
    xpos,ypos = glfw.get_cursor_pos(window)

    # Reset mouse position for next frame
    glfw.set_cursor_pos(window, 1024/2, 768/2);

    # Compute new orientation
    horizontalAngle += mouseSpeed * float(1024.0/2.0 - xpos );
    verticalAngle   += mouseSpeed * float( 768.0/2.0 - ypos );

    # Direction : Spherical coordinates to Cartesian coordinates conversion
    direction = vec3(
        mathf.cos(verticalAngle) * mathf.sin(horizontalAngle), 
        mathf.sin(verticalAngle),
        mathf.cos(verticalAngle) * mathf.cos(horizontalAngle)
    )
    
    # Right vector
    right = vec3(
        mathf.sin(horizontalAngle - 3.14/2.0), 
        0.0,
        mathf.cos(horizontalAngle - 3.14/2.0)
    )
    
    # Up vector
    up = vec3.cross( right, direction )

    # Move forward
    if glfw.get_key( window, glfw.KEY_UP ) == glfw.PRESS or glfw.get_key( window, glfw.KEY_W ) == glfw.PRESS:
        position += direction * deltaTime * speed;
    
    # Move backward
    if glfw.get_key( window, glfw.KEY_DOWN ) == glfw.PRESS or glfw.get_key( window, glfw.KEY_S ) == glfw.PRESS:
        position -= direction * deltaTime * speed
    
    # Strafe right
    if glfw.get_key( window, glfw.KEY_RIGHT ) == glfw.PRESS or glfw.get_key( window, glfw.KEY_D ) == glfw.PRESS:
        position += right * deltaTime * speed
    
    # Strafe left
    if glfw.get_key( window, glfw.KEY_LEFT ) == glfw.PRESS or glfw.get_key( window, glfw.KEY_A ) == glfw.PRESS:
        position -= right * deltaTime * speed
    

    FoV = initialFoV# - 5 * glfwGetMouseWheel(); # Now GLFW 3 requires setting up a callback for this. It's a bit too complicated for this beginner's tutorial, so it's disabled instead.

    # Projection matrix : 45 Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units
    ProjectionMatrix = mat4.perspective(FoV, 4.0 / 3.0, 0.1, 100.0)
    # Camera matrix
    ViewMatrix       = mat4.lookat(
                                position,           # Camera is here
                                position+direction, # and looks here : at the same position, plus "direction"
                                up                  # Head is up (set to 0,-1,0 to look upside-down)
                           )

    # For the next frame, the "last time" will be "now"
    lastTime = currentTime
コード例 #37
0
        paddle1.rotation -= 0.1
    if glfw.get_key(window, glfw.KEY_J) == glfw.PRESS:
        paddle2.rotation += 0.1
    if glfw.get_key(window, glfw.KEY_L) == glfw.PRESS:
        paddle2.rotation -= 0.1


square_vertices = np.array(
    [[-5.0, -5.0, 0.0], [5.0, -5.0, 0.0], [5.0, 5.0, 0.0], [-5.0, 5.0, 0.0]],
    dtype=np.float32,
)

TARGET_FRAMERATE = 60  # fps

# to try to standardize on 60 fps, compare times between frames
time_at_beginning_of_previous_frame = glfw.get_time()

# Loop until the user closes the window
while not glfw.window_should_close(window):
    # poll the time to try to get a constant framerate
    while (glfw.get_time() <
           time_at_beginning_of_previous_frame + 1.0 / TARGET_FRAMERATE):
        pass
    # set for comparison on the next frame
    time_at_beginning_of_previous_frame = glfw.get_time()

    # Poll for and process events
    glfw.poll_events()

    width, height = glfw.get_framebuffer_size(window)
    glViewport(0, 0, width, height)
コード例 #38
0
ファイル: mjvive.py プロジェクト: openai/mujoco-py
    openvr.VRCompositor().submit(openvr.Eye_Left, hmd.vTex, hmd.boundLeft)
    openvr.VRCompositor().submit(openvr.Eye_Right, hmd.vTex, hmd.boundRight)
    # swap if window is double-buffered, flush just in case
    if ctx.con.windowDoublebuffer:
        glfw.swap_buffers(window)
    gl.glFlush()


if __name__ == '__main__':
    filename = os.path.join(mujoco_path, 'model', 'humanoid.xml')
    v_initPre()
    initMuJoCo(filename, hmd.width * 2, hmd.height)
    v_initPost()

    FPS = 90.0
    lasttm = glfw.get_time()
    frametime = sim.data.time
    viewFull = PyMjrRect()
    viewFull.width, viewFull.height = 2 * hmd.width, hmd.height
    nullCam = PyMjvCamera()

    while not glfw.window_should_close(window):
        if sim.data.time - frametime > 1 / FPS or sim.data.time < frametime:
            functions.mjv_updateScene(sim.model, sim.data, ctx.vopt, ctx.pert, nullCam, CAT_ALL, ctx.scn)
            v_update()
            functions.mjr_setBuffer(FB_OFFSCREEN, ctx.con)
            functions.mjr_render(viewFull, ctx.scn, ctx.con)
            FPS = .9 * FPS + .1 / (glfw.get_time() - lasttm)
            lasttm = glfw.get_time()
            functions.mjr_overlay(FONT_BIG, GRID_BOTTOMLEFT, viewFull, 'FPS %.1f' % FPS, '', ctx.con)
            v_render()
コード例 #39
0
def main():

    # initialize glfw
    if not glfw.init():
        return

    window = glfw.create_window(800, 800, "OpenGL window", None, None)

    if not window:
        glfw.terminate()
        return

    glfw.make_context_current(window)
    #        positions        colors
    cube = [
        -0.5, -0.5, 0.5, 1.0, 0.0, 0.0, 0.5, -0.5, 0.5, 0.0, 1.0, 0.0, 0.5,
        0.5, 0.5, 0.0, 0.0, 1.0, -0.5, 0.5, 0.5, 1.0, 1.0, 1.0, -0.5, -0.5,
        -0.5, 1.0, 0.0, 0.0, 0.5, -0.5, -0.5, 0.0, 1.0, 0.0, 0.5, 0.5, -0.5,
        0.0, 0.0, 1.0, -0.5, 0.5, -0.5, 1.0, 1.0, 1.0
    ]

    cube = numpy.array(cube, dtype=numpy.float32)

    indices = [
        0, 1, 2, 2, 3, 0, 4, 5, 6, 6, 7, 4, 4, 5, 1, 1, 0, 4, 6, 7, 3, 3, 2, 6,
        5, 6, 2, 2, 1, 5, 7, 4, 0, 0, 3, 7
    ]

    indices = numpy.array(indices, dtype=numpy.uint32)

    vertex_shader = """
    #version 330
    in vec3 position;
    in vec3 color;
    uniform mat4 transform;
    out vec3 newColor;
    void main()
    {
        gl_Position = transform * vec4(position, 1.0f);
        newColor = color;
    }
    """

    fragment_shader = """
    #version 330
    in vec3 newColor;

    out vec4 outColor;
    void main()
    {
        outColor = vec4(newColor, 1.0f);
    }
    """
    shader = OpenGL.GL.shaders.compileProgram(
        OpenGL.GL.shaders.compileShader(vertex_shader, GL_VERTEX_SHADER),
        OpenGL.GL.shaders.compileShader(fragment_shader, GL_FRAGMENT_SHADER))

    VBO = glGenBuffers(1)
    glBindBuffer(GL_ARRAY_BUFFER, VBO)
    glBufferData(GL_ARRAY_BUFFER, 192, cube, GL_STATIC_DRAW)

    EBO = glGenBuffers(1)
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO)
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, 144, indices, GL_STATIC_DRAW)

    position = glGetAttribLocation(shader, "position")
    glVertexAttribPointer(position, 3, GL_FLOAT, GL_FALSE, 24,
                          ctypes.c_void_p(0))
    glEnableVertexAttribArray(position)

    color = glGetAttribLocation(shader, "color")
    glVertexAttribPointer(color, 3, GL_FLOAT, GL_FALSE, 24,
                          ctypes.c_void_p(12))
    glEnableVertexAttribArray(color)

    glUseProgram(shader)

    glClearColor(0.2, 0.3, 0.2, 1.0)  #color
    glEnable(GL_DEPTH_TEST)
    #glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)

    while not glfw.window_should_close(window):
        glfw.poll_events()

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        rot_x = pyrr.Matrix44.from_x_rotation(0.5 * glfw.get_time())
        rot_y = pyrr.Matrix44.from_y_rotation(0.8 * glfw.get_time())

        transformLoc = glGetUniformLocation(shader, "transform")
        glUniformMatrix4fv(transformLoc, 1, GL_FALSE, rot_x * rot_y)

        glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, None)

        glfw.swap_buffers(window)

    glfw.terminate()
コード例 #40
0
def main():
    global shader
    vertex_src = """
    # version 330

    layout(location = 0) in vec3 a_position;
    layout(location = 1) in vec2 a_texture;
    layout(location = 2) in vec3 a_color;

    uniform mat4 model;
    uniform mat4 projection;
    uniform mat4 view;

    out vec3 v_color;
    out vec2 v_texture;

    void main()
    {
        gl_Position = projection * view * model * vec4(a_position, 1.0);
        v_texture = a_texture;
        v_color = a_color;
    }
    """

    fragment_src = """
    # version 330

    in vec2 v_texture;
    in vec3 v_color;

    out vec4 out_color;
    uniform int switcher;

    uniform sampler2D s_texture;

    void main()
    {
        if (switcher == 0){
            out_color = texture(s_texture, v_texture);
        }
        else if (switcher == 1){
            out_color = vec4(v_color, 1.0);   
        }

    }
    """

    # initializing glfw library
    if not glfw.init():
        raise Exception("glfw can not be initialized!")

    if "Windows" in pltf.platform():
        glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
        glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 6)
        glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
        glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
    else:
        glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
        glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 1)
        glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
        glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)

    # creating the window
    window = glfw.create_window(1280, 720, "My OpenGL window", None, None)

    # check if window was created
    if not window:
        glfw.terminate()
        raise Exception("glfw window can not be created!")

    # set window's position
    glfw.set_window_pos(window, 100, 100)

    # set the callback function for window resize
    glfw.set_window_size_callback(window, window_resize)

    # make the context current
    glfw.make_context_current(window)

    cube_vertices = [-0.5, -0.5, 0.5, 0.0, 0.0,
                     0.5, -0.5, 0.5, 1.0, 0.0,
                     0.5, 0.5, 0.5, 1.0, 1.0,
                     -0.5, 0.5, 0.5, 0.0, 1.0,

                     -0.5, -0.5, -0.5, 0.0, 0.0,
                     0.5, -0.5, -0.5, 1.0, 0.0,
                     0.5, 0.5, -0.5, 1.0, 1.0,
                     -0.5, 0.5, -0.5, 0.0, 1.0,

                     0.5, -0.5, -0.5, 0.0, 0.0,
                     0.5, 0.5, -0.5, 1.0, 0.0,
                     0.5, 0.5, 0.5, 1.0, 1.0,
                     0.5, -0.5, 0.5, 0.0, 1.0,

                     -0.5, 0.5, -0.5, 0.0, 0.0,
                     -0.5, -0.5, -0.5, 1.0, 0.0,
                     -0.5, -0.5, 0.5, 1.0, 1.0,
                     -0.5, 0.5, 0.5, 0.0, 1.0,

                     -0.5, -0.5, -0.5, 0.0, 0.0,
                     0.5, -0.5, -0.5, 1.0, 0.0,
                     0.5, -0.5, 0.5, 1.0, 1.0,
                     -0.5, -0.5, 0.5, 0.0, 1.0,

                     0.5, 0.5, -0.5, 0.0, 0.0,
                     -0.5, 0.5, -0.5, 1.0, 0.0,
                     -0.5, 0.5, 0.5, 1.0, 1.0,
                     0.5, 0.5, 0.5, 0.0, 1.0]

    cube_indices = [0, 1, 2, 2, 3, 0,
                    4, 5, 6, 6, 7, 4,
                    8, 9, 10, 10, 11, 8,
                    12, 13, 14, 14, 15, 12,
                    16, 17, 18, 18, 19, 16,
                    20, 21, 22, 22, 23, 20]

    cube_vertices = np.array(cube_vertices, dtype=np.float32)
    cube_indices = np.array(cube_indices, dtype=np.uint32)

    quad_vertices = [-0.5, -0.5, 0, 0.0, 0.0,
                     0.5, -0.5, 0, 1.0, 0.0,
                     0.5, 0.5, 0, 1.0, 1.0,
                     -0.5, 0.5, 0, 0.0, 1.0]

    quad_indices = [0, 1, 2, 2, 3, 0]

    quad_vertices = np.array(quad_vertices, dtype=np.float32)
    quad_indices = np.array(quad_indices, dtype=np.uint32)

    triangle_vertices = [-0.5, -0.5, 0, 1, 0, 0,
                         0.5, -0.5, 0, 0, 1, 0,
                         0.0, 0.5, 0, 0, 0, 1]

    triangle_vertices = np.array(triangle_vertices, dtype=np.float32)



    # Cube VAO
    VAO = glGenVertexArrays(3)
    VBO = glGenBuffers(3)
    EBO = glGenBuffers(2)

    # Cube VAO
    glBindVertexArray(VAO[0])

    shader = compileProgram(compileShader(vertex_src, GL_VERTEX_SHADER), compileShader(fragment_src, GL_FRAGMENT_SHADER))
    # Cube Vertex Buffer Object
    glBindBuffer(GL_ARRAY_BUFFER, VBO[0])
    glBufferData(GL_ARRAY_BUFFER, cube_vertices.nbytes, cube_vertices, GL_STATIC_DRAW)

    # Cube Element Buffer Object
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO[0])
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, cube_indices.nbytes, cube_indices, GL_STATIC_DRAW)

    glEnableVertexAttribArray(0)
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, cube_vertices.itemsize * 5, ctypes.c_void_p(0))

    glEnableVertexAttribArray(1)
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, cube_vertices.itemsize * 5, ctypes.c_void_p(12))

    # Quad VAO
    glBindVertexArray(VAO[1])
    # Quad Vertex Buffer Object
    glBindBuffer(GL_ARRAY_BUFFER, VBO[1])
    glBufferData(GL_ARRAY_BUFFER, quad_vertices.nbytes, quad_vertices, GL_STATIC_DRAW)

    # Quad Element Buffer Object
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO[1])
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, quad_indices.nbytes, quad_indices, GL_STATIC_DRAW)

    glEnableVertexAttribArray(0)
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, cube_vertices.itemsize * 5, ctypes.c_void_p(0))

    glEnableVertexAttribArray(1)
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, cube_vertices.itemsize * 5, ctypes.c_void_p(12))

    # Triangle VAO
    glBindVertexArray(VAO[2])
    # Triangle Vertex Buffer Object
    glBindBuffer(GL_ARRAY_BUFFER, VBO[2])
    glBufferData(GL_ARRAY_BUFFER, triangle_vertices.nbytes, triangle_vertices, GL_STATIC_DRAW)

    glEnableVertexAttribArray(0)
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, triangle_vertices.itemsize * 6, ctypes.c_void_p(0))

    glEnableVertexAttribArray(2)
    glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, triangle_vertices.itemsize * 6, ctypes.c_void_p(12))

    textures = glGenTextures(2)

    cube_texture = load_texture("textures/crate.jpg", textures[0])
    quad_texture = load_texture("textures/cat.png", textures[1])

    glUseProgram(shader)
    glClearColor(0, 0.1, 0.1, 1)
    glEnable(GL_DEPTH_TEST)
    glEnable(GL_BLEND)
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

    projection = pyrr.matrix44.create_perspective_projection_matrix(45, 1280 / 720, 0.1, 100)
    cube_pos = pyrr.matrix44.create_from_translation(pyrr.Vector3([1, 0, 0]))
    quad_pos = pyrr.matrix44.create_from_translation(pyrr.Vector3([-1, 0, 0]))
    triangle_pos = pyrr.matrix44.create_from_translation(pyrr.Vector3([0, 1, -1]))

    # eye, target, up
    view = pyrr.matrix44.create_look_at(pyrr.Vector3([0, 0, 3]), pyrr.Vector3([0, 0, 0]), pyrr.Vector3([0, 1, 0]))

    model_loc = glGetUniformLocation(shader, "model")
    proj_loc = glGetUniformLocation(shader, "projection")
    view_loc = glGetUniformLocation(shader, "view")
    switcher_loc = glGetUniformLocation(shader, "switcher")

    glUniformMatrix4fv(proj_loc, 1, GL_FALSE, projection)
    glUniformMatrix4fv(view_loc, 1, GL_FALSE, view)
    glUseProgram(0)

    # the main application loop
    while not glfw.window_should_close(window):
        glfw.poll_events()

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        glUseProgram(shader)
        glUniform1i(switcher_loc, 0)

        rot_x = pyrr.Matrix44.from_x_rotation(0.5 * glfw.get_time())
        rot_y = pyrr.Matrix44.from_y_rotation(0.8 * glfw.get_time())

        rotation = pyrr.matrix44.multiply(rot_x, rot_y)
        model = pyrr.matrix44.multiply(rotation, cube_pos)

        glBindVertexArray(VAO[0])
        glBindTexture(GL_TEXTURE_2D, textures[0])
        glUniformMatrix4fv(model_loc, 1, GL_FALSE, model)
        glDrawElements(GL_TRIANGLES, len(cube_indices), GL_UNSIGNED_INT, None)

        model = pyrr.matrix44.multiply(rot_x, quad_pos)

        glBindVertexArray(VAO[1])
        glBindTexture(GL_TEXTURE_2D, textures[1])
        glUniformMatrix4fv(model_loc, 1, GL_FALSE, model)
        glDrawElements(GL_TRIANGLES, len(quad_indices), GL_UNSIGNED_INT, None)

        model = pyrr.matrix44.multiply(rot_y, triangle_pos)

        glBindVertexArray(VAO[2])
        glUniform1i(switcher_loc, 1)
        glUniformMatrix4fv(model_loc, 1, GL_FALSE, model)
        glDrawArrays(GL_TRIANGLES, 0, 3)

        glUseProgram(0)

        glfw.swap_buffers(window)

    # terminate glfw, free up allocated resources
    glfw.terminate()
コード例 #41
0
def handle_movement_of_paddles():
    global paddle1, paddle2

    if glfw.get_key(window, glfw.KEY_S) == glfw.PRESS:
        paddle1.input_offset_y -= 0.1
    if glfw.get_key(window, glfw.KEY_W) == glfw.PRESS:
        paddle1.input_offset_y += 0.1
    if glfw.get_key(window, glfw.KEY_K) == glfw.PRESS:
        paddle2.input_offset_y -= 0.1
    if glfw.get_key(window, glfw.KEY_I) == glfw.PRESS:
        paddle2.input_offset_y += 0.1

TARGET_FRAMERATE = 60 # fps

# to try to standardize on 60 fps, compare times between frames
time_at_beginning_of_previous_frame = glfw.get_time()

# Loop until the user closes the window
while not glfw.window_should_close(window):
    # poll the time to try to get a constant framerate
    while glfw.get_time() < time_at_beginning_of_previous_frame +  1.0/TARGET_FRAMERATE:
        pass
    # set for comparison on the next frame
    time_at_beginning_of_previous_frame = glfw.get_time()

    # Poll for and process events
    glfw.poll_events()

    width, height = glfw.get_framebuffer_size(window)
    glViewport(0, 0, width, height)
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
コード例 #42
0
def clearColorSetViewport(r,g,b,a=1.0):
        glClearColor(r, g, b, a);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glViewport(0, 0, window_width, window_height);

if __name__=='__main__':
    glfw.init()
    window_width = 640
    window_height = 480
    win = glfw.create_window(window_width , window_height,"GL", None, None)
    setGLFWOptions(win)

    matrixScene.window_width = window_width
    matrixScene.window_height = window_height

    time.actual_time = time.previous_time = glfw.get_time()

    showInfoAboutGl()


    app = Obj('./models/Cat.obj', 'shaders/13_vertex_shader.glsl', 'shaders/13_fragment_shader.glsl')
    app.setTexFiltering()

    while not glfw.window_should_close(win):
        time.previous_time = time.actual_time;
        time.actual_time = glfw.get_time();
        clearColorSetViewport(0.5,0.1,0.2)
        app.render()
        glfw.swap_buffers(win)
        glfw.poll_events()
コード例 #43
0
    # Telling OpenGL to use our shader program
    glUseProgram(shaderProgram)

    # Setting up the clear screen color
    glClearColor(0.85, 0.85, 0.85, 1.0)

    # Creating shapes on GPU memory
    gpuQuadBlack = createQuad([0, 0, 0])
    gpuQuadWhite = createQuad([1, 1, 1])

    # Fill mode Polygon
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)

    # Get initial time
    t0 = glfw.get_time()

    while not glfw.window_should_close(window):
        # Getting the time difference from the previous iteration
        t1 = glfw.get_time()
        dt = t1 - t0
        t0 = t1

        # Using GLFW to check for input events
        glfw.poll_events()

        # Filling or not the shapes depending on the controller state
        if controller.fillPolygon:
            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
        else:
            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
コード例 #44
0
def main():

    # Initialize GLFW and open a window
    if not opengl_init():
        return

    # Enable key events
    glfw.set_input_mode(window,glfw.STICKY_KEYS,GL_TRUE) 
    glfw.set_cursor_pos(window, 1024/2, 768/2)

    # Set opengl clear color to something other than red (color used by the fragment shader)
    glClearColor(0.0,0.0,0.4,0.0)
    
    # Enable depth test
    glEnable(GL_DEPTH_TEST)

    # Accept fragment if it closer to the camera than the former one
    glDepthFunc(GL_LESS)

    # Cull triangles which normal is not towards the camera
    glEnable(GL_CULL_FACE)

    vertex_array_id = glGenVertexArrays(1)
    glBindVertexArray( vertex_array_id )

    # Create and compile our GLSL program from the shaders
    program_id = common.LoadShaders( "Shaders/Tutorial8/StandardShading.vertexshader",
        "Shaders/Tutorial8/StandardShading.fragmentshader" )
    
    # Get a handle for our "MVP" uniform
    matrix_id = glGetUniformLocation(program_id, "MVP")
    view_matrix_id = glGetUniformLocation(program_id, "V")
    model_matrix_id = glGetUniformLocation(program_id, "M")

    # Load the texture
    texture = load_image("Content/uvmap_suzanne.bmp")

    # Get a handle for our "myTextureSampler" uniform
    texture_id  = glGetUniformLocation(program_id, "myTextureSampler")

    # Read our OBJ file
    vertices,faces,uvs,normals,colors = objloader.load("Content/suzanne.obj")
    vertex_data,uv_data,normal_data = objloader.process_obj( vertices,faces,uvs,normals,colors)

    # Our OBJ loader uses Python lists, convert to ctype arrays before sending to OpenGL
    vertex_data = objloader.generate_2d_ctypes(vertex_data)
    uv_data = objloader.generate_2d_ctypes(uv_data)
    normal_data = objloader.generate_2d_ctypes(normal_data)

    # Load OBJ in to a VBO
    vertex_buffer = glGenBuffers(1);
    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer)
    glBufferData(GL_ARRAY_BUFFER, len(vertex_data) * 4 * 3, vertex_data, GL_STATIC_DRAW)

    uv_buffer = glGenBuffers(1)
    glBindBuffer(GL_ARRAY_BUFFER, uv_buffer)
    glBufferData(GL_ARRAY_BUFFER, len(uv_data) * 4 * 2, uv_data, GL_STATIC_DRAW)

    normal_buffer = glGenBuffers(1)
    glBindBuffer(GL_ARRAY_BUFFER, normal_buffer)
    glBufferData(GL_ARRAY_BUFFER, len(normal_data) * 4 * 3, normal_data, GL_STATIC_DRAW)

    # vsync and glfw do not play nice.  when vsync is enabled mouse movement is jittery.
    common.disable_vsyc()
    
    # Get a handle for our "LightPosition" uniform
    glUseProgram(program_id);
    light_id = glGetUniformLocation(program_id, "LightPosition_worldspace");

    last_time = glfw.get_time()
    frames = 0

    while glfw.get_key(window,glfw.KEY_ESCAPE) != glfw.PRESS and not glfw.window_should_close(window):
        glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT)

        current_time = glfw.get_time()
        if current_time - last_time >= 1.0:
            glfw.set_window_title(window,"Tutorial 8.  FPS: %d"%(frames))
            frames = 0
            last_time = current_time

        glUseProgram(program_id)

        controls.computeMatricesFromInputs(window)
        ProjectionMatrix = controls.getProjectionMatrix();
        ViewMatrix = controls.getViewMatrix();
        ModelMatrix = mat4.identity();
        mvp = ProjectionMatrix * ViewMatrix * ModelMatrix;

        # Send our transformation to the currently bound shader, 
        # in the "MVP" uniform
        glUniformMatrix4fv(matrix_id, 1, GL_FALSE,mvp.data)
        glUniformMatrix4fv(model_matrix_id, 1, GL_FALSE, ModelMatrix.data);
        glUniformMatrix4fv(view_matrix_id, 1, GL_FALSE, ViewMatrix.data);

        lightPos = vec3(4,4,4)
        glUniform3f(light_id, lightPos.x, lightPos.y, lightPos.z)

        # Bind our texture in Texture Unit 0
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, texture);
        # Set our "myTextureSampler" sampler to user Texture Unit 0
        glUniform1i(texture_id, 0);

        #1rst attribute buffer : vertices
        glEnableVertexAttribArray(0)
        glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
        glVertexAttribPointer(
            0,                  # attribute 0. No particular reason for 0, but must match the layout in the shader.
            3,                  # len(vertex_data)
            GL_FLOAT,           # type
            GL_FALSE,           # ormalized?
            0,                  # stride
            null                # array buffer offset (c_type == void*)
            )

        # 2nd attribute buffer : colors
        glEnableVertexAttribArray(1)
        glBindBuffer(GL_ARRAY_BUFFER, uv_buffer);
        glVertexAttribPointer(
            1,                  # attribute 1. No particular reason for 1, but must match the layout in the shader.
            2,                  # len(vertex_data)
            GL_FLOAT,           # type
            GL_FALSE,           # ormalized?
            0,                  # stride
            null                # array buffer offset (c_type == void*)
            )

        # 3rd attribute buffer : normals
        glEnableVertexAttribArray(2);
        glBindBuffer(GL_ARRAY_BUFFER, normal_buffer);
        glVertexAttribPointer(
            2,                                  # attribute
            3,                                  # size
            GL_FLOAT,                           # type
            GL_FALSE,                           # ormalized?
            0,                                  # stride
            null                                # array buffer offset (c_type == void*)
        )


        # Draw the triangles, vertex data now contains individual vertices
        # so use array length
        glDrawArrays(GL_TRIANGLES, 0, len(vertex_data))

        # Not strictly necessary because we only have 
        glDisableVertexAttribArray(0)
        glDisableVertexAttribArray(1)
        glDisableVertexAttribArray(2)
    
    
        # Swap front and back buffers
        glfw.swap_buffers(window)

        # Poll for and process events
        glfw.poll_events()

        frames += 1

    # !Note braces around vertex_buffer and uv_buffer.  
    # glDeleteBuffers expects a list of buffers to delete
    glDeleteBuffers(1, [vertex_buffer])
    glDeleteBuffers(1, [uv_buffer])
    glDeleteBuffers(1, [normal_buffer])
    glDeleteProgram(program_id)
    glDeleteTextures([texture_id])
    glDeleteVertexArrays(1, [vertex_array_id])

    glfw.terminate()