NovaBryan/EVE_Dump
Log | Files | 📦 下载最新源码 (.zip) | Refs | README

cameraBase.py (10740B)


      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\eve\client\script\ui\camera\cameraBase.py
      2 import blue
      3 import math
      4 import trinity
      5 import geo2
      6 import uthread2
      7 import evegraphics.settings as gfxsettings
      8 
      9 class CameraBase(object):
     10 
     11     def __init__(self):
     12         self._camera = trinity.EveCamera()
     13         self._CreateErrorHandler()
     14         self.cameraParent = None
     15         self.cameraInterestID = None
     16         self.cameraInterest = None
     17 
     18     def ResetCurveStartTime(self):
     19         self._camera.ResetStartTime()
     20 
     21     def GetTrinityCamera(self):
     22         return self._camera
     23 
     24     def GetLookAtItemID(self):
     25         pass
     26 
     27     def ResetCamera(self):
     28         pass
     29 
     30     def IsLocked(self):
     31         return False
     32 
     33     def _Update(self):
     34         pass
     35 
     36     def _ErrorListener(self, *args):
     37 
     38         def _threaded():
     39             lookat = self.GetLookAtItemID()
     40             ball = sm.GetService('michelle').GetBall(lookat)
     41             model = getattr(ball, 'model', None)
     42             if model is None:
     43                 exceptionMessage = 'EveCamera: Lookat model is none. '
     44                 exceptionMessage += str(lookat) + '/' + str(session.shipid)
     45                 raise Exception(exceptionMessage)
     46             exceptionMessage = 'EveCamera: \n'
     47             exceptionMessage += 'Lookat: ' + str(lookat) + '/' + str(session.shipid) + '\n'
     48             exceptionMessage += 'WorldPos: ' + str(model.modelWorldPosition) + '\n'
     49             exceptionMessage += 'Curves: ' + str(model.translationCurve.GetVectorAt(blue.os.GetSimTime())) + ' / '
     50             exceptionMessage += str(model.rotationCurve.GetQuaternionAt(blue.os.GetSimTime())) + '\n'
     51             if hasattr(model.rotationCurve, 'startCurve'):
     52                 startCurve = model.rotationCurve.startCurve
     53                 exceptionMessage += 'Is wasd ball\n'
     54                 exceptionMessage += 'start' + str(startCurve.GetVectorAt(blue.os.GetSimTime())) + ' / '
     55                 exceptionMessage += str(startCurve.GetQuaternionAt(blue.os.GetSimTime())) + '\n'
     56                 endCurve = model.rotationCurve.endCurve
     57                 exceptionMessage += 'end' + str(endCurve.GetVectorAt(blue.os.GetSimTime())) + ' / '
     58                 exceptionMessage += str(endCurve.GetQuaternionAt(blue.os.GetSimTime())) + '\n'
     59             self.ResetCamera()
     60             raise Exception(exceptionMessage)
     61 
     62         uthread2.StartTasklet(_threaded)
     63 
     64     def _CreateErrorHandler(self):
     65         eventHandler = blue.BlueEventToPython()
     66         eventHandler.handler = self._ErrorListener
     67         self.errorHandler = eventHandler
     68 
     69     def Dolly(self, *args, **kw):
     70         return self._camera.Dolly(*args, **kw)
     71 
     72     def OrbitParent(self, dx, dy):
     73         if gfxsettings.Get(gfxsettings.UI_CAMERA_INVERT_Y):
     74             dy *= -1
     75         return self._camera.OrbitParent(dx, dy)
     76 
     77     def RotateOnOrbit(self, dx, dy):
     78         return self._camera.RotateOnOrbit(dx, dy)
     79 
     80     def SetOrbit(self, *args, **kw):
     81         return self._camera.SetOrbit(*args, **kw)
     82 
     83     def SetRotationOnOrbit(self, *args, **kw):
     84         return self._camera.SetRotationOnOrbit(*args, **kw)
     85 
     86     def Zoom(self, *args, **kw):
     87         return self._camera.Zoom(*args, **kw)
     88 
     89     def GetYaw(self):
     90         rot = geo2.QuaternionRotationGetYawPitchRoll(self.rotationAroundParent)
     91         look = geo2.QuaternionRotationGetYawPitchRoll(self.rotationOfInterest)
     92         yaw = rot[0] + look[0] - math.pi
     93         return yaw
     94 
     95     @property
     96     def alignment(self):
     97         return self._camera.alignment
     98 
     99     @alignment.setter
    100     def alignment(self, value):
    101         self._camera.alignment = value
    102 
    103     @property
    104     def backClip(self):
    105         return self._camera.backClip
    106 
    107     @backClip.setter
    108     def backClip(self, value):
    109         self._camera.backClip = value
    110 
    111     @property
    112     def centerOffset(self):
    113         return self._camera.centerOffset
    114 
    115     @centerOffset.setter
    116     def centerOffset(self, value):
    117         self._camera.centerOffset = value
    118 
    119     @property
    120     def errorHandler(self):
    121         return self._camera.errorHandler
    122 
    123     @errorHandler.setter
    124     def errorHandler(self, value):
    125         self._camera.errorHandler = value
    126 
    127     @property
    128     def extraTranslation(self):
    129         return self._camera.extraTranslation
    130 
    131     @extraTranslation.setter
    132     def extraTranslation(self, value):
    133         self._camera.extraTranslation = value
    134 
    135     @property
    136     def fieldOfView(self):
    137         return self._camera.fieldOfView
    138 
    139     @fieldOfView.setter
    140     def fieldOfView(self, value):
    141         self._camera.fieldOfView = value
    142 
    143     @property
    144     def fov(self):
    145         return self._camera.fieldOfView
    146 
    147     @fov.setter
    148     def fov(self, value):
    149         self._camera.fieldOfView = value
    150 
    151     @property
    152     def friction(self):
    153         return self._camera.friction
    154 
    155     @friction.setter
    156     def friction(self, value):
    157         self._camera.friction = value
    158 
    159     @property
    160     def frontClip(self):
    161         return self._camera.frontClip
    162 
    163     @frontClip.setter
    164     def frontClip(self, value):
    165         self._camera.frontClip = value
    166 
    167     @property
    168     def idleMove(self):
    169         return self._camera.idleMove
    170 
    171     @idleMove.setter
    172     def idleMove(self, value):
    173         self._camera.idleMove = value
    174 
    175     @property
    176     def idleScale(self):
    177         return self._camera.idleScale
    178 
    179     @idleScale.setter
    180     def idleScale(self, value):
    181         self._camera.idleScale = value
    182 
    183     @property
    184     def idleSpeed(self):
    185         return self._camera.idleSpeed
    186 
    187     @idleSpeed.setter
    188     def idleSpeed(self, value):
    189         self._camera.idleSpeed = value
    190 
    191     @property
    192     def interest(self):
    193         return self._camera.interest
    194 
    195     @interest.setter
    196     def interest(self, value):
    197         self._camera.interest = value
    198 
    199     @property
    200     def intr(self):
    201         return self._camera.intr
    202 
    203     @intr.setter
    204     def intr(self, value):
    205         self._camera.intr = value
    206 
    207     @property
    208     def maxPitch(self):
    209         return self._camera.maxPitch
    210 
    211     @maxPitch.setter
    212     def maxPitch(self, value):
    213         self._camera.maxPitch = value
    214 
    215     @property
    216     def maxSpeed(self):
    217         return self._camera.maxSpeed
    218 
    219     @maxSpeed.setter
    220     def maxSpeed(self, value):
    221         self._camera.maxSpeed = value
    222 
    223     @property
    224     def maxYaw(self):
    225         return self._camera.maxYaw
    226 
    227     @maxYaw.setter
    228     def maxYaw(self, value):
    229         self._camera.maxYaw = value
    230 
    231     @property
    232     def minPitch(self):
    233         return self._camera.minPitch
    234 
    235     @minPitch.setter
    236     def minPitch(self, value):
    237         self._camera.minPitch = value
    238 
    239     @property
    240     def minYaw(self):
    241         return self._camera.minYaw
    242 
    243     @minYaw.setter
    244     def minYaw(self, value):
    245         self._camera.minYaw = value
    246 
    247     @property
    248     def noise(self):
    249         return self._camera.noise
    250 
    251     @noise.setter
    252     def noise(self, value):
    253         self._camera.noise = value
    254 
    255     @property
    256     def noiseCurve(self):
    257         return self._camera.noiseCurve
    258 
    259     @noiseCurve.setter
    260     def noiseCurve(self, value):
    261         self._camera.noiseCurve = value
    262 
    263     @property
    264     def noiseDamp(self):
    265         return self._camera.noiseDamp
    266 
    267     @noiseDamp.setter
    268     def noiseDamp(self, value):
    269         self._camera.noiseDamp = value
    270 
    271     @property
    272     def noiseDampCurve(self):
    273         return self._camera.noiseDampCurve
    274 
    275     @noiseDampCurve.setter
    276     def noiseDampCurve(self, value):
    277         self._camera.noiseDampCurve = value
    278 
    279     @property
    280     def noiseScale(self):
    281         return self._camera.noiseScale
    282 
    283     @noiseScale.setter
    284     def noiseScale(self, value):
    285         self._camera.noiseScale = value
    286 
    287     @property
    288     def noiseScaleCurve(self):
    289         return self._camera.noiseScaleCurve
    290 
    291     @noiseScaleCurve.setter
    292     def noiseScaleCurve(self, value):
    293         self._camera.noiseScaleCurve = value
    294 
    295     @property
    296     def parent(self):
    297         return self._camera.parent
    298 
    299     @parent.setter
    300     def parent(self, value):
    301         self._camera.parent = value
    302 
    303     @property
    304     def pitch(self):
    305         return self._camera.pitch
    306 
    307     @pitch.setter
    308     def pitch(self, value):
    309         self._camera.pitch = value
    310 
    311     @property
    312     def pos(self):
    313         return self._camera.pos
    314 
    315     @pos.setter
    316     def pos(self, value):
    317         self._camera.pos = value
    318 
    319     @property
    320     def eyePosition(self):
    321         return self._camera.pos
    322 
    323     @property
    324     def projectionMatrix(self):
    325         return self._camera.projectionMatrix
    326 
    327     @projectionMatrix.setter
    328     def projectionMatrix(self, value):
    329         self._camera.projectionMatrix = value
    330 
    331     @property
    332     def rightVec(self):
    333         return self._camera.rightVec
    334 
    335     @rightVec.setter
    336     def rightVec(self, value):
    337         self._camera.rightVec = value
    338 
    339     @property
    340     def rotationAroundParent(self):
    341         return self._camera.rotationAroundParent
    342 
    343     @rotationAroundParent.setter
    344     def rotationAroundParent(self, value):
    345         self._camera.rotationAroundParent = value
    346 
    347     def GetRotationQuat(self):
    348         return self.rotationAroundParent
    349 
    350     @property
    351     def rotationOfInterest(self):
    352         return self._camera.rotationOfInterest
    353 
    354     @rotationOfInterest.setter
    355     def rotationOfInterest(self, value):
    356         self._camera.rotationOfInterest = value
    357 
    358     @property
    359     def translationFromParent(self):
    360         return self._camera.translationFromParent
    361 
    362     @translationFromParent.setter
    363     def translationFromParent(self, value):
    364         self._camera.translationFromParent = value
    365 
    366     @property
    367     def upVec(self):
    368         return self._camera.upVec
    369 
    370     @upVec.setter
    371     def upVec(self, value):
    372         self._camera.upVec = value
    373 
    374     def GetYAxis(self):
    375         return self.upVec
    376 
    377     def GetXAxis(self):
    378         return self.rightVec
    379 
    380     @property
    381     def update(self):
    382         return self._camera.update
    383 
    384     @update.setter
    385     def update(self, value):
    386         self._camera.update = value
    387 
    388     @property
    389     def useExtraTranslation(self):
    390         return self._camera.useExtraTranslation
    391 
    392     @useExtraTranslation.setter
    393     def useExtraTranslation(self, value):
    394         self._camera.useExtraTranslation = value
    395 
    396     @property
    397     def viewMatrix(self):
    398         return self._camera.viewMatrix
    399 
    400     @viewMatrix.setter
    401     def viewMatrix(self, value):
    402         self._camera.viewMatrix = value
    403 
    404     @property
    405     def viewVec(self):
    406         return self._camera.viewVec
    407 
    408     @viewVec.setter
    409     def viewVec(self, value):
    410         self._camera.viewVec = value
    411 
    412     def GetLookAtDirection(self):
    413         return self.viewVec
    414 
    415     @property
    416     def yaw(self):
    417         return self._camera.yaw
    418 
    419     @yaw.setter
    420     def yaw(self, value):
    421         self._camera.yaw = value
    422 
    423     @property
    424     def zoomCurve(self):
    425         return self._camera.zoomCurve
    426 
    427     @zoomCurve.setter
    428     def zoomCurve(self, value):
    429         self._camera.zoomCurve = value