terraindemo.py

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

import localogre as ogre
import sampleframework

class TerrainApplication(sampleframework.Application):

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

    def _createCamera( self ):
        self.camera = self.sceneManager.createCamera( 'PlayerCam' )
        self.camera.setPosition( ogre.Vector3( 128, 25, 128 ) )
        self.camera.lookAt( ogre.Vector3( 0, 0, -300 ) )
        self.camera.setNearClipDistance( 1 )
        self.camera.setFarClipDistance( 384 )

    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.White )
    
    def _createScene( self ):
        sceneManager = self.sceneManager
        camera = self.camera
        
        sceneManager.setAmbientLight( ogre.ColourValue( 0.5, 0.5, 0.5 ) )

        # create a water plane/scene node
        wavePlane = ogre.Plane()
        wavePlane.normal = ogre.Vector3.UNIT_Y
        wavePlane.d = -1.5
        planeSpecification = ogre.PlaneSpecification( wavePlane, 2800, 2800 )
        planeSpecification.setTesselation( 20, 20 )
        planeSpecification.setTiling( 10, 10 )
        planeSpecification.upVector = ogre.Vector3.UNIT_Z
        ogre.MeshManager.getSingleton().createPlane( 'WaterPlane', planeSpecification )

        waterEntity = sceneManager.createEntity( 'water', 'WaterPlane' )
        waterEntity.setMaterialName( 'Examples/TextureEffect4' )

        waterNode = sceneManager.getRootSceneNode().createChildSceneNode( 'WaterNode',
                                                                          ogre.Vector3.ZERO,
                                                                          ogre.Quaternion.IDENTITY )
        waterNode.attachObject( waterEntity )
        waterNode.translate( 1000, 0, 1000, ogre.Node.TransformSpace.TS_PARENT )

        light = sceneManager.createLight( 'MainLight' )
        light.setPosition( 20, 80, 50 )

        sceneManager.setWorldGeometry( 'terrain.cfg' )

        sceneManager.setFog( ogre.FogMode.FOG_EXP2, ogre.ColourValue.White, 0.008, 0.0, 250 )

    def _createFrameListener( self ):
        self.frameListener = TerrainListener( self.renderWindow, self.camera, self.sceneManager )
        self.root.addFrameListener( self.frameListener )

class TerrainListener(sampleframework.FrameListener):
    def __init__( self, renderWindow, camera, sceneManager ):
        sampleframework.FrameListener.__init__( self, renderWindow, camera )
        self.sceneManager = sceneManager
        self.waterFlow = 0.0
        self.flowAmount = 0.0
        self.flowUp = True
        self.targetQuality = 3.0
        self.minimumQuality = 10
        self.moveSpeed = 10.0

    def frameStarted( self, frameEvent ):
        self._animateWave( frameEvent )
        self._handleTargetQualitySettings( frameEvent )
        return sampleframework.FrameListener.frameStarted( self, frameEvent )

    def _animateWave( self, frameEvent ):
        FLOW_SPEED = 0.2
        FLOW_HEIGHT = 0.8
        
        self.waterFlow = FLOW_SPEED * frameEvent.timeSinceLastFrame
        waterNode = self.camera.getSceneManager().getRootSceneNode().getChild('WaterNode') # in python, no need to cast
        if waterNode:
            if self.flowUp:
                self.flowAmount += self.waterFlow
            else:
                self.flowAmount -= self.waterFlow
            if self.flowAmount >= FLOW_HEIGHT:
                self.flowUp = False
            elif self.flowAmount <= 0.0:
                self.flowUp = True
            y = self.waterFlow
            if not self.flowUp:
                y = -y
            waterNode.translate( 0, y, 0, ogre.Node.TransformSpace.TS_PARENT  )

    def _handleTargetQualitySettings( self, frameEvent ):
        if self._isToggleKeyDown( ogre.KeyCode.KC_9, 0.20 ):
            self.targetQuality += 0.25
            self.sceneManager.setRealOption( 'TARGET_QUALITY', self.targetQuality )
            self.renderWindow.setDebugText( 'TARGET_QUALITY: %f' % self.targetQuality  )

        if self._isToggleKeyDown( ogre.KeyCode.KC_8, 0.20 ):
            self.targetQuality -= 0.25
            self.sceneManager.setRealOption( 'TARGET_QUALITY', self.targetQuality )
            self.renderWindow.setDebugText( 'TARGET_QUALITY: %f' % self.targetQuality  )
        
        if self._isToggleKeyDown( ogre.KeyCode.KC_6, 0.20 ):
            self.minimumQuality += 1
            self.sceneManager.setRealOption( 'MINIMUM_QUALITY', self.minimumQuality )
            self.renderWindow.setDebugText( 'MINIMUM_QUALITY: %d' % self.minimumQuality  )
        
        if self._isToggleKeyDown( ogre.KeyCode.KC_5, 0.20 ):
            self.minimumQuality -= 1
            self.sceneManager.setRealOption( 'MINIMUM_QUALITY', self.minimumQuality )
            self.renderWindow.setDebugText( 'MINIMUM_QUALITY: %d' % self.minimumQuality  )

if __name__ == '__main__':
    application = TerrainApplication()
    application.go()