def __init__(self, name, params): GLObject.__init__(self, params) # segment name self.segmentID = name self.shaderProgram = -1 self.shader = None # texture for base coloring self.baseImage = None # segments needs material self.material = params.get('material') # get some default attributes self.isPlanar = self.getAttr("isPlane", False) if self.isPlanar: self.createReflectionHandler = createPlaneReflectionHandler else: pass self.reflectionHandler = None self.vertexPositionName = "vec4(vertexPosition, 1.0)" self.vertexNormalName = "vertexNormal" self.vertexColorName = "vertexColor" self.vertexUVName = "vertexUV"
def __init__(self, params): GLObject.__init__(self, params) self.matReflection = self.getAttr("matReflectionIntensity", 0.0) self.textures = [] textures = params.get('textures', []) for tex in textures: self.addTexture(tex)
def __init__(self, position=None): GLObject.__init__(self, {}) # the camera position self.position = position # model viw matrix of this camera self.modelViewMatrix = None print "REGISTER CAM MV ", Camera.CAMERA_MODELVIEW_SIGNAL # register the signal on this object self.signalRegister( Camera.CAMERA_MODELVIEW_SIGNAL )
def createDrawFunction(self): """ generate the function used for drawing. """ GLObject.createDrawFunction(self) if self.material!=None: # let material create the draw function and # include the material state setter/unsetter self.material.createDrawFunction() self.joinStaticStates(enable=self.material.enableStaticStates, disable=self.material.disableStaticStates) self.joinDynamicStates(enable=self.material.enableDynamicStates, disable=self.material.disableDynamicStates)
def __init__(self, params): # FIXME: lights may be on the same unit for long time, # we do not have to set the states each frame then! self.name = params.get('name') GLObject.__init__(self, params) self.lightCutOff = self.getAttr("lightCutOff", 180.0) # signal stuff self.signalRegister( Light.LIGHT_POSITION_SIGNAL ) self.signalRegister( Light.LIGHT_DIRECTION_SIGNAL ) # shadow maps for this light self.shadowMapArray = None # TODO: make xml configurable self.dimming = 0.3
def create(self, app): """ creates gl resources of model. @param lights: list of gl_helper.light.Light instances """ GLObject.create(self, app, self.lights) self.createDrawFunction() for l in self.lights: l.createGuard(app, self.lights) for s in self.segments: s.createGuard(app, self.lights) # TODO: VBO: create some bigger vbos for vbo segments self.postCreate()
def create(self, app, lights): """ create the shadow maps. """ if self.getAttr("useShadowMap", False): type = self.getLightType() #kernel = ShadowMap.noKernel() #kernel = ShadowMap.kernel44() if type==Light.POINT_LIGHT: # TODO: SM: point light shadows raise NotImplementedError elif type==Light.DIRECTIONAL_LIGHT: # directional light needs scene frustum app.needFrustumPoints = True mapSize = 2048.0 numSplits = 4 self.shadowMapArray = ShadowMapArray(app, app.sceneCamera, mapSize) frustas = splitFrustum(app.sceneFrustum, numSplits, 0.75) for frustum in frustas: camera = DirectionalShadowCamera( app, self, frustum, mapSize ) self.shadowMapArray.addShadowMap( DirectionalShadowMap( camera )) else: # spot light mapSize = 2048 self.shadowMapArray = ShadowMapArray(app, app.sceneCamera, mapSize) camera = SpotShadowCamera(app, self) self.shadowMapArray.addShadowMap( SpotShadowMap( camera ) ) if self.shadowMapArray!=None: self.shadowMapArray.create(app) GLObject.create(self, app, lights)
def create(self, app, lights): """ call after configuration. currently only once callable because some vertex data calculations cannot get undone (face groups). """ self.app = app self.enabledLights = range(len(lights)) self.lights = lights self.hidden = False GLObject.create(self, app, lights) # material needs to get gl resources for textures if self.material != None: self.material.createGuard(app, lights) # splits up creation self.createResources() self.createResourcesPost() self.createShader() self.createDrawFunction() self.postCreate()
def create(self, app, lights): for tex in self.textures: tex.create() GLObject.create(self, app, lights)
def __init__(self, params): GLObject.__init__(self, params) self.controlPoints = params.get("ctrls") self.params = params.get("params") self.target = params.get("target")
def __init__(self, winSize=(1024,768), modes=OPENGL|DOUBLEBUF|HWSURFACE, nearClip=1.0, farClip=200.0, fov=45.0, caption='OpenGL fun', iconName=None, useJoysticks=[0], hideCursor=False): ''' Constructor, opens the window and initials opengl/pygame. ''' GLObject.__init__(self, {}) # signal stuff self.signalRegister( GLApp.APP_SIZE_SIGNAL ) self.signalRegister( GLApp.APP_PROJECTION_CHANGED ) self.modes = modes self.winSize = winSize self.timePassed = 0 self.FPS = 0 self.farClip = farClip self.nearClip = nearClip self.fov = fov self.caption = caption self.sceneBounds = None # save the projection for faster calculations self.projectionMat = None pygame.init() # init display pygame.display.gl_set_attribute(pygame.GL_RED_SIZE, 8) pygame.display.gl_set_attribute(pygame.GL_GREEN_SIZE, 8) pygame.display.gl_set_attribute(pygame.GL_BLUE_SIZE, 8) pygame.display.gl_set_attribute(pygame.GL_ALPHA_SIZE, 8) # vsync pygame.display.gl_set_attribute(pygame.GL_SWAP_CONTROL, 1) (self.screen, self.winSize) = self.setWindowSize(winSize) print "INFO: OpenGL and PyGame initialed." printGLInfo() # hide cursor for custom mouse drawing pygame.mouse.set_visible(not hideCursor) # lookup joystick devices if useJoysticks!=[]: numJoysticks = pygame.joystick.get_count() self.joypads = [] if not numJoysticks: print "WARNING: No joystick connected." else: if numJoysticks<len(useJoysticks): print "WARNING: Only %d joysticks connected." % numJoysticks for x in useJoysticks: if x < numJoysticks: j = pygame.joystick.Joystick(x) self.joypads.append(JoyStick(j)) print "INFO: Using joystick: '%s' with %d buttons and %d axes." \ % (j.get_name(), j.get_numbuttons(), j.get_numaxes()) else: self.joypads = [] # set window title pygame.display.set_caption(caption) # set window icon if iconName!=None: surface = image.load("../textures/" + iconName) pygame.display.set_icon(surface) self.loadFonts() self.running = True (self.mouseX, self.mouseY) = (0, 0) self.initGL()
def disableDynamicStates(self): GLObject.disableDynamicStates(self) for l in self.lights: l.disableDynamicStates()
def enableDynamicStates(self): GLObject.enableDynamicStates(self) for l in self.lights: l.enableDynamicStates()
def createDrawFunction(self): for l in self.lights: l.createDrawFunction() GLObject.createDrawFunction(self)
def __init__(self, params, name, dynamic=False): self.name = name self.dynamic = dynamic GLObject.__init__(self, params)
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, segments, params): GLObject.__init__(self, params) # list of segments self.segments = segments self.lights = []