コード例 #1
0
    def __updateOscillators(self, deltaTime):
        if not SniperCamera.isCameraDynamic():
            self.__impulseOscillator.reset()
            self.__movementOscillator.reset()
            self.__noiseOscillator.reset()
            return (mathUtils.createRotationMatrix(Vector3(0, 0, 0)), mathUtils.createRotationMatrix(Vector3(0, 0, 0)))
        oscillatorAcceleration = self.__calcCurOscillatorAcceleration(deltaTime)
        self.__movementOscillator.externalForce += oscillatorAcceleration
        self.__impulseOscillator.update(deltaTime)
        self.__movementOscillator.update(deltaTime)
        self.__noiseOscillator.update(deltaTime)
        noiseDeviation = Vector3(self.__noiseOscillator.deviation)
        deviation = self.__impulseOscillator.deviation + self.__movementOscillator.deviation + noiseDeviation
        oscVelocity = self.__impulseOscillator.velocity + self.__movementOscillator.velocity + self.__noiseOscillator.velocity
        if abs(deviation.x) < 1e-05 and abs(oscVelocity.x) < 0.0001:
            deviation.x = 0
        if abs(deviation.y) < 1e-05 and abs(oscVelocity.y) < 0.0001:
            deviation.y = 0
        if abs(deviation.z) < 1e-05 and abs(oscVelocity.z) < 0.0001:
            deviation.z = 0
        curZoomIdx = 0
        zooms = self.__cfg['zooms']
        for idx in xrange(len(zooms)):
            if self.__zoom == zooms[idx]:
                curZoomIdx = idx
                break

        zoomExposure = self.__zoom * self.__dynamicCfg['zoomExposure'][curZoomIdx]
        deviation /= zoomExposure
        impulseDeviation = (self.__impulseOscillator.deviation + noiseDeviation) / zoomExposure
        self.__impulseOscillator.externalForce = Vector3(0)
        self.__movementOscillator.externalForce = Vector3(0)
        self.__noiseOscillator.externalForce = Vector3(0)
        return (mathUtils.createRotationMatrix(Vector3(deviation.x, deviation.y, deviation.z)), mathUtils.createRotationMatrix(impulseDeviation))
コード例 #2
0
ファイル: snipercamera.py プロジェクト: webiumsk/WOT0.9.10
    def __updateOscillators(self, deltaTime):
        if not SniperCamera.isCameraDynamic():
            self.__impulseOscillator.reset()
            self.__movementOscillator.reset()
            self.__noiseOscillator.reset()
            return (mathUtils.createRotationMatrix(Vector3(0, 0, 0)), mathUtils.createRotationMatrix(Vector3(0, 0, 0)))
        oscillatorAcceleration = self.__calcCurOscillatorAcceleration(deltaTime)
        self.__movementOscillator.externalForce += oscillatorAcceleration
        self.__impulseOscillator.update(deltaTime)
        self.__movementOscillator.update(deltaTime)
        self.__noiseOscillator.update(deltaTime)
        noiseDeviation = Vector3(self.__noiseOscillator.deviation)
        deviation = self.__impulseOscillator.deviation + self.__movementOscillator.deviation + noiseDeviation
        oscVelocity = self.__impulseOscillator.velocity + self.__movementOscillator.velocity + self.__noiseOscillator.velocity
        if abs(deviation.x) < 1e-05 and abs(oscVelocity.x) < 0.0001:
            deviation.x = 0
        if abs(deviation.y) < 1e-05 and abs(oscVelocity.y) < 0.0001:
            deviation.y = 0
        if abs(deviation.z) < 1e-05 and abs(oscVelocity.z) < 0.0001:
            deviation.z = 0
        curZoomIdx = 0
        zooms = self.__cfg['zooms']
        for idx in xrange(len(zooms)):
            if self.__zoom == zooms[idx]:
                curZoomIdx = idx
                break

        zoomExposure = self.__zoom * self.__dynamicCfg['zoomExposure'][curZoomIdx]
        deviation /= zoomExposure
        impulseDeviation = (self.__impulseOscillator.deviation + noiseDeviation) / zoomExposure
        self.__impulseOscillator.externalForce.set(0, 0, 0)
        self.__movementOscillator.externalForce.set(0, 0, 0)
        self.__noiseOscillator.externalForce.set(0, 0, 0)
        return (mathUtils.createRotationMatrix(Vector3(deviation.x, deviation.y, deviation.z)), mathUtils.createRotationMatrix(impulseDeviation))
コード例 #3
0
    def __assembleModel(self):
        from vehicle_systems import model_assembler
        resources = self.__resources
        self.__vEntity.model = resources[self.__vDesc.name]
        if not self.__isVehicleDestroyed:
            self.__fashions = VehiclePartsTuple(BigWorld.WGVehicleFashion(False), BigWorld.WGBaseFashion(), BigWorld.WGBaseFashion(), BigWorld.WGBaseFashion())
            model_assembler.setupTracksFashion(self.__vDesc, self.__fashions.chassis)
            self.__vEntity.model.setupFashions(self.__fashions)
            self.__initMaterialHandlers()
            model_assembler.assembleCollisionObstaclesCollector(self, None)
            model_assembler.assembleTessellationCollisionSensor(self, None)
            self.wheelsAnimator = model_assembler.createWheelsAnimator(self.__vEntity.model, self.__vDesc, None)
            self.trackNodesAnimator = model_assembler.createTrackNodesAnimator(self.__vEntity.model, self.__vDesc, self.wheelsAnimator)
            chassisFashion = self.__fashions.chassis
            splineTracksImpl = model_assembler.setupSplineTracks(chassisFashion, self.__vDesc, self.__vEntity.model, self.__resources)
            model_assembler.assembleTracks(self.__resources, self.__vDesc, self, splineTracksImpl, True)
            self.updateCustomization(self.__outfit)
            dirtEnabled = BigWorld.WG_dirtEnabled() and 'HD' in self.__vDesc.type.tags
            if dirtEnabled:
                dirtHandlers = [BigWorld.PyDirtHandler(True, self.__vEntity.model.node(TankPartNames.CHASSIS).position.y),
                 BigWorld.PyDirtHandler(False, self.__vEntity.model.node(TankPartNames.HULL).position.y),
                 BigWorld.PyDirtHandler(False, self.__vEntity.model.node(TankPartNames.TURRET).position.y),
                 BigWorld.PyDirtHandler(False, self.__vEntity.model.node(TankPartNames.GUN).position.y)]
                modelHeight, _ = self.computeVehicleHeight()
                self.dirtComponent = Vehicular.DirtComponent(dirtHandlers, modelHeight)
                for fashionIdx, _ in enumerate(TankPartNames.ALL):
                    self.__fashions[fashionIdx].addMaterialHandler(dirtHandlers[fashionIdx])

                self.dirtComponent.setBase()
        else:
            self.__fashions = VehiclePartsTuple(BigWorld.WGBaseFashion(), BigWorld.WGBaseFashion(), BigWorld.WGBaseFashion(), BigWorld.WGBaseFashion())
            self.__vEntity.model.setupFashions(self.__fashions)
            self.wheelsAnimator = None
            self.trackNodesAnimator = None
            self.dirtComponent = None
        cfg = hangarCFG()
        turretYaw = self.__vDesc.gun.staticTurretYaw
        gunPitch = self.__vDesc.gun.staticPitch
        if not ('AT-SPG' in self.__vDesc.type.tags or 'SPG' in self.__vDesc.type.tags):
            if turretYaw is None:
                turretYaw = cfg['vehicle_turret_yaw']
                turretYawLimits = self.__vDesc.gun.turretYawLimits
                if turretYawLimits is not None:
                    turretYaw = mathUtils.clamp(turretYawLimits[0], turretYawLimits[1], turretYaw)
            if gunPitch is None:
                gunPitch = cfg['vehicle_gun_pitch']
                gunPitchLimits = self.__vDesc.gun.pitchLimits['absolute']
                gunPitch = mathUtils.clamp(gunPitchLimits[0], gunPitchLimits[1], gunPitch)
        else:
            if turretYaw is None:
                turretYaw = 0.0
            if gunPitch is None:
                gunPitch = 0.0
        turretYawMatrix = mathUtils.createRotationMatrix((turretYaw, 0.0, 0.0))
        self.__vEntity.model.node(TankPartNames.TURRET, turretYawMatrix)
        gunPitchMatrix = mathUtils.createRotationMatrix((0.0, gunPitch, 0.0))
        self.__vEntity.model.node(TankPartNames.GUN, gunPitchMatrix)
        return
