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 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
# 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 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)
