sampleframework.py

使用stl技术,(还没看,是听说的)

import localogre as ogre

# Big bug: Vector.ZERO is returned as a reference. If modified, then the static is modified !

class Application:
    def __init__( self ):
        self.frameListener = None
        self.root = None
        self.camera = None
        self.renderWindow = None
        self.sceneManager = None

    def __del__( self ):
        self.frameListener = None
        self.root = None
        self.camera = None
        self.renderWindow = None
        self.sceneManager = None

    def go( self ):
        if not self._setUp():
            return
        self.root.startRendering()


    def _setUp( self ):
        self.root = ogre.Root()

        self._setUpResources()
        carryOn = self._configure()
        if not carryOn:
            return False
        
        self._chooseSceneManager()
        self._createCamera()
        self._createViewports()

        #ogre.TextureManager.getSingleton().setDefaultNumMipMaps(5)

        self._createScene()
        self._createFrameListener()
        return True

    def _setUpResources( self ):
        config = ogre.ConfigFile()
        config.load( 'resources.cfg'  )
        for key, path in config.getSettingsIterator():
            ogre.ResourceManager.addCommonArchiveEx( path, key )

    def _configure( self ):
        carryOn = self.root.showConfigDialog()
        if carryOn:
            self.renderWindow = self.root.initialise( True )
        return carryOn

    def _chooseSceneManager( self ):
        self.sceneManager = self.root.getSceneManager( ogre.SceneType.ST_GENERIC )

    def _createCamera( self ):
        self.camera = self.sceneManager.createCamera( 'PlayerCam' )
        self.camera.setPosition( ogre.Vector3( 0, 0, 500 ) )
        self.camera.lookAt( ogre.Vector3( 0, 0, -300 ) )
        self.camera.setNearClipDistance( 5 )

    def _createViewports( self ):
        self.viewport = self.renderWindow.addViewport( self.camera, 0, 0.0, 0.0, 1.0, 1.0 )  # virtual with policy overload issue
        self.viewport.setBackgroundColour( ogre.ColourValue(0,0,0) )
        
    def _createScene( self ):
        pass

    def _createFrameListener( self ):
        self.frameListener = FrameListener( self.renderWindow, self.camera )
        self.frameListener.showDebugOverlay( True )
        self.root.addFrameListener( self.frameListener )