コード例 #4
0
 def __cameraUpdate(self):
     if not (self.__autoUpdateDxDyDz.x == 0.0 and self.__autoUpdateDxDyDz.y == 0.0 and self.__autoUpdateDxDyDz.z == 0.0):
         self.__update(self.__autoUpdateDxDyDz.x, self.__autoUpdateDxDyDz.y, self.__autoUpdateDxDyDz.z)
     inertDt = deltaTime = self.measureDeltaTime()
     replayCtrl = BattleReplay.g_replayCtrl
     if replayCtrl.isPlaying:
         repSpeed = replayCtrl.playbackSpeed
         if repSpeed == 0.0:
             inertDt = 0.01
             deltaTime = 0.0
         else:
             inertDt = deltaTime = deltaTime / repSpeed
     self.__aimingSystem.update(deltaTime)
     virginShotPoint = self.__aimingSystem.getThirdPersonShotPoint()
     delta = self.__inputInertia.positionDelta
     sign = delta.dot(Vector3(0, 0, 1))
     self.__inputInertia.update(inertDt)
     delta = (delta - self.__inputInertia.positionDelta).length
     if delta != 0.0:
         self.__cam.setScrollDelta(math.copysign(delta, sign))
     FovExtended.instance().setFovByMultiplier(self.__inputInertia.fovZoomMultiplier)
     unshakenPos = self.__inputInertia.calcWorldPos(self.__aimingSystem.idealMatrix if self.__adCfg['enable'] else self.__aimingSystem.matrix)
     vehMatrix = Math.Matrix(self.__aimingSystem.vehicleMProv)
     vehiclePos = vehMatrix.translation
     fromVehicleToUnshakedPos = unshakenPos - vehiclePos
     deviationBasis = mathUtils.createRotationMatrix(Vector3(self.__aimingSystem.yaw, 0, 0))
     impulseDeviation, movementDeviation, oscillationsZoomMultiplier = self.__updateOscillators(deltaTime)
     relCamPosMatrix = mathUtils.createTranslationMatrix(impulseDeviation + movementDeviation)
     relCamPosMatrix.postMultiply(deviationBasis)
     relCamPosMatrix.translation += fromVehicleToUnshakedPos
     upRotMat = mathUtils.createRotationMatrix(Vector3(0, 0, -impulseDeviation.x * self.__dynamicCfg['sideImpulseToRollRatio'] - self.__noiseOscillator.deviation.z))
     upRotMat.postMultiply(relCamPosMatrix)
     self.__cam.up = upRotMat.applyVector(Vector3(0, 1, 0))
     relTranslation = relCamPosMatrix.translation
     self.__setCameraPosition(relTranslation)
     shotPoint = self.__calcFocalPoint(virginShotPoint, deltaTime)
     vehToShotPoint = shotPoint - vehiclePos
     self.__setCameraAimPoint(vehToShotPoint)
     replayCtrl = BattleReplay.g_replayCtrl
     if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
         aimOffset = replayCtrl.getAimClipPosition()
         if not BigWorld.player().isForcedGuiControlMode() and GUI.mcursor().inFocus:
             GUI.mcursor().position = aimOffset
     else:
         aimOffset = self.__calcAimOffset(oscillationsZoomMultiplier)
         if replayCtrl.isRecording:
             replayCtrl.setAimClipPosition(aimOffset)
     self.__cam.aimPointClipCoords = aimOffset
     self.__aimOffset = aimOffset
     if self.__shiftKeySensor is not None:
         self.__shiftKeySensor.update(1.0)
         if self.__shiftKeySensor.currentVelocity.lengthSquared > 0.0:
             self.shiftCamPos(self.__shiftKeySensor.currentVelocity)
             self.__shiftKeySensor.currentVelocity = Math.Vector3()
     return 0.0
