home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 January / Gamestar_80_2006-01_dvd.iso / Dema / Civilization4 / data1.cab / Civ4DemoComponent / Assets / Python / CvCameraControls.py < prev    next >
Encoding:
Python Source  |  2005-11-09  |  11.4 KB  |  371 lines
  1. ## Sid Meier's Civilization 4
  2. ## Copyright Firaxis Games 2005
  3. ## 
  4. ## CvCameraControls
  5.  
  6. from CvPythonExtensions import *
  7. import CvUtil
  8.  
  9. gc = CyGlobalContext()
  10.  
  11. class CvCameraControls:
  12.     ' class to handle moving the camera '
  13.     
  14.     # GLOBALVARS - add any new variables here so that they exist for the __init__ call
  15.     SINGLE_PLOT_UNITS = 180.0
  16.     ZOOM_SPEED_DEFAULT = 0.5
  17.     TURN_SPEED_DEFAULT = 0.5
  18.     PITCH_SPEED_DEFAULT = 0.5
  19.     CAMERA_MIN_DISTANCE_DEFAULT = gc.getDefineFLOAT("CAMERA_MIN_DISTANCE")
  20.     
  21.     bLookAt = False
  22.     originalPositionNiPoint3 = None
  23.     newPositionNiPoint3 = None
  24.     lookAtSpeed = 0
  25.     # Rotate
  26.     bRotate = False
  27.     bRotateContinuous = False
  28.     fRotateDestination = None
  29.     fRotateTracking = 0.0
  30.     rotateDirection = None
  31.     fRotateSpeed = 0.0
  32.     # Zoom
  33.     bZoom = False
  34.     fCurrentZoom = 0.0
  35.     fZoomDestination = None
  36.     zoomDirection = None
  37.     fZoomSpeed = 0.0
  38.     # Turn
  39.     bTurn = False
  40.     fCurrentBaseTurn = 0.0
  41.     fTurnDestination = 0.0 # degrees
  42.     turnDirection = None
  43.     fTurnSpeed = 0.0
  44.     # Pitch
  45.     bPitch = False
  46.     fCurrentBasePitch = 0.0
  47.     fPitchDestination = 0.0 # degrees
  48.     pitchDirection = None
  49.     fPitchSpeed = 0.0
  50.     
  51.     def __init__( self ):
  52.         self.resetCameraControls()
  53.         
  54.     def resetCameraControls( self ):    
  55.         self.resetRotate()
  56.         self.resetZoom()
  57.         self.resetTurn()
  58.         self.resetPitch()
  59.         
  60.         # interface values
  61.         self.bDebugModeState = CyGame().isDebugMode()
  62.         self.bCityBillboardVisibility = CyEngine().getCityBillboardVisibility()
  63.         self.bUnitFlagVisibility = CyEngine().getUnitFlagVisibility()
  64.         self.bSelectionCursorVisibility = CyEngine().getSelectionCursorVisibility()
  65.         self.InterfaceVisibilityState = CyInterface().getShowInterface()
  66.     
  67.     def centerCameraByCoords( self, t_Coords ):
  68.         ' center camera based on t_Coords '
  69.         iX, iY = t_Coords
  70.         CyCamera().JustLookAtPlot( CyMap().plot( iX, iY ) )
  71.     
  72.     def centerCamera( self, pPlot ):
  73.         ' center camera by plot '
  74.         CyCamera().JustLookAt( pPlot.getPoint() )
  75.     
  76.     def centerCameraByObject( self, pObject ):
  77.         ' center camera on pObject - valid items are cities, units '
  78.         CyCamera().JustLookAt( pObject.getPlot().getPoint() )
  79.     
  80.     def moveCameraXPlots( self, iNumPlots ):
  81.         ' moves the camera iNumPlots on the X coord '
  82.         fRotateUnits = iNumPlots * self.SINGLE_PLOT_UNITS        
  83.         self.moveCamera( ( fRotateUnits, 0.0, 0.0 ) )
  84.     
  85.     def moveCameraYPlots( self, iNumPlots ):
  86.         ' moves the camera iNumPlots on the Y coord '
  87.         fRotateUnits = iNumPlots * self.SINGLE_PLOT_UNITS        
  88.         self.moveCamera( ( 0.0, fRotateUnits, 0.0 ) )
  89.     
  90.     def setCameraMovementSpeed( self, iCameraMovementSpeed = CameraMovementSpeeds.CAMERAMOVEMENTSPEED_SLOW ):
  91.         CyCamera().SetCameraMovementSpeed(int(CameraMovementSpeeds.CAMERAMOVEMENTSPEED_SLOW))
  92.     
  93.     def doMoveCamera( self, t_Coord ):
  94.         ' moves the camera based on the x/y/z values in t_Coord '
  95.         if len(t_Coord) == 3:
  96.             CyCamera().Translate( NiPoint3( t_Coord[0], t_Coord[1], t_Coord[2] ) )
  97.  
  98.     def doRotateGlobe( self ):
  99.         if bDebugModeState == False:
  100.             CyGame().toggleDebugMode()
  101.         self.zoomCamera(1.0)
  102.         self.doRotateCamera( True, -self.SINGLE_PLOT_UNITS )
  103.     
  104. ######################
  105. # Rotate Controls
  106. ######################
  107.     def doRotateCamera( self, fRotateDestination, fRotateSpeed ):
  108.         self.bRotate = True
  109.         self.fRotateDestination = fRotateDestination
  110.         self.fRotateSpeed = fRotateSpeed        
  111.  
  112.         if ( self.fRotateDestination == "Continuous" ):
  113.             self.bRotateContinuous = True
  114.             self.rotateDirection = "Continuous"
  115.             
  116.         if ( self.fRotateDestination < 0.0 ):
  117.             self.rotateDirection = "Left"
  118.             self.rotateTracking = -self.fRotateDestination
  119.         
  120.         if ( self.fRotateDestination > 0.0 ):
  121.             self.rotateDirection = "Right"
  122.             self.rotateTracking = self.fRotateDestination
  123.         
  124.         #self.updateRotate( 1.0 )
  125.     
  126.     def updateRotate( self, fDeltaTime ):
  127.         ' updates the Rotate based on fDeltaTime and the set Rotate Speed '
  128.         bAtDestination = False
  129.         
  130.         if ( self.bRotate and self.rotateDirection ):
  131.             fRotateModifier = self.fRotateSpeed * fDeltaTime
  132.             # Left (-)  use -360.0 for fRotateDestination to rotate left
  133.             if ( self.rotateDirection == "Left" ):
  134.                 self.rotateTracking += fRotateModifier
  135.                 if ( not self.bRotateContinuous and self.rotateTracking >= 0.0 ):
  136.                     bAtDestination = True
  137.             # Right (+) use 360.0 for fRotateDestination to rotate right
  138.             if ( self.rotateDirection == "Right" ):
  139.                 self.rotateTracking -= fRotateModifier
  140.                 if ( not self.bRotateContinuous and self.rotateTracking <= 0.0 ):
  141.                     bAtDestination = True
  142.             
  143.             if ( not bAtDestination ):
  144.                 self.doMoveCamera( ( fRotateModifier, 0.0, 0.0 ) )
  145.         
  146.             if ( bAtDestination ):
  147.                 self.resetRotate()
  148.     
  149.     def resetRotate( self ):
  150.         ' resets Rotate to default values '
  151.         self.bRotate = False
  152.         self.bRotateContinuous = False
  153.         self.fRotateDestination = None
  154.         self.rotateDirection = None
  155.         self.fRotateSpeed = 0.0
  156.  
  157. ######################
  158. # Zoom Controls
  159. ######################
  160.     def doZoomCamera( self, fZoomDestination, fZoomSpeed ): 
  161.         ' moves the camera and checks if camera has reached destination '
  162.         if ( fZoomDestination ):
  163.             # toggle zoom camera control updates on
  164.             self.bZoom = True
  165.             if ( fZoomSpeed ):    # if not None
  166.                 self.fZoomSpeed = fZoomSpeed
  167.             else:
  168.                 self.fZoomSpeed = self.ZOOM_SPEED_DEFAULT
  169.             
  170.             self.fZoomDestination = fZoomDestination
  171.             
  172.             if ( self.fCurrentZoom > self.fZoomDestination ):
  173.                 self.zoomDirection = "ZoomIn"
  174.             
  175.             elif ( self.fCurrentZoom < self.fZoomDestination ):
  176.                 self.zoomDirection = "ZoomOut"
  177.             
  178.             else:
  179.                 self.resetZoom()
  180.         
  181.     def updateZoom( self, fDeltaTime ):
  182.         ' updates the Zoom based on fDeltaTime and the set Zoom Speed '
  183.         bAtDestination = False
  184.         fZoomModifier = fDeltaTime * self.fZoomSpeed
  185.         
  186.         if ( self.zoomDirection):
  187.             if ( self.zoomDirection == 'ZoomIn' ):
  188.                 fNewZoom = CyCamera().GetZoom() - fZoomModifier            
  189.             elif ( self.zoomDirection == 'ZoomOut' ):
  190.                 fNewZoom = CyCamera().GetZoom() + fZoomModifier
  191.             
  192.             # move camera based on whether its zooming in or out
  193.             CyCamera().SetZoom( fNewZoom )
  194.             
  195.             if ( self.zoomDirection == 'ZoomIn' and fNewZoom < self.fZoomDestination ):
  196.                 bAtDestination = True
  197.             if ( self.zoomDirection == 'ZoomOut' and fNewZoom > self.fZoomDestination ):
  198.                 bAtDestination = True
  199.         
  200.         if ( bAtDestination ):
  201.             self.resetZoom()
  202.                 
  203.     def resetZoom( self ):
  204.         ' resets Zoom to default values '
  205.         self.bZoom = False
  206.         self.fCurrentZoom = CyCamera().GetZoom()
  207.         self.fZoomSpeed = 0.0
  208.         self.zoomDirection = None
  209.         self.fZoomDestination = None
  210.  
  211. ######################
  212. # Turn Controls
  213. ######################
  214.     def isTurn( self ):
  215.         return self.bTurn
  216.     
  217.     #def doTurnCamera( self, fTurnDestination, fTurnSpeed = self.TURN_SPEED_DEFAULT ):
  218.     def doTurnCamera( self, fTurnDestination, fTurnSpeed ):
  219.         ' moves the camera and checks if camera has reached destination '        
  220.         self.fTurnDestination = fTurnDestination + CyCamera().GetBaseTurn()
  221.         if ( fTurnDestination != 0.0 ):
  222.             self.bTurn = True
  223.             self.fTurnDestination = fTurnDestination
  224.             self.fTurnSpeed = fTurnSpeed
  225.             
  226.         elif ( self.fTurnDestination > 0.0 ):
  227.             self.turnDirection = "Right"
  228.         else:
  229.             self.turnDirection = "Left"
  230.  
  231.     def updateTurn( self, fDeltaTime ):
  232.         ' updates the Turn based on fDeltaTime and the set Turn Speed '
  233.         bAtDestination = False
  234.         
  235.         if ( self.turnDirection ):
  236.             fTurnModifer = fDeltaTime * self.fTurnSpeed
  237.             
  238.             if ( self.turnDirection == "Right" ):
  239.                 fNewTurn = CyCamera().GetBaseTurn() - fTurnModifier
  240.             if ( self.turnDirection == "Left" ):
  241.                 fNewTurn = CyCamera().GetBaseTurn() - fTurnModifier
  242.                 
  243.             CyCamera().SetBaseTurn( fNewTurn )
  244.             
  245.             if ( self.zoomDirection == "Right" and fNewTurn < self.fTurnDestination ):
  246.                 bAtDestination = True
  247.             if ( self.zoomDirection == "Left" and fNewTurn > self.fTurnDestination ):
  248.                 bAtDestination = True
  249.         
  250.         if ( bAtDestination ):
  251.             self.resetTurn()
  252.     
  253.     def resetTurn( self ):
  254.         ' resets Turn to default values '
  255.         self.bTurn = False
  256.         self.fCurrentBaseTurn = CyCamera().GetBaseTurn()
  257.         self.fTurnDestination = 0.0 # degrees
  258.         self.turnDirection = None
  259.         self.fTurnSpeed = 0.0
  260.     
  261. ######################
  262. # Pitch Controls
  263. ######################
  264.     def isPitch( self ):
  265.         return self.bPitch
  266.     
  267.     def doPitchCamera( self, fPitchDestination, fPitchSpeed ):
  268.         ' moves the camera and checks if camera has reached destination '
  269.         self.bPitch = True
  270.         self.fCurrentPitch = CyCamera().GetBasePitch()
  271.         self.fPitchDestination = fPitchDestination
  272.         self.fPitchSpeed = fPitchSpeed
  273.             
  274.         if ( fPitchDestination > 0 ):
  275.             self.pitchDirection = "Up"
  276.         else:
  277.             self.pitchDirection = "Down"
  278.  
  279.     def updatePitch( self, fDeltaTime ):
  280.         ' updates the pitch based on fDeltaTime and the set Pitch Speed '
  281.         bAtDestination = False
  282.         if ( self.PitchDirection ):
  283.             fPitchModifer = fDeltaTime * self.fPitchSpeed
  284.             if ( self.pitchDirection == "Up" ):
  285.                 fNewPitch = CyCamera().GetBasePitch() - fPitchModifier
  286.             if ( self.pitchDirection == "Down" ):
  287.                 fNewPitch = CyCamera().GetBasePitch() - fPitchModifier
  288.             CyCamera().SetBasePitch(fNewPitch)
  289.             
  290.             if ( self.pitchDirection == "Up" and fNewPitch < self.fPitchDestination ):
  291.                 bAtDestination = True
  292.             elif ( self.pitchDirection == "Down" and fNewPitch > self.fPitchDestination ):
  293.                 bAtDestination = True
  294.         
  295.         if ( bAtDestination ):
  296.             self.resetPitch()
  297.     
  298.     def resetPitch( self ):
  299.         ' resets Pitch to default values '
  300.         self.bPitch = False
  301.         self.fCurrentBasePitch = CyCamera().GetBasePitch()
  302.         self.fPitchDestination = 0.0 # degrees
  303.         self.pitchDirection = None
  304.         self.fPitchSpeed = 0.0
  305.  
  306. # NEWCONTROLSHERE
  307.  
  308. ######################
  309. # Interface Fxns
  310. ######################
  311.     def setCAMERA_MIN_DISTANCE( self, fVal ):
  312.         CyGlobalContext().setDefineFLOAT("CAMERA_MIN_DISTANCE", fVal)
  313.     
  314.     def setDebugMode( self, bState ):
  315.         if ( self.bSetDebugModeState != bState ):
  316.             CyGame().toggleDebugMode()
  317.  
  318.     def setCityBillboardVisibility( self, bState ):
  319.         if ( self.bCityBillboardVisibility != bState ):
  320.             CyEngine().setCityBillboardVisibility( bState )
  321.  
  322.     def setUnitFlagVisibility( self, bState ):
  323.         if ( self.bUnitFlagVisibility != bState ):
  324.             CyEngine().setUnitFlagVisibility( bState )
  325.  
  326.     def setSelectionCursorVisibility( self, bState ):
  327.         if ( self.bSelectionCursorVisibility != bState ):
  328.             CyEngine().setSelectionCursorVisibility( bState )
  329. ######################
  330. ## Simple Look At
  331. ######################
  332.     def doLookAt(self, ptPosition, ptTarget, fSpeed):
  333.         self.bLookAt = True
  334.         CyCamera().SetDestinationPosition(ptPosition)
  335.         CyCamera().SetTargetDestination(ptTarget)
  336.         CyCamera().SetLookAtSpeed(fSpeed)
  337.     
  338. #    def updateLookAt(self, fDeltaTime):
  339. #        if not bCyCamera().GetCurrentPosition() == CyCamera().GetDestinationPosition():
  340.             
  341.     
  342.         
  343. ######################
  344. # Update / Input Handlers
  345. ######################
  346.     def isActive( self ):
  347.         if ( self.bRotate or self.bZoom or self.bTurn or self.bPitch ):
  348.             return True
  349.         return False
  350.     
  351.     def onUpdate( self, fDeltaTime ):
  352.         ' loops through UpdateMaps and returns a list of all controls that are being updated '
  353.         # add any new controls as a CONTROLUPDATE
  354.         if ( self.bLookAt or self.bRotate or self.bZoom or self.bTurn or self.bPitch ):
  355.             if self.bLookAt:
  356.                 self.updateLookAt( fDeltaTime )
  357.             if self.bRotate:
  358.                 self.updateRotate( fDeltaTime )
  359.             if self.bZoom:
  360.                 self.updateZoom( fDeltaTime )
  361.             if self.bTurn:
  362.                 self.updateTurn( fDeltaTime )
  363.             if self.bPitch:
  364.                 self.updatePitch( fDeltaTime )
  365.     
  366.     def handleInput( self, theKey ):
  367.         return
  368.  
  369. g_CameraControls = CvCameraControls()
  370.  
  371.