def __init__(self): self.models = [] self.lights = [] # render to texture scenes self.sceneFBOS = [] # all units <self.textureCounter are reserved self.textureCounter = 0 self.textureMatrixCounter = 0 # matrix used for projective textures will be stored at this unit # only used when self.useProjectiveTextures=True self.useProjectiveTextures = False self.projectiveTextureIndex = -1 self.projectiveTextureMatrixIndex = -1 self.projectivTextureMatrix = ProjectiveTextureMatrix(self) # set to true if you need the frustum points/centroid calculated self.needFrustumPoints = False # and the associated frustum self.sceneFrustum = Frustum(0.0, 1.0) GLApp.__init__(self) # camera for user movement self.sceneCamera = UserCamera(self) # create screen textures self.sceneTexture = Texture2D(width=self.winSize[0], height=self.winSize[1]) self.sceneTexture.create() self.sceneDepthTexture = DepthTexture2D(width=self.winSize[0], height=self.winSize[1]) self.sceneDepthTexture.create() # a shader that only handles the depth self.depthShader = DepthShader() self.visualizeDepthShader = VisualizeDepthShader() ### TESTING ### self.lightAngle = 0.0
class ModelApp(GLApp): """ ModelApp splits rendering in multiple passes using fbos. """ def __init__(self): self.models = [] self.lights = [] # render to texture scenes self.sceneFBOS = [] # all units <self.textureCounter are reserved self.textureCounter = 0 self.textureMatrixCounter = 0 # matrix used for projective textures will be stored at this unit # only used when self.useProjectiveTextures=True self.useProjectiveTextures = False self.projectiveTextureIndex = -1 self.projectiveTextureMatrixIndex = -1 self.projectivTextureMatrix = ProjectiveTextureMatrix(self) # set to true if you need the frustum points/centroid calculated self.needFrustumPoints = False # and the associated frustum self.sceneFrustum = Frustum(0.0, 1.0) GLApp.__init__(self) # camera for user movement self.sceneCamera = UserCamera(self) # create screen textures self.sceneTexture = Texture2D(width=self.winSize[0], height=self.winSize[1]) self.sceneTexture.create() self.sceneDepthTexture = DepthTexture2D(width=self.winSize[0], height=self.winSize[1]) self.sceneDepthTexture.create() # a shader that only handles the depth self.depthShader = DepthShader() self.visualizeDepthShader = VisualizeDepthShader() ### TESTING ### self.lightAngle = 0.0 def reserveTextureUnit(self): """ increase texture counter. """ self.textureCounter += 1 return self.textureCounter - 1 def reserveTextureMatrixUnit(self): """ increase texture counter. """ self.textureMatrixCounter += 1 return self.textureMatrixCounter - 1 def enableProjectiveTextures(self): """ sets flag for enabling projective textures and reserves one texture unit for the projection matrix. """ if self.projectiveTextureIndex != -1: return self.projectiveTextureIndex = self.reserveTextureUnit() self.projectiveTextureMatrixIndex = self.reserveTextureMatrixUnit() self.useProjectiveTextures = True def _loadProjectiveTextureMatrix(): self.projectivTextureMatrix.load(self.projectiveTextureMatrixIndex) self.signalConnect(GLApp.APP_PROJECTION_CHANGED, _loadProjectiveTextureMatrix) self.sceneCamera.signalConnect(Camera.CAMERA_MODELVIEW_SIGNAL, _loadProjectiveTextureMatrix) def addModel(self, model): """ adds a model to this application. """ self.models.append(model) self.lights += model.lights self.lights = unique(self.lights) for s in model.segments: if s.usesProjectiveTexture(): self.enableProjectiveTextures() break def prependFBO(self, sceneFBO, drawScene, sceneCamera): """ prepends a render to texture operation before scene rendering is done. """ self.sceneFBOS = [(sceneFBO, drawScene, sceneCamera)] + self.sceneFBOS def appendFBO(self, sceneFBO, drawScene, sceneCamera): """ appends a render to texture operation before scene rendering is done. """ self.sceneFBOS.append((sceneFBO, drawScene, sceneCamera)) def setDefaultSceneFBO(self): """ set the default fbo for offscreen scene rendering. """ drawSceneFBO = FBO() drawSceneFBO.addColorTexture(self.sceneTexture) drawSceneFBO.setDepthTexture(self.sceneDepthTexture) drawSceneFBO.create() self.appendFBO(drawSceneFBO, self.drawSceneComplete, self.sceneCamera) def drawSceneComplete(self): """ draws scene with color. """ map(lambda m: m.draw(self, m), self.models) def drawSceneGeometry(self): """ draws the scene geometry only. usefull for depth value rendering. """ map(_drawModelGeometry, self.models) def setWindowSize(self, size): """ also set frustum projection. """ ret = GLApp.setWindowSize(self, size) # set the frustum projection self.sceneFrustum.setProjection(self.fov, self.aspect, self.nearClip, self.farClip) return ret def orthogonalPass(self, debugShadows=False): """ draw stuff in orthogonal projection. mainly the scene can be post processed here and some gui elements could be drawn. """ ### DRAW THE SCENE ### # TODO: post shader magic ! glUseProgram(0) # enable the scene texture # Note that texture unit 0 should be active now. glEnable(GL_TEXTURE_2D) glBindTexture(GL_TEXTURE_2D, self.sceneTexture.glID) # make sure texture matrix is set to identity glMatrixMode(GL_TEXTURE) glLoadIdentity() glMatrixMode(GL_MODELVIEW) glBegin(GL_QUADS) glTexCoord2f(0.0, 0.0) glVertex3f(0.0, 0.0, -1.0) glTexCoord2f(1.0, 0.0) glVertex3f(self.winSize[0], 0.0, -1.0) glTexCoord2f(1.0, 1.0) glVertex3f(self.winSize[0], self.winSize[1], -1.0) glTexCoord2f(0.0, 1.0) glVertex3f(0.0, self.winSize[1], -1.0) glEnd() ### DEBUG DRAWINGS ### # debug shadow maps if debugShadows: # draw the shadow maps self.visualizeDepthShader.enable() layerLoc = glGetUniformLocation(self.visualizeDepthShader.program, "layer") drawShadowMaps(self.lights, layerLoc) # reset viewport and reset to ffp glViewport(0, 0, self.winSize[0], self.winSize[1]) glUseProgram(0) glBindTexture(GL_TEXTURE_2D, 0) glDisable(GL_TEXTURE_2D) GLApp.orthogonalPass(self) def processEvent(self, event): """ processes one event. """ # pass some events to the scene camera if event.type == MOUSEMOTION: self.sceneCamera.motion(*event.pos) elif event.type == MOUSEBUTTONUP or event.type == MOUSEBUTTONDOWN: self.sceneCamera.mouseEvent(event.button, event.type, event.pos[0], event.pos[1]) def animationStep(self): ####### TESTING ########## self.lightAngle += 0.005 if self.lightAngle >= 2.0 * pi: self.lightAngle -= 2.0 * pi lightRadius = 4.0 self.lights[0].lightPosition = array( [lightRadius * sin(self.lightAngle), lightRadius, lightRadius * cos(self.lightAngle), 0.0], float32 ) self.lights[0].signalQueueEmit(Light.LIGHT_POSITION_SIGNAL) ####### TESTING ########## def processFrame(self, timePassedSecs): """ draws a scene """ # update the model view matrix self.sceneCamera.updateKeys() self.sceneCamera.update() # process queued GLObject events GLObject.signalsEmit() # enable some default scene states glEnable(GL_DEPTH_TEST) ######## SHADOW MAP RENDERING START ######## # offset the geometry slightly to prevent z-fighting # note that this introduces some light-leakage artifacts glEnable(GL_POLYGON_OFFSET_FILL) glPolygonOffset(1.1, 4096.0) # cull front faces for shadow rendering, # this moves z-fighting to backfaces. glCullFace(GL_FRONT) # enable depth rendering shader. # FIXME: support segment geometry shader! # geometry shader could change the shadow shape! self.depthShader.enable() map(_updateLightShadowMap, self.lights) glBindFramebuffer(GL_FRAMEBUFFER, 0) glDisable(GL_POLYGON_OFFSET_FILL) ######## SHADOW MAP RENDERING STOP ######## #### TODO: FOG: integrate FOG #### glEnable(GL_FOG) glFogi(GL_FOG_MODE, GL_EXP2) # approximate the atmosphere's filtering effect as a linear function sunDir = array([4.0, 4.0, 4.0, 0.0], float32) # TODO: FOG: what is the sun dir ? skyColor = array([0.8, sunDir[1] * 0.1 + 0.7, sunDir[1] * 0.4 + 0.5, 1.0], float32) glClearColor(*skyColor) glFogf(GL_FOG_DENSITY, 0.4) glFogf(GL_FOG_START, 16.0) glFogf(GL_FOG_END, self.farClip) glFogfv(GL_FOG_COLOR, skyColor) # fill projection matrix glMatrixMode(GL_PROJECTION) glLoadMatrixf(self.projectionMatrix) glMatrixMode(GL_MODELVIEW) # draw stuff in 3d projection lastCam = None glPushAttrib(GL_COLOR_BUFFER_BIT) for (fbo, draw, cam) in self.sceneFBOS: # render to fbo fbo.enable() if cam != lastCam: cam.enable() lastCam = cam draw() # disable render to texture FBO.disable() glPopAttrib() glViewport(0, 0, self.winSize[0], self.winSize[1]) #### TODO: FOG: integrate FOG #### glDisable(GL_FOG) # change to orthogonal projection glMatrixMode(GL_PROJECTION) glLoadMatrixf(self.orthoMatrix) glMatrixMode(GL_MODELVIEW) glLoadIdentity() # no depth test needed in orthogonal rendering glDisable(GL_DEPTH_TEST) # draw orthogonal to the screen self.orthogonalPass()
def __init__(self, app, camera): # light point of view camera self.camera = camera self.sceneCamera = app.sceneCamera ProjectiveTextureMatrix.__init__(self, app)