コード例 #5
0
ファイル: arcadecamera.py プロジェクト: jamesxia4/wot_client
 def __cameraUpdate(self):
     if not (self.__autoUpdateDxDyDz.x == 0.0 and self.__autoUpdateDxDyDz.y == 0.0 and self.__autoUpdateDxDyDz.z == 0.0):
         self.__update(self.__autoUpdateDxDyDz.x, self.__autoUpdateDxDyDz.y, self.__autoUpdateDxDyDz.z)
     inertDt = deltaTime = self.measureDeltaTime()
     replayCtrl = BattleReplay.g_replayCtrl
     if replayCtrl.isPlaying:
         repSpeed = replayCtrl.playbackSpeed
         if repSpeed == 0.0:
             inertDt = 0.01
             deltaTime = 0.0
         else:
             inertDt = deltaTime = deltaTime / repSpeed
     self.__aimingSystem.update(deltaTime)
     virginShotPoint = self.__aimingSystem.getThirdPersonShotPoint()
     self.__inputInertia.update(inertDt)
     FovExtended.instance().setFovByMultiplier(self.__inputInertia.fovZoomMultiplier)
     unshakenPos = self.__inputInertia.calcWorldPos(self.__aimingSystem.matrix)
     vehMatrix = Math.Matrix(self.__aimingSystem.vehicleMProv)
     vehiclePos = vehMatrix.translation
     fromVehicleToUnshakedPos = unshakenPos - vehiclePos
     deviationBasis = mathUtils.createRotationMatrix(Vector3(self.__aimingSystem.yaw, 0, 0))
     impulseDeviation, movementDeviation, oscillationsZoomMultiplier = self.__updateOscillators(deltaTime)
     relCamPosMatrix = mathUtils.createTranslationMatrix(impulseDeviation + movementDeviation)
     relCamPosMatrix.postMultiply(deviationBasis)
     relCamPosMatrix.translation += fromVehicleToUnshakedPos
     upRotMat = mathUtils.createRotationMatrix(Vector3(0, 0, -impulseDeviation.x * self.__dynamicCfg['sideImpulseToRollRatio'] - self.__noiseOscillator.deviation.z))
     upRotMat.postMultiply(relCamPosMatrix)
     self.__cam.up = upRotMat.applyVector(Vector3(0, 1, 0))
     relTranslation = relCamPosMatrix.translation
     self.__setCameraPosition(relTranslation)
     shotPoint = self.__calcFocalPoint(virginShotPoint, deltaTime)
     vehToShotPoint = shotPoint - vehiclePos
     self.__setCameraAimPoint(vehToShotPoint)
     replayCtrl = BattleReplay.g_replayCtrl
     if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
         aimOffset = replayCtrl.getAimClipPosition()
     else:
         aimOffset = self.__calcAimOffset(oscillationsZoomMultiplier)
         if replayCtrl.isRecording:
             replayCtrl.setAimClipPosition(aimOffset)
     self.__cam.aimPointClipCoords = aimOffset
     self.__aim.offset(aimOffset)
     if self.__shiftKeySensor is not None:
         self.__shiftKeySensor.update(1.0)
         if self.__shiftKeySensor.currentVelocity.lengthSquared > 0.0:
             self.shiftCamPos(self.__shiftKeySensor.currentVelocity)
             self.__shiftKeySensor.currentVelocity = Math.Vector3()
     return 0.0
コード例 #6
0
ファイル: VideoCamera.py プロジェクト: webiumsk/WOT-0.9.17-CT
 def __getMovementDirections(self):
     m = mathUtils.createRotationMatrix(self.__ypr)
     result = (m.applyVector(Vector3(1, 0, 0)), Vector3(0, 1, 0), m.applyVector(Vector3(0, 0, 1)))
     if self.__alignerToLand.enabled:
         result[0].y = 0.0
         result[2].y = 0.0
     return result
コード例 #7
0
ファイル: videocamera.py プロジェクト: webiumsk/WoT
 def __getMovementDirections(self):
     m = mathUtils.createRotationMatrix(self.__ypr)
     result = (m.applyVector(Vector3(1, 0, 0)), Vector3(0, 1, 0), m.applyVector(Vector3(0, 0, 1)))
     if self.__alignerToLand.enabled:
         result[0].y = 0.0
         result[2].y = 0.0
     return result
コード例 #8
0
 def enable(self, targetPos, saveDist):
     self.__prevTime = BigWorld.time()
     self.__aimingSystem.enable(targetPos)
     self.__activeDistRangeSettings = self.__getActiveDistRangeForArena()
     if self.__activeDistRangeSettings is not None:
         self.__aimingSystem.height = self.__getDistRange()[0]
     srcMat = mathUtils.createRotationMatrix((self.__cameraYaw, -math.pi * 0.499, 0.0))
     self.__cam.source = srcMat
     if not saveDist:
         self.__updateCamDistCfg()
         self.__camDist = self.__cfg['camDist']
     self.__cam.pivotPosition = Math.Vector3(0.0, self.__camDist, 0.0)
     camTarget = Math.MatrixProduct()
     camTarget.b = self.__aimingSystem.matrix
     self.__cam.target = camTarget
     self.__cam.forceUpdate()
     BigWorld.camera(self.__cam)
     BigWorld.player().positionControl.moveTo(self.__aimingSystem.matrix.translation)
     BigWorld.player().positionControl.followCamera(True)
     FovExtended.instance().enabled = False
     BigWorld.projection().fov = StrategicCamera.ABSOLUTE_VERTICAL_FOV
     self.__cameraUpdate()
     self.delayCallback(0.0, self.__cameraUpdate)
     self.__needReset = 1
     return
コード例 #9
0
 def __init__(self, height, yaw):
     super(StrategicAimingSystem, self).__init__()
     self._matrix = mathUtils.createRotationMatrix((yaw, 0, 0))
     self._planePosition = Vector3(0, 0, 0)
     self.__camDist = 0.0
     self.__height = height
     self.__heightFromPlane = 0.0
コード例 #10
0
ファイル: cameras.py プロジェクト: 19colt87/WOTDecompiled
def getAimMatrix(x, y):
    fov = BigWorld.projection().fov
    near = BigWorld.projection().nearPlane
    aspect = getScreenAspectRatio()
    yLength = near * math.tan(fov * 0.5)
    xLength = yLength * aspect
    result = mathUtils.createRotationMatrix(Math.Vector3(math.atan2(xLength * x, near), math.atan2(yLength * y, near), 0))
    return result
コード例 #11
0
 def applyImpulse(self, position, impulse, reason=ImpulseReason.ME_HIT):
     adjustedImpulse, noiseMagnitude = self.__dynamicCfg.adjustImpulse(
         impulse, reason)
     yawMat = mathUtils.createRotationMatrix(
         (-self.__aimingSystem.yaw, 0, 0))
     impulseLocal = yawMat.applyVector(adjustedImpulse)
     self.__impulseOscillator.applyImpulse(impulseLocal)
     self.__applyNoiseImpulse(noiseMagnitude)
コード例 #12
0
 def applyImpulse(self, position, impulse, reason=ImpulseReason.ME_HIT):
     adjustedImpulse, noiseMagnitude = self.__dynamicCfg.adjustImpulse(impulse, reason)
     impulseFlatDir = Vector3(adjustedImpulse.x, 0, adjustedImpulse.z)
     impulseFlatDir.normalise()
     cameraYawMat = mathUtils.createRotationMatrix(Vector3(-self.__cameraYaw, 0.0, 0.0))
     impulseLocal = cameraYawMat.applyVector(impulseFlatDir * (-1 * adjustedImpulse.length))
     self.__positionOscillator.applyImpulse(impulseLocal)
     self.__applyNoiseImpulse(noiseMagnitude)
コード例 #13
0
ファイル: strategiccamera.py プロジェクト: kblw/wot_client
 def applyImpulse(self, position, impulse, reason = ImpulseReason.ME_HIT):
     adjustedImpulse, noiseMagnitude = self.__dynamicCfg.adjustImpulse(impulse, reason)
     impulseFlatDir = Vector3(adjustedImpulse.x, 0, adjustedImpulse.z)
     impulseFlatDir.normalise()
     cameraYawMat = mathUtils.createRotationMatrix(Vector3(-StrategicCamera._CAMERA_YAW, 0.0, 0.0))
     impulseLocal = cameraYawMat.applyVector(impulseFlatDir * (-1 * adjustedImpulse.length))
     self.__positionOscillator.applyImpulse(impulseLocal)
     self.__applyNoiseImpulse(noiseMagnitude)
コード例 #14
0
def getAimMatrix(x, y, fov = None):
    if fov is None:
        fov = BigWorld.projection().fov
    near = BigWorld.projection().nearPlane
    aspect = getScreenAspectRatio()
    yLength = near * math.tan(fov * 0.5)
    xLength = yLength * aspect
    result = mathUtils.createRotationMatrix(Math.Vector3(math.atan2(xLength * x, near), math.atan2(yLength * y, near), 0))
    return result
コード例 #15
0
 def __getTurretYawGunPitch(self, targetPos, compensateGravity=False):
     player = BigWorld.player()
     stabilisedMatrix = Math.Matrix(player.inputHandler.steadyVehicleMatrixCalculator.stabilisedMProv)
     turretYaw, gunPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleTypeDescriptor, stabilisedMatrix, targetPos, compensateGravity)
     rotation = mathUtils.createRotationMatrix((turretYaw, gunPitch, 0.0))
     rotation.postMultiply(stabilisedMatrix)
     invertSteady = Math.Matrix(self.__vehicleMProv)
     invertSteady.invert()
     rotation.postMultiply(invertSteady)
     return (rotation.yaw, rotation.pitch)
コード例 #16
0
def computeTransform(confDict):
    matDict = {
        'preRotate': mathUtils.createIdentityMatrix(),
        'postRotate': mathUtils.createIdentityMatrix(),
        'vect': mathUtils.createIdentityMatrix()
    }
    if any(
            isinstance(confDict[confKey][0], tuple)
            for confKey in matDict.keys()):
        for confKey in matDict.keys():
            if isinstance(confDict[confKey][0], tuple):
                keyframes = []
                for keyframe in confDict[confKey]:
                    timeStamp, value = keyframe
                    if 'vect' in confKey:
                        Mat = mathUtils.createTranslationMatrix(value)
                    else:
                        Mat = mathUtils.createRotationMatrix(value)
                    keyframes.append((timeStamp, Mat))
                MatAn = Math.MatrixAnimation()
                MatAn.keyframes = keyframes
                MatAn.time = 0.0
                MatAn.loop = True
            elif 'vect' in confKey:
                MatAn = mathUtils.createTranslationMatrix(confDict[confKey])
            else:
                MatAn = mathUtils.createRotationMatrix(confDict[confKey])
            matDict[confKey] = MatAn

        matProd = mathUtils.MatrixProviders.product(matDict['vect'],
                                                    matDict['postRotate'])
        LightMat = mathUtils.MatrixProviders.product(matDict['preRotate'],
                                                     matProd)
    else:
        preRotate = mathUtils.createRotationMatrix(confDict['preRotate'])
        postRotate = mathUtils.createRotationMatrix(confDict['postRotate'])
        LightMat = mathUtils.createTranslationMatrix(confDict['vect'])
        LightMat.postMultiply(postRotate)
        LightMat.preMultiply(preRotate)
    return LightMat
コード例 #17
0
def StrategicCamera__cameraUpdate( self, *args ):
    replayCtrl = BattleReplay.g_replayCtrl

    if not spgAim.enabled:
        srcMat = mathUtils.createRotationMatrix((0, -math.pi * 0.499, 0))
        self._StrategicCamera__cam.source = srcMat
        self._StrategicCamera__cam.target.b = self._StrategicCamera__aimingSystem.matrix

        BigWorld.projection().nearPlane = spgAim._prevNearPlane
        BigWorld.projection().farPlane = spgAim._prevFarPlane
        BigWorld.projection().fov = StrategicCamera.StrategicCamera.ABSOLUTE_VERTICAL_FOV
        return oldStrategicCamera__cameraUpdate( self )

    return spgAim.onStrategicCameraUpdate(self, *args)
コード例 #18
0
def StrategicCamera__cameraUpdate(self, *args):
    replayCtrl = BattleReplay.g_replayCtrl

    if not spgAim.enabled:
        srcMat = mathUtils.createRotationMatrix((0, -math.pi * 0.499, 0))
        self._StrategicCamera__cam.source = srcMat
        self._StrategicCamera__cam.target.b = self._StrategicCamera__aimingSystem.matrix

        BigWorld.projection().nearPlane = spgAim._prevNearPlane
        BigWorld.projection().farPlane = spgAim._prevFarPlane
        BigWorld.projection(
        ).fov = StrategicCamera.StrategicCamera.ABSOLUTE_VERTICAL_FOV
        return oldStrategicCamera__cameraUpdate(self)

    return spgAim.onStrategicCameraUpdate(self, *args)
コード例 #19
0
ファイル: arcadecamera.py プロジェクト: jamesxia4/wot_client
 def __calcCurOscillatorAcceleration(self, deltaTime):
     vehicle = BigWorld.player().getVehicleAttached()
     if vehicle is None:
         return Vector3(0, 0, 0)
     vehFilter = vehicle.filter
     curVelocity = getattr(vehFilter, 'velocity', Vector3(0.0))
     relativeSpeed = curVelocity.length / vehicle.typeDescriptor.physics['speedLimits'][0]
     if relativeSpeed >= ArcadeCamera._MIN_REL_SPEED_ACC_SMOOTHING:
         self.__accelerationSmoother.maxAllowedAcceleration = self.__dynamicCfg['accelerationThreshold']
     else:
         self.__accelerationSmoother.maxAllowedAcceleration = self.__dynamicCfg['accelerationMax']
     acceleration = self.__accelerationSmoother.update(vehicle, deltaTime)
     yawMat = mathUtils.createRotationMatrix((-self.__aimingSystem.yaw, 0, 0))
     acceleration = yawMat.applyVector(-acceleration)
     oscillatorAcceleration = Vector3(acceleration.x, acceleration.y, acceleration.z)
     return oscillatorAcceleration * self.__dynamicCfg['accelerationSensitivity']
コード例 #20
0
 def _update(self):
     worldMatrix = Matrix(self._cam.invViewMatrix)
     desiredPosition = self.__basisMProv.checkTurretDetachment(
         worldMatrix.translation)
     if desiredPosition is not None:
         self.__position = desiredPosition
     prevPos = Math.Vector3(self.__position)
     delta = self.__calcCurrentDeltaAdjusted()
     self.__updateSenses(delta)
     if self._targetRadiusSensor:
         self.__rotationRadius += self._targetRadiusSensor.currentVelocity * delta
     if self.__isVerticalVelocitySeparated:
         self._verticalMovementSensor.update(delta)
     else:
         self._verticalMovementSensor.currentVelocity = self._movementSensor.currentVelocity.y
         self._verticalMovementSensor.sensitivity = self._movementSensor.sensitivity
     if self._inertiaEnabled:
         self.__inertialMovement(delta)
     else:
         self.__simpleMovement(delta)
     self.__ypr += self.__yprVelocity * delta
     self.__position += self.__velocity * delta
     if self.__rotateAroundPointEnabled:
         self.__position = self.__getAlignedToPointPosition(
             mathUtils.createRotationMatrix(self.__ypr))
     if self._alignerToLand.enabled and not self.__basisMProv.isBound:
         if abs(self.__velocity.y) > 0.1:
             self._alignerToLand.enable(self.__position,
                                        self._alignerToLand.ignoreTerrain)
         self.__position = self._alignerToLand.getAlignedPosition(
             self.__position)
     lookAtPosition = self.__basisMProv.lookAtPosition
     if lookAtPosition is not None:
         self.__ypr = self.__getLookAtYPR(lookAtPosition)
     if self.__cameraInterpolator.active:
         self.__ypr = self.__clampPR(self.__ypr)
     else:
         self.__ypr = self.__clampYPR(self.__ypr)
     self.__position = self._checkSpaceBounds(prevPos, self.__position)
     self._cam.invViewProvider.a = mathUtils.createRTMatrix(
         self.__ypr, self.__position)
     self._cam.invViewProvider.b = self.__basisMProv.matrix
     if self.__cameraInterpolator.active:
         self.__cameraInterpolator.tick()
     BigWorld.projection().fov = self.__calcFov()
     self.__resetSenses()
     return 0.0
コード例 #21
0
ファイル: benchmark.py プロジェクト: webiumsk/WOT-0.9.15.1
def setupTank(chassisFashion, gunFashion, vehicleDesc, worldMatrix, resources):
    print resources
    tank = resources[vehicleDesc.name]
    tank.matrix = worldMatrix
    tanks.append(tank)
    effect = Pixie.create('particles/Tank/exhaust/large_gas_gear.xml')
    tank.node('HP_gunFire').attach(effect)
    tank.node('HP_gunFire').attach(
        BigWorld.Model('helpers/models/position_gizmo.model'))
    tank.node('HP_Track_Exhaus_1').attach(
        BigWorld.Model('helpers/models/unit_cube.model'))
    m = mathUtils.createTranslationMatrix(Vector3(0, 10, 5))
    fakeMatrixes.append(m)
    tank.node('gun').attach(effect.clone(), m)
    BigWorld.addModel(tank)
    recoilDescr = vehicleDesc.gun['recoil']
    recoil = BigWorld.RecoilAnimator(recoilDescr['backoffTime'],
                                     recoilDescr['returnTime'],
                                     recoilDescr['amplitude'],
                                     recoilDescr['lodDist'])
    recoil.basisMatrix = tank.node('G').localMatrix
    recoil = assemblerModule.createGunAnimator(vehicleDesc,
                                               tank.node('G').localMatrix)
    recoil.lodSetting = 10
    tank.node('G', recoil)
    gunFashion.gunLocalMatrix = recoil
    recoil.lodLink = DataLinks.createFloatLink(chassisFashion, 'lastLod')
    swingingAnimator = assemblerModule.createSwingingAnimator(
        vehicleDesc,
        tank.node('hull').localMatrix, worldMatrix)
    chassisFashion.setupSwinging(swingingAnimator, 'hull')
    swingingAnimator.lodLink = DataLinks.createFloatLink(
        chassisFashion, 'lastLod')
    tank.setupFashions([chassisFashion, None, None, gunFashion])
    fashions.append(swingingAnimator)
    tank.node('hull', swingingAnimator)
    animMatrix = Math.MatrixAnimation()
    keys = []
    for x in xrange(100):
        angle = math.pi * 0.5 * (1 if x & 1 else -1)
        keys.append((x * 3, mathUtils.createRotationMatrix((angle, 0, 0))))

    animMatrix.keyframes = tuple(keys)
    tank.node('turret', animMatrix)
    return
コード例 #22
0
 def __cameraUpdate(self):
     deltaTime = self.__updateTime()
     self.__handleMovement()
     aimPoint = Vector3(self.__aimingSystem.aimPoint)
     self.__aimOffset = self.__calculateAimOffset(aimPoint)
     self.__updateTrajectoryDrawer()
     translation, rotation = self.__calculateIdealState(deltaTime)
     self.__interpolateStates(deltaTime, translation, mathUtils.createRotationMatrix(rotation))
     self.__camDist = aimPoint - self.__targetMatrix.translation
     self.__camDist = self.__camDist.length
     self.__cam.source = self.__sourceMatrix
     self.__cam.target.b = self.__targetMatrix
     self.__cam.pivotPosition = Vector3(0, 0, 0)
     BigWorld.player().positionControl.moveTo(aimPoint)
     self.__updateOscillator(deltaTime)
     self.__aimingSystem.update(deltaTime)
     if not self.__autoUpdatePosition:
         self.__dxdydz = Vector3(0, 0, 0)
コード例 #23
0
 def __getRemoteAim(self, allowModeChange=True):
     player = BigWorld.player()
     vehicle = player.getVehicleAttached()
     pos = Math.Vector3(vehicle.position)
     pos += player.remoteCameraSniper.camMatrixTranslation
     camMat = mathUtils.createTranslationMatrix(-pos)
     dir = player.remoteCameraSniper.camMatrixRotation
     getVector3 = getattr(player.filter, 'getVector3', None)
     if getVector3 is not None:
         time = BigWorld.serverTime()
         dirFiltered = getVector3(AVATAR_SUBFILTERS.CAMERA_SNIPER_ROTATION,
                                  time)
         dir = dirFiltered
     else:
         LOG_WARNING(
             "SniperCamera.__getRemoteAim, the filter doesn't have getVector3 method!"
         )
     camMat.postMultiply(mathUtils.createRotationMatrix(dir))
     return camMat
コード例 #24
0
ファイル: strategiccamera.py プロジェクト: kblw/wot_client
 def enable(self, targetPos, saveDist):
     self.__prevTime = BigWorld.time()
     self.__aimingSystem.enable(targetPos)
     srcMat = mathUtils.createRotationMatrix((0.0, -math.pi * 0.499, 0.0))
     self.__cam.source = srcMat
     if not saveDist:
         self.__camDist = self.__cfg['camDist']
     self.__cam.pivotPosition = Math.Vector3(0.0, self.__camDist, 0.0)
     camTarget = Math.MatrixProduct()
     camTarget.b = self.__aimingSystem.matrix
     self.__cam.target = camTarget
     BigWorld.camera(self.__cam)
     BigWorld.player().positionControl.moveTo(self.__aimingSystem.matrix.translation)
     BigWorld.player().positionControl.followCamera(True)
     FovExtended.instance().enabled = False
     BigWorld.projection().fov = StrategicCamera.ABSOLUTE_VERTICAL_FOV
     self.__cameraUpdate()
     self.delayCallback(0.0, self.__cameraUpdate)
     self.__needReset = 1
コード例 #25
0
 def enable(self, targetPos, saveDist):
     self.__prevTime = BigWorld.time()
     self.__aimingSystem.enable(targetPos)
     srcMat = mathUtils.createRotationMatrix((0.0, -math.pi * 0.499, 0.0))
     self.__cam.source = srcMat
     if not saveDist:
         self.__camDist = self.__cfg['camDist']
     self.__cam.pivotPosition = Math.Vector3(0.0, self.__camDist, 0.0)
     camTarget = Math.MatrixProduct()
     camTarget.b = self.__aimingSystem.matrix
     self.__cam.target = camTarget
     self.__cam.wg_applyParams()
     BigWorld.camera(self.__cam)
     BigWorld.player().positionControl.moveTo(self.__aimingSystem.matrix.translation)
     BigWorld.player().positionControl.followCamera(True)
     FovExtended.instance().enabled = False
     BigWorld.projection().fov = StrategicCamera.ABSOLUTE_VERTICAL_FOV
     self.__cameraUpdate()
     self.delayCallback(0.0, self.__cameraUpdate)
     self.__needReset = 1
コード例 #26
0
ファイル: clientbenchmark.py プロジェクト: aevitas/wotsdk
def setupTank(chassisFashion, gunFashion, vehicleDesc, worldMatrix, resources):
    print resources
    tank = resources[vehicleDesc.name]
    tank.matrix = worldMatrix
    tanks.append(tank)
    effect = Pixie.create('particles/Tank/exhaust/large_gas_gear.xml')
    tank.node('HP_gunFire').attach(effect)
    tank.node('HP_gunFire').attach(BigWorld.Model('helpers/models/position_gizmo.model'))
    tank.node('HP_Track_Exhaus_1').attach(BigWorld.Model('helpers/models/unit_cube.model'))
    m = mathUtils.createTranslationMatrix(Vector3(0, 10, 5))
    fakeMatrixes.append(m)
    tank.node('gun').attach(effect.clone(), m)
    BigWorld.addModel(tank)
    recoilDescr = vehicleDesc.gun['recoil']
    recoil = BigWorld.RecoilAnimator(recoilDescr['backoffTime'], recoilDescr['returnTime'], recoilDescr['amplitude'], recoilDescr['lodDist'])
    recoil.basisMatrix = tank.node('G').localMatrix
    recoil = assemblerModule.createGunAnimator(vehicleDesc, tank.node('G').localMatrix)
    recoil.lodSetting = 10
    tank.node('G', recoil)
    gunFashion.gunLocalMatrix = recoil
    recoil.lodLink = DataLinks.createFloatLink(chassisFashion, 'lastLod')
    swingingAnimator = assemblerModule.createSwingingAnimator(vehicleDesc, tank.node('hull').localMatrix, worldMatrix)
    chassisFashion.setupSwinging(swingingAnimator, 'hull')
    swingingAnimator.lodLink = DataLinks.createFloatLink(chassisFashion, 'lastLod')
    tank.setupFashions([chassisFashion,
     None,
     None,
     gunFashion])
    fashions.append(swingingAnimator)
    tank.node('hull', swingingAnimator)
    animMatrix = Math.MatrixAnimation()
    keys = []
    for x in xrange(100):
        angle = math.pi * 0.5 * (1 if x & 1 else -1)
        keys.append((x * 3, mathUtils.createRotationMatrix((angle, 0, 0))))

    animMatrix.keyframes = tuple(keys)
    tank.node('turret', animMatrix)
    return
コード例 #27
0
ファイル: videocamera.py プロジェクト: webiumsk/WoT
 def __update(self):
     worldMatrix = Matrix(self.__cam.invViewMatrix)
     desiredPosition = self.__basisMProv.checkTurretDetachment(worldMatrix.translation)
     if desiredPosition is not None:
         self.__position = desiredPosition
     prevPos = Math.Vector3(self.__position)
     delta = self.__calcCurrentDeltaAdjusted()
     self.__updateSenses(delta)
     self.__rotationRadius += self.__targetRadiusSensor.currentVelocity * delta
     if self.__isVerticalVelocitySeparated:
         self.__verticalMovementSensor.update(delta)
     else:
         self.__verticalMovementSensor.currentVelocity = self.__movementSensor.currentVelocity.y
         self.__verticalMovementSensor.sensitivity = self.__movementSensor.sensitivity
     if self.__inertiaEnabled:
         self.__inertialMovement(delta)
     else:
         self.__simpleMovement(delta)
     self.__ypr += self.__yprVelocity * delta
     self.__position += self.__velocity * delta
     if self.__rotateAroundPointEnabled:
         self.__position = self.__getAlignedToPointPosition(mathUtils.createRotationMatrix(self.__ypr))
     if self.__alignerToLand.enabled and not self.__basisMProv.isBound:
         if abs(self.__velocity.y) > 0.1:
             self.__alignerToLand.enable(self.__position, self.__alignerToLand.ignoreTerrain)
         self.__position = self.__alignerToLand.getAlignedPosition(self.__position)
     lookAtPosition = self.__basisMProv.lookAtPosition
     if lookAtPosition is not None:
         self.__ypr = self.__getLookAtYPR(lookAtPosition)
     self.__ypr = self.__clampYPR(self.__ypr)
     self.__position = self.__checkSpaceBounds(prevPos, self.__position)
     self.__cam.invViewProvider.a = mathUtils.createRTMatrix(self.__ypr, self.__position)
     self.__cam.invViewProvider.b = self.__basisMProv.matrix
     BigWorld.projection().fov = self.__calcFov()
     self.__resetSenses()
     return 0.0
コード例 #28
0
 def __cameraUpdate(self):
     if not (self.__autoUpdateDxDyDz.x == 0.0 and self.__autoUpdateDxDyDz.y
             == 0.0 and self.__autoUpdateDxDyDz.z == 0.0):
         self.__update(self.__autoUpdateDxDyDz.x, self.__autoUpdateDxDyDz.y,
                       self.__autoUpdateDxDyDz.z)
     player = BigWorld.player()
     vehicle = player.getVehicleAttached()
     inertDt = deltaTime = self.measureDeltaTime()
     replayCtrl = BattleReplay.g_replayCtrl
     if replayCtrl.isPlaying:
         repSpeed = replayCtrl.playbackSpeed
         if repSpeed == 0.0:
             inertDt = 0.01
             deltaTime = 0.0
         else:
             inertDt = deltaTime = deltaTime / repSpeed
     self.__aimingSystem.update(deltaTime)
     virginShotPoint = self.__aimingSystem.getThirdPersonShotPoint()
     delta = self.__inputInertia.positionDelta
     sign = delta.dot(Vector3(0, 0, 1))
     self.__inputInertia.update(inertDt)
     delta = (delta - self.__inputInertia.positionDelta).length
     if delta != 0.0:
         self.__cam.setScrollDelta(math.copysign(delta, sign))
     FovExtended.instance().setFovByMultiplier(
         self.__inputInertia.fovZoomMultiplier)
     unshakenPos = self.__inputInertia.calcWorldPos(
         self.__aimingSystem.idealMatrix if self.
         __adCfg['enable'] else self.__aimingSystem.matrix)
     vehMatrix = Math.Matrix(self.__aimingSystem.vehicleMProv)
     vehiclePos = vehMatrix.translation
     fromVehicleToUnshakedPos = unshakenPos - vehiclePos
     deviationBasis = mathUtils.createRotationMatrix(
         Vector3(self.__aimingSystem.yaw, 0, 0))
     impulseDeviation, movementDeviation, oscillationsZoomMultiplier = self.__updateOscillators(
         deltaTime)
     relCamPosMatrix = mathUtils.createTranslationMatrix(impulseDeviation +
                                                         movementDeviation)
     relCamPosMatrix.postMultiply(deviationBasis)
     relCamPosMatrix.translation += fromVehicleToUnshakedPos
     upRotMat = mathUtils.createRotationMatrix(
         Vector3(
             0, 0, -impulseDeviation.x *
             self.__dynamicCfg['sideImpulseToRollRatio'] -
             self.__noiseOscillator.deviation.z))
     upRotMat.postMultiply(relCamPosMatrix)
     self.__cam.up = upRotMat.applyVector(Vector3(0, 1, 0))
     relTranslation = relCamPosMatrix.translation
     shotPoint = self.__calcFocalPoint(virginShotPoint, deltaTime)
     vehToShotPoint = shotPoint - vehiclePos
     if self.__isRemoteCamera and vehicle is not None:
         relTranslation = player.remoteCameraArcade.relTranslation
         vehToShotPoint = player.remoteCameraArcade.shotPoint
         getVector3 = getattr(player.filter, 'getVector3', None)
         if getVector3 is not None:
             time = BigWorld.serverTime()
             relTranslation = getVector3(
                 AVATAR_SUBFILTERS.CAMERA_ARCADE_REL_TRANSLATION, time)
             vehToShotPoint = getVector3(
                 AVATAR_SUBFILTERS.CAMERA_ARCADE_SHOT_POINT, time)
         else:
             LOG_WARNING(
                 "ArcadeCamera.__cameraUpdate, the filter doesn't have getVector3 method!"
             )
     self.__setCameraAimPoint(vehToShotPoint)
     self.__setCameraPosition(relTranslation)
     replayCtrl = BattleReplay.g_replayCtrl
     if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
         aimOffset = replayCtrl.getAimClipPosition()
         if not BigWorld.player().isForcedGuiControlMode() and GUI.mcursor(
         ).inFocus:
             GUI.mcursor().position = aimOffset
     else:
         aimOffset = self.__calcAimOffset(oscillationsZoomMultiplier)
         if replayCtrl.isRecording:
             replayCtrl.setAimClipPosition(aimOffset)
     self.__cam.aimPointClipCoords = aimOffset
     self.__aimOffset = aimOffset
     if vehicle is not None and not player.isObserver():
         vehicle.setArcadeCameraDataForObservers(vehToShotPoint,
                                                 relTranslation)
     if self.__shiftKeySensor is not None:
         self.__shiftKeySensor.update(1.0)
         if self.__shiftKeySensor.currentVelocity.lengthSquared > 0.0:
             self.shiftCamPos(self.__shiftKeySensor.currentVelocity)
             self.__shiftKeySensor.currentVelocity = Math.Vector3()
     return 0.0
コード例 #29
0
 def __init__(self, height, yaw):
     self._matrix = mathUtils.createRotationMatrix((yaw, 0, 0))
     self.__planePosition = Vector3(0, 0, 0)
     self.__height = height
コード例 #30
0
 def __worldYawPitchToTurret(self, worldYaw, worldPitch):
     worldToTurret = Matrix(self.__vehicleMProv)
     worldToTurret.invert()
     worldToTurret.preMultiply(
         mathUtils.createRotationMatrix((worldYaw, worldPitch, 0.0)))
     return (worldToTurret.yaw, worldToTurret.pitch)
コード例 #31
0
 def __worldYawPitchToTurret(self, worldYaw, worldPitch):
     worldToTurret = Matrix(self.__vehicleMProv)
     worldToTurret.invert()
     worldToTurret.preMultiply(mathUtils.createRotationMatrix((worldYaw, worldPitch, 0.0)))
     return (worldToTurret.yaw, worldToTurret.pitch)
コード例 #32
0
 def __init__(self):
     BigWorld.UserDataObject.__init__(self)
     launchDir = mathUtils.createRotationMatrix((self.__dict__['yaw'], self.__dict__['pitch'], 0)).applyToAxis(2)
     launchDir.normalise()
     self.launchVelocity = launchDir * self.speed
コード例 #33
0
 def __init__(self, height, yaw):
     self._matrix = mathUtils.createRotationMatrix((yaw, 0, 0))
     self.__planePosition = Vector3(0, 0, 0)
     self.__height = height
     self.__heightFromPlane = 0.0
コード例 #34
0
 def setYaw(self, yaw):
     self._matrix = mathUtils.createRotationMatrix((yaw, 0, 0))
     self._updateMatrix()
コード例 #35
0
def StrategicCamera__cameraUpdate(self):
    replayCtrl = BattleReplay.g_replayCtrl

    global gSPGSniperEnabled
    if not gSPGSniperEnabled:
        srcMat = mathUtils.createRotationMatrix((0, -math.pi * 0.49, 0))
        self._StrategicCamera__cam.source = srcMat
        self._StrategicCamera__cam.target.b = self._StrategicCamera__aimingSystem.matrix

        if not replayCtrl.isPlaying:
            BigWorld.projection().nearPlane = self._prevNearPlane
            BigWorld.projection().farPlane = self._prevFarPlane
            BigWorld.projection(
            ).fov = StrategicCamera.StrategicCamera.ABSOLUTE_VERTICAL_FOV
        return oldStrategicCamera__cameraUpdate(self)

    distRange = self._StrategicCamera__cfg['distRange'][:]
    if distRange[0] < 20:
        distRange[0] = 20
    distRange[1] = 600

    player = BigWorld.player()
    descr = player.vehicleTypeDescriptor

    shotEnd = self._StrategicCamera__aimingSystem.matrix.translation

    shellVelocity = Math.Vector3(
        self._StrategicCamera__aimingSystem._shellVelocity)
    shellVelocity.normalise()

    srcMat = Math.Matrix()
    srcMat.setRotateYPR((shellVelocity.yaw, -shellVelocity.pitch, 0))
    shift = srcMat.applyVector(
        Math.Vector3(self._StrategicCamera__dxdydz.x, 0,
                     -self._StrategicCamera__dxdydz.y)
    ) * self._StrategicCamera__curSense

    if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
        aimOffset = replayCtrl.getAimClipPosition()
    else:
        aimWorldPos = self._StrategicCamera__aimingSystem.matrix.applyPoint(
            Math.Vector3(0, 0, 0))
        aimOffset = cameras.projectPoint(aimWorldPos)
        if replayCtrl.isRecording:
            replayCtrl.setAimClipPosition(
                Math.Vector2(aimOffset.x, aimOffset.y))

    self._StrategicCamera__aim.offset((aimOffset.x, aimOffset.y))
    shotDescr = BigWorld.player().vehicleTypeDescriptor.shot
    BigWorld.wg_trajectory_drawer().setParams(
        shotDescr['maxDistance'], Math.Vector3(0, -shotDescr['gravity'], 0),
        self._StrategicCamera__aim.offset())
    curTime = BigWorld.time()
    deltaTime = curTime - self._StrategicCamera__prevTime
    self._StrategicCamera__prevTime = curTime

    if replayCtrl.isPlaying:
        if self._StrategicCamera__needReset != 0:
            if self._StrategicCamera__needReset > 1:
                player = BigWorld.player()
                if player.inputHandler.ctrl is not None:
                    player.inputHandler.ctrl.resetGunMarkers()

            self._StrategicCamera__needReset = 0
        else:
            self._StrategicCamera__needReset += 1

        if replayCtrl.isControllingCamera:
            self._StrategicCamera__aimingSystem.updateTargetPos(
                replayCtrl.getGunRotatorTargetPoint())
        else:
            self._StrategicCamera__aimingSystem.handleMovement(
                shift.x, shift.z)
            if shift.x != 0 and shift.z != 0 or self._StrategicCamera__dxdydz.z != 0:
                self._StrategicCamera__needReset = 2

    self._StrategicCamera__aimingSystem.handleMovement(shift.x, shift.z)
    self._StrategicCamera__camDist -= self._StrategicCamera__dxdydz.z * float(
        self._StrategicCamera__curSense)
    maxPivotHeight = (distRange[1] -
                      distRange[0]) / BigWorld._ba_config['spg']['zoomSpeed']
    self._StrategicCamera__camDist = mathUtils.clamp(
        0, maxPivotHeight, self._StrategicCamera__camDist)
    self._StrategicCamera__cfg['camDist'] = self._StrategicCamera__camDist
    if self._StrategicCamera__dxdydz.z != 0 and self._StrategicCamera__onChangeControlMode is not None and mathUtils.almostZero(
            self._StrategicCamera__camDist - maxPivotHeight):
        self._StrategicCamera__onChangeControlMode()
    self._StrategicCamera__updateOscillator(deltaTime)
    if not self._StrategicCamera__autoUpdatePosition:
        self._StrategicCamera__dxdydz = Math.Vector3(0, 0, 0)

    fov = min(6.0 * descr.gun['shotDispersionAngle'], math.pi * 0.5)
    zoomFactor = 1.0 / math.tan(fov * 0.5) / 5.0

    #old scheme
    #zoomDistance = ( self._StrategicCamera__camDist + distRange[0] ) * zoomFactor

    #new scheme
    zoomDistance = distRange[0] * zoomFactor
    fovFactor = self._StrategicCamera__camDist / maxPivotHeight
    fov = fov * (1.0 - fovFactor) + math.radians(20.0) * fovFactor

    cameraOffset = -shellVelocity.scale(zoomDistance)
    cameraPosition = shotEnd + cameraOffset

    collPoint = None
    collPoint = BigWorld.wg_collideSegment(
        player.spaceID, shotEnd -
        shellVelocity.scale(1.0 if shellVelocity.y > 0.0 else distRange[0] *
                            zoomFactor * 0.25), cameraPosition, 128)

    if collPoint is None:
        collPoint = player.arena.collideWithSpaceBB(shotEnd, cameraPosition)
        if collPoint is not None:
            collPoint += shellVelocity
    else:
        collPoint = collPoint[0]

    recalculateDist = False
    if collPoint is not None:
        cameraPosition = collPoint
        cameraOffset = cameraPosition - shotEnd
        recalculateDist = True

    if cameraOffset.length > 700.0:
        cameraOffset.normalise()
        cameraOffset = cameraOffset.scale(700.0)
        cameraPosition = shotEnd + cameraOffset
        recalculateDist = True

    #if recalculateDist:
    #    self._StrategicCamera__camDist = cameraOffset.length / zoomFactor - distRange[0]

    #bb = BigWorld.player().arena.arenaType.boundingBox
    #cameraPositionClamped = _clampPoint2DInBox2D(bb[0] - Math.Vector2( 50.0, 50.0 ), bb[1] + Math.Vector2( 50.0, 50.0 ), Math.Vector2(cameraPosition.x, cameraPosition.z))

    #if abs( cameraPositionClamped.x - cameraPosition.x ) > 0.1 or abs( cameraPositionClamped.y - cameraPosition.z ) > 0.1:
    #    clampFactor = min( ( cameraPositionClamped.x - shotEnd.x ) / cameraOffset.x if abs( cameraOffset.x ) > 0.001 else 1.0, ( cameraPositionClamped.y - shotEnd.z ) / cameraOffset.z if abs( cameraOffset.z ) > 0.001 else 1.0 )
    #else:
    #    clampFactor = 1.0

    #if clampFactor < 0.99:
    #    cameraOffset *= clampFactor
    #    cameraPosition = shotEnd + cameraOffset
    #    self._StrategicCamera__camDist = cameraOffset.length / zoomFactor - distRange[0]

    trgMat = Math.Matrix()
    trgMat.setTranslate(cameraPosition)

    self._StrategicCamera__cam.source = srcMat
    self._StrategicCamera__cam.target.b = trgMat
    self._StrategicCamera__cam.pivotPosition = Math.Vector3(0, 0, 0)

    delta = self._prevFarPlane - self._prevNearPlane

    BigWorld.projection().nearPlane = max(cameraOffset.length - delta * 0.5,
                                          1.0)
    BigWorld.projection().farPlane = max(cameraOffset.length + delta * 0.5,
                                         self._prevFarPlane)
    BigWorld.projection().fov = fov
    BigWorld.player().positionControl.moveTo(shotEnd)

    #LOG_ERROR( '{0} {1}'.format( cameraPosition, self._StrategicCamera__camDist ) )
    #FLUSH_LOG( )

    return 0
コード例 #36
0
 def applyImpulse(self, position, impulse, reason = ImpulseReason.ME_HIT):
     adjustedImpulse, noiseMagnitude = self.__dynamicCfg.adjustImpulse(impulse, reason)
     yawMat = mathUtils.createRotationMatrix((-self.__aimingSystem.yaw, 0, 0))
     impulseLocal = yawMat.applyVector(adjustedImpulse)
     self.__impulseOscillator.applyImpulse(impulseLocal)
     self.__applyNoiseImpulse(noiseMagnitude)
コード例 #37
0
 def __init__(self):
     BigWorld.UserDataObject.__init__(self)
     launchDir = mathUtils.createRotationMatrix((self.__dict__['yaw'], self.__dict__['pitch'], 0)).applyToAxis(2)
     launchDir.normalise()
     self.launchVelocity = launchDir * self.speed