def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # change light position over time #self.lightPos[2] = math.cos(currentTime) * 2.0 # 0. Create depth cubemap transformation matrices aspect = float(self.shadowWidth) / self.shadowHeight near_plane = 1.0 far_plane = 25.0 shadowProj = glm.perspective(90.0, aspect, near_plane, far_plane) shadowTransforms = [] shadowTransforms.append(shadowProj * glm.lookAt(self.lightPos, self.lightPos + np.array([1.0, 0.0, 0.0], np.float32), np.array([0.0, -1.0, 0.0], np.float32))) shadowTransforms.append(shadowProj * glm.lookAt(self.lightPos, self.lightPos + np.array([-1.0, 0.0, 0.0], np.float32), np.array([0.0, -1.0, 0.0], np.float32))) shadowTransforms.append(shadowProj * glm.lookAt(self.lightPos, self.lightPos + np.array([0.0, 1.0, 0.0], np.float32), np.array([0.0, 0.0, 1.0], np.float32))) shadowTransforms.append(shadowProj * glm.lookAt(self.lightPos, self.lightPos + np.array([0.0, -1.0, 0.0], np.float32), np.array([0.0, 0.0, -1.0], np.float32))) shadowTransforms.append(shadowProj * glm.lookAt(self.lightPos, self.lightPos + np.array([0.0, 0.0, 1.0], np.float32), np.array([0.0, -1.0, 0.0], np.float32))) shadowTransforms.append(shadowProj * glm.lookAt(self.lightPos, self.lightPos + np.array([0.0, 0.0, -1.0], np.float32), np.array([0.0, -1.0, 0.0], np.float32))) # shadowTransforms = np.array(shadowTransforms, np.float32) # 1. Render scene to depth cubemap glViewport(0, 0, self.shadowWidth, self.shadowHeight) glBindFramebuffer(GL_FRAMEBUFFER, self.depthMapFBO) glClear(GL_DEPTH_BUFFER_BIT) glUseProgram(self.__simpleDepthShader) for i in range(6): glUniformMatrix4fv(glGetUniformLocation(self.__simpleDepthShader, 'shadowTransforms[{}]'.format(i)), 1, GL_FALSE, shadowTransforms[i]) glUniform1f(glGetUniformLocation(self.__simpleDepthShader, 'far_plane'), far_plane) glUniform3fv(glGetUniformLocation(self.__simpleDepthShader, 'lightPos'), 1, self.lightPos) self.renderScene(self.__simpleDepthShader) glBindFramebuffer(GL_FRAMEBUFFER, 0) # 2. render scene as normal glViewport(0, 0, self.width(), self.height()) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glUseProgram(self.__shader) projection = glm.perspective(self.camera.zoom, float(self.width())/self.height(), 0.1, 100.0) view = self.camera.viewMatrix glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'projection'), 1, GL_FALSE, projection) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'view'), 1, GL_FALSE, view) # set light uniforms glUniform3fv(glGetUniformLocation(self.__shader, 'lightPos'), 1, self.lightPos) glUniform3fv(glGetUniformLocation(self.__shader, 'viewPos'), 1, self.camera.position) # Enable/Disable shadows by pressing 'SPACE' glUniform1i(glGetUniformLocation(self.__shader, 'shadows'), self.shadows) glUniform1f(glGetUniformLocation(self.__shader, 'far_plane'), far_plane) glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, self.woodTexture) glActiveTexture(GL_TEXTURE1) glBindTexture(GL_TEXTURE_CUBE_MAP, self.depthCubeMap) self.renderScene(self.__shader) glUseProgram(0)
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # clear the colorbuffer glClearColor(0.1, 0.1, 0.1, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # draw objects glUseProgram(self.__shader) view = self.camera.viewMatrix projection = glm.perspective(self.camera.zoom, float(self.width())/self.height(), 0.1, 100.0) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'view'), 1, GL_FALSE, view) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'projection'), 1, GL_FALSE, projection) # cubes glBindVertexArray(self.cubeVAO) glBindTexture(GL_TEXTURE_2D, self.cubeTexture) model = glm.translate(np.identity(4, np.float32), -1.0, 0.0, -1.0) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'model'), 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) model = glm.translate(np.identity(4, np.float32), 2.0, 0.0, 0.0) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'model'), 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) # floor glBindVertexArray(self.planeVAO) glBindTexture(GL_TEXTURE_2D, self.floorTexture) model = np.identity(4, np.float32) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'model'), 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 6) glBindVertexArray(0) glUseProgram(0)
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # clear the colorbuffer glClearColor(0.1, 0.1, 0.1, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # configure view/projection matrices glUseProgram(self.__shader) view = self.camera.viewMatrix projection = glm.perspective(self.camera.zoom, float(self.width())/self.height(), 0.1, 100.0) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'view'), 1, GL_FALSE, view) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'projection'), 1, GL_FALSE, projection) # render normal-mapped quad rotVec = glm.normalize(np.array([1.0, 0.0, 1.0], np.float32)) model = glm.rotate(np.identity(4, np.float32), currentTime * -10.0, rotVec[0], rotVec[1], rotVec[2]) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'model'), 1, GL_FALSE, model) glUniform3fv(glGetUniformLocation(self.__shader, 'lightPos'), 1, self.lightPos) glUniform3fv(glGetUniformLocation(self.__shader, 'viewPos'), 1, self.camera.position) glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, self.diffuseMap) glActiveTexture(GL_TEXTURE1) glBindTexture(GL_TEXTURE_2D, self.normalMap) self.renderQuad() # render light source (simply re-renders a smaller plane at the light's position for debugging/visualization) # model = glm.scale(np.identity(4, np.float32), 0.1, 0.1, 0.1) # model = glm.translate(model, self.lightPos[0], self.lightPos[1], self.lightPos[2]) # glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'model'), 1, GL_FALSE, model) # self.renderQuad() glUseProgram(0)
def renderGL(self): """opengl render method""" # get the time in seconds t = glfwGetTime() # clear first glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # use the shader program glUseProgram(self.__shaderProgram) # calculate ViewProjection matrix projection = glm.perspective(90.0, 4.0 / 3.0, .1, 100.0) # translate the world/view position view = glm.translate(glm.mat4(1.0), glm.vec3(0.0, 0.0, -5.0)) # make the camera rotate around the origin view = glm.rotate(view, 90.0 * t, glm.vec3(1.0, 1.0, 1.0)) viewProjection = np.array(projection * view, dtype=np.float32) # set the uniform glUniformMatrix4fv(self.__vpLocation, 1, GL_FALSE, viewProjection) # bind the vao glBindVertexArray(self.__vao) # draw # the additional parameter indicates how many instances to render glDrawElementsInstanced(GL_TRIANGLES, 6 * 6, GL_UNSIGNED_INT, None, 8) glBindVertexArray(0) glUseProgram(0)
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # Render # Clear the colorbuffer glClearColor(0.05, 0.05, 0.05, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glUseProgram(self.__shaderProgram) view = self.camera.viewMatrix #view = glm.translate(view, 0.0, 0.0, -3.0) projection = glm.perspective(self.camera.zoom, float(self.width()) / self.height(), 0.1, 100.0) # get their uniform location modelLoc = glGetUniformLocation(self.__shaderProgram, 'model') viewLoc = glGetUniformLocation(self.__shaderProgram, 'view') projLoc = glGetUniformLocation(self.__shaderProgram, 'projection') glUniformMatrix4fv(viewLoc, 1, GL_FALSE, view) glUniformMatrix4fv(projLoc, 1, GL_FALSE, projection) model = np.identity(4, np.float32) model = glm.scale(model, 0.2, 0.2, 0.2) model = glm.translate(model, 0.0, -1.75, 0.0) glUniformMatrix4fv(modelLoc, 1, GL_FALSE, model) self.model.draw(self.__shaderProgram)
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # Render # Clear the colorbuffer glClearColor(0.1, 0.1, 0.1, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Draw objects glUseProgram(self.__shader) view = self.camera.viewMatrix projection = glm.perspective(self.camera.zoom, float(self.width())/self.height(), 0.1, 100.0) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'view'), 1, GL_FALSE, view) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'projection'), 1, GL_FALSE, projection) # Set light uniforms glUniform3fv(glGetUniformLocation(self.__shader, 'lightPos'), 4, self.lightPos) glUniform3fv(glGetUniformLocation(self.__shader, 'lightColors'), 4, self.lightColors) glUniform3fv(glGetUniformLocation(self.__shader, 'viewPos'), 1, self.camera.position) glUniform1i(glGetUniformLocation(self.__shader, 'gamma'), self.gammaEnabled) # floor glBindVertexArray(self.planeVAO) glBindTexture(GL_TEXTURE_2D, self.floorTextureGammaCorrected if self.gammaEnabled else self.floorTexture) glDrawArrays(GL_TRIANGLES, 0, 6) glBindVertexArray(0) print "Gamma enabled" if self.gammaEnabled else "Gamma disabled"
def renderGL(self): """opengl render method""" # get the time in seconds t = glfwGetTime() # clear first glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # use the shader program glUseProgram(self.__shaderProgram) # calculate ViewProjection matrix projection = glm.perspective(90.0, 4.0 / 3.0, .1, 100.0) projection = np.array(projection, dtype=np.float32) # translate the world/view position view = glm.translate(glm.mat4(1.0), glm.vec3(0.0, 0.0, -50.0)) # make the camera rotate around the origin view = glm.rotate(view, 30.0 * math.sin(t * 0.1), glm.vec3(1.0, 0.0, 0.0)) view = glm.rotate(view, -22.5 * t, glm.vec3(0.0, 1.0, 0.0)) view = np.array(view, dtype=np.float32) # set the uniform glUniformMatrix4fv(self.__viewLocation, 1, GL_FALSE, view) glUniformMatrix4fv(self.__projLocation, 1, GL_FALSE, projection) # bind the vao glBindVertexArray(self.__vao) # draw glDrawArrays(GL_POINTS, 0, self.__particles) glBindVertexArray(0) glUseProgram(0)
def testPerspective(self) : fov=45.0 near=0.02 far=10.0 aspect=1024.0/720.0 perspNGL=pyngl.perspective(fov,aspect,near,far) perspGLM=glm.perspective(pyngl.radians(fov),aspect,near,far) self.assertTrue(self.glmToNGL(perspGLM)==perspNGL)
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # Bind to framebuffer and draw to color texture # as we normally would glBindFramebuffer(GL_FRAMEBUFFER, self.framebuffer) # Render # Clear the colorbuffer glClearColor(0.1, 0.1, 0.1, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glEnable(GL_DEPTH_TEST) glUseProgram(self.__shaderProgram) view = self.camera.viewMatrix projection = glm.perspective(self.camera.zoom, float(self.width()) / self.height(), 0.1, 100.0) # get their uniform location modelLoc = glGetUniformLocation(self.__shaderProgram, 'model') viewLoc = glGetUniformLocation(self.__shaderProgram, 'view') projLoc = glGetUniformLocation(self.__shaderProgram, 'projection') glUniformMatrix4fv(viewLoc, 1, GL_FALSE, view) glUniformMatrix4fv(projLoc, 1, GL_FALSE, projection) # Floor glBindVertexArray(self.floorVAO) glBindTexture(GL_TEXTURE_2D, self.floorTexture) glUniformMatrix4fv(modelLoc, 1, GL_FALSE, np.identity(4, np.float32)) glDrawArrays(GL_TRIANGLES, 0, 6) glBindVertexArray(0) # Cubes glBindVertexArray(self.cubeVAO) glBindTexture(GL_TEXTURE_2D, self.cubeTexture) model = glm.translate(np.identity(4, np.float32), -1, 0, -1) glUniformMatrix4fv(modelLoc, 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) model = glm.translate(np.identity(4, np.float32), 2, 0, 0) glUniformMatrix4fv(modelLoc, 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) glBindVertexArray(0) # Bind to default framebuffer again and draw the # quad plane with attched screen texture glBindFramebuffer(GL_FRAMEBUFFER, 0) # Clear all relevant buffers glClearColor(1.0, 1.0, 1.0, 1.0) glClear(GL_COLOR_BUFFER_BIT) glDisable(GL_DEPTH_TEST) # Draw Screen glUseProgram(self.__screenShaderProgram) glBindVertexArray(self.quadVAO) glBindTexture(GL_TEXTURE_2D, self.textureColorBuffer) glDrawArrays(GL_TRIANGLES, 0, 6) glBindVertexArray(0)
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # Render # Clear the colorbuffer glClearColor(0.1, 0.1, 0.1, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glUseProgram(self.__lightingShader) objectColorLoc = glGetUniformLocation(self.__lightingShader, 'objectColor') lightColorLoc = glGetUniformLocation(self.__lightingShader, 'lightColor') lightPosLoc = glGetUniformLocation(self.__lightingShader, 'lightPos') viewPosLoc = glGetUniformLocation(self.__lightingShader, 'viewPos') glUniform3f(objectColorLoc, 1.0, 0.5, 0.31) glUniform3f(lightColorLoc, 1.0, 0.5, 1.0) glUniform3f(lightPosLoc, self.lightPos[0], self.lightPos[1], self.lightPos[2]) glUniform3f(viewPosLoc, self.camera.position[0], self.camera.position[1], self.camera.position[2]) view = self.camera.viewMatrix projection = glm.perspective(self.camera.zoom, float(self.width()) / self.height(), 0.1, 100.0) # get their uniform location modelLoc = glGetUniformLocation(self.__lightingShader, 'model') viewLoc = glGetUniformLocation(self.__lightingShader, 'view') projLoc = glGetUniformLocation(self.__lightingShader, 'projection') glUniformMatrix4fv(viewLoc, 1, GL_FALSE, view) glUniformMatrix4fv(projLoc, 1, GL_FALSE, projection) # Draw the container (using container's vertex attributes) glBindVertexArray(self.__containerVAO) model = np.identity(4, np.float32) glUniformMatrix4fv(modelLoc, 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) glBindVertexArray(0) # Also draw the lamp object, again binding the appropriate shader glUseProgram(self.__lampShader) # Get location objects for the matrices on the lamp shader (these could be different on a different shader) modelLoc = glGetUniformLocation(self.__lampShader, 'model') viewLoc = glGetUniformLocation(self.__lampShader, 'view') projLoc = glGetUniformLocation(self.__lampShader, 'projection') # set matrices glUniformMatrix4fv(viewLoc, 1, GL_FALSE, view) glUniformMatrix4fv(projLoc, 1, GL_FALSE, projection) model = np.identity(4, np.float32) model = glm.scale(model, 0.2, 0.2, 0.2) model = glm.translate(model, self.lightPos[0], self.lightPos[1], self.lightPos[2]) glUniformMatrix4fv(modelLoc, 1, GL_FALSE, model) # Draw the light object (using light's vertex attributes) glBindVertexArray(self.__lightVAO) glDrawArrays(GL_TRIANGLES, 0, 36) glBindVertexArray(0)
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # change light position over time self.lightPos[2] = math.cos(currentTime) * 2.0 # 1. Render depth of scene to texture (from light's perspective) # Get light projection/view matrix. near_plane = 1.0 far_plane = 7.5 lightProjection = glm.ortho(-10.0, 10.0, -10.0, 10.0, near_plane, far_plane) #lightProjection = glm.perspective(45.0, float(self.width())/self.height(), near_plane, far_plane) lightView = glm.lookAt(self.lightPos, np.zeros(3, np.float32), np.ones(3, np.float32)) lightSpaceMatrix = lightProjection * lightView # now render scene from light's point of view glUseProgram(self.__simpleDepthShader) glUniformMatrix4fv(glGetUniformLocation(self.__simpleDepthShader, 'lightSpaceMatrix'), 1, GL_FALSE, lightSpaceMatrix) glViewport(0, 0, self.shadowWidth, self.shadowHeight) glBindFramebuffer(GL_FRAMEBUFFER, self.depthMapFBO) glClear(GL_DEPTH_BUFFER_BIT) self.renderScene(self.__simpleDepthShader) glBindFramebuffer(GL_FRAMEBUFFER, 0) # 2. render scene as normal glViewport(0, 0, self.width(), self.height()) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glUseProgram(self.__shader) projection = glm.perspective(self.camera.zoom, float(self.width())/self.height(), 0.1, 100.0) view = self.camera.viewMatrix glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'projection'), 1, GL_FALSE, projection) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'view'), 1, GL_FALSE, view) # set light uniforms glUniform3fv(glGetUniformLocation(self.__shader, 'lightPos'), 1, self.lightPos) glUniform3fv(glGetUniformLocation(self.__shader, 'viewPos'), 1, self.camera.position) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'lightSpaceMatrix'), 1, GL_FALSE, lightSpaceMatrix) # Enable/Disable shadows by pressing 'SPACE' glUniform1i(glGetUniformLocation(self.__shader, 'shadows'), self.shadows) glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, self.woodTexture) glActiveTexture(GL_TEXTURE1) glBindTexture(GL_TEXTURE_2D, self.depthMap) self.renderScene(self.__shader) # 3. DEBUG: visualize depth map by rendering it to plane glUseProgram(self.__debugDepthQuad) glUniform1f(glGetUniformLocation(self.__debugDepthQuad, 'near_plane'), near_plane) glUniform1f(glGetUniformLocation(self.__debugDepthQuad, 'far_plane'), far_plane) glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, self.depthMap) #self.renderQuad() # uncomment this line to see depth map glUseProgram(0)
def _update(self): eye = numpy.array((self.angle.sin(), self.elevation.sin(), self.angle.cos())) eye = eye * self.distance / numpy.linalg.norm(eye) target = (0, 0, 0) upv = (0, 1, 0) self._model_view = glm.lookAt(eye, target, upv) fovy = 70.0 * (math.pi / 180.0) aspect = self.aspect_ratio() near = 0.1 far = 100.0 self._proj = glm.perspective(fovy, aspect, near, far) self._mvp = self._proj * self._model_view
def set_perspective(self): view_origin = glm.vec3(0, 0, 1) self.view_matrix = glm.lookAt(view_origin, glm.vec3(0, 0, 0), glm.vec3(0, 1, 0)) if self.transformation_mode % 3 is ORTHO_TRANSFORMATION: self.perspective_matrix = glm.ortho(-1, 1, -1, 1, 0, 100) elif self.transformation_mode % 3 is FRUSTUM_TRANSFORMATION: self.perspective_matrix = glm.frustum(-1, 1, -1, 1, 1.0, 100.0) elif self.transformation_mode % 3 is PERSPECTIVE_TRANSFORMATION: self.perspective_matrix = glm.perspective(glm.radians(90), 1, 1.0, 100.0) self.transformation_mode += 1
def changeText(number): texturas = ['./psico1.png', './dark.png', './bone2.png'] texture_surface = pygame.image.load(texturas[number]) texture_data = pygame.image.tostring(texture_surface, 'RGB') width = texture_surface.get_width() height = texture_surface.get_height() view = glm.mat4(1) projection = glm.perspective(glm.radians(45), 800 / 600, 0.1, 1000.0) model = glm.mat4(1) texture = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, texture) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, texture_data) glGenerateMipmap(GL_TEXTURE_2D)
def update_gl(): camera_front = -glm.normalize( glm.vec3( math.cos(math.radians(Camera._yaw)) * math.cos(math.radians(Camera._pitch)), math.sin(math.radians(Camera._pitch)), math.sin(math.radians(Camera._yaw)) * math.cos(math.radians(Camera._pitch)))) Program.forward_mat4( "projection", glm.perspective(math.radians(Camera._field_of_view), Config.width / Config.height, 0.1, 100)) Program.forward_mat4( "view", glm.lookAt(camera_front, glm.vec3(), Camera._camera_up)) Program.forward_vec3("camera_position", camera_front)
def render(window): global program, vao, indices, cube_positions GLFW.glfwPollEvents() GL.glViewport(0, 0, window.width, window.height) cameraPos = GLM.vec3(0.0, 0.0, 3.0) cameraTarget = GLM.vec3(0.0, 0.0, 0.0) cameraDirection = GLM.normalize(cameraPos - cameraTarget) up = GLM.vec3(0.0, 1.0, 0.0) cameraRight = GLM.normalize(GLM.cross(up, cameraDirection)) cameraUp = GLM.cross(cameraDirection, cameraRight) view = GLM.lookAt(GLM.vec3(0.0, 0.0, 3.0), GLM.vec3(0.0, 0.0, 0.0), GLM.vec3(0.0, 1.0, 0.0)) GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) program.useProgram() view = GLM.mat4(1.0) view = GLM.translate(view, GLM.vec3(0.0, 0.0, -3.0)) projection = GLM.perspective(GLM.radians(45.0), window.width / window.height, 0.1, 100.0) program.setMat4("projection", projection) for w in range(10): radius = 10.0 camX = MATH.sin(GLFW.glfwGetTime()) * radius camZ = MATH.cos(GLFW.glfwGetTime()) * radius view = GLM.lookAt(GLM.vec3(camX, 0.0, camZ), GLM.vec3(0.0, 0.0, 0.0), GLM.vec3(0.0, 1.0, 0.0)) model = GLM.mat4(1.0) model = GLM.translate(model, cube_positions[w]) model = GLM.rotate(model, GLM.radians(20.0 * w), GLM.vec3(1.0, 0.3, 0.5)) program.setMat4("model", model) program.setMat4("view", view) vao.useVAO(program) GL.glDrawArrays(GL.GL_TRIANGLES, 0, 36) vao.unBind() GLFW.glfwSwapBuffers(window.getWindow())
def __init__(self, screen): self.screen = screen _, _, self.width, self.height = screen.get_rect() glEnable(GL_DEPTH_TEST) glViewport(0, 0, self.width, self.height) # Perspective Projection Matrix self.projection = glm.perspective(glm.radians(60), self.width / self.height, 0.1, 1000) self.cube_pos = glm.vec3(0, 0, -3) self.camera_pos = glm.vec3(0, 0, 0) self.cam_pitch = 0 self.cam_yaw = 0 self.cam_roll = 0 self.current_position = 2
def set_state(self, shader, width, height): dirty = self._aspect != width / height self._aspect = width / height if dirty or self._dirty: shader['view'] = flatten(glm.lookAt(self.position, self.position - self.front, self.up)) shader['projection'] = flatten(glm.perspective( self.yfov, self._aspect, self.znear, self.zfar )) shader['camera.position'] = self.position self._dirty.clear()
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # Render # Clear the colorbuffer glClearColor(0.1, 0.1, 0.1, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glEnable(GL_DEPTH_TEST) glUseProgram(self.__shaderProgram) view = self.camera.viewMatrix projection = glm.perspective(self.camera.zoom, float(self.width()) / self.height(), 0.1, 100.0) # get their uniform location modelLoc = glGetUniformLocation(self.__shaderProgram, 'model') viewLoc = glGetUniformLocation(self.__shaderProgram, 'view') projLoc = glGetUniformLocation(self.__shaderProgram, 'projection') glUniformMatrix4fv(viewLoc, 1, GL_FALSE, view) glUniformMatrix4fv(projLoc, 1, GL_FALSE, projection) model = np.identity(4, np.float32) glUniformMatrix4fv(modelLoc, 1, GL_FALSE, model) # Cubes glBindVertexArray(self.cubeVAO) glBindTexture(GL_TEXTURE_CUBE_MAP, self.skyboxTexture) glDrawArrays(GL_TRIANGLES, 0, 36) glBindVertexArray(0) # Draw skybox as last glDepthFunc(GL_LEQUAL) glUseProgram(self.__skyboxShaderProgram) view = np.array(self.camera.viewMatrix) view[3][0] = 0.0 view[3][1] = 0.0 view[3][2] = 0.0 glUniformMatrix4fv(glGetUniformLocation(self.__skyboxShaderProgram, 'view'), 1, GL_FALSE, view) glUniformMatrix4fv(glGetUniformLocation(self.__skyboxShaderProgram, 'projection'), 1, GL_FALSE, projection) # skybox cube glBindVertexArray(self.skyboxVAO) glBindTexture(GL_TEXTURE_CUBE_MAP, self.skyboxTexture) glDrawArrays(GL_TRIANGLES, 0, 36) glBindVertexArray(0) glDepthFunc(GL_LESS)
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # Render # Clear the colorbuffer glClearColor(0.1, 0.1, 0.1, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glUseProgram(self.__shaderProgram) view = self.camera.viewMatrix projection = glm.perspective(self.camera.zoom, float(self.width()) / self.height(), 0.1, 100.0) # get their uniform location modelLoc = glGetUniformLocation(self.__shaderProgram, 'model') viewLoc = glGetUniformLocation(self.__shaderProgram, 'view') projLoc = glGetUniformLocation(self.__shaderProgram, 'projection') glUniformMatrix4fv(viewLoc, 1, GL_FALSE, view) glUniformMatrix4fv(projLoc, 1, GL_FALSE, projection) # Cubes glBindVertexArray(self.cubeVAO) glBindTexture(GL_TEXTURE_2D, self.cubeTexture) model = glm.translate(np.identity(4, np.float32), -1, 0, -1) glUniformMatrix4fv(modelLoc, 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) model = glm.translate(np.identity(4, np.float32), 2, 0, 0) glUniformMatrix4fv(modelLoc, 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) # Floor glBindVertexArray(self.planeVAO) glBindTexture(GL_TEXTURE_2D, self.floorTexture) glUniformMatrix4fv(modelLoc, 1, GL_FALSE, np.identity(4, np.float32)) glDrawArrays(GL_TRIANGLES, 0, 6) # Vergetation glBindVertexArray(self.transparentVAO) glBindTexture(GL_TEXTURE_2D, self.transparentTexture) for i in self.vegetation: model = glm.translate(np.identity(4, np.float32), i[0], i[1], i[2]) glUniformMatrix4fv(modelLoc, 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 6) glBindVertexArray(0)
def __Display(self): self.__current_time = time() self.__time = self.__current_time - self.__start_time if self.__vp_valid == False: self.__vp_size = (glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT)) self.__vp_valid = True glViewport(0, 0, *self.__vp_size) self.__proj = glm.perspective( glm.radians(90), self.__vp_size[0] / self.__vp_size[1], 0.1, 100) self.__update_proj = True self._Draw(self.__time) self._DrawHUD(self.__time) glutSwapBuffers() glutPostRedisplay()
def on_draw(self): glDisable(GL_CULL_FACE) glEnable(GL_DEPTH_TEST) self.clear() if self._projection in "io": proj = glm.ortho(-.5, .5, .5, -.5, -2, 2) else: proj = glm.perspective(30., self.width / self.height, 0.01, 10.) proj = glm.translate(proj, (0, 0, -1)) proj = glm.rotate(proj, self.rotate_x, (1, 0, 0)) proj = glm.rotate(proj, self.rotate_y, (0, 1, 0)) proj = glm.rotate(proj, self.rotate_z, (0, 0, 1)) #print(proj) if not self.texture.is_created(): self.texture.create() self.texture.bind() #self.texture.upload_image("./assets/STEEL.BMP") #self.texture.upload_image("./assets/bluenoise.png") self.texture.upload_image("./assets/blueplate.png") #self.texture.upload([random.randrange(256) for x in range(16*16*3)], 16, input_type=GL_BYTE) if self.fbo: if self.fbo.is_created(): if self.fbo.width != self.width or self.fbo.height != self.height: self.fbo.release() self.fbo = Framebuffer2D(self.width, self.height) if not self.fbo.is_created(): self.fbo.create() self.fbo.bind() self.fbo.clear() self.drawable.shader.set_uniform("u_projection", proj) self.drawable.shader.set_uniform("u_time", time.time() - self.start_time) self.texture.bind() self.drawable.draw() if self.fbo: self.fbo.unbind() self.fbo.color_texture(0).bind() #self.fbo.depth_texture().bind() self.quad.draw(self.width, self.height)
def on_draw(self, event): # Read about depth testing and changing stated in vispy here http://vispy.org/gloo.html?highlight=set_state gloo.clear(color=[0.2, 0.3, 0.3, 1.0], depth=True) self.view = glm.mat4(1.0) self.view = glm.translate(self.view, glm.vec3(0.0, 0.0, -3.0)) # to rotate camera along 45 degree or unit vector's direction # self.view = glm.rotate(self.view, (time() - self.startTime)* glm.radians(50), glm.vec3(1, 1, 1)) self.projection = glm.mat4(1.0) self.projection = glm.perspective(glm.radians(45.0), builtins.width / builtins.height, 0.1, 100.0) # vispy takes numpy array in m * n matrix form self.view = (np.array(self.view.to_list()).astype(np.float32)) self.projection = (np.array(self.projection.to_list()).astype( np.float32)) # reshaping to (m, n) to (1, m*n) to support data input in vispy self.view = self.view.reshape( (1, self.view.shape[0] * self.view.shape[1])) self.projection = self.projection.reshape( (1, self.projection.shape[0] * self.projection.shape[1])) self.program['view'] = self.view self.program['projection'] = self.projection i = 0 for cubePosition in self.cubePositions: i += 1 self.model = glm.mat4(1.0) self.model = glm.translate(self.model, cubePosition) self.model = glm.rotate( self.model, glm.radians( (time() - self.startTime) * glm.radians(2000) * i / 2), glm.vec3(1.0, 0.3, 0.5)) self.model = (np.array(self.model.to_list()).astype(np.float32)) self.model = self.model.reshape( (1, self.model.shape[0] * self.model.shape[1])) self.program['model'] = self.model self.program.draw('triangles') self.update()
def start(): window = pyglet.window.Window(resizable=True) pyglet.gl.glEnable(pyglet.gl.GL_DEPTH_TEST) pyshaders.transpose_matrices(False) shader = pyshaders.from_string(vert, frag) shader.use() view = glm.lookAt( glm.vec3(1.2, 1.2, 1.2), glm.vec3(0, 0, 0), glm.vec3(0, 0, 1), ) proj = glm.perspective(glm.radians(45), 800/600, 1, 10) pattern = pyglet.image.CheckerImagePattern() tex = pattern.create_image(64, 64).get_texture() textured = pyglet.graphics.TextureGroup(tex) batch = pyglet.graphics.Batch() batch.add( 36, pyglet.gl.GL_TRIANGLES, textured, ("0g3f", cube(0, 0, 0)), ("1g2f", (0, 2, 0, 0, 2, 0, 0, 2, 2, 2, 2, 0) * 6) ) t = 0 def update(dt): nonlocal t m = glm.mat4(1) m = glm.rotate(m, t, (0, 0, 1)) shader.uniforms.model = m shader.uniforms.view = view shader.uniforms.proj = proj t += dt pyglet.clock.schedule(update) @window.event() def on_draw(): window.clear() batch.draw()
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # Render # Clear the colorbuffer glClearColor(0.2, 0.3, 0.3, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glUseProgram(self.__shaderProgram) glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, self.texture1) glUniform1i(glGetUniformLocation(self.__shaderProgram, 'ourTexture1'), 0) glActiveTexture(GL_TEXTURE1) glBindTexture(GL_TEXTURE_2D, self.texture2) glUniform1i(glGetUniformLocation(self.__shaderProgram, 'ourTexture2'), 1) view = self.camera.viewMatrix view = glm.translate(view, 0.0, 0.0, -3.0) projection = glm.perspective(self.camera.zoom, float(self.width()) / self.height(), 0.1, 1000.0) # get their uniform location modelLoc = glGetUniformLocation(self.__shaderProgram, 'model') viewLoc = glGetUniformLocation(self.__shaderProgram, 'view') projLoc = glGetUniformLocation(self.__shaderProgram, 'projection') glUniformMatrix4fv(viewLoc, 1, GL_FALSE, view) glUniformMatrix4fv(projLoc, 1, GL_FALSE, projection) glBindVertexArray(self.__vao) for i in self.__cubePositions: # calculate the model matrix for each object and pass it to shader before drawing angle = math.degrees(20.0 * self.__cubePositions.index(i)) model = glm.rotate(np.identity(4, np.float32), angle, 1.0, 0.3, 0.5) model = glm.translate(model, i[0], i[1], i[2]) glUniformMatrix4fv(modelLoc, 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) glBindVertexArray(0)
def __init__(self): self.zoom = 1 self.model = glm.mat4(1.0) self.camera_pos = glm.vec3(0, 10, 7) self.camera_front = glm.normalize(glm.vec3(0, -1, -1)) self.camera_up = glm.vec3(0, 1, 0) self.view = glm.lookAt(self.camera_pos, self.camera_pos * self.camera_front, self.camera_up) self.projection = glm.perspective( glm.radians(45), OPTIONS["size"][0] / OPTIONS["size"][1], 0.1, 1000) self.model = glm.rotate(self.model, glm.radians(-90.0), glm.vec3(0, 1, 0)) self.light_pos = glm.vec3(10, 10, 10) self.is_running = False self.is_animation_running = False
def render(self): T = glfw.get_time() if self.program is not None: gl.glUseProgram(self.program) M = m.translate(m.mat4(1.0), m.vec3(0.0, -0.7, 0.0)) campos = m.vec3(math.cos(T) * 2.0, 0.0, math.sin(T) * 2.0) V = m.lookAt(campos, m.vec3(0.0), m.vec3(0.0, 1.0, 0.0)) P = m.perspective(m.radians(74.0), 1.0, 0.001, 100.0) u_MVP = P * V * M self.uniform("u_MVP", u_MVP) if self.vao is not None: gl.glBindVertexArray(self.vao) gl.glDrawElements(gl.GL_TRIANGLES, self.len_indices, gl.GL_UNSIGNED_SHORT, None)
def OnInit(self): self.is_trans = True self.vertex_shaders = [st.ANIMATED_VERTEX_SHADER] self.fragment_shaders = [st.ANIMATED_FRAGMENT_SHADER] self.texture_name = 'wood.jpg' self.time = Timer(duration=2.0, repeating=1) self.time.addEventHandler("fraction", self.OnTimerFraction) self.time.register(self) self.time.start() self.vertexes, self.indices, self.normals, self.uv = self.load_data() self.load_object() self.load_shader() self.load_texture() self.location = np.array([0.0, 0.0, 0.0]) self.EYE = np.array([0.0, 0.0, 10.0]) self.PREF = np.array([0.0, 0.0, -1.0]) self.vv = np.array([0.0, 1.0, 0.0]) self.N = (self.PREF - self.EYE) / np.linalg.norm(self.PREF - self.EYE) self.U = np.cross(self.N, self.vv) / np.linalg.norm(np.cross(self.N, self.vv)) self.EYE_UP = np.cross(self.U, self.N) self.d = 0.1 height = 500 width = 500 self.half_h = height / 2 self.f = 100.0 self.width = width self.height = height slope = np.sqrt((pow(self.d, 2) + pow((width / 2), 2))) self.fov = 2 * np.arctan(self.half_h / slope) left_bottom_near = self.EYE + self.d * self.N - self.half_h * self.U - self.half_h * self.EYE_UP right_top_near = self.EYE + self.d * self.N + self.half_h * self.U + self.half_h * self.EYE_UP self.VIEW = np.array([left_bottom_near[0], right_top_near[0], left_bottom_near[1], right_top_near[1], np.array([self.d]), np.array([self.f])]) self.LOOK_AT = np.array([0, 0, 0]) self.ProjectionMatrix = glm.perspective(self.fov, float(self.width) / float(self.height), self.d, self.f) self.ViewMatrix = glm.lookAt(glm.vec3(self.EYE[0], self.EYE[1], self.EYE[2]), glm.vec3(self.LOOK_AT[0], self.LOOK_AT[1], self.LOOK_AT[2]), glm.vec3(self.vv[0], self.vv[1], self.vv[2]) ) self.MVP = self.ProjectionMatrix * self.ViewMatrix * glm.mat4(1.0)
def __init__(self, _data, _image): self.data = _data self.image = _image self.VBO = None self.VAO = None self.EBO = None self.TEX = None self.programId = 0 # MODEL-VIEW-PROJECTION MATRIX self.Projection = glm.perspective(glm.radians(60.0), 4.0 / 3.0, 0.1, 100.0) self.View = glm.mat4( glm.lookAt(glm.vec3(0, 0, 7), glm.vec3(0, 0, 0), glm.vec3(0, 1, 0))) self.Model = glm.mat4(1.0) self.MVP = self.Projection * self.View * self.Model self.MVP = np.array(self.MVP, dtype=np.float32)
def __mainloop(self): proj, view, model = glm.mat4(1), glm.mat4(1), glm.mat4(1) aspect = self.__vp_size[0]/self.__vp_size[1] proj = glm.perspective(glm.radians(90.0), aspect, 0.1, 10.0) view = glm.lookAt(glm.vec3(0,-3,0), glm.vec3(0, 0, 0), glm.vec3(0,0,1)) angle1 = self.elapsed_ms() * math.pi * 2 / 5000.0 angle2 = self.elapsed_ms() * math.pi * 2 / 7333.0 model = glm.rotate(model, angle1, glm.vec3(1, 0, 0)) model = glm.rotate(model, angle2, glm.vec3(0, 1, 0)) glUniformMatrix4fv(self.___uniform['u_proj'], 1, GL_FALSE, glm.value_ptr(proj) ) glUniformMatrix4fv(self.___uniform['u_view'], 1, GL_FALSE, glm.value_ptr(view) ) glUniformMatrix4fv(self.___uniform['u_model'], 1, GL_FALSE, glm.value_ptr(model) ) glClearColor(0.2, 0.3, 0.3, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glDrawElements(GL_TRIANGLES, self.__no_indices, GL_UNSIGNED_INT, None)
def display(): glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) elapsed_ms = glutGet(GLUT_ELAPSED_TIME) projection = glm.perspective(glm.radians(60), aspect, 0.1, 10.0) view = glm.lookAt(glm.vec3(0, 0, 4), glm.vec3(0, 0, 0), glm.vec3(0, 1, 0)) angle = elapsed_ms * math.pi * 2 / 5000.0 model = glm.rotate(glm.mat4(1), angle * 0.5, glm.vec3(0, 1, 0)) model = glm.rotate(model, angle, glm.vec3(1, 0, 0)) glUniformMatrix4fv(0, 1, GL_FALSE, glm.value_ptr(projection)) glUniformMatrix4fv(1, 1, GL_FALSE, glm.value_ptr(view)) glUniformMatrix4fv(2, 1, GL_FALSE, glm.value_ptr(model)) glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, None) glutSwapBuffers() glutPostRedisplay()
def update_matrices(self): # create projection matrix self.p_matrix = glm.perspective( glm.radians(options.FOV + 10 * (self.speed - WALKING_SPEED) / (SPRINTING_SPEED - WALKING_SPEED)), float(self.view_width) / self.view_height, 0.1, 500) # create modelview matrix self.mv_matrix = glm.mat4(1.0) self.mv_matrix = glm.rotate(self.mv_matrix, self.rotation[1], -glm.vec3(1.0, 0.0, 0.0)) self.mv_matrix = glm.rotate(self.mv_matrix, self.rotation[0] + math.tau / 4, glm.vec3(0.0, 1.0, 0.0)) self.mv_matrix = glm.translate(self.mv_matrix, -glm.vec3(*self.interpolated_position) - glm.vec3(0, self.eyelevel, 0)) # modelviewprojection matrix self.shader.uniform_matrix(self.mvp_matrix_location, self.p_matrix * self.mv_matrix) self.update_frustum(self.p_matrix * self.mv_matrix)
def drawObject(self): # Update camera model, view, proj = glm.mat4(1), glm.mat4(1), glm.perspective( 45, self.width() / self.height(), 0.01, 100) center, up, eye = glm.vec3(0, -0.075, 0), glm.vec3(0, -1, 0), glm.vec3( 0, 0, -0.4 * (self.zoomLevel / 10)) view = glm.lookAt(eye, center, up) model = glm.rotate(model, self.xRot / 160.0, glm.vec3(1, 0, 0)) model = glm.rotate(model, self.yRot / 160.0, glm.vec3(0, 1, 0)) model = glm.rotate(model, self.zRot / 160.0, glm.vec3(0, 0, 1)) mvp = proj * view * model GL.glUniformMatrix4fv(self.UNIFORM_LOCATIONS['mvp'], 1, False, glm.value_ptr(mvp)) # Update data self.pos_vbo.set_array(self.pos) self.col_vbo.set_array(self.col) # Point size GL.glPointSize(4) # Position self.pos_vbo.bind() GL.glEnableVertexAttribArray(0) GL.glVertexAttribPointer(0, 3, GL.GL_FLOAT, GL.GL_FALSE, 0, None) # Color self.col_vbo.bind() GL.glEnableVertexAttribArray(1) GL.glVertexAttribPointer(1, 3, GL.GL_FLOAT, GL.GL_FALSE, 0, None) # Draw GL.glDrawArrays(GL.GL_POINTS, 0, self.pos.shape[0]) # Center debug if False: self.qglColor(QtGui.QColor(255, 0, 0)) GL.glPointSize(20) GL.glBegin(GL.GL_POINTS) GL.glVertex3d(0, 0, 0) GL.glEnd()
def __init__(self, screen): self.screen = screen _, _, self.width, self.height = screen.get_rect() glEnable(GL_DEPTH_TEST) glViewport(0, 0, self.width, self.height) self.modelList = [] self.activeModelIndex = 0 self.active_shader = None self.camPosition = glm.vec3(0, 0, 0) self.camRotation = glm.vec3(0, 0, 0) self.projection = glm.perspective(glm.radians(60), self.width / self.height, 0.1, 1000) self.pointLight = glm.vec4(0, 0, 0, 0) self.angle = 90 self.viewMatrix = self.getViewMatrix() self.__roll = 0 self.__pitch = 0 self.__yaw = 0
def renderGL(self): """opengl render method""" # get the time in seconds t = glfwGetTime() # clear first glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # use the shader program glUseProgram(self.__shaderProgram) # calculate ViewProjection matrix projection = glm.perspective(90.0, 4.0 / 3.0, .1, 100.0) # translate the world/view position view = glm.translate(glm.mat4(1.0), glm.vec3(0.0, 0.0, -5.0)) # make the camera rotate around the origin view = glm.rotate(view, 90.0 * t, glm.vec3(1.0, 1.0, 1.0)) viewProjection = np.array(projection * view, dtype=np.float32) # set the uniform glUniformMatrix4fv(self.__vpLocation, 1, GL_FALSE, viewProjection) # bind texture to texture unit 0 glActiveTexture(GL_TEXTURE0) #glBindTexture(GL_TEXTURE_BUFFER, self.__bufferTex) # set texture uniform glUniform1i(self.__otLocation, 0) # bind the vao glBindVertexArray(self.__vao) # draw # the additional parameter indicates how many instances to render glDrawElementsInstanced(GL_TRIANGLES, 6 * 6, GL_UNSIGNED_INT, None, 8) glBindVertexArray(0) glUseProgram(0)
def render(self): """ 描画処理を行う。 """ glClearColor(0, 0.0, 0.0, 0.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # ビュー行列を生成 eye = [0.0, 30.0, 0.0] # 視点 target = [0.0, 0.0, 0.0] # 注視点 up = [0.0, 0.0, -1.0] # 画面上方向 view_matrix = glm.lookAt(glm.vec3(*eye), glm.vec3(*target), glm.vec3(*up)) view_matrix = glm.rotate( view_matrix, # 注視点を中心としてカメラをグルグル回す self.camera_roll, glm.vec3(0.0, 0.0, 1.0)) self.camera_roll += math.radians(0.10) # 透視射影行列を生成 view_angle = 90.0 # 視野角(degree) aspect_rate = 1.0 z_near = 0.1 # これ以上近い物体は見えない z_far = 100.0 # これ以上遠い物体は見えない projection_matrix = glm.perspective(math.radians(view_angle), aspect_rate, z_near, z_far) # シェーダの設定を行う # シェーダ(self.shader)に対しては以下の3種類の行列を適切に供給する必要がある。 # - モデル(model)行列: モデル毎に固有の行列。モデルの姿勢と位置を示す4x4正方行列 # - ビュー(view)行列: カメラの姿勢と位置を示す4x4正方行列 # - 射影(projection)行列: 射影方式とパラメータを表す4x4正方行列 self.shader.set_view_matrix(view_matrix) # ビュー行列を更新 self.shader.set_projection_matrix(projection_matrix) # 射影行列を更新 # 歯車を描画 for gear in self.gears: gear.update() # 歯車の状態を更新 model_matrix = gear.get_model_matrix() self.shader.set_model_matrix(model_matrix) # モデル行列を更新 gear.draw() # 描画
def update(self, field_view=None, width=None, height=None, znear=None, zfar=None): if field_view != None: self.field_view = field_view if width != None: self.width = width if height != None: self.height = height if znear != None: self.znear = znear if zfar != None: self.zfar = zfar glViewport(0, 0, self.width, self.height) self.__matrix = glm.perspective(self.field_view, self.width / self.height, self.znear, self.zfar)
def render(resources, frame_size, elapsed_time): GL.glClearColor(0.2, 0.2, 0.2, 0.0) GL.glClearDepth(1.0) GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) GL.glEnable(GL.GL_DEPTH_TEST) GL.glEnable(GL.GL_CULL_FACE) model_view_projection = ( glm.perspective(45.0, frame_size[0] / frame_size[1], 0.1, 10000.0) * glm.lookAt(glm.vec3(3.0, 3.0, 3.0), glm.vec3(0.0, 0.0, 0.0), glm.vec3(0.0, 0.0, 1.0)) * glm.rotate(glm.mat4(1.0), elapsed_time, glm.vec3(1.0, 0.0, 0.0)) ) GL.glUseProgram(resources.program) GL.glUniformMatrix4fv(0, 1, False, glm.value_ptr(model_view_projection)) resources.cube_draw_call() GL.glUseProgram(0) GL.glDisable(GL.GL_DEPTH_TEST) GL.glDisable(GL.GL_CULL_FACE)
def __mainloop(self): if not self.__vp_valid: self.width = glutGet(GLUT_WINDOW_WIDTH) self.height = glutGet(GLUT_WINDOW_HEIGHT) self.__vp_size = [self.width, self.height] self.__vp_valid = True aspect = self.width / self.height self.proj = glm.perspective(glm.radians(90.0), aspect, self.near, self.far) glUniformMatrix4fv(self.___uniform['u_proj'], 1, GL_FALSE, glm.value_ptr(self.proj) ) glUniformMatrix4fv(self.___uniform['u_view'], 1, GL_FALSE, glm.value_ptr(self.view) ) glUniformMatrix4fv(self.___uniform['u_model'], 1, GL_FALSE, glm.value_ptr(self.model) ) glClearColor(0.2, 0.3, 0.3, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glDrawArrays(GL_TRIANGLES, 0, self.__no_vert) glutSwapBuffers() glutPostRedisplay()
def computeMatrices(self): self.direction = glm.vec3( math.cos(self.YAngle) * math.sin(self.XAngle), math.sin(self.YAngle), math.cos(self.YAngle) * math.cos(self.XAngle)) self.right = glm.vec3(math.sin(self.XAngle - 3.14 / 2.0), 0.0, math.cos(self.XAngle - 3.14 / 2.0)) self.up = glm.cross(self.right, self.direction) self.lookPos = self.position + self.direction self.ProjectionMatrix = glm.perspective( glm.radians(self.Fov), float(self.ScreenWidth) / float(self.ScreenHeight), 0.1, 1000.0) self.ViewMatrix = glm.lookAt( self.position, # Camera is here self. lookPos, # and looks here : at the same position, plus "direction" self.up # Head is up (set to 0,-1,0 to look upside-down) )
def __init__(self, screen): self.screen = screen _, _, self.width, self.height = screen.get_rect() glEnable(GL_DEPTH_TEST) glViewport(0, 0, self.width, self.height) self.temp = 0 self.modelList = [] # View Matrix self.camPosition = glm.vec3(0, 0, 0) self.camRotation = glm.vec3(0, 0, 0) # pitch, yaw, roll # Light self.pointLight = glm.vec4(0, 0, 0, 0) # Perspective Projection Matrix self.projection = glm.perspective(glm.radians(60), self.width / self.height, 0.1, 1000)
def __init__(self, position=np.array([0.0, 0.0, 10.0]), pref=np.array([0.0, 0.0, -1.0]), vv=np.array([0.0, 1.0, 0.0]), d=4.0, width=500, height=4.0, f=100.0): # if use shader, remember change d->0.1, height->500 self.EYE = position self.PREF = pref self.vv = vv self.N = (self.PREF - self.EYE) / np.linalg.norm(self.PREF - self.EYE) self.U = np.cross(self.N, self.vv) / np.linalg.norm( np.cross(self.N, self.vv)) self.EYE_UP = np.cross(self.U, self.N) self.d = d self.half_h = height / 2 self.f = f self.width = width self.height = height slope = np.sqrt((pow(d, 2) + pow((width / 2), 2))) self.fov = 2 * np.arctan(self.half_h / slope) left_bottom_near = self.EYE + self.d * self.N - self.half_h * self.U - self.half_h * self.EYE_UP right_top_near = self.EYE + self.d * self.N + self.half_h * self.U + self.half_h * self.EYE_UP self.VIEW = np.array([ left_bottom_near[0], right_top_near[0], left_bottom_near[1], right_top_near[1], np.array([self.d]), np.array([self.f]) ]) # self.VIEW = np.array([-5, 5, -5, 5, self.d, self.f]) # self.LOOK_AT = self.EYE + self.PREF self.LOOK_AT = np.array([0, 0, 0]) self.ProjectionMatrix = glm.perspective( self.fov, float(self.width) / float(self.height), self.d, self.f) self.calcView() self.calcMVP()
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # clear the colorbuffer glClearColor(0.1, 0.1, 0.1, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # draw objects glUseProgram(self.__shader) view = self.camera.viewMatrix projection = glm.perspective(self.camera.zoom, float(self.width()) / self.height(), 0.1, 100.0) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'view'), 1, GL_FALSE, view) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'projection'), 1, GL_FALSE, projection) # cubes glBindVertexArray(self.cubeVAO) glBindTexture(GL_TEXTURE_2D, self.cubeTexture) model = glm.translate(np.identity(4, np.float32), -1.0, 0.0, -1.0) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'model'), 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) model = glm.translate(np.identity(4, np.float32), 2.0, 0.0, 0.0) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'model'), 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) # floor glBindVertexArray(self.planeVAO) glBindTexture(GL_TEXTURE_2D, self.floorTexture) model = np.identity(4, np.float32) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'model'), 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 6) glBindVertexArray(0) glUseProgram(0)
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # 1. Render scene into floating point framebuffer glBindFramebuffer(GL_FRAMEBUFFER, self.hdrFBO) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) projection = glm.perspective(self.camera.zoom, float(self.width()) / self.height(), 0.1, 100.0) view = self.camera.viewMatrix glUseProgram(self.__shader) glUniformMatrix4fv(glGetUniformLocation(self.__shader, "projection"), 1, GL_FALSE, projection) glUniformMatrix4fv(glGetUniformLocation(self.__shader, "view"), 1, GL_FALSE, view) glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, self.woodTexture) # set lighting uniforms for i in range(len(self.lightPos)): glUniform3fv(glGetUniformLocation(self.__shader, "lights[{}].Position".format(i)), 1, self.lightPos[i]) glUniform3fv(glGetUniformLocation(self.__shader, "lights[{}].Color".format(i)), 1, self.lightColors[i]) glUniform3fv(glGetUniformLocation(self.__shader, "viewPos"), 1, self.camera.position) # render tunnel model = glm.scale(np.identity(4, np.float32), 5.0, 5.0, 55.0) model = glm.translate(model, 0.0, 0.0, 25.0) glUniformMatrix4fv(glGetUniformLocation(self.__shader, "model"), 1, GL_FALSE, model) glUniform1i(glGetUniformLocation(self.__shader, "inverse_normals"), GL_TRUE) self.renderCube() glBindFramebuffer(GL_FRAMEBUFFER, 0) # 2. Now render floating point color buffer to 2D quad and tonemap HDR colors to default framebuffer's (clamped) color range glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glUseProgram(self.__hdrShader) glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, self.colorBuffer) glUniform1i(glGetUniformLocation(self.__hdrShader, "hdr"), self.hdr) glUniform1f(glGetUniformLocation(self.__hdrShader, "exposure"), self.exposure) self.renderQuad() glUseProgram(0) print "exposure: {}".format(self.exposure)
def initializeGL(self): glClearColor(0,1,0,1) glEnable(GL_DEPTH_TEST) glDepthFunc(GL_LESS) #glEnable(GL_TEXTURE_2D) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) self.updateView() self.projection = glm.perspective(45.0, float(self.width()) / float(self.height()), 0.01, 1000.0) glViewport(0,0, self.width(), self.height()) shader_data = [self.loadShader('shaders/colorvert.vs', GL_VERTEX_SHADER), self.loadShader('shaders/colorfrag.fs', GL_FRAGMENT_SHADER)] self.createShaderProgram('color', shader_data) shader_data = [self.loadShader('shaders/grayvert.vs', GL_VERTEX_SHADER), self.loadShader('shaders/grayfrag.fs', GL_FRAGMENT_SHADER)] self.createShaderProgram('gray', shader_data) shader_data = [self.loadShader('shaders/fontvert.vs', GL_VERTEX_SHADER), self.loadShader('shaders/fontfrag.fs', GL_FRAGMENT_SHADER)] self.createShaderProgram('gui', shader_data)
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # 1. Geometry Pass: render scene's geometry/color data into gbuffer glBindFramebuffer(GL_FRAMEBUFFER, self.gbuffer) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) projection = glm.perspective(self.camera.zoom, float(self.width()) / self.height(), 0.1, 50.0) view = self.camera.viewMatrix glUseProgram(self.__geometyPassShader) glUniformMatrix4fv(glGetUniformLocation(self.__geometyPassShader, 'projection'), 1, GL_FALSE, projection) glUniformMatrix4fv(glGetUniformLocation(self.__geometyPassShader, 'view'), 1, GL_FALSE, view) # Floor cube model = glm.scale(np.identity(4, np.float32), 20.0, 1.0, 28.0) model = glm.translate(model, 0.0, -1.0, 0.0) glUniformMatrix4fv(glGetUniformLocation(self.__geometyPassShader, 'model'), 1, GL_FALSE, model) self.renderCube() # Nanosuit model on the floor model = glm.scale(np.identity(4, np.float32), 0.5, 0.5, 0.5) model = glm.rotate(model, -90.0, 1.0, 0.0, 0.0) model = glm.translate(model, 0.0, 0.0, 5.0) glUniformMatrix4fv(glGetUniformLocation(self.__geometyPassShader, 'model'), 1, GL_FALSE, model) self.cyborg.draw(self.__geometyPassShader) glBindFramebuffer(GL_FRAMEBUFFER, 0) # 2. Create SSAO texture glBindFramebuffer(GL_FRAMEBUFFER, self.ssaoFBO) glClear(GL_COLOR_BUFFER_BIT) glUseProgram(self.__ssaoShader) glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, self.gPositionDepth) glActiveTexture(GL_TEXTURE1) glBindTexture(GL_TEXTURE_2D, self.gNormal) glActiveTexture(GL_TEXTURE2) glBindTexture(GL_TEXTURE_2D, self.noiseTexture) # send kernel + rotation [glUniform3fv(glGetUniformLocation(self.__ssaoShader, 'samples[{}]'.format(i)), 1, self.ssaoKernel[i]) for i in range(64)] glUniformMatrix4fv(glGetUniformLocation(self.__ssaoShader, 'projection'), 1, GL_FALSE, projection) self.renderQuad() glBindFramebuffer(GL_FRAMEBUFFER, 0) # 3. Blur SSAO texture to remove noise glBindFramebuffer(GL_FRAMEBUFFER, self.ssaoBlurFBO) glClear(GL_COLOR_BUFFER_BIT) glUseProgram(self.__ssaoBlurShader) glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, self.ssaoColorBuffer) self.renderQuad() glBindFramebuffer(GL_FRAMEBUFFER, 0) # 4. Lighting Pass: calculate lighting by iterating over a screen filled quad pixel-by-pixel using the gbuffer's content. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glUseProgram(self.__lightingPassShader) glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, self.gPositionDepth) glActiveTexture(GL_TEXTURE1) glBindTexture(GL_TEXTURE_2D, self.gNormal) glActiveTexture(GL_TEXTURE2) glBindTexture(GL_TEXTURE_2D, self.gAlbedo) glActiveTexture(GL_TEXTURE3) # add extra SSAO texture to lighting pass glBindTexture(GL_TEXTURE_2D, self.ssaoColorBufferBlur) # also send light relevent uniforms lightPosView = (self.camera.viewMatrix * np.array([self.lightPos[0], self.lightPos[1], self.lightPos[2], 1.0], np.float32))[3, :4] glUniform3fv(glGetUniformLocation(self.__lightingPassShader, 'light.Position'), 1, lightPosView) glUniform3fv(glGetUniformLocation(self.__lightingPassShader, 'light.Color'), 1, self.lightColor) # Update attenuation parameters and calculate radius _constant = 1.0 # Note that we don't send this to the shader, we assume it is always 1.0 (in our case) linear = 0.09 quadratic = 0.032 glUniform1f(glGetUniformLocation(self.__lightingPassShader, 'light.Linear'), linear) glUniform1f(glGetUniformLocation(self.__lightingPassShader, 'light.Quadratic'), quadratic) glUniform1i(glGetUniformLocation(self.__lightingPassShader, 'draw_mode'), self.draw_mode) self.renderQuad() glUseProgram(0)
def renderGL(self): """opengl render method""" # get the time in seconds t = glfwGetTime() # use the transform shader program glUseProgram(self.__tshaderProgram) # set the uniforms glUniform3fv(self.__centerLocation, 3, self.__center) glUniform1fv(self.__radiusLocation, 3, self.__radius) glUniform3fv(self.__gLocation, 1, self.__g) glUniform1f(self.__dtLocation, self.__dt) glUniform1f(self.__bounceLocation, self.__bounce) glUniform1i(self.__seedLocation, randint(0, 0x7fff)) # bind the current vao glBindVertexArray(self.__vao[(self.__currentBuffer + 1) % self.__bufferCount]) # bind transform feedback target glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, self.__vbo[self.__currentBuffer]) glEnable(GL_RASTERIZER_DISCARD) # perform transform feedback glBeginTransformFeedback(GL_POINTS) glDrawArrays(GL_POINTS, 0, self.__particles) glEndTransformFeedback() glDisable(GL_RASTERIZER_DISCARD) # clear first glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # use the shader program glUseProgram(self.__shaderProgram) # calculate ViewProjection matrix projection = glm.perspective(90.0, 4.0 / 3.0, .1, 100.0) projection = np.array(projection, dtype=np.float32) # translate the world/view position view = glm.translate(glm.mat4(1.0), glm.vec3(0.0, 0.0, -30.0)) # make the camera rotate around the origin view = glm.rotate(view, 30.0, glm.vec3(1.0, 0.0, 0.0)) view = glm.rotate(view, -22.5 * t, glm.vec3(0.0, 1.0, 0.0)) view = np.array(view, dtype=np.float32) # set the uniform glUniformMatrix4fv(self.__viewLocation, 1, GL_FALSE, view) glUniformMatrix4fv(self.__projLocation, 1, GL_FALSE, projection) # bind the vao glBindVertexArray(self.__vao[self.__currentBuffer]) # draw glDrawArrays(GL_POINTS, 0, self.__particles) glBindVertexArray(0) glUseProgram(0) # advance buffer index self.__currentBuffer = (self.__currentBuffer + 1) % self.__bufferCount
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # Render # Clear the colorbuffer glClearColor(0.1, 0.1, 0.1, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glUseProgram(self.__lightingShader) lightPosLoc = glGetUniformLocation(self.__lightingShader, 'light.position') lightSpotdirLoc = glGetUniformLocation(self.__lightingShader, 'light.direction') lightSpotCutoffLoc = glGetUniformLocation(self.__lightingShader, 'light.cutOff') lightSpotOuterCutoffLoc = glGetUniformLocation(self.__lightingShader, 'light.outerCutOff') viewPosLoc = glGetUniformLocation(self.__lightingShader, 'viewPos') glUniform3f(lightPosLoc, self.camera.position[0], self.camera.position[1], self.camera.position[2]) glUniform3f(lightSpotdirLoc, self.camera.front[0], self.camera.front[1], self.camera.front[2]) glUniform1f(lightSpotCutoffLoc, math.cos(math.radians(12.5))) glUniform1f(lightSpotOuterCutoffLoc, math.cos(math.radians(17.5))) glUniform3f(viewPosLoc, self.camera.position[0], self.camera.position[1], self.camera.position[2]) # set lights properties glUniform3f(glGetUniformLocation(self.__lightingShader, 'light.ambient'), 0.1, 0.1, 0.1) glUniform3f(glGetUniformLocation(self.__lightingShader, 'light.diffuse'), 0.8, 0.8, 0.8) glUniform3f(glGetUniformLocation(self.__lightingShader, 'light.specular'), 1.0, 1.0, 1.0) glUniform1f(glGetUniformLocation(self.__lightingShader, 'light.constant'), 1.0) glUniform1f(glGetUniformLocation(self.__lightingShader, 'light.linear'), 0.09) glUniform1f(glGetUniformLocation(self.__lightingShader, 'light.quadratic'), 0.032) # set material properties glUniform1f(glGetUniformLocation(self.__lightingShader, 'material.shininess'), 32.0) view = self.camera.viewMatrix projection = glm.perspective(self.camera.zoom, float(self.width()) / self.height(), 0.1, 100.0) # get their uniform location modelLoc = glGetUniformLocation(self.__lightingShader, 'model') viewLoc = glGetUniformLocation(self.__lightingShader, 'view') projLoc = glGetUniformLocation(self.__lightingShader, 'projection') glUniformMatrix4fv(viewLoc, 1, GL_FALSE, view) glUniformMatrix4fv(projLoc, 1, GL_FALSE, projection) # bind diffuse map glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, self.diffuseMap) # bind specular map glActiveTexture(GL_TEXTURE1) glBindTexture(GL_TEXTURE_2D, self.specularMap) ## Draw the container (using container's vertex attributes) #glBindVertexArray(self.__containerVAO) #model = np.identity(4, np.float32) #glUniformMatrix4fv(modelLoc, 1, GL_FALSE, model) #glDrawArrays(GL_TRIANGLES, 0, 36) #glBindVertexArray(0) glBindVertexArray(self.__containerVAO) for i in self.__cubePositions: # calculate the model matrix for each object and pass it to shader before drawing angle = math.degrees(20.0 * self.__cubePositions.index(i)) model = glm.rotate(np.identity(4, np.float32), angle, 1.0, 0.3, 0.5) model = glm.translate(model, i[0], i[1], i[2]) glUniformMatrix4fv(modelLoc, 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) glBindVertexArray(0)
colors2 = np.array([ 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, ], dtype=np.float32) vao2, vbo2, ebo2 = create_vertex_array2(coords=points2, colors=colors2, indices=indices2) shader1 = shaders.vertex_color() projection = glm.identity(4) projection = glm.perspective(80.0, 600. / 600., .1, 100.0) # projection = glm.create_perspective_projection_matrix(45.0, 600. / 600., .1, 100.0, dtype=np.float32) w, h = glfwGetFramebufferSize(window) glViewport(0, 0, w, h) # glDepthRange(-10, 10) glEnable(GL_DEPTH_TEST) # draw only if the shape is closer to the viewer glDepthFunc(GL_LESS) # smaller means closer # glPolygonMode(GL_FRONT_AND_BACK, GL_LINE) # Wireframe while not glfwWindowShouldClose(window): time = glfwGetTime() glClearColor(0.6, 0.6, 0.8, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # glClear(GL_COLOR_BUFFER_BIT) glUseProgram(shader1)
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # 1. Render scene into floating point framebuffer glBindFramebuffer(GL_FRAMEBUFFER, self.bloomFBO) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) projection = glm.perspective(self.camera.zoom, float(self.width())/self.height(), 0.1, 100.0) view = self.camera.viewMatrix glUseProgram(self.__shader) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'projection'), 1, GL_FALSE, projection) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'view'), 1, GL_FALSE, view) glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, self.woodTexture) # set lighting uniforms for i in range(len(self.lightPos)): glUniform3fv(glGetUniformLocation(self.__shader, 'lights[{}].Position'.format(i)), 1, self.lightPos[i]) glUniform3fv(glGetUniformLocation(self.__shader, 'lights[{}].Color'.format(i)), 1, self.lightColors[i]) glUniform3fv(glGetUniformLocation(self.__shader, 'viewPos'), 1, self.camera.position) # create one large cube that acts as the floor model = glm.scale(np.identity(4, np.float32), 25.0, 1.0, 25.0) model = glm.translate(model, 0.0, -1.0, 0.0) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'model'), 1, GL_FALSE, model) self.renderCube() # then create multiple cubes as the scenery glBindTexture(GL_TEXTURE_2D, self.containerTexture) model = glm.translate(np.identity(4, np.float32), 0.0, 1.5, 0.0) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'model'), 1, GL_FALSE, model) self.renderCube() model = glm.translate(np.identity(4, np.float32), 2.0, 0.0, 1.0) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'model'), 1, GL_FALSE, model) self.renderCube() model = glm.rotate(np.identity(4, np.float32), 60.0, 1.0, 0.0, 1.0) model = glm.scale(model, 2.0, 2.0, 2.0) model = glm.translate(model, -1.0, -1.0, 2.0) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'model'), 1, GL_FALSE, model) self.renderCube() model = glm.rotate(np.identity(4, np.float32), 23.0, 1.0, 0.0, 1.0) model = glm.scale(model, 2.5, 2.5, 2.5) model = glm.translate(model, 0.0, 2.7, 4.0) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'model'), 1, GL_FALSE, model) self.renderCube() model = glm.rotate(np.identity(4, np.float32), 124.0, 1.0, 0.0, 1.0) model = glm.scale(model, 2.0, 2.0, 2.0) model = glm.translate(model, -2.0, 1.0, -3.0) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'model'), 1, GL_FALSE, model) self.renderCube() self.renderCube() model = glm.translate(np.identity(4, np.float32), -3.0, 0.0, 0.0) glUniformMatrix4fv(glGetUniformLocation(self.__shader, 'model'), 1, GL_FALSE, model) self.renderCube() # finally show all the light sources as bright cubes glUseProgram(self.__lightShader) glUniformMatrix4fv(glGetUniformLocation(self.__lightShader, 'projection'), 1, GL_FALSE, projection) glUniformMatrix4fv(glGetUniformLocation(self.__lightShader, 'view'), 1, GL_FALSE, view) for i in range(len(self.lightPos)): model = glm.scale(np.identity(4, np.float32), 0.5, 0.5, 0.5) model = glm.translate(model, self.lightPos[i][0], self.lightPos[i][1], self.lightPos[i][2]) glUniformMatrix4fv(glGetUniformLocation(self.__lightShader, 'model'), 1, GL_FALSE, self.lightPos[i]) glUniform3fv(glGetUniformLocation(self.__lightShader, 'lightColor'), 1, self.lightColors[i]) self.renderCube() glBindFramebuffer(GL_FRAMEBUFFER, 0) # 2. Blur bright fragments w/ two-pass Gaussian Blur horizontal = True first_iteration = True amount = 10 glUseProgram(self.__blurShader) for i in range(amount): glBindFramebuffer(GL_FRAMEBUFFER, self.pingpongFBO[int(horizontal)]) glUniform1i(glGetUniformLocation(self.__blurShader, 'horizontal'), horizontal) glBindTexture(GL_TEXTURE_2D, self.colorBuffers[1] if first_iteration else self.pingpongColorbuffers[int(not horizontal)]) self.renderQuad() horizontal = not horizontal if first_iteration: first_iteration = False glBindFramebuffer(GL_FRAMEBUFFER, 0) # 2. Now render floating point color buffer to 2D quad and tonemap HDR colors to default framebuffer's (clamped) color range glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glUseProgram(self.__bloomFinalShader) glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, self.colorBuffers[0]) # glBindTexture(GL_TEXTURE_2D, self.pingpongColorbuffers[int(not horizontal)]) glActiveTexture(GL_TEXTURE1) glBindTexture(GL_TEXTURE_2D, self.pingpongColorbuffers[int(not horizontal)]) glUniform1i(glGetUniformLocation(self.__bloomFinalShader, 'bloom'), self.bloom) glUniform1f(glGetUniformLocation(self.__bloomFinalShader, 'exposure'), self.exposure) self.renderQuad() glUseProgram(0) print 'exposure: {}'.format(self.exposure)
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # Render # Clear the colorbuffer glClearColor(0.1, 0.1, 0.1, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glUseProgram(self.__lightingShader) viewPosLoc = glGetUniformLocation(self.__lightingShader, 'viewPos') glUniform3f(viewPosLoc, self.camera.position[0], self.camera.position[1], self.camera.position[2]) # set material properties glUniform1f(glGetUniformLocation(self.__lightingShader, 'material.shininess'), 32.0) # Directional light glUniform3f(glGetUniformLocation(self.__lightingShader, "dirLight.direction"), -0.2, -1.0, -0.3) glUniform3f(glGetUniformLocation(self.__lightingShader, "dirLight.ambient"), 0.05, 0.05, 0.05) glUniform3f(glGetUniformLocation(self.__lightingShader, "dirLight.diffuse"), 0.4, 0.4, 0.4) glUniform3f(glGetUniformLocation(self.__lightingShader, "dirLight.specular"), 0.5, 0.5, 0.5) # point lights for i in self.__pointLightPositions: index = self.__pointLightPositions.index(i) glUniform3f(glGetUniformLocation(self.__lightingShader, "pointLights[{}].position".format(index)), i[0], i[0], i[0]) glUniform3f(glGetUniformLocation(self.__lightingShader, "pointLights[{}].ambient".format(index)), 0.05, 0.05, 0.05) glUniform3f(glGetUniformLocation(self.__lightingShader, "pointLights[{}].diffuse".format(index)), 0.8, 0.8, 0.8) glUniform3f(glGetUniformLocation(self.__lightingShader, "pointLights[{}].specular".format(index)), 1.0, 1.0, 1.0) glUniform1f(glGetUniformLocation(self.__lightingShader, "pointLights[{}].constant".format(index)), 1.0) glUniform1f(glGetUniformLocation(self.__lightingShader, "pointLights[{}].linear".format(index)), 0.09) glUniform1f(glGetUniformLocation(self.__lightingShader, "pointLights[{}].quadratic".format(index)), 0.032) # spotlight glUniform3f(glGetUniformLocation(self.__lightingShader, "spotLight.position"), self.camera.position[0], self.camera.position[1], self.camera.position[2]) glUniform3f(glGetUniformLocation(self.__lightingShader, "spotLight.direction"), self.camera.front[0], self.camera.front[1], self.camera.front[2]) glUniform3f(glGetUniformLocation(self.__lightingShader, "spotLight.ambient"), 0.0, 0.0, 0.0) glUniform3f(glGetUniformLocation(self.__lightingShader, "spotLight.diffuse"), 1.0, 1.0, 1.0) glUniform3f(glGetUniformLocation(self.__lightingShader, "spotLight.specular"), 1.0, 1.0, 1.0) glUniform1f(glGetUniformLocation(self.__lightingShader, "spotLight.constant"), 1.0) glUniform1f(glGetUniformLocation(self.__lightingShader, "spotLight.linear"), 0.09); glUniform1f(glGetUniformLocation(self.__lightingShader, "spotLight.quadratic"), 0.032) glUniform1f(glGetUniformLocation(self.__lightingShader, "spotLight.cutOff"), math.cos(math.radians(12.5))) glUniform1f(glGetUniformLocation(self.__lightingShader, "spotLight.outerCutOff"), math.cos(math.radians(15.0))) view = self.camera.viewMatrix projection = glm.perspective(self.camera.zoom, float(self.width()) / self.height(), 0.1, 100.0) # get their uniform location modelLoc = glGetUniformLocation(self.__lightingShader, 'model') viewLoc = glGetUniformLocation(self.__lightingShader, 'view') projLoc = glGetUniformLocation(self.__lightingShader, 'projection') glUniformMatrix4fv(viewLoc, 1, GL_FALSE, view) glUniformMatrix4fv(projLoc, 1, GL_FALSE, projection) # bind diffuse map glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, self.diffuseMap) # bind specular map glActiveTexture(GL_TEXTURE1) glBindTexture(GL_TEXTURE_2D, self.specularMap) glBindVertexArray(self.__containerVAO) for i in self.__cubePositions: # calculate the model matrix for each object and pass it to shader before drawing angle = math.degrees(20.0 * self.__cubePositions.index(i)) model = glm.rotate(np.identity(4, np.float32), angle, 1.0, 0.3, 0.5) model = glm.translate(model, i[0], i[1], i[2]) glUniformMatrix4fv(modelLoc, 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) glBindVertexArray(0) # Also draw the lamp object, again binding the appropriate shader glUseProgram(self.__lampShader) # Get location objects for the matrices on the lamp shader (these could be different on a different shader) modelLoc = glGetUniformLocation(self.__lampShader, 'model') viewLoc = glGetUniformLocation(self.__lampShader, 'view') projLoc = glGetUniformLocation(self.__lampShader, 'projection') glUniformMatrix4fv(viewLoc, 1, GL_FALSE, view) glUniformMatrix4fv(projLoc, 1, GL_FALSE, projection) glBindVertexArray(self.__lightVAO) for i in self.__pointLightPositions: model = glm.scale(np.identity(4, np.float32), 0.2, 0.2, 0.2) model = glm.translate(model, i[0], i[1], i[2]) glUniformMatrix4fv(modelLoc, 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) glBindVertexArray(0)
def initializeGL(self): # setup some OpenGL options glEnable(GL_DEPTH_TEST) vertexShader, fragmentShader = self.loadShaders('8.uniform_buffers.vs', '8.red.frag') self.__shaderRed = shaders.compileProgram(vertexShader, fragmentShader) vertexShader, fragmentShader = self.loadShaders('8.uniform_buffers.vs', '8.green.frag') self.__shaderGreen = shaders.compileProgram(vertexShader, fragmentShader) vertexShader, fragmentShader = self.loadShaders('8.uniform_buffers.vs', '8.blue.frag') self.__shaderBlue = shaders.compileProgram(vertexShader, fragmentShader) vertexShader, fragmentShader = self.loadShaders('8.uniform_buffers.vs', '8.yellow.frag') self.__shaderYellow = shaders.compileProgram(vertexShader, fragmentShader) vertices = np.array([ -0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, -0.5, -0.5, 0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, 0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, -0.5, 0.5, -0.5, -0.5, 0.5, 0.5, ], np.float32) # setup cube VAO self.cubeVAO = glGenVertexArrays(1) vbo = glGenBuffers(1) glBindVertexArray(self.cubeVAO) glBindBuffer(GL_ARRAY_BUFFER, vbo) glBufferData(GL_ARRAY_BUFFER, vertices.nbytes, vertices, GL_STATIC_DRAW) glEnableVertexAttribArray(0) glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * vertices.itemsize, None) glBindVertexArray(0) # Create a uniform buffer object # First. We get the relevant block indices uniformBlockIndexRed = glGetUniformBlockIndex(self.__shaderRed, 'Matrices') uniformBlockIndexGreen= glGetUniformBlockIndex(self.__shaderGreen, 'Matrices') uniformBlockIndexBlue = glGetUniformBlockIndex(self.__shaderBlue, 'Matrices') uniformBlockIndexYellow = glGetUniformBlockIndex(self.__shaderYellow, 'Matrices') # Then we link each shader's uniform block to this uniform binding point glUniformBlockBinding(self.__shaderRed, uniformBlockIndexRed, 0) glUniformBlockBinding(self.__shaderGreen, uniformBlockIndexGreen, 0) glUniformBlockBinding(self.__shaderBlue, uniformBlockIndexBlue, 0) glUniformBlockBinding(self.__shaderYellow, uniformBlockIndexYellow, 0) # Now actually create the buffer self.uboMatrices = glGenBuffers(1) glBindBuffer(GL_UNIFORM_BUFFER, self.uboMatrices) glBufferData(GL_UNIFORM_BUFFER, 2 * self.identityMat4.nbytes, None, GL_STATIC_DRAW) glBindBuffer(GL_UNIFORM_BUFFER, 0) # Define the range of the buffer that links to a uniform binding point glBindBufferRange(GL_UNIFORM_BUFFER, 0, self.uboMatrices, 0, 2 * self.identityMat4.nbytes) # Store the projection matrix (we only have to do this once) (note: we're not using zoom anymore by changing the FoV. We only create the projection matrix once now) projection = glm.perspective(45.0, float(self.width())/self.height(), 0.1, 100.0) glBindBuffer(GL_UNIFORM_BUFFER, self.uboMatrices) glBufferSubData(GL_UNIFORM_BUFFER, 0, self.identityMat4.nbytes, projection) glBindBuffer(GL_UNIFORM_BUFFER, 0)
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime # Render # Clear the colorbuffer glClearColor(0.1, 0.1, 0.1, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT) glUseProgram(self.__singleColorProgram) view = self.camera.viewMatrix projection = glm.perspective(self.camera.zoom, float(self.width()) / self.height(), 0.1, 100.0) # get their uniform location modelLoc = glGetUniformLocation(self.__shaderProgram, 'model') glUniformMatrix4fv(glGetUniformLocation(self.__singleColorProgram, 'view'), 1, GL_FALSE, view) glUniformMatrix4fv(glGetUniformLocation(self.__singleColorProgram, 'projection'), 1, GL_FALSE, projection) glUseProgram(self.__shaderProgram) glUniformMatrix4fv(glGetUniformLocation(self.__shaderProgram, 'view'), 1, GL_FALSE, view) glUniformMatrix4fv(glGetUniformLocation(self.__shaderProgram, 'projection'), 1, GL_FALSE, projection) # Draw floor as normal, we only care about the containers. The floor should NOT fill the stencil buffer so we set its mask to 0x00 glStencilMask(0x00) # Floor glBindVertexArray(self.planeVAO) glBindTexture(GL_TEXTURE_2D, self.floorTexture) glUniformMatrix4fv(glGetUniformLocation(self.__shaderProgram, 'model'), 1, GL_FALSE, np.identity(4, np.float32)) glDrawArrays(GL_TRIANGLES, 0, 6) glBindVertexArray(0) # 1st. Render pass, draw objects as normal, filling the stencil buffer glStencilFunc(GL_ALWAYS, 1, 0xFF) glStencilMask(0xFF) # Cubes glBindVertexArray(self.cubeVAO) glBindTexture(GL_TEXTURE_2D, self.cubeTexture) model = glm.translate(np.identity(4, np.float32), -1, 0, -1) glUniformMatrix4fv(glGetUniformLocation(self.__shaderProgram, 'model'), 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) model = glm.translate(np.identity(4, np.float32), 2, 0, 0) glUniformMatrix4fv(glGetUniformLocation(self.__shaderProgram, 'model'), 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) glBindVertexArray(0) # 2nd. Render pass, now draw slightly scaled versions of the objects, this time disabling stencil writing. # Because stencil buffer is now filled with several 1s. The parts of the buffer that are 1 are now not drawn, thus only drawing # the objects' size differences, making it look like borders. glStencilFunc(GL_NOTEQUAL, 1, 0xFF) glStencilMask(0x00) glDisable(GL_DEPTH_TEST) glUseProgram(self.__singleColorProgram) scale = 1.1 # Cubes glBindVertexArray(self.cubeVAO) glBindTexture(GL_TEXTURE_2D, self.cubeTexture) model = glm.scale(np.identity(4, np.float32), scale, scale, scale) model = glm.translate(model, -1, 0, -1) glUniformMatrix4fv(glGetUniformLocation(self.__singleColorProgram, 'model'), 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) model = glm.scale(np.identity(4, np.float32), scale, scale, scale) model = glm.translate(model, 2, 0, 0) glUniformMatrix4fv(glGetUniformLocation(self.__singleColorProgram, 'model'), 1, GL_FALSE, model) glDrawArrays(GL_TRIANGLES, 0, 36) glBindVertexArray(0) glStencilMask(0xFF) glEnable(GL_DEPTH_TEST)
def paintGL(self): currentTime = self.__timer.elapsed() / 1000.0 self.__deltaTime = currentTime - self.__lastTime self.__lastTime = currentTime glPolygonMode(GL_FRONT_AND_BACK, GL_LINE if self.wireframe else GL_FILL) # 1. Geometry Pass: render scene's geometry/color data into gbuffer glBindFramebuffer(GL_FRAMEBUFFER, self.gbuffer) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) projection = glm.perspective(self.camera.zoom, float(self.width()) / self.height(), 0.1, 100.0) view = self.camera.viewMatrix glUseProgram(self.__geometyPassShader) glUniformMatrix4fv(glGetUniformLocation(self.__geometyPassShader, 'projection'), 1, GL_FALSE, projection) glUniformMatrix4fv(glGetUniformLocation(self.__geometyPassShader, 'view'), 1, GL_FALSE, view) for pos in self.objectPosition: model = glm.scale(np.identity(4, np.float32), 0.25, 0.25, 0.25) model = glm.translate(model, pos[0], pos[1], pos[2]) glUniformMatrix4fv(glGetUniformLocation(self.__geometyPassShader, 'model'), 1, GL_FALSE, model) self.cyborg.draw(self.__geometyPassShader) glBindFramebuffer(GL_FRAMEBUFFER, 0) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) # 2. Lighting Pass: calculate lighting by iterating over a screen filled quad pixel-by-pixel using the gbuffer's content. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glUseProgram(self.__lightingPassShader) glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, self.gPosition) glActiveTexture(GL_TEXTURE1) glBindTexture(GL_TEXTURE_2D, self.gNormal) glActiveTexture(GL_TEXTURE2) glBindTexture(GL_TEXTURE_2D, self.gAlbedoSpec) # also send light relevent uniforms for i in range(len(self.lightPos)): glUniform3fv(glGetUniformLocation(self.__lightingPassShader, 'lights[{}].Position'.format(i)), 1, self.lightPos[i]) glUniform3fv(glGetUniformLocation(self.__lightingPassShader, 'lights[{}].Color'.format(i)), 1, self.lightColors[i]) # Update attenuation parameters and calculate radius _constant = 1.0 # Note that we don't send this to the shader, we assume it is always 1.0 (in our case) linear = 0.7 quadratic = 1.8 glUniform1f(glGetUniformLocation(self.__lightingPassShader, 'lights[{}].Linear'.format(i)), linear) glUniform1f(glGetUniformLocation(self.__lightingPassShader, 'lights[{}].Quadratic'.format(i)), quadratic) # Then calculate radius of light volume/sphere lightThreshold = 5.0 # 5 # 256 maxBrightness = max(max(self.lightColors[i][0], self.lightColors[i][1]), self.lightColors[i][2]) radius = (-linear + math.sqrt(linear * linear - 4 * quadratic * (_constant - (256.0 / lightThreshold) * maxBrightness))) / (2 * quadratic) glUniform1f(glGetUniformLocation(self.__lightingPassShader, 'lights[{}].Radius'.format(i)), radius) glUniform3fv(glGetUniformLocation(self.__lightingPassShader, 'viewPos'), 1, self.camera.position) glUniform1i(glGetUniformLocation(self.__lightingPassShader, 'draw_mode'), self.draw_mode) self.renderQuad() # 2.5. Copy content of geometry's depth buffer to default framebuffer's depth buffer glBindFramebuffer(GL_READ_FRAMEBUFFER, self.gbuffer) glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0) # write to default framebuffer glBlitFramebuffer(0, 0, self.width(), self.height(), 0, 0, self.width(), self.height(), GL_DEPTH_BUFFER_BIT, GL_NEAREST) glBindFramebuffer(GL_FRAMEBUFFER, 0) # 3. Render lights on top of scene, by blitting glUseProgram(self.__lightBoxShader) glUniformMatrix4fv(glGetUniformLocation(self.__lightBoxShader, 'projection'), 1, GL_FALSE, projection) glUniformMatrix4fv(glGetUniformLocation(self.__lightBoxShader, 'view'), 1, GL_FALSE, view) for i in range(len(self.lightPos)): model = glm.scale(np.identity(4, np.float32), 0.25, 0.25, 0.25) model = glm.translate(model, self.lightPos[i][0], self.lightPos[i][1], self.lightPos[i][2]) glUniformMatrix4fv(glGetUniformLocation(self.__lightBoxShader, 'model'), 1, GL_FALSE, model) glUniform3fv(glGetUniformLocation(self.__lightBoxShader, 'lightColor'), 1, self.lightColors[i]) self.renderCube() glUseProgram(0)