class FrameListener(ogre.FrameListener):
    def __init__( self, renderWindow, camera ):
        ogre.FrameListener.__init__( self )
        self.camera = camera
        self.renderWindow = renderWindow
        self.statisticsOn = True
        self.numScreenShots = 0
        self.timeUntilNextToggle = 0
        self.sceneDetailIndex = 0
        self.moveScale = 0.0
        self.rotationScale = 0.0
        self.translateVector = ogre.Vector3(0,0,0)
        self.aniso = 1
        self.filtering = ogre.TextureFilterOptions.TFO_BILINEAR
        self.showDebugOverlay( True )
        self.moveSpeed = 100.0
        self.rotationSpeed = 8.0

        # ignore buffered input stuff
        self.inputDevice = ogre.PlatformManager.getSingleton().createInputReader()
        self.inputDevice.initialise( renderWindow, True, True, False ) #too much boolean

    def __del__(self): 
        #ogre.PlatformManager.getSingleton().destroyInputReader( self.inputDevice )  # PlatformManager already killed when called...
        pass

    def frameStarted( self, frameEvent ):
        self.inputDevice.capture()
        if self.timeUntilNextToggle >= 0:
            self.timeUntilNextToggle -= frameEvent.timeSinceLastFrame

        if frameEvent.timeSinceLastFrame == 0:
            self.moveScale = 1
            self.rotationScale = 0.1
        else:
            self.moveScale = self.moveSpeed * frameEvent.timeSinceLastFrame
            self.rotationScale = self.rotationSpeed * frameEvent.timeSinceLastFrame

        self.rotationX = 0.0            
        self.rotationY = 0.0
        self.translateVector = ogre.Vector3(0,0,0)

        if not self._processUnbufferedKeyInput( frameEvent ):
            return False

        self._processUnbufferedMouseInput( frameEvent )

        self._moveCamera()
        return True

    def frameEnded(self, frameEvent):
        self._updateStatistics()
        return True

    def showDebugOverlay( self, show ):
        overlay = ogre.OverlayManager.getSingleton().getByName( 'Core/DebugOverlay' )
        if overlay is None:
            raise "Could not find overlay Core/DebugOverlay"        # need to look into exception integration with ogre python
        if show:
            overlay.show()
        else:
            overlay.hide()

    def _processUnbufferedKeyInput( self, frameEvent ):
        if self.inputDevice.isKeyDown( ogre.KeyCode.KC_A ):
            self.translateVector.x = -self.moveScale
        if self.inputDevice.isKeyDown( ogre.KeyCode.KC_D ):
            self.translateVector.x = self.moveScale
        if self.inputDevice.isKeyDown( ogre.KeyCode.KC_UP ) or self.inputDevice.isKeyDown( ogre.KeyCode.KC_W ):
            self.translateVector.z = -self.moveScale
        if self.inputDevice.isKeyDown( ogre.KeyCode.KC_DOWN ) or self.inputDevice.isKeyDown( ogre.KeyCode.KC_S ):
            self.translateVector.z = self.moveScale
        if self.inputDevice.isKeyDown( ogre.KeyCode.KC_PGUP ):
            self.translateVector.y = self.moveScale
        if self.inputDevice.isKeyDown( ogre.KeyCode.KC_PGDOWN ):
            self.translateVector.y = - self.moveScale

        if self.inputDevice.isKeyDown( ogre.KeyCode.KC_RIGHT ):
            self.rotationX = - self.rotationScale
        if self.inputDevice.isKeyDown( ogre.KeyCode.KC_LEFT ):
            self.rotationX = self.rotationScale

        if self._isToggleKeyDown( ogre.KeyCode.KC_F ):
            self.statisticsOn = not self.statisticsOn
            self.showDebugOverlay( self.statisticsOn )

        if self._isToggleKeyDown( ogre.KeyCode.KC_T ):
            if self.filtering == ogre.TextureFilterOptions.TFO_BILINEAR:
                self.filtering = ogre.TextureFilterOptions.TFO_TRILINEAR
                self.aniso = 1
            elif self.filtering == ogre.TextureFilterOptions.TFO_TRILINEAR:
                self.filtering = ogre.TextureFilterOptions.TFO_ANISOTROPIC
                self.aniso = 8
            else:
                self.filtering = ogre.TextureFilterOptions.TFO_BILINEAR
                self.aniso = 1
            ogre.MaterialManager.getSingleton().setDefaultTextureFiltering( self.filtering )
            ogre.MaterialManager.getSingleton().setDefaultAnisotropy( self.aniso )
            self.showDebugOverlay( self.statisticsOn )

        if self._isToggleKeyDown( ogre.KeyCode.KC_SYSRQ, 0.5 ):
            path = 'screenshot_%d.png' % self.numScreenShots
            self.numScreenShots += 1
            self.renderWindow.writeContentsToFile( path )
            self.renderWindow.setDebugText( 'screenshot taken: ' + path  )

        if self._isToggleKeyDown( ogre.KeyCode.KC_R, 0.5 ):
            detailsLevel = [ ogre.SceneDetailLevel.SDL_SOLID,
                             ogre.SceneDetailLevel.SDL_WIREFRAME,
                             ogre.SceneDetailLevel.SDL_POINTS ]
            self.sceneDetailIndex = (self.sceneDetailIndex + 1) % len(detailsLevel)
            self.camera.setDetailLevel( detailsLevel[self.sceneDetailIndex] )

        if self.inputDevice.isKeyDown( ogre.KeyCode.KC_ESCAPE ):
            return False    # stop rendering

        return True        
        
    def _isToggleKeyDown( self, keyCode, toggleTime = 1.0 ):
        if self.inputDevice.isKeyDown( keyCode )and self.timeUntilNextToggle <=0:
            self.timeUntilNextToggle = toggleTime
            return True
        return False

    def _processUnbufferedMouseInput( self, frameEvent ):
        if self.inputDevice.getMouseButton( 1 ):
            self.translateVector.x += self.inputDevice.getMouseRelativeX() * 0.13
            self.translateVector.y -= self.inputDevice.getMouseRelativeY() * 0.13
        else:
            self.rotationX = - self.inputDevice.getMouseRelativeX() * 0.13
            self.rotationY = - self.inputDevice.getMouseRelativeY() * 0.13

        if self.inputDevice.getMouseRelativeZ() > 0:
            self.translateVector.z = - self.moveScale * 8.0
        if self.inputDevice.getMouseRelativeZ() < 0:
            self.translateVector.z = self.moveScale * 8.0

    def _moveCamera( self ):
        self.camera.yaw( self.rotationX )
        self.camera.pitch( self.rotationY )
        self.camera.moveRelative( self.translateVector )

    def _updateStatistics( self ):
        statistics = self.renderWindow.getStatistics()
        self._setGuiCaption( 'Core/AverageFps', 'Average FPS: %f' % statistics.avgFPS )
        self._setGuiCaption( 'Core/CurrFps', 'Current FPS: %f' % statistics.lastFPS )
        self._setGuiCaption( 'Core/BestFps',
                             'Best FPS: %f %d ms' % (statistics.bestFPS, statistics.bestFrameTime) )
        self._setGuiCaption( 'Core/WorstFps',
                             'Worst FPS: %f %d ms' % (statistics.worstFPS, statistics.worstFrameTime) )
        self._setGuiCaption( 'Core/NumTris', 'Triangle Count: %d' % statistics.triangleCount )
        self._setGuiCaption( 'Core/DebugText', self.renderWindow.getDebugText() )

    def _setGuiCaption( self, elementName, text ):        
        guiElement = ogre.GuiManager.getSingleton().getGuiElement( elementName, False )
        guiElement.setCaption( text  )