def __init__(self, deliveryPoint, dropAltitude, dropTime):
CallbackDelayer.__init__(self)
angle = random.random() * 2 * math.pi
self.__flightYaw = angle
rotationMatrix = math_utils.createRotationMatrix((angle, 0, 0))
dropPoint = deliveryPoint + Math.Vector3(0, dropAltitude, 0)
beginPosition = dropPoint - rotationMatrix.applyVector(
self.ARRIVAL_TRAJECTORY_INCLINATION)
flatFlyVelocity = rotationMatrix.applyToAxis(2) * self.FLIGHT_SPEED
beginPointDesc = CurveControlPoint(
beginPosition, flatFlyVelocity,
dropTime - self.FLY_TIME_BEFORE_DROP)
dropPointDesc = CurveControlPoint(dropPoint, flatFlyVelocity, dropTime)
dropPlaneConfig = self.__dynamicObjectsCache.getConfig(
self.__sessionProvider.arenaVisitor.getArenaGuiType(
)).getDropPlane()
spaceId = BigWorld.player().spaceID
compoundName = 'dropPlaneModel'
modelAssembler = BigWorld.CompoundAssembler(compoundName, spaceId)
modelAssembler.addRootPart(dropPlaneConfig.model, 'root')
animationBuilder = AnimationSequence.Loader(
dropPlaneConfig.flyAnimation, spaceId)
planeDesc = BomberDesc(modelAssembler, dropPlaneConfig.sound,
beginPointDesc, dropPointDesc, animationBuilder)
self.dropPlane = CompoundBomber(planeDesc)
endPosition = dropPoint + rotationMatrix.applyVector(
self.DEPARTURE_TRAJECTORY_INCLINATION)
self.dropPlane.addControlPoint(endPosition, flatFlyVelocity,
dropTime + self.FLY_TIME_AFTER_DROP)
delayTime = dropTime - BigWorld.time() - self.FLY_TIME_BEFORE_DROP
self.delayCallback(delayTime, self.__openCargo)
self.delayCallback(delayTime + self.UNLOAD_ANIMATION_TIME,
self.__closeCargo)
self.prevTime = BigWorld.time()
def __cameraUpdate(self):
deltaTime = self.__updateTime()
self.__aimOffset = self.__calculateAimOffset(
self.__aimingSystem.aimPoint)
self.__handleMovement()
aimPoint = Vector3(self.__aimingSystem.aimPoint)
self.__updateTrajectoryDrawer()
rotation, desiredDistance, collisionDist = self.__calculateIdealState(
deltaTime)
self.__interpolateStates(deltaTime,
math_utils.createRotationMatrix(rotation),
desiredDistance, collisionDist)
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)
if aimPoint.distSqrTo(self.__prevAimPoint) > 0.010000000000000002:
BigWorld.player().positionControl.moveTo(aimPoint)
self.__prevAimPoint = aimPoint
self.__updateOscillator(deltaTime)
self.__aimingSystem.update(deltaTime)
if self.__onChangeControlMode is not None and self.__switchers.needToSwitch(
self.__dxdydz.z, self.__desiredCamDist,
self._cfg['distRange'][0], self._cfg['distRange'][1],
self._cfg['transitionDist']):
self.__onChangeControlMode(*self.__switchers.getSwitchParams())
if not self.__transitionEnabled and self.__desiredCamDist - TRANSITION_DIST_HYSTERESIS <= self._cfg[
'transitionDist']:
self.__transitionEnabled = True
self.__enableSwitchers(False)
if not self.__autoUpdatePosition:
self.__dxdydz = Vector3(0, 0, 0)
return 0.01
def __init__(self, height, yaw):
super(BaseStrategicAimingSystem, self).__init__()
self._matrix = math_utils.createRotationMatrix((yaw, 0, 0))
self._planePosition = Vector3(0, 0, 0)
self.__camDist = 0.0
self.__height = height
self.__heightFromPlane = 0.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 = math_utils.createRotationMatrix(Vector3(-self.__cameraYaw, 0.0, 0.0))
impulseLocal = cameraYawMat.applyVector(impulseFlatDir * (-1 * adjustedImpulse.length))
self.__positionOscillator.applyImpulse(impulseLocal)
self.__applyNoiseImpulse(noiseMagnitude)
def applyImpulse(self, position, impulse, reason=ImpulseReason.ME_HIT):
adjustedImpulse, noiseMagnitude = self.__dynamicCfg.adjustImpulse(
impulse, reason)
yawMat = math_utils.createRotationMatrix(
(-self.__aimingSystem.yaw, 0, 0))
impulseLocal = yawMat.applyVector(adjustedImpulse)
self.__impulseOscillator.applyImpulse(impulseLocal)
self.__applyNoiseImpulse(noiseMagnitude)
def __getMovementDirections(self):
m = math_utils.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
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 = math_utils.createRotationMatrix(Math.Vector3(math.atan2(xLength * x, near), math.atan2(yLength * y, near), 0))
return result
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 = math_utils.createRotationMatrix((turretYaw, gunPitch, 0.0))
rotation.postMultiply(stabilisedMatrix)
invertSteady = Math.Matrix(self._vehicleMProv)
invertSteady.invert()
rotation.postMultiply(invertSteady)
return (rotation.yaw, rotation.pitch)
def rotateGunToDefault(self):
if self.compoundModel is None:
return False
else:
localGunMatrix = self.__getGunNode().local
currentGunPitch = localGunMatrix.pitch
gunPitchAngle = self._getGunPitch()
if abs(currentGunPitch - gunPitchAngle) < 0.0001:
return False
gunPitchMatrix = math_utils.createRotationMatrix((0.0, gunPitchAngle, 0.0))
self.__setGunMatrix(gunPitchMatrix)
return True
def __updateOscillators(self, deltaTime):
if not SniperCamera.isCameraDynamic():
self.__impulseOscillator.reset()
self.__movementOscillator.reset()
self.__noiseOscillator.reset()
return (math_utils.createRotationMatrix(Vector3(0, 0, 0)),
math_utils.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 (math_utils.createRotationMatrix(
Vector3(deviation.x, deviation.y, deviation.z)),
math_utils.createRotationMatrix(impulseDeviation))
def computeTransform(confDict):
matDict = {
'preRotate': math_utils.createIdentityMatrix(),
'postRotate': math_utils.createIdentityMatrix(),
'vect': math_utils.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 = math_utils.createTranslationMatrix(value)
else:
Mat = math_utils.createRotationMatrix(value)
keyframes.append((timeStamp, Mat))
MatAn = Math.MatrixAnimation()
MatAn.keyframes = keyframes
MatAn.time = 0.0
MatAn.loop = True
elif 'vect' in confKey:
MatAn = math_utils.createTranslationMatrix(confDict[confKey])
else:
MatAn = math_utils.createRotationMatrix(confDict[confKey])
matDict[confKey] = MatAn
matProd = math_utils.MatrixProviders.product(matDict['vect'],
matDict['postRotate'])
LightMat = math_utils.MatrixProviders.product(matDict['preRotate'],
matProd)
else:
preRotate = math_utils.createRotationMatrix(confDict['preRotate'])
postRotate = math_utils.createRotationMatrix(confDict['postRotate'])
LightMat = math_utils.createTranslationMatrix(confDict['vect'])
LightMat.postMultiply(postRotate)
LightMat.preMultiply(preRotate)
return LightMat
def _getTurretYawGunPitch(self, targetPos, compensateGravity=False):
vehicleMatrix = Matrix(self._vehicleMProv)
turretOffset = GunMatCalc.turretOffset(self._vehicleTypeDescriptor)
gunShotOffset = GunMatCalc.gunShotOffset(self._vehicleTypeDescriptor, self.__gunIndex)
speed = self._vehicleTypeDescriptor.shot.speed
gravity = self._vehicleTypeDescriptor.shot.gravity if not compensateGravity else 0.0
turretYaw, gunPitch = BigWorld.wg_getShotAngles(turretOffset, gunShotOffset, vehicleMatrix, speed, gravity, 0.0, 0.0, targetPos, False)
rotation = math_utils.createRotationMatrix((turretYaw, gunPitch, 0.0))
rotation.postMultiply(vehicleMatrix)
invertSteady = Matrix(self._vehicleMProv)
invertSteady.invert()
rotation.postMultiply(invertSteady)
return (rotation.yaw, rotation.pitch)
def getDynamicPitchLimits(self, turretYaw=0.0):
def _getCorrectGunPitch(vehicleMatrix, turretYaw, gunPitch, overrideTurretLocalZ=None):
turretMat = AimingSystems.getTurretJointMat(self._vehicleTypeDescriptor, vehicleMatrix, turretYaw, overrideTurretLocalZ)
gunMat = AimingSystems.getGunJointMat(self._vehicleTypeDescriptor, turretMat, gunPitch, overrideTurretLocalZ)
return gunMat.pitch
typeDescr = self._vehicleTypeDescriptor
gunLimits = typeDescr.gun.pitchLimits
gunAngleMin = gunLimits['minPitch'][0][1]
gunAngleMax = gunLimits['maxPitch'][0][1]
hullAngleMin = typeDescr.type.hullAimingParams['pitch']['wheelsCorrectionAngles']['pitchMin']
hullAngleMax = typeDescr.type.hullAimingParams['pitch']['wheelsCorrectionAngles']['pitchMax']
isBackTurretSector = turretYaw < math.pi * -0.5 or turretYaw > math.pi * 0.5
if isBackTurretSector:
hullAngleMin, hullAngleMax = hullAngleMax, hullAngleMin
hullMatrixAngleMin = math_utils.createRotationMatrix((0, hullAngleMin, 0))
hullMatrixAngleMax = math_utils.createRotationMatrix((0, hullAngleMax, 0))
maxPitch = _getCorrectGunPitch(hullMatrixAngleMax, turretYaw, gunAngleMax)
minPitch = _getCorrectGunPitch(hullMatrixAngleMin, turretYaw, gunAngleMin)
return {'absolute': (minPitch, maxPitch),
'maxPitch': ((0.0, maxPitch), (math.pi * 2.0, maxPitch)),
'minPitch': ((0.0, minPitch), (math.pi * 2.0, minPitch))}
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(
math_utils.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 BigWorld.camera(
) == self.__cameraTransition and self.__cameraTransition.isInTransition(
):
self.__ypr = self.__clampPR(self.__ypr)
else:
self.__ypr = self.__clampYPR(self.__ypr)
self.__position = self._checkSpaceBounds(prevPos, self.__position)
self._cam.invViewProvider.a = math_utils.createRTMatrix(
self.__ypr, self.__position)
self._cam.invViewProvider.b = self.__basisMProv.matrix
BigWorld.projection().fov = self.__calcFov()
self.__resetSenses()
return 0.0
def enable(self,
targetPos,
saveDist,
switchToPos=None,
switchToPlace=None):
BigWorld.wg_trajectory_drawer().setStrategicMode(False)
self.__prevTime = 0.0
if switchToPlace == SwitchToPlaces.TO_TRANSITION_DIST:
self.__camDist = math_utils.clamp(self._cfg['distRange'][0],
self._cfg['distRange'][1],
self._cfg['transitionDist'])
elif switchToPlace == SwitchToPlaces.TO_RELATIVE_POS and switchToPos is not None:
minDist, maxDist = self._cfg['distRange']
self.__camDist = (maxDist - minDist) * switchToPos + minDist
elif switchToPlace == SwitchToPlaces.TO_NEAR_POS and switchToPos is not None:
minDist, maxDist = self._cfg['distRange']
self.__camDist = math_utils.clamp(minDist, maxDist, switchToPos)
elif self.settingsCore.getSetting(SPGAim.AUTO_CHANGE_AIM_MODE):
self.__camDist = math_utils.clamp(self._cfg['distRange'][0],
self._cfg['transitionDist'],
self.__camDist)
self.__desiredCamDist = self.__camDist
self.__scrollSmoother.start(self.__desiredCamDist)
self.__enableSwitchers()
self.__aimingSystem.enable(targetPos)
self.__positionHysteresis.update(Vector3(0.0, 0.0, 0.0))
self.__timeHysteresis.update(BigWorld.timeExact())
camTarget = MatrixProduct()
self.__rotation = max(self.__aimingSystem.direction.pitch,
self._cfg['minimalPitch'])
cameraDirection = self.__getCameraDirection()
self.__targetMatrix.translation = self.aimingSystem.aimPoint - cameraDirection.scale(
self.__camDist)
self.__cam.target = camTarget
self.__cam.target.b = self.__targetMatrix
self.__sourceMatrix = math_utils.createRotationMatrix(
(cameraDirection.yaw, -cameraDirection.pitch, 0.0))
self.__cam.source = self.__sourceMatrix
self.__cam.forceUpdate()
BigWorld.camera(self.__cam)
BigWorld.player().positionControl.moveTo(self.__aimingSystem.hitPoint)
BigWorld.player().positionControl.followCamera(False)
self.__cameraUpdate()
self.delayCallback(0.01, self.__cameraUpdate)
self.__needReset = 1
return
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,
math_utils.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)
if aimPoint.distSqrTo(self.__prevAimPoint) > 0.010000000000000002:
BigWorld.player().positionControl.moveTo(aimPoint)
self.__prevAimPoint = aimPoint
self.__updateOscillator(deltaTime)
self.__aimingSystem.update(deltaTime)
if not self.__autoUpdatePosition:
self.__dxdydz = Vector3(0, 0, 0)
def __calcCurOscillatorAcceleration(self, deltaTime):
vehicle = BigWorld.player().getVehicleAttached()
if vehicle is None:
return Vector3(0, 0, 0)
else:
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 = math_utils.createRotationMatrix(
(-self.__aimingSystem.yaw, 0, 0))
acceleration = yawMat.applyVector(-acceleration)
oscillatorAcceleration = Vector3(acceleration.x, acceleration.y,
acceleration.z)
return oscillatorAcceleration * self.__dynamicCfg[
'accelerationSensitivity']
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(),
BigWorld.WGBaseFashion(),
BigWorld.WGBaseFashion(),
BigWorld.WGBaseFashion())
model_assembler.setupTracksFashion(self.__vDesc,
self.__fashions.chassis)
self.__vEntity.model.setupFashions(self.__fashions)
model_assembler.assembleCollisionObstaclesCollector(
self, None, self.__vDesc,
BigWorld.player().spaceID)
model_assembler.assembleTessellationCollisionSensor(self, None)
wheelsScroll = None
wheelsSteering = None
if self.__vDesc.chassis.generalWheelsAnimatorConfig is not None:
scrollableWheelsCount = self.__vDesc.chassis.generalWheelsAnimatorConfig.getWheelsCount(
)
wheelsScroll = [(lambda: 0.0)
for _ in xrange(scrollableWheelsCount)]
steerableWheelsCount = self.__vDesc.chassis.generalWheelsAnimatorConfig.getSteerableWheelsCount(
)
wheelsSteering = [(lambda: 0.0)
for _ in xrange(steerableWheelsCount)]
chassisFashion = self.__fashions.chassis
splineTracksImpl = model_assembler.setupSplineTracks(
chassisFashion, self.__vDesc, self.__vEntity.model,
self.__resources, self.__outfit.modelsSet)
self.wheelsAnimator = model_assembler.createWheelsAnimator(
self, ColliderTypes.VEHICLE_COLLIDER, self.__vDesc, lambda: 0,
wheelsScroll, wheelsSteering, splineTracksImpl)
self.trackNodesAnimator = model_assembler.createTrackNodesAnimator(
self, self.__vDesc)
model_assembler.assembleTracks(self.__resources, self.__vDesc,
self, splineTracksImpl, True)
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 = self.createComponent(
Vehicular.DirtComponent, dirtHandlers, modelHeight)
for fashionIdx, _ in enumerate(TankPartNames.ALL):
self.__fashions[fashionIdx].addMaterialHandler(
dirtHandlers[fashionIdx])
self.dirtComponent.setBase()
outfitData = camouflages.getOutfitData(
self, self.__outfit, self.__vDesc,
self.__vState != 'undamaged')
self.c11nComponent = self.createComponent(
Vehicular.C11nEditComponent, self.__fashions,
self.compoundModel, outfitData)
self.__updateDecals(self.__outfit)
self.__updateSequences(self.__outfit)
else:
self.__fashions = VehiclePartsTuple(BigWorld.WGVehicleFashion(),
BigWorld.WGBaseFashion(),
BigWorld.WGBaseFashion(),
BigWorld.WGBaseFashion())
self.__vEntity.model.setupFashions(self.__fashions)
self.wheelsAnimator = None
self.trackNodesAnimator = None
self.dirtComponent = None
self.flagComponent = None
self.__staticTurretYaw = self.__vDesc.gun.staticTurretYaw
self.__staticGunPitch = self.__vDesc.gun.staticPitch
if not ('AT-SPG' in self.__vDesc.type.tags
or 'SPG' in self.__vDesc.type.tags):
if self.__staticTurretYaw is None:
self.__staticTurretYaw = self._getTurretYaw()
turretYawLimits = self.__vDesc.gun.turretYawLimits
if turretYawLimits is not None:
self.__staticTurretYaw = math_utils.clamp(
turretYawLimits[0], turretYawLimits[1],
self.__staticTurretYaw)
if self.__staticGunPitch is None:
self.__staticGunPitch = self._getGunPitch()
gunPitchLimits = self.__vDesc.gun.pitchLimits['absolute']
self.__staticGunPitch = math_utils.clamp(
gunPitchLimits[0], gunPitchLimits[1],
self.__staticGunPitch)
else:
if self.__staticTurretYaw is None:
self.__staticTurretYaw = 0.0
if self.__staticGunPitch is None:
self.__staticGunPitch = 0.0
turretYawMatrix = math_utils.createRotationMatrix(
(self.__staticTurretYaw, 0.0, 0.0))
self.__vEntity.model.node(TankPartNames.TURRET, turretYawMatrix)
gunPitchMatrix = math_utils.createRotationMatrix(
(0.0, self.__staticGunPitch, 0.0))
self.__setGunMatrix(gunPitchMatrix)
return
def __init__(self, yaw, dropPoint, endPoint, descendTime):
self.__matrix = math_utils.createRotationMatrix((yaw, 0, 0))
self.easing = Easing.linearEasing(dropPoint, endPoint, descendTime)
self.prevTime = BigWorld.time()
self.tick()
def __worldYawPitchToTurret(self, worldYaw, worldPitch):
worldToTurret = Math.Matrix(self._vehicleMProv)
worldToTurret.invert()
worldToTurret.preMultiply(
math_utils.createRotationMatrix((worldYaw, worldPitch, 0.0)))
return (worldToTurret.yaw, worldToTurret.pitch)
def __updateCameraYaw(self):
altModeEnabled = self.settingsCore.getSetting(settings_constants.SPGAim.SPG_STRATEGIC_CAM_MODE) == 1
pitch = -math.pi * 0.499 if not altModeEnabled else math.radians(-88.0)
self.__cameraYaw = round(self.aimingSystem.getCamYaw(), _CAM_YAW_ROUND)
srcMat = math_utils.createRotationMatrix((self.__cameraYaw, pitch, 0.0))
self.__cam.source = srcMat
def __init__(self):
BigWorld.UserDataObject.__init__(self)
launchDir = math_utils.createRotationMatrix(
(self.__dict__['yaw'], self.__dict__['pitch'], 0)).applyToAxis(2)
launchDir.normalise()
self.__launchVelocity = launchDir * self.speed
def __updateTurretMatrix(self, yaw, time):
m = math_utils.createRotationMatrix((yaw, 0.0, 0.0))
self.__turretMatrixAnimator.update(m, time)
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.matrix)
vehMatrix = Math.Matrix(self.__aimingSystem.vehicleMProv)
vehiclePos = vehMatrix.translation
fromVehicleToUnshakedPos = unshakenPos - vehiclePos
deviationBasis = math_utils.createRotationMatrix(
Vector3(self.__aimingSystem.yaw, 0, 0))
impulseDeviation, movementDeviation, oscillationsZoomMultiplier = self.__updateOscillators(
deltaTime)
relCamPosMatrix = math_utils.createTranslationMatrix(impulseDeviation +
movementDeviation)
relCamPosMatrix.postMultiply(deviationBasis)
relCamPosMatrix.translation += fromVehicleToUnshakedPos
upRotMat = math_utils.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
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 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
def setYaw(self, yaw):
self._matrix = math_utils.createRotationMatrix((yaw, 0, 0))
self._updateMatrix()
