def __calculateIdealState(self, deltaTime):
aimPoint = self.__aimingSystem.aimPoint
direction = self.__aimingSystem.direction
impactPitch = max(direction.pitch, self.__cfg['minimalPitch'])
self.__rotation = max(self.__rotation, impactPitch)
distRange = self.__cfg['distRange']
distanceCurSq = (
aimPoint -
BigWorld.player().getVehicleAttached().position).lengthSquared
distanceMinSq = distRange[0]**2.0
forcedPitch = impactPitch
if distanceCurSq < distanceMinSq:
forcedPitch = atan2(sqrt(distanceMinSq - distanceCurSq),
sqrt(distanceCurSq))
angularShift = self.__cfg['angularSpeed'] * deltaTime
angularShift = angularShift if self.__choosePitchLevel(
aimPoint) else -angularShift
minPitch = max(forcedPitch, impactPitch)
maxPitch = max(forcedPitch, self.__cfg['maximalPitch'])
self.__rotation = mathUtils.clamp(minPitch, maxPitch,
self.__rotation + angularShift)
desiredDistance = self.__getDesiredCameraDistance()
cameraDirection = self.__getCameraDirection()
desiredDistance = self.__resolveCollisions(aimPoint, desiredDistance,
cameraDirection)
desiredDistance = mathUtils.clamp(distRange[0], distRange[1],
desiredDistance)
translation = aimPoint - cameraDirection.scale(desiredDistance)
rotation = Vector3(cameraDirection.yaw, -cameraDirection.pitch, 0.0)
return (translation, rotation)
def setCameraLocation(self, targetPos = None, pivotPos = None, yaw = None, pitch = None, dist = None, ignoreConstraints = False):
sourceMat = Math.Matrix(self.__cam.source)
if yaw is None:
yaw = sourceMat.yaw
if pitch is None:
pitch = sourceMat.pitch
if dist is None:
dist = self.__cam.pivotMaxDist
if not ignoreConstraints:
yaw = self.__yawCameraFilter.toLimit(yaw)
pitch = mathUtils.clamp(math.radians(_CFG['cam_pitch_constr'][0]), math.radians(_CFG['cam_pitch_constr'][1]), pitch)
if self.__selectedEmblemInfo is not None:
dist = mathUtils.clamp(self.__camDistConstr[1][0], self.__camDistConstr[1][1], dist)
else:
dist = mathUtils.clamp(self.__camDistConstr[0][0], self.__camDistConstr[0][1], dist)
if self.__boundingRadius is not None:
dist = dist if dist > self.__boundingRadius else self.__boundingRadius
mat = Math.Matrix()
pitch = mathUtils.clamp(-math.pi / 2 * 0.99, math.pi / 2 * 0.99, pitch)
mat.setRotateYPR((yaw, pitch, 0.0))
self.__cam.source = mat
self.__cam.pivotMaxDist = dist
if targetPos is not None:
self.__cam.target.setTranslate(targetPos)
if pivotPos is not None:
self.__cam.pivotPosition = pivotPos
return
def updateCameraByMouseMove(self, dx, dy, dz):
sourceMat = Math.Matrix(self.__cam.source)
yaw = sourceMat.yaw
pitch = sourceMat.pitch
dist = self.__cam.pivotMaxDist
yaw += dx * _CFG['cam_sens']
pitch -= dy * _CFG['cam_sens']
dist -= dz * _CFG['cam_sens']
if yaw > 2.0 * math.pi:
yaw -= 2.0 * math.pi
elif yaw < -2.0 * math.pi:
yaw += 2.0 * math.pi
pitch = mathUtils.clamp(math.radians(_CFG['cam_pitch_constr'][0]),
math.radians(_CFG['cam_pitch_constr'][1]),
pitch)
prevDist = dist
dist = mathUtils.clamp(_CFG['cam_dist_constr'][0],
_CFG['cam_dist_constr'][1], dist)
if self.__boundingRadius is not None:
dist = dist if dist > self.__boundingRadius else self.__boundingRadius
if dist > prevDist and dz > 0:
if self.__selectedEmblemInfo is not None:
self.locateCameraOnEmblem(*self.__selectedEmblemInfo)
return
mat = Math.Matrix()
mat.setRotateYPR((yaw, pitch, 0.0))
self.__cam.source = mat
self.__cam.pivotMaxDist = dist
return
def setCameraLocation(self, targetPos = None, pivotPos = None, yaw = None, pitch = None, dist = None, ignoreConstraints = False):
sourceMat = Math.Matrix(self.__cam.source)
if yaw is None:
yaw = sourceMat.yaw
if pitch is None:
pitch = sourceMat.pitch
if dist is None:
dist = self.__cam.pivotMaxDist
if not ignoreConstraints:
if yaw > 2.0 * math.pi:
yaw -= 2.0 * math.pi
elif yaw < -2.0 * math.pi:
yaw += 2.0 * math.pi
pitch = mathUtils.clamp(math.radians(_CFG['cam_pitch_constr'][0]), math.radians(_CFG['cam_pitch_constr'][1]), pitch)
dist = mathUtils.clamp(_CFG['cam_dist_constr'][0], _CFG['cam_dist_constr'][1], dist)
if self.__boundingRadius is not None:
dist = dist if dist > self.__boundingRadius else self.__boundingRadius
mat = Math.Matrix()
pitch = mathUtils.clamp(-math.pi / 2 * 0.99, math.pi / 2 * 0.99, pitch)
mat.setRotateYPR((yaw, pitch, 0.0))
self.__cam.source = mat
self.__cam.pivotMaxDist = dist
if targetPos is not None:
self.__cam.target.setTranslate(targetPos)
if pivotPos is not None:
self.__cam.pivotPosition = pivotPos
def updateCameraByMouseMove(self, dx, dy, dz):
if self.__selectedEmblemInfo is not None:
self.__cam.target.setTranslate(_CFG['preview_cam_start_target_pos'])
self.__cam.pivotPosition = _CFG['preview_cam_pivot_pos']
sourceMat = Math.Matrix(self.__cam.source)
yaw = sourceMat.yaw
pitch = sourceMat.pitch
dist = self.__cam.pivotMaxDist
yaw += dx * _CFG['cam_sens']
pitch -= dy * _CFG['cam_sens']
dist -= dz * _CFG['cam_sens']
if yaw > 2.0 * math.pi:
yaw -= 2.0 * math.pi
elif yaw < -2.0 * math.pi:
yaw += 2.0 * math.pi
pitch = mathUtils.clamp(math.radians(_CFG['cam_pitch_constr'][0]), math.radians(_CFG['cam_pitch_constr'][1]), pitch)
prevDist = dist
dist = mathUtils.clamp(_CFG['cam_dist_constr'][0], _CFG['cam_dist_constr'][1], dist)
if self.__boundingRadius is not None:
dist = dist if dist > self.__boundingRadius else self.__boundingRadius
if dist > prevDist and dz > 0:
if self.__selectedEmblemInfo is not None:
self.locateCameraOnEmblem(*self.__selectedEmblemInfo)
return
mat = Math.Matrix()
mat.setRotateYPR((yaw, pitch, 0.0))
self.__cam.source = mat
self.__cam.pivotMaxDist = dist
def __updateCameraByMouseMove(self, dx, dy, dz):
if self.__cam is not BigWorld.camera():
return
sourceMat = Math.Matrix(self.__cam.source)
yaw = sourceMat.yaw
pitch = sourceMat.pitch
dist = self.__cam.pivotMaxDist
currentMatrix = Math.Matrix(self.__cam.invViewMatrix)
currentYaw = currentMatrix.yaw
yaw = self.__yawCameraFilter.getNextYaw(currentYaw, yaw, dx)
from gui.ClientHangarSpace import hangarCFG
cfg = hangarCFG()
pitch -= dy * cfg['cam_sens']
dist -= dz * cfg['cam_dist_sens']
camPitchConstr = self.__camConstraints[0]
startPitch, endPitch = camPitchConstr
pitch = mathUtils.clamp(math.radians(startPitch), math.radians(endPitch), pitch)
distConstr = cfg['preview_cam_dist_constr'] if self.__selectedEmblemInfo else self.__camConstraints[2]
minDist, maxDist = distConstr
dist = mathUtils.clamp(minDist, maxDist, dist)
self.__locatedOnEmbelem = False
mat = Math.Matrix()
mat.setRotateYPR((yaw, pitch, 0.0))
self.__cam.source = mat
self.__cam.pivotMaxDist = dist
if self.settingsCore.getSetting('dynamicFov') and abs(distConstr[1] - distConstr[0]) > 0.001:
relativeDist = (dist - distConstr[0]) / (distConstr[1] - distConstr[0])
_, minFov, maxFov = self.settingsCore.getSetting('fov')
fov = mathUtils.lerp(minFov, maxFov, relativeDist)
BigWorld.callback(0, partial(FovExtended.instance().setFovByAbsoluteValue, math.radians(fov), 0.1))
def __inLimit(self, prevYaw, newYaw, newPitch):
if self.__yawLimits is not None:
prevYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1],
prevYaw)
newYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1],
newYaw)
prevPitchLimits = calcPitchLimitsFromDesc(prevYaw, self.__pitchLimits)
pitchLimits = calcPitchLimitsFromDesc(newYaw, self.__pitchLimits)
if SniperAimingSystem.__FILTER_ENABLED:
pitchLimitsMin = pitchLimits[0] + self.__pitchDeviation[0]
pitchLimitsMax = pitchLimits[1] + self.__pitchDeviation[1]
prevLimMin = prevPitchLimits[0] + self.__pitchDeviation[0]
prevLimMax = prevPitchLimits[1] + self.__pitchDeviation[1]
else:
pitchLimitsMin = pitchLimits[0]
pitchLimitsMax = pitchLimits[1]
prevLimMin = prevPitchLimits[0]
prevLimMax = prevPitchLimits[1]
prevLimitedPitch = mathUtils.clamp(prevLimMin, prevLimMax, newPitch)
limitedPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax,
newPitch)
dp = limitedPitch - prevLimitedPitch
return (newYaw, limitedPitch,
pitchLimitsMin <= newPitch <= pitchLimitsMax, pitchLimitsMin,
dp)
def __calcAimOffset(self, aimLocalTransform = None):
worldCrosshair = Matrix(self.__crosshairMatrix)
aimingSystemMatrix = self.__aimingSystem.matrix
if aimLocalTransform is not None:
worldCrosshair.postMultiply(aimLocalTransform)
worldCrosshair.postMultiply(aimingSystemMatrix)
aimOffset = cameras.projectPoint(worldCrosshair.translation)
return Vector2(mathUtils.clamp(-0.95, 0.95, aimOffset.x), mathUtils.clamp(-0.95, 0.95, aimOffset.y))
def __calcAimOffset(self, aimLocalTransform = None):
worldCrosshair = Matrix(self.__crosshairMatrix)
aimingSystemMatrix = self.__aimingSystem.matrix
if aimLocalTransform is not None:
worldCrosshair.postMultiply(aimLocalTransform)
worldCrosshair.postMultiply(aimingSystemMatrix)
aimOffset = cameras.projectPoint(worldCrosshair.translation)
return Vector2(mathUtils.clamp(-0.95, 0.95, aimOffset.x), mathUtils.clamp(-0.95, 0.95, aimOffset.y))
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
def __clampToLimits(self, turretYaw, gunPitch):
if self.__yawLimits is not None:
turretYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], turretYaw)
desc = BigWorld.player().vehicleTypeDescriptor
pitchLimits = calcPitchLimitsFromDesc(turretYaw, desc.gun['pitchLimits'])
pitchLimitsMin = pitchLimits[0]
pitchLimitsMax = pitchLimits[1]
gunPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax, gunPitch)
return (turretYaw, gunPitch)
def __clampToLimits(self, turretYaw, gunPitch):
if self.__yawLimits is not None:
turretYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], turretYaw)
pitchLimits = calcPitchLimitsFromDesc(turretYaw, self.getPitchLimits())
adjustment = max(0, self.__returningOscillator.deviation.y)
pitchLimits[0] -= adjustment
pitchLimits[1] += adjustment
gunPitch = mathUtils.clamp(pitchLimits[0], pitchLimits[1] + self.__pitchCompensating, gunPitch)
return (turretYaw, gunPitch)
def __getClampedCursor(self):
cursorPosition = GUI.mcursor().position
cursorPosition.x = mathUtils.clamp(-self.CURSOR_POSITION_CLAMP_VALUE,
self.CURSOR_POSITION_CLAMP_VALUE,
cursorPosition.x)
cursorPosition.y = mathUtils.clamp(-self.CURSOR_POSITION_CLAMP_VALUE,
self.CURSOR_POSITION_CLAMP_VALUE,
cursorPosition.y)
return cursorPosition
def setCameraLocation(self,
targetPos=None,
pivotPos=None,
yaw=None,
pitch=None,
dist=None,
camConstraints=None,
ignoreConstraints=False,
smothiedTransition=True,
previewMode=False,
verticalOffset=0.0):
from gui.ClientHangarSpace import hangarCFG
cfg = hangarCFG()
sourceMat = Math.Matrix(self.__cam.source)
if yaw is None:
yaw = sourceMat.yaw
if pitch is None:
pitch = sourceMat.pitch
if dist is None:
dist = self.__cam.pivotMaxDist
self.__cam.screenSpaceVerticalOffset = verticalOffset
if camConstraints is not None:
self.__camConstraints = camConstraints
else:
self.__camConstraints[0] = cfg['cam_pitch_constr']
self.__camConstraints[1] = cfg['cam_yaw_constr']
camYawConstr = self.__camConstraints[1]
startYaw, endYaw = camYawConstr
self.__yawCameraFilter.setConstraints(math.radians(startYaw),
math.radians(endYaw))
self.__yawCameraFilter.setYawLimits(camYawConstr)
if not ignoreConstraints:
yaw = self.__yawCameraFilter.toLimit(yaw)
pitchOffset = self.__cam.pitchOffset
camPitchConstr = self.__camConstraints[0]
startPitch, endPitch = (math.radians(pc) - pitchOffset
for pc in camPitchConstr)
pitch = mathUtils.clamp(startPitch, endPitch, pitch)
distConstr = cfg[
'preview_cam_dist_constr'] if self.__isPreviewMode else self.__camConstraints[
2]
minDist, maxDist = distConstr
dist = mathUtils.clamp(minDist, maxDist, dist)
mat = Math.Matrix()
pitch = mathUtils.clamp(-math.pi / 2 * 0.99, math.pi / 2 * 0.99, pitch)
mat.setRotateYPR((yaw, pitch, 0.0))
self.__cam.source = mat
self.__cam.pivotMaxDist = dist
if targetPos is not None:
self.__cam.target.setTranslate(targetPos)
if pivotPos is not None:
self.__cam.pivotPosition = pivotPos
if not smothiedTransition:
self.__cam.forceUpdate()
self.setPreviewMode(previewMode)
return
def __calculateAimOffset(self, aimWorldPos):
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
aimOffset = replayCtrl.getAimClipPosition()
else:
aimOffset = cameras.projectPoint(aimWorldPos)
aimOffset = Vector2(mathUtils.clamp(-0.95, 0.95, aimOffset.x), mathUtils.clamp(-0.95, 0.95, aimOffset.y))
if replayCtrl.isRecording:
replayCtrl.setAimClipPosition(aimOffset)
return aimOffset
def __clampToLimits(self, turretYaw, gunPitch):
if self.__yawLimits is not None:
turretYaw = mathUtils.clamp(self.__yawLimits[0],
self.__yawLimits[1], turretYaw)
desc = BigWorld.player().vehicleTypeDescriptor
pitchLimits = calcPitchLimitsFromDesc(turretYaw,
desc.gun['pitchLimits'])
pitchLimitsMin = pitchLimits[0]
pitchLimitsMax = pitchLimits[1]
gunPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax, gunPitch)
return (turretYaw, gunPitch)
def __clampToLimits(self, turretYaw, gunPitch, withDeviation = False):
if self.__yawLimits is not None:
turretYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], turretYaw)
pitchLimits = calcPitchLimitsFromDesc(turretYaw, self.__pitchLimits)
if withDeviation:
pitchLimitsMin = min(pitchLimits[0] + self.__pitchDeviation[0], _MAX_DEVIATION)
pitchLimitsMax = max(pitchLimits[1] + self.__pitchDeviation[1], -_MAX_DEVIATION)
else:
pitchLimitsMin = pitchLimits[0]
pitchLimitsMax = pitchLimits[1]
gunPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax, gunPitch)
return (turretYaw, gunPitch)
def __clampToLimits(self, turretYaw, gunPitch):
if self.__yawLimits is not None:
turretYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], turretYaw)
pitchLimits = calcPitchLimitsFromDesc(turretYaw, self.__pitchLimits)
if SniperAimingSystem.__FILTER_ENABLED:
pitchLimitsMin = min(pitchLimits[0] + self.__pitchDeviation[0], _MAX_DEVIATION)
pitchLimitsMax = max(pitchLimits[1] + self.__pitchDeviation[1], -_MAX_DEVIATION)
else:
pitchLimitsMin = pitchLimits[0]
pitchLimitsMax = pitchLimits[1]
gunPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax + self.__pitchCompensating, gunPitch)
return (turretYaw, gunPitch)
def clampToLimits(base, self, turretYaw, gunPitch):
if config.get('battle/camera/enabled') and config.get('battle/camera/sniper/noCameraLimit/enabled'):
if not BigWorld.isKeyDown(KEY_RIGHTMOUSE) and self._SniperAimingSystem__yawLimits is not None and config.get('battle/camera/sniper/noCameraLimit/mode') == "hotkey":
turretYaw = mathUtils.clamp(self._SniperAimingSystem__yawLimits[0], self._SniperAimingSystem__yawLimits[1], turretYaw)
getPitchLimits = avatar_getter.getVehicleTypeDescriptor().gun.combinedPitchLimits
pitchLimits = calcPitchLimitsFromDesc(turretYaw, getPitchLimits)
adjustment = max(0, self._SniperAimingSystem__returningOscillator.deviation.y)
pitchLimits[0] -= adjustment
pitchLimits[1] += adjustment
gunPitch = mathUtils.clamp(pitchLimits[0], pitchLimits[1] + self._SniperAimingSystem__pitchCompensating, gunPitch)
return (turretYaw, gunPitch)
return base(self, turretYaw, gunPitch)
def __inLimit(self, yaw, pitch, withDeviation = False):
if self.__yawLimits is not None:
yaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], yaw)
pitchLimits = calcPitchLimitsFromDesc(yaw, self.__pitchLimits)
if withDeviation:
pitchLimitsMin = pitchLimits[0] + self.__pitchDeviation[0]
pitchLimitsMax = pitchLimits[1] + self.__pitchDeviation[1]
else:
pitchLimitsMin = pitchLimits[0]
pitchLimitsMax = pitchLimits[1]
limitedPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax, pitch)
return (pitchLimitsMin <= pitch <= pitchLimitsMax, limitedPitch)
def clampToLimits(base, self, turretYaw, gunPitch):
if config.get('battle/camera/enabled') and config.get('battle/camera/sniper/noCameraLimit/enabled'):
if not BigWorld.isKeyDown(KEY_RIGHTMOUSE) and self._SniperAimingSystem__yawLimits is not None and config.get('battle/camera/sniper/noCameraLimit/mode') == "hotkey":
turretYaw = mathUtils.clamp(self._SniperAimingSystem__yawLimits[0], self._SniperAimingSystem__yawLimits[1], turretYaw)
getPitchLimits = avatar_getter.getVehicleTypeDescriptor().gun.combinedPitchLimits
pitchLimits = calcPitchLimitsFromDesc(turretYaw, getPitchLimits)
adjustment = max(0, self._SniperAimingSystem__returningOscillator.deviation.y)
pitchLimits[0] -= adjustment
pitchLimits[1] += adjustment
gunPitch = mathUtils.clamp(pitchLimits[0], pitchLimits[1] + self._SniperAimingSystem__pitchCompensating, gunPitch)
return (turretYaw, gunPitch)
return base(self, turretYaw, gunPitch)
def __clampToLimits(self, turretYaw, gunPitch):
if self.__yawLimits is not None:
turretYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], turretYaw)
pitchLimits = calcPitchLimitsFromDesc(turretYaw, self.__pitchLimits)
if SniperAimingSystem.__FILTER_ENABLED:
pitchLimitsMin = min(pitchLimits[0] + self.__pitchDeviation[0], _MAX_DEVIATION)
pitchLimitsMax = max(pitchLimits[1] + self.__pitchDeviation[1], -_MAX_DEVIATION)
else:
pitchLimitsMin = pitchLimits[0]
pitchLimitsMax = pitchLimits[1]
gunPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax + self.__pitchCompensating, gunPitch)
return (turretYaw, gunPitch)
def __inLimit(self, yaw, pitch, withDeviation=False):
if self.__yawLimits is not None:
yaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1],
yaw)
pitchLimits = calcPitchLimitsFromDesc(yaw, self.__pitchLimits)
if withDeviation:
pitchLimitsMin = pitchLimits[0] + self.__pitchDeviation[0]
pitchLimitsMax = pitchLimits[1] + self.__pitchDeviation[1]
else:
pitchLimitsMin = pitchLimits[0]
pitchLimitsMax = pitchLimits[1]
limitedPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax, pitch)
return (pitchLimitsMin <= pitch <= pitchLimitsMax, limitedPitch)
def updateCameraByMouseMove(self, dx, dy, dz):
if self.__selectedEmblemInfo is not None:
self.__cam.target.setTranslate(
_CFG['preview_cam_start_target_pos'])
self.__cam.pivotPosition = _CFG['preview_cam_pivot_pos']
if self.__locatedOnEmbelem:
self.__cam.maxDistHalfLife = 0.0
else:
self.__cam.maxDistHalfLife = _CFG['cam_fluency']
sourceMat = Math.Matrix(self.__cam.source)
yaw = sourceMat.yaw
pitch = sourceMat.pitch
dist = self.__cam.pivotMaxDist
currentMatrix = Math.Matrix(self.__cam.invViewMatrix)
currentYaw = currentMatrix.yaw
yaw = self.__yawCameraFilter.getNextYaw(currentYaw, yaw, dx)
pitch -= dy * _CFG['cam_sens']
dist -= dz * _CFG['cam_sens']
pitch = mathUtils.clamp(math.radians(_CFG['cam_pitch_constr'][0]),
math.radians(_CFG['cam_pitch_constr'][1]),
pitch)
prevDist = dist
distConstr = self.__camDistConstr[
1] if self.__selectedEmblemInfo is not None else self.__camDistConstr[
0]
dist = mathUtils.clamp(distConstr[0], distConstr[1], dist)
if self.__boundingRadius is not None:
boundingRadius = self.__boundingRadius if self.__boundingRadius < distConstr[
1] else distConstr[1]
dist = dist if dist > boundingRadius else boundingRadius
if dist > prevDist and dz > 0:
if self.__selectedEmblemInfo is not None:
self.locateCameraOnEmblem(*self.__selectedEmblemInfo)
return
self.__locatedOnEmbelem = False
mat = Math.Matrix()
mat.setRotateYPR((yaw, pitch, 0.0))
self.__cam.source = mat
self.__cam.pivotMaxDist = dist
if self.settingsCore.getSetting(
'dynamicFov') and abs(distConstr[1] - distConstr[0]) > 0.001:
relativeDist = (dist - distConstr[0]) / (distConstr[1] -
distConstr[0])
_, minFov, maxFov = self.settingsCore.getSetting('fov')
fov = mathUtils.lerp(minFov, maxFov, relativeDist)
BigWorld.callback(
0,
functools.partial(FovExtended.instance().setFovByAbsoluteValue,
math.radians(fov), 0.1))
return
def __calcAimOffset(self, aimLocalTransform=None):
player = BigWorld.player()
vehicle = player.getVehicleAttached()
if self.__isRemoteCamera and vehicle is not None:
aimingSystemMatrix = self.__getRemoteAim(False)
aimingSystemMatrix.invert()
else:
aimingSystemMatrix = self.__aimingSystem.matrix
worldCrosshair = Matrix(self.__crosshairMatrix)
if aimLocalTransform is not None:
worldCrosshair.postMultiply(aimLocalTransform)
worldCrosshair.postMultiply(aimingSystemMatrix)
aimOffset = cameras.projectPoint(worldCrosshair.translation)
return Vector2(mathUtils.clamp(-0.95, 0.95, aimOffset.x),
mathUtils.clamp(-0.95, 0.95, aimOffset.y))
def __clampToLimits(self, turretYaw, gunPitch, withDeviation=False):
if self.__yawLimits is not None:
turretYaw = mathUtils.clamp(self.__yawLimits[0],
self.__yawLimits[1], turretYaw)
pitchLimits = calcPitchLimitsFromDesc(turretYaw, self.__pitchLimits)
if withDeviation:
pitchLimitsMin = min(pitchLimits[0] + self.__pitchDeviation[0],
_MAX_DEVIATION)
pitchLimitsMax = max(pitchLimits[1] + self.__pitchDeviation[1],
-_MAX_DEVIATION)
else:
pitchLimitsMin = pitchLimits[0]
pitchLimitsMax = pitchLimits[1]
gunPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax, gunPitch)
return (turretYaw, gunPitch)
def setCameraLocation(self,
targetPos=None,
pivotPos=None,
yaw=None,
pitch=None,
dist=None,
camConstraints=None,
ignoreConstraints=False,
smothiedTransition=True):
from gui.ClientHangarSpace import hangarCFG
cfg = hangarCFG()
sourceMat = Math.Matrix(self.__cam.source)
if yaw is None:
yaw = sourceMat.yaw
if pitch is None:
pitch = sourceMat.pitch
if dist is None:
dist = self.__cam.pivotMaxDist
if camConstraints is not None:
self.__camConstraints = camConstraints
else:
self.__camConstraints[0] = cfg['cam_pitch_constr']
self.__camConstraints[1] = cfg['cam_yaw_constr']
self.__yawCameraFilter.setConstraints(
math.radians(self.__camConstraints[1][0]),
math.radians(self.__camConstraints[1][1]))
self.__yawCameraFilter.setYawLimits(self.__camConstraints[1])
if not ignoreConstraints:
yaw = self.__yawCameraFilter.toLimit(yaw)
pitch = mathUtils.clamp(math.radians(self.__camConstraints[0][0]),
math.radians(self.__camConstraints[0][1]),
pitch)
distConstr = cfg[
'preview_cam_dist_constr'] if self.__selectedEmblemInfo else self.__camConstraints[
2]
dist = mathUtils.clamp(distConstr[0], distConstr[1], dist)
mat = Math.Matrix()
pitch = mathUtils.clamp(-math.pi / 2 * 0.99, math.pi / 2 * 0.99, pitch)
mat.setRotateYPR((yaw, pitch, 0.0))
self.__cam.source = mat
self.__cam.pivotMaxDist = dist
if targetPos is not None:
self.__cam.target.setTranslate(targetPos)
if pivotPos is not None:
self.__cam.pivotPosition = pivotPos
if not smothiedTransition:
self.__cam.forceUpdate()
return
def handleMovement(self, dx, dy):
self.__idealTurretYaw, self.__idealGunPitch = self.__worldYawPitchToTurret(
self.__worldYaw, self.__worldPitch)
pitchExcess = self.__calcPitchExcess(self.__idealTurretYaw + dx,
self.__idealGunPitch + dy)
if pitchExcess * dy < 0:
dy = 0
self.__idealTurretYaw, self.__idealGunPitch = self.__clampToLimits(
self.__idealTurretYaw + dx, self.__idealGunPitch + dy)
if pitchExcess != 0.0:
self.__adjustPitchLimitExtension(abs(pitchExcess), True)
currentGunMat = self.__getPlayerGunMat(self.__idealTurretYaw,
self.__idealGunPitch)
self.__worldYaw = currentGunMat.yaw
self.__worldPitch = currentGunMat.pitch
self._matrix.set(currentGunMat)
self.__oscillator.velocity = Vector3(0.0, 0.0, 0.0)
self.__returningOscillator.velocity = Vector3(0.0, 0.0, 0.0)
_, uncompensatedPitch = self.__getTurretYawGunPitch(
self.getDesiredShotPoint())
self.__pitchCompensating = mathUtils.clamp(
math.radians(-2.0), math.radians(2.0),
self.__idealGunPitch - uncompensatedPitch)
if abs(self.__pitchCompensating) < 0.01:
self.__pitchCompensating = 0.0
def readFloat(dataSec, name, minVal, maxVal, defaultVal):
if dataSec is None:
return defaultVal
else:
value = dataSec.readFloat(name, defaultVal)
value = mathUtils.clamp(minVal, maxVal, value)
return value
def __cameraUpdate(self):
currentTime = BigWorld.timeExact()
self.__elapsedTime += currentTime - self.__prevTime
self.__prevTime = currentTime
interpolationCoefficient = self.__easingMethod(
self.__elapsedTime, 1.0, self.__totalInterpolationTime)
interpolationCoefficient = mathUtils.clamp(0.0, 1.0,
interpolationCoefficient)
iSource = self.__initialState.source
iTarget = self.__initialState.target.b.translation
iPivotPosition = self.__initialState.pivotPosition
fSource = self.__finalState.source
fTarget = self.__finalState.target.b.translation
fPivotPosition = self.__finalState.pivotPosition
self.__cam.source = Math.slerp(iSource, fSource,
interpolationCoefficient)
self.__cam.target.b.translation = mathUtils.lerp(
iTarget, fTarget, interpolationCoefficient)
self.__cam.pivotPosition = mathUtils.lerp(iPivotPosition,
fPivotPosition,
interpolationCoefficient)
BigWorld.projection().fov = mathUtils.lerp(self.__initialFov,
self.__finalFov,
interpolationCoefficient)
if self.__elapsedTime > self.__totalInterpolationTime:
self.delayCallback(0.0, self.disable)
return 10.0
def __setupCamera(self):
from gui.ClientHangarSpace import hangarCFG
cfg = hangarCFG()
self.__cam = BigWorld.CursorCamera()
self.__cam.isHangar = True
self.__cam.spaceID = self.__spaceId
self.__cam.pivotMaxDist = mathUtils.clamp(cfg['cam_dist_constr'][0],
cfg['cam_dist_constr'][1],
cfg['cam_start_dist'])
self.__cam.pivotMinDist = 0.0
self.__cam.maxDistHalfLife = cfg['cam_fluency']
self.__cam.turningHalfLife = cfg['cam_fluency']
self.__cam.movementHalfLife = cfg['cam_fluency']
self.__cam.pivotPosition = cfg['cam_pivot_pos']
self.__camConstraints[0] = cfg['cam_pitch_constr']
self.__camConstraints[1] = cfg['cam_yaw_constr']
self.__camConstraints[2] = (0.0, 0.0)
self.__yawCameraFilter = HangarCameraYawFilter(
math.radians(cfg['cam_yaw_constr'][0]),
math.radians(cfg['cam_yaw_constr'][1]), cfg['cam_sens'])
self.__yawCameraFilter.setYawLimits(self.__camConstraints[1])
mat = Math.Matrix()
yaw = self.__yawCameraFilter.toLimit(
math.radians(cfg['cam_start_angles'][0]))
mat.setRotateYPR((yaw, math.radians(cfg['cam_start_angles'][1]), 0.0))
self.__cam.source = mat
mat = Math.Matrix()
mat.setTranslate(cfg['cam_start_target_pos'])
self.__cam.target = mat
self.__cam.wg_applyParams()
BigWorld.camera(self.__cam)
self.__cameraIdle = HangarCameraIdle(self.__cam)
self.__cameraParallax = HangarCameraParallax(self.__cam)
self.__cam.setDynamicCollisions(True)
def handleMovement(self, dx, dy):
self.__idealYaw, self.__idealPitch = self.__worldYawPitchToTurret(self.__g_curYaw, self.__pitchfilter.value())
newPitch = self.__idealPitch + dy
newYaw = self.__idealYaw + dx
self.__idealYaw, idealPitch, inLimit, pitchMin, dp = self.__inLimit(self.__idealYaw, newYaw, newPitch)
newPitch += dp
if not inLimit:
d1 = pitchMin - self.__idealPitch
d2 = pitchMin - newPitch
if math.fabs(d1) >= math.fabs(d2):
self.__idealPitch = idealPitch
currentGunMat = AimingSystems.getPlayerGunMat(self.__idealYaw, self.__idealPitch)
self.__pitchfilter.adjust(currentGunMat.pitch - self.__pitchfilter.value())
else:
currentGunMat = AimingSystems.getPlayerGunMat(self.__idealYaw, idealPitch)
self.__pitchfilter.reset(currentGunMat.pitch)
self.__g_curYaw = currentGunMat.yaw
self.__g_curPitch = currentGunMat.pitch
self._matrix.set(currentGunMat)
self.__oscillator.velocity = Vector3(0.0, 0.0, 0.0)
_, uncompensatedPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleTypeDescriptor, BigWorld.player().getOwnVehicleStabilisedMatrix(), self.getDesiredShotPoint())
if inLimit:
self.__pitchCompensating = mathUtils.clamp(math.radians(-2.0), math.radians(2.0), idealPitch - uncompensatedPitch)
else:
self.__pitchCompensating = 0.0
def getNextGunPitch(self, curAngle, shotAngle, timeDiff, angleLimits):
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying:
gunPitch = replayCtrl.getGunPitch()
if gunPitch > -100000:
return gunPitch
if self.__maxGunRotationSpeed == 0.0:
shotAngle = curAngle
shotDiff = 0.0
descr = self.__avatar.getVehicleDescriptor()
speedLimit = descr.gun.rotationSpeed * timeDiff
else:
if math.fabs(curAngle - shotAngle) < VehicleGunRotator.__ANGLE_EPS:
if angleLimits is not None:
return mathUtils.clamp(angleLimits[0], angleLimits[1],
shotAngle)
return shotAngle
shotDiff = shotAngle - curAngle
speedLimit = self.__maxGunRotationSpeed * timeDiff
if angleLimits is not None:
if shotAngle < angleLimits[0]:
shotDiff = angleLimits[0] - curAngle
elif shotAngle > angleLimits[1]:
shotDiff = angleLimits[1] - curAngle
staticPitch = self.__getGunStaticPitch()
if staticPitch is not None and shotDiff * (curAngle -
staticPitch) < 0.0:
speedLimit *= 2.0
if staticPitch is not None and self.estimatedTurretRotationTime > 0.0:
idealYawSpeed = abs(shotDiff) / self.estimatedTurretRotationTime
speedLimit = min(speedLimit, idealYawSpeed * timeDiff)
return curAngle + min(
shotDiff, speedLimit) if shotDiff > 0.0 else curAngle + max(
shotDiff, -speedLimit)
def __getDesiredCameraDistance(self):
distRange = self.__cfg['distRange']
self.__desiredCamDist -= self.__dxdydz.z * self.__curSense
self.__desiredCamDist = mathUtils.clamp(distRange[0], distRange[1], self.__desiredCamDist)
self.__desiredCamDist = self.__aimingSystem.overrideCamDist(self.__desiredCamDist)
self.__cfg['camDist'] = self.__camDist
return self.__desiredCamDist
def __update(self, dx, dy, dz, rotateMode = True, zoomMode = True, isCallback = False):
prevPos = self.__inputInertia.calcWorldPos(self.__aimingSystem.matrix)
distChanged = False
if zoomMode and dz != 0:
prevDist = self.__aimingSystem.distanceFromFocus
distDelta = dz * float(self.__curScrollSense)
distMinMax = self.__cfg['distRange']
newDist = mathUtils.clamp(distMinMax.min, distMinMax.max, prevDist - distDelta)
if abs(newDist - prevDist) > 0.001:
self.__aimingSystem.distanceFromFocus = newDist
self.__userCfg['startDist'] = newDist
self.__inputInertia.glideFov(self.__calcRelativeDist())
self.__aimingSystem.aimMatrix = self.__calcAimMatrix()
distChanged = True
changeControlMode = prevDist == newDist and mathUtils.almostZero(newDist - distMinMax.min)
if changeControlMode and self.__onChangeControlMode is not None:
self.__onChangeControlMode()
return
if rotateMode:
self.__updateAngles(dx, dy)
if ENABLE_INPUT_ROTATION_INERTIA and not distChanged:
self.__aimingSystem.update(0.0)
if ENABLE_INPUT_ROTATION_INERTIA or distChanged:
worldDeltaPos = prevPos - self.__aimingSystem.matrix.translation
matInv = Matrix(self.__aimingSystem.matrix)
matInv.invert()
self.__inputInertia.glide(matInv.applyVector(worldDeltaPos))
def handleMovement(self, dx, dy):
self.__idealYaw, self.__idealPitch = self.__worldYawPitchToTurret(self.__g_curYaw, self.__pitchfilter.value())
newPitch = self.__idealPitch + dy
newYaw = self.__idealYaw + dx
self.__idealYaw, idealPitch, inLimit, pitchMin, dp = self.__inLimit(self.__idealYaw, newYaw, newPitch)
newPitch += dp
if not inLimit:
d1 = pitchMin - self.__idealPitch
d2 = pitchMin - newPitch
if math.fabs(d1) >= math.fabs(d2):
self.__idealPitch = idealPitch
currentGunMat = AimingSystems.getPlayerGunMat(self.__idealYaw, self.__idealPitch)
self.__pitchfilter.adjust(currentGunMat.pitch - self.__pitchfilter.value())
else:
currentGunMat = AimingSystems.getPlayerGunMat(self.__idealYaw, idealPitch)
self.__pitchfilter.reset(currentGunMat.pitch)
self.__g_curYaw = currentGunMat.yaw
self.__g_curPitch = currentGunMat.pitch
self._matrix.set(currentGunMat)
self.__oscillator.velocity = Vector3(0.0, 0.0, 0.0)
_, uncompensatedPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleTypeDescriptor, BigWorld.player().getOwnVehicleStabilisedMatrix(), self.getDesiredShotPoint())
if inLimit:
self.__pitchCompensating = mathUtils.clamp(math.radians(-2.0), math.radians(2.0), idealPitch - uncompensatedPitch)
else:
self.__pitchCompensating = 0.0
def __getNextGunPitch(self, curAngle, shotAngle, timeDiff, angleLimits):
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying:
gunPitch = replayCtrl.getGunPitch()
if gunPitch > -100000:
return gunPitch
if self.__maxGunRotationSpeed == 0.0:
shotAngle = curAngle
shotDiff = 0.0
descr = self.__avatar.vehicleTypeDescriptor
speedLimit = descr.gun['rotationSpeed'] * timeDiff
else:
if math.fabs(curAngle - shotAngle) < VehicleGunRotator.__ANGLE_EPS:
if angleLimits is not None:
return mathUtils.clamp(angleLimits[0], angleLimits[1], shotAngle)
else:
return shotAngle
shotDiff = shotAngle - curAngle
speedLimit = self.__maxGunRotationSpeed * timeDiff
if angleLimits is not None:
if shotAngle < angleLimits[0]:
shotDiff = angleLimits[0] - curAngle
elif shotAngle > angleLimits[1]:
shotDiff = angleLimits[1] - curAngle
if shotDiff > 0.0:
return curAngle + min(shotDiff, speedLimit)
else:
return curAngle + max(shotDiff, -speedLimit)
return
def __setStartParams(self, params):
a = params.minValue
b = params.maxValue - params.minValue
clampedValue = mathUtils.clamp(params.minValue, params.maxValue,
params.startValue)
dArg = -1.0 + (clampedValue - a) * 2.0 / b if b != 0.0 else 0.0
params.startTime = math.asin(dArg)
def __update(self, dx, dy, dz, rotateMode = True, zoomMode = True, isCallback = False):
prevPos = self.__inputInertia.calcWorldPos(self.__aimingSystem.matrix)
distChanged = False
if zoomMode and dz != 0:
prevDist = self.__aimingSystem.distanceFromFocus
distDelta = dz * float(self.__curScrollSense)
distMinMax = self.__cfg['distRange']
newDist = mathUtils.clamp(distMinMax.min, distMinMax.max, prevDist - distDelta)
if abs(newDist - prevDist) > 0.001:
self.__aimingSystem.distanceFromFocus = newDist
self.__userCfg['startDist'] = newDist
self.__inputInertia.glideFov(self.__calcRelativeDist())
self.__aimingSystem.aimMatrix = self.__calcAimMatrix()
distChanged = True
changeControlMode = prevDist == newDist and mathUtils.almostZero(newDist - distMinMax.min)
if changeControlMode and self.__onChangeControlMode is not None:
self.__onChangeControlMode()
return
if rotateMode:
self.__updateAngles(dx, dy)
if ENABLE_INPUT_ROTATION_INERTIA and not distChanged:
self.__aimingSystem.update(0.0)
if ENABLE_INPUT_ROTATION_INERTIA or distChanged:
worldDeltaPos = prevPos - self.__aimingSystem.matrix.translation
matInv = Matrix(self.__aimingSystem.matrix)
matInv.invert()
self.__inputInertia.glide(matInv.applyVector(worldDeltaPos))
return
def __interpolateStates(self, deltaTime, translation, rotation):
lerpParam = mathUtils.clamp(
0.0, 1.0, deltaTime * self.__cfg['interpolationSpeed'])
self.__sourceMatrix = slerp(self.__sourceMatrix, rotation, lerpParam)
self.__targetMatrix.translation = mathUtils.lerp(
self.__targetMatrix.translation, translation, lerpParam)
return (self.__sourceMatrix, self.__targetMatrix)
def __init__(self):
ClientSelectableObject.__init__(self)
CallbackDelayer.__init__(self)
TimeDeltaMeter.__init__(self)
self.__state = CameraMovementStates.FROM_OBJECT
self.__camera = cameras.FreeCamera()
self.cameraPitch = mathUtils.clamp(-math.pi / 2 * 0.99,
math.pi / 2 * 0.99,
self.cameraPitch)
self.cameraYaw = normalizeAngle(self.cameraYaw)
self.__goalPosition = Math.Vector3(0.0, 0.0, 0.0)
self.__goalDistance = None
self.__goalTarget = Math.Vector3(0.0, 0.0, 0.0)
self.__startPosition = Math.Vector3(0.0, 0.0, 0.0)
self.__startYaw = 0.0
self.__startPitch = 0.0
self.__curTime = None
self.__easedInYaw = 0.0
self.__easedInPitch = 0.0
self.__easeInDuration = 0.0
self.__startFov = None
self.__goalFov = None
if self.enableYawLimits:
self.__yawLimits = Math.Vector2(self.yawLimitMin, self.yawLimitMax)
else:
self.__yawLimits = None
self.__pitchLimits = Math.Vector2(math.degrees(self.pitchLimitMin),
math.degrees(self.pitchLimitMax))
self.__p1 = Math.Vector3(0.0, 0.0, 0.0)
self.__p2 = Math.Vector3(0.0, 0.0, 0.0)
self.__wasPreviousUpdateSkipped = False
return
def readFloat(dataSec, name, minVal, maxVal, defaultVal):
if dataSec is None:
return defaultVal
else:
value = dataSec.readFloat(name, defaultVal)
value = mathUtils.clamp(minVal, maxVal, value)
return value
def refresh(self, delta):
vehicleTypeDescriptor = self._vehicle.typeDescriptor
vehicleSpeed = self._vehicle.speedInfo.value[0]
if vehicleSpeed > 0.0:
self._relativeSpeed = vehicleSpeed / vehicleTypeDescriptor.physics['speedLimits'][0]
else:
self._relativeSpeed = vehicleSpeed / vehicleTypeDescriptor.physics['speedLimits'][1]
self._relativeSpeed = clamp(-1.0, 1.0, self._relativeSpeed)
def readVec3(dataSec, name, minVal, maxVal, defaultVal):
if dataSec is None:
return Math.Vector3(defaultVal)
value = dataSec.readVector3(name, Math.Vector3(defaultVal))
for i in xrange(3):
value[i] = mathUtils.clamp(minVal[i], maxVal[i], value[i])
return value
def handleMovement(self, dx, dy):
self.__idealTurretYaw, self.__idealGunPitch = self.__worldYawPitchToTurret(self.__worldYaw, self.__worldPitch)
self.__idealTurretYaw, self.__idealGunPitch = self.__clampToLimits(self.__idealTurretYaw + dx, self.__idealGunPitch + dy)
currentGunMat = AimingSystems.getPlayerGunMat(self.__idealTurretYaw, self.__idealGunPitch)
self.__worldYaw = currentGunMat.yaw
self.__worldPitch = currentGunMat.pitch
self._matrix.set(currentGunMat)
self.__oscillator.velocity = Vector3(0.0, 0.0, 0.0)
_, uncompensatedPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleTypeDescriptor, BigWorld.player().getOwnVehicleMatrix(), self.getDesiredShotPoint())
self.__pitchCompensating = mathUtils.clamp(math.radians(-2.0), math.radians(2.0), self.__idealGunPitch - uncompensatedPitch)
def adjustImpulse(self, impulse, reason):
impulseSensitivity = self['impulseSensitivities'].get(reason, 0.0)
noiseImpulseSensitivity = self['noiseSensitivities'].get(reason, 0.0)
resultImpulse = impulse * impulseSensitivity
impulseMinMax = self['impulseLimits'].get(reason, None)
if impulseMinMax is not None:
resultImpulse = mathUtils.clampVectorLength(impulseMinMax[0], impulseMinMax[1], resultImpulse)
noiseMagnitude = impulse.length * noiseImpulseSensitivity
noiseMinMax = self['noiseLimits'].get(reason, None)
if noiseMinMax is not None:
noiseMagnitude = mathUtils.clamp(noiseMinMax[0], noiseMinMax[1], noiseMagnitude)
return (resultImpulse, noiseMagnitude)
def updateCameraByMouseMove(self, dx, dy, dz):
if self.__selectedEmblemInfo is not None:
self.__cam.target.setTranslate(_CFG['preview_cam_start_target_pos'])
self.__cam.pivotPosition = _CFG['preview_cam_pivot_pos']
if self.__locatedOnEmbelem:
self.__cam.maxDistHalfLife = 0.0
else:
self.__cam.maxDistHalfLife = _CFG['cam_fluency']
sourceMat = Math.Matrix(self.__cam.source)
yaw = sourceMat.yaw
pitch = sourceMat.pitch
dist = self.__cam.pivotMaxDist
currentMatrix = Math.Matrix(self.__cam.invViewMatrix)
currentYaw = currentMatrix.yaw
yaw = self.__yawCameraFilter.getNextYaw(currentYaw, yaw, dx)
pitch -= dy * _CFG['cam_sens']
dist -= dz * _CFG['cam_sens']
pitch = mathUtils.clamp(math.radians(_CFG['cam_pitch_constr'][0]), math.radians(_CFG['cam_pitch_constr'][1]), pitch)
prevDist = dist
distConstr = self.__camDistConstr[1] if self.__selectedEmblemInfo is not None else self.__camDistConstr[0]
dist = mathUtils.clamp(distConstr[0], distConstr[1], dist)
if self.__boundingRadius is not None:
boundingRadius = self.__boundingRadius if self.__boundingRadius < distConstr[1] else distConstr[1]
dist = dist if dist > boundingRadius else boundingRadius
if dist > prevDist and dz > 0:
if self.__selectedEmblemInfo is not None:
self.locateCameraOnEmblem(*self.__selectedEmblemInfo)
return
self.__locatedOnEmbelem = False
mat = Math.Matrix()
mat.setRotateYPR((yaw, pitch, 0.0))
self.__cam.source = mat
self.__cam.pivotMaxDist = dist
if g_settingsCore.getSetting('dynamicFov') and abs(distConstr[1] - distConstr[0]) > 0.001:
relativeDist = (dist - distConstr[0]) / (distConstr[1] - distConstr[0])
_, minFov, maxFov = g_settingsCore.getSetting('fov')
fov = mathUtils.lerp(minFov, maxFov, relativeDist)
BigWorld.callback(0, functools.partial(FovExtended.instance().setFovByAbsoluteValue, math.radians(fov), 0.1))
return
def __inLimit(self, prevYaw, newYaw, newPitch):
if self.__yawLimits is not None:
prevYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], prevYaw)
newYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], newYaw)
prevPitchLimits = calcPitchLimitsFromDesc(prevYaw, self.__pitchLimits)
pitchLimits = calcPitchLimitsFromDesc(newYaw, self.__pitchLimits)
if SniperAimingSystem.__FILTER_ENABLED:
pitchLimitsMin = pitchLimits[0] + self.__pitchDeviation[0]
pitchLimitsMax = pitchLimits[1] + self.__pitchDeviation[1]
prevLimMin = prevPitchLimits[0] + self.__pitchDeviation[0]
prevLimMax = prevPitchLimits[1] + self.__pitchDeviation[1]
else:
pitchLimitsMin = pitchLimits[0]
pitchLimitsMax = pitchLimits[1]
prevLimMin = prevPitchLimits[0]
prevLimMax = prevPitchLimits[1]
prevLimitedPitch = mathUtils.clamp(prevLimMin, prevLimMax, newPitch)
limitedPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax, newPitch)
dp = limitedPitch - prevLimitedPitch
return (newYaw,
limitedPitch,
pitchLimitsMin <= newPitch <= pitchLimitsMax,
pitchLimitsMin,
dp)
def __setupCamera(self):
self.__cam = BigWorld.CursorCamera()
self.__cam.spaceID = self.__spaceId
self.__cam.pivotMaxDist = mathUtils.clamp(_CFG['cam_dist_constr'][0], _CFG['cam_dist_constr'][1], _CFG['cam_start_dist'])
self.__cam.pivotMinDist = 0.0
self.__cam.maxDistHalfLife = _CFG['cam_fluency']
self.__cam.turningHalfLife = _CFG['cam_fluency']
self.__cam.movementHalfLife = 0.0
self.__cam.pivotPosition = _CFG['cam_pivot_pos']
mat = Math.Matrix()
yaw = self.__yawCameraFilter.toLimit(math.radians(_CFG['cam_start_angles'][0]))
mat.setRotateYPR((yaw, math.radians(_CFG['cam_start_angles'][1]), 0.0))
self.__cam.source = mat
mat = Math.Matrix()
mat.setTranslate(_CFG['cam_start_target_pos'])
self.__cam.target = mat
BigWorld.camera(self.__cam)
def __cameraUpdate(self):
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
aimOffset = replayCtrl.getAimClipPosition()
else:
aimOffset = self.__calcAimOffset()
if replayCtrl.isRecording:
replayCtrl.setAimClipPosition(aimOffset)
self.__aimOffsetFunc(aimOffset)
shotDescr = BigWorld.player().vehicleTypeDescriptor.shot
BigWorld.wg_trajectory_drawer().setParams(shotDescr['maxDistance'], Math.Vector3(0, -shotDescr['gravity'], 0), self.__aimOffsetFunc())
curTime = BigWorld.time()
deltaTime = curTime - self.__prevTime
self.__prevTime = curTime
if replayCtrl.isPlaying:
if self.__needReset != 0:
if self.__needReset > 1:
from helpers import isPlayerAvatar
player = BigWorld.player()
if isPlayerAvatar():
if player.inputHandler.ctrl is not None:
player.inputHandler.ctrl.resetGunMarkers()
self.__needReset = 0
else:
self.__needReset += 1
if replayCtrl.isControllingCamera:
self.__aimingSystem.updateTargetPos(replayCtrl.getGunRotatorTargetPoint())
else:
self.__aimingSystem.handleMovement(self.__dxdydz.x * self.__curSense, -self.__dxdydz.y * self.__curSense)
if self.__dxdydz.x != 0 or self.__dxdydz.y != 0 or self.__dxdydz.z != 0:
self.__needReset = 2
else:
self.__aimingSystem.handleMovement(self.__dxdydz.x * self.__curSense, -self.__dxdydz.y * self.__curSense)
distRange = self.__cfg['distRange']
self.__camDist -= self.__dxdydz.z * float(self.__curSense)
maxPivotHeight = distRange[1] - distRange[0]
self.__camDist = mathUtils.clamp(0, maxPivotHeight, self.__camDist)
self.__cfg['camDist'] = self.__camDist
self.__cam.pivotPosition = Math.Vector3(0.0, self.__camDist, 0.0)
if self.__dxdydz.z != 0 and self.__onChangeControlMode is not None and mathUtils.almostZero(self.__camDist - maxPivotHeight):
self.__onChangeControlMode()
self.__updateOscillator(deltaTime)
if not self.__autoUpdatePosition:
self.__dxdydz = Vector3(0, 0, 0)
return 0.0
def update(self, dt):
remainedDt = dt
remainedDt = mathUtils.clamp(0.0, Oscillator._STEP_LENGTH * 3, remainedDt)
while remainedDt > 0.0:
deltaTime = Oscillator._STEP_LENGTH
if deltaTime > remainedDt:
deltaTime = remainedDt
remainedDt -= deltaTime
force = self.__calcForce()
acc = force / self.mass
self.velocity += acc * deltaTime
self.deviation += self.velocity * deltaTime
unclampedPos = self.deviation
self.deviation = mathUtils.clampVector3(-self.constraints, self.constraints, self.deviation)
if unclampedPos.x != self.deviation.x:
self.velocity.x = 0.0
if unclampedPos.y != self.deviation.y:
self.velocity.y = 0.0
if unclampedPos.z != self.deviation.z:
self.velocity.z = 0.0
def update(self):
vehicleSpeed = self.__vehicle.speedInfo.value[2]
appearance = self.__appearance
self.__variableArgs['speed'] = vehicleSpeed
self.__variableArgs['isPC'] = self.__vehicle.isPlayerVehicle
direction = 1 if vehicleSpeed >= 0.0 else -1
self.__variableArgs['direction'] = direction
self.__variableArgs['rotSpeed'] = self.__vehicle.speedInfo.value[1]
matKindsUnderTracks = getCorrectedMatKinds(appearance)
self.__variableArgs['deltaR'], self.__variableArgs['directionR'], self.__variableArgs['matkindR'] = self.__getScrollParams(appearance.trackScrollController.rightScroll(), appearance.trackScrollController.rightContact(), matKindsUnderTracks[CustomEffectManager._RIGHT_TRACK], direction)
self.__variableArgs['deltaL'], self.__variableArgs['directionL'], self.__variableArgs['matkindL'] = self.__getScrollParams(appearance.trackScrollController.leftScroll(), appearance.trackScrollController.leftContact(), matKindsUnderTracks[CustomEffectManager._LEFT_TRACK], direction)
matInv = Math.Matrix(self.__vehicle.matrix)
matInv.invert()
velocityLocal = matInv.applyVector(self.__vehicle.filter.velocity)
velLen = velocityLocal.length
if velLen > 1.0:
vehicleDir = Math.Vector3(0.0, 0.0, 1.0)
velocityLocal = Math.Vector2(velocityLocal.z, velocityLocal.x)
cosA = velocityLocal.dot(Math.Vector2(vehicleDir.z, vehicleDir.x)) / velLen
self.__variableArgs['hullAngle'] = math.acos(mathUtils.clamp(0.0, 1.0, math.fabs(cosA)))
else:
self.__variableArgs['hullAngle'] = 0.0
self.__variableArgs['isUnderWater'] = 1 if appearance.isUnderwater else 0
self.__correctWaterNodes()
self.__variableArgs['gearUp'] = self.__gearUP
self.__variableArgs['RPM'] = self.__engineState.relativeRPM
self.__gearUP = False
self.__variableArgs['engineLoad'] = self.__engineState.mode
self.__variableArgs['engineStart'] = self.__engineState.starting
self.__variableArgs['physicLoad'] = self.__engineState.physicLoad
for effectSelector in self.__selectors:
effectSelector.update(self.__variableArgs)
if _ENABLE_VALUE_TRACKER:
self.__vt.addValue2('speed', self.__variableArgs['speed'])
self.__vt.addValue2('direction', self.__variableArgs['direction'])
self.__vt.addValue2('rotSpeed', self.__variableArgs['rotSpeed'])
self.__vt.addValue2('deltaR', self.__variableArgs['deltaR'])
self.__vt.addValue2('deltaL', self.__variableArgs['deltaL'])
self.__vt.addValue2('hullAngle', self.__variableArgs['hullAngle'])
self.__vt.addValue2('isUnderWater', self.__variableArgs['isUnderWater'])
self.__vt.addValue2('directionR', self.__variableArgs['directionR'])
self.__vt.addValue2('directionL', self.__variableArgs['directionL'])
if self.__variableArgs['matkindL'] > -1:
materialL = material_kinds.EFFECT_MATERIAL_INDEXES_BY_IDS[self.__variableArgs['matkindL']]
self.__vt.addValue('materialL', material_kinds.EFFECT_MATERIALS[materialL])
else:
self.__vt.addValue('materialL', 'No')
if self.__variableArgs['matkindR'] > -1:
materialR = material_kinds.EFFECT_MATERIAL_INDEXES_BY_IDS[self.__variableArgs['matkindR']]
self.__vt.addValue('materialR', material_kinds.EFFECT_MATERIALS[materialR])
else:
self.__vt.addValue('materialR', 'No')
if _ENABLE_VALUE_TRACKER_ENGINE:
self.__vt.addValue2('engineStart', self.__variableArgs['engineStart'])
self.__vt.addValue2('gearUP', self.__variableArgs['gearUp'])
self.__vt.addValue2('RPM', self.__variableArgs['RPM'])
self.__vt.addValue2('engineLoad', self.__engineState.mode)
self.__vt.addValue2('physicLoad', self.__engineState.physicLoad)
if _ENABLE_PIXIE_TRACKER:
self.__vt.addValue2('Pixie Count', PixieCache.pixiesCount)
def __clampToLimits(self, turretYaw, gunPitch):
if self.__yawLimits is not None:
turretYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], turretYaw)
pitchLimits = calcPitchLimitsFromDesc(turretYaw, self.__pitchLimits)
gunPitch = mathUtils.clamp(pitchLimits[0], pitchLimits[1] + self.__pitchCompensating, gunPitch)
return (turretYaw, gunPitch)
def __calcFov(self):
fov = BigWorld.projection().fov + self.__zoomSensor.currentVelocity
return mathUtils.clamp(0.1, math.pi - 0.1, fov)
def refresh(self, delta):
super(DetailedEngineStateWWISE, self).refresh(delta)
self.calculateRPM()
self.calculateGear()
if not self._vehicle.isPlayerVehicle or self._vehicle.physicsMode == VEHICLE_PHYSICS_MODE.STANDARD:
speed = self._vehicle.speedInfo.value[0]
self.__speed = (speed - self.__speed) * 0.2 * delta
speedRange = self._vehicle.typeDescriptor.physics['speedLimits'][0] + self._vehicle.typeDescriptor.physics['speedLimits'][1]
speedRangeGear = speedRange / 3
self._gearNum = math.ceil(math.floor(math.fabs(self.__speed) * 50) / 50 / speedRangeGear)
if self.__prevGearNum2 != self._gearNum:
self.__prevGearNum = self.__prevGearNum2
self._gearUp = self.__prevGearNum2 < self._gearNum and self._engineLoad > self._IDLE
if self._gearUp and self._gearUpCbk is not None:
self._gearUpCbk()
if self._gearNum == 2 and self.__prevGearNum < self._gearNum:
self.__gear_2 = 100
else:
self.__gear_2 = 0
if self._gearNum == 3 and self.__prevGearNum < self._gearNum:
self.__gear_3 = 100
else:
self.__gear_3 = 0
self.__prevGearNum2 = self._gearNum
if self._gearNum != 0 and self._engineLoad > self._IDLE:
self._reativelRPM = math.fabs(1 + (self.__speed - self._gearNum * speedRangeGear) / speedRangeGear)
self._reativelRPM = self._reativelRPM * (1.0 - self._GEAR_DELTA * self._gearNum) + self._GEAR_DELTA * self._gearNum
else:
self._reativelRPM = 0.0
self._rpm = self._reativelRPM * 100.0
else:
self._gearUp = self.__newPhysicGear > self._gearNum
if self._gearUp and self._gearUpCbk is not None:
self._gearUpCbk()
self._gearNum = self.__newPhysicGear
self.__rotationSpeed = self._vehicle.speedInfo.value[1]
self.__roatationRelSpeed = self.__rotationSpeed / self._vehicle.typeDescriptor.physics['rotationSpeedLimit']
self._engineLoad = 2 if self._mode == 3 else self._mode
self._roughnessValue = -(self._vehicle.pitch - self.__prevPitch) / delta
self.__prevPitch = self._vehicle.pitch
if self._mode >= 2:
absRelSpeed = abs(self._relativeSpeed)
if absRelSpeed > 0.01:
k_mg = -abs(self._vehicle.pitch) / self._maxClimbAngle if self._relativeSpeed * self._vehicle.pitch > 0.0 else abs(self._vehicle.pitch) / self._maxClimbAngle
self._physicLoad = (1.0 + k_mg) * 0.5
if self._relativeSpeed > 0.0:
speedImpactK = 1.0 / 0.33
else:
speedImpactK = 1.0 / 0.9
speedImpact = clamp(0.01, 1.0, absRelSpeed * speedImpactK)
speedImpact = clamp(0.0, 2.0, 1.0 / speedImpact)
self._physicLoad = clamp(0.0, 1.0, self._physicLoad * speedImpact)
self._physicLoad += self._roughnessValue if self._roughnessValue > 0 else 0
self._physicLoad += clamp(0.0, 1.0, absRelSpeed - 0.9)
self._physicLoad = clamp(0.0, 1.0, self._physicLoad)
self._physicLoad = max(self._physicLoad, abs(self.__roatationRelSpeed))
else:
self._physicLoad = 1.0
else:
self._physicLoad = self._mode - 1
return
def clampFov(fov):
return mathUtils.clamp(0.017, 3.12, fov)
def __setPitch(self, value):
self.__cursor.pitch = mathUtils.clamp(self.__anglesRange[0], self.__anglesRange[1], value)
def __calcAimOffset(self):
aimWorldPos = self.__aimingSystem.matrix.applyPoint(Vector3(0, -self.__aimingSystem.height, 0))
aimOffset = cameras.projectPoint(aimWorldPos)
return Vector2(mathUtils.clamp(-0.95, 0.95, aimOffset.x), mathUtils.clamp(-0.95, 0.95, aimOffset.y))
def setCameraDistance(self, distance):
distRange = self.__cfg['distRange']
clampedDist = mathUtils.clamp(distRange[0], distRange[1], distance)
self.__aimingSystem.distanceFromFocus = clampedDist
self.__inputInertia.teleport(self.__calcRelativeDist())
