def __applyZoom(self, zoomFactor):
self.__zoomFactor = zoomFactor
if BattleReplay.g_replayCtrl.isRecording:
BattleReplay.g_replayCtrl.serializeCallbackData(
CallbackDataNames.APPLY_ZOOM, (zoomFactor, ))
FovExtended.instance().setFovByMultiplier(1 / zoomFactor)
self.__updateCrosshairMatrix()
def destroy(self):
self.hangarSpace.onSpaceCreate -= self.__onSpaceCreated
self.hangarSpace.onSpaceDestroy -= self.__onSpaceDestroy
self.settingsCore.onSettingsChanged -= self.__handleSettingsChange
g_eventBus.removeListener(CameraRelatedEvents.IDLE_CAMERA,
self.__handleIdleCameraActivation)
g_eventBus.removeListener(CameraRelatedEvents.VEHICLE_LOADING,
self.__handleVehicleLoading)
g_eventBus.removeListener(CameraRelatedEvents.CAMERA_ENTITY_UPDATED,
self.__handleEntityUpdated)
g_eventBus.removeListener(
CameraRelatedEvents.FORCE_DISABLE_CAMERA_MOVEMENT,
self.__handleDisableMovement)
if self.__cameraIdle:
self.__cameraIdle.destroy()
self.__cameraIdle = None
if self.__cameraParallax:
self.__cameraParallax.destroy()
self.__cameraParallax = None
if self.__cam is BigWorld.camera():
self.__cam.spaceID = 0
BigWorld.worldDrawEnabled(False)
self.__cam = None
FovExtended.instance().resetFov()
return
def onEnterWorld(self, prereqs):
if self.isPlayerVehicle:
global yaw, old_yaw, pitch, old_pitch, old_multiplier, dataHor, dataVert, turretYawLimits, scaleHor, scaleVert
global minStep, maxPitch, minPitch, currentStep, minBound, maxBound, screenHeight, screenWidth, player
global old_gunAnglesPacked, isAlive, cameraMode
player = BigWorld.player()
yaw = 0.0
pitch = 0.0
old_multiplier = 1.0
old_gunAnglesPacked = None
old_yaw = None
old_pitch = None
isAlive = self.isAlive
screenHeight = BigWorld.screenHeight()
screenWidth = BigWorld.screenWidth()
currentStep = STEP
verticalFov = FovExtended.instance().actualDefaultVerticalFov
horizontalFov = FovExtended.calcHorizontalFov(verticalFov)
scaleHor = screenWidth / horizontalFov if horizontalFov else screenWidth
scaleVert = screenHeight / verticalFov if verticalFov else screenHeight
gun = self.typeDescriptor.gun
minBound, maxBound = gun['pitchLimits']['absolute']
minStep = (maxBound - minBound) / 63
turretYawLimits = gun['turretYawLimits']
maxPitch =gun['pitchLimits']['maxPitch']
minPitch = gun['pitchLimits']['minPitch']
dataHor, dataVert = coordinate(yaw, pitch)
cameraMode = None
as_event('ON_ANGLES_AIMING')
def activate(self, targetPos, cameraParams):
if self.__isActive:
return
self.__prevCam = BigWorld.camera()
self.__prevVerticalFov = BigWorld.projection().fov
self.__cam.spaceID = self.__prevCam.spaceID
self.__yawCameraFilter = HangarCameraYawFilter(
math.radians(cameraParams.yawConstraints[0]),
math.radians(cameraParams.yawConstraints[1]), self.__camSens)
self.__pitchConstraints = cameraParams.pitchConstraints
self.__distConstraints = cameraParams.distanceConstraints
pivotY, pivotMaxDist, initYaw, initPitch = self.__calculateCursorCameraParams(
targetPos, cameraParams)
self.__cam.target.setTranslate(targetPos)
self.__cam.pivotPosition = Math.Vector3(0.0, pivotY, 0.0)
self.__cam.pivotMaxDist = pivotMaxDist
sourceMat = Math.Matrix()
sourceMat.setRotateYPR(Math.Vector3(initYaw, initPitch, 0.0))
self.__cam.source = sourceMat
self.__cam.wg_applyParams()
BigWorld.camera(self.__cam)
horizontalFov = math.radians(cameraParams.fov)
self.__setHorizontalFov(horizontalFov)
self.__currentVerticalFov = self.__nativeVerticalFov = BigWorld.projection(
).fov
FovExtended.instance().onSetFovSettingEvent += self.__onSetFovSetting
FovExtended.instance().onRefreshFovEvent += self.__onRefreshFov
self.__isActive = True
def deactivate(self, instantly=True):
if not self.__isActive:
return
else:
if self.__cameraParallax:
self.__cameraParallax.deactivate()
self.__cameraParallax.destroy()
self.__cameraParallax = None
if self.__cameraIdle:
self.__cameraIdle.destroy()
self.__cameraIdle = None
space = self.hangarSpace.space
if space is not None:
initialCameraIdle = space.getCameraManager().getCameraIdle()
if initialCameraIdle:
initialCameraIdle.setDefaultStartDelay()
self.__cam = self.__initialCam
self.moveToGameObject(None, instantly)
vEntity = self.hangarSpace.getVehicleEntity()
if vEntity is not None:
vEntity.setState(CameraMovementStates.ON_OBJECT)
FovExtended.instance(
).onSetFovSettingEvent -= self.__onSetFovSetting
g_eventBus.removeListener(
CameraRelatedEvents.LOBBY_VIEW_MOUSE_MOVE,
self.__handleLobbyViewMouseEvent)
self.__isActive = False
self.__prevParams = None
return
def __destroy(self):
LOG_DEBUG('Hangar successfully destroyed.')
MusicControllerWWISE.unloadCustomSounds()
if self.__cam == BigWorld.camera():
self.__cam.spaceID = 0
BigWorld.camera(None)
BigWorld.worldDrawEnabled(False)
self.__cam = None
self.__loadingStatus = 0.0
if self.__vAppearance is not None:
self.__vAppearance.destroy()
self.__vAppearance = None
self.__onLoadedCallback = None
self.__boundingRadius = None
if self.__waitCallback is not None:
BigWorld.cancelCallback(self.__waitCallback)
self.__waitCallback = None
g_keyEventHandlers.remove(self.handleKeyEvent)
g_mouseEventHandlers.remove(self.handleMouseEventGlobal)
BigWorld.SetDrawInflux(False)
MapActivities.g_mapActivities.stop()
if self.__spaceId is not None and BigWorld.isClientSpace(self.__spaceId):
if self.__spaceMappingId is not None:
BigWorld.delSpaceGeometryMapping(self.__spaceId, self.__spaceMappingId)
BigWorld.clearSpace(self.__spaceId)
BigWorld.releaseSpace(self.__spaceId)
self.__spaceMappingId = None
self.__spaceId = None
self.__vEntityId = None
BigWorld.wg_disableSpecialFPSMode()
g_postProcessing.disable()
FovExtended.instance().resetFov()
return
def disable(self):
self.__aimingSystem.disable()
self.stopCallback(self.__cameraUpdate)
BigWorld.camera(None)
BigWorld.player().positionControl.followCamera(False)
self.__positionOscillator.reset()
FovExtended.instance().resetFov()
FovExtended.instance().enabled = True
def disable(self):
self.__aimingSystem.disable()
self.stopCallback(self.__cameraUpdate)
BigWorld.camera(None)
BigWorld.player().positionControl.followCamera(False)
self.__positionOscillator.reset()
FovExtended.instance().resetFov()
FovExtended.instance().enabled = True
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
def StrategicAimingSystem_enable(self, targetPos):
global dataHor, dataVert, scaleHor, scaleVert, yHor, yVert, cameraMode
verticalFov = FovExtended.instance().actualDefaultVerticalFov
horizontalFov = FovExtended.calcHorizontalFov(verticalFov)
yHor = 0
yVert = 0
scaleHor = screenWidth / horizontalFov if horizontalFov else screenWidth
scaleVert = screenHeight / verticalFov if verticalFov else screenHeight
dataHor, dataVert = coordinate(yaw, pitch)
cameraMode = 'str'
as_event('ON_ANGLES_AIMING')
def ArcadeAimingSystem_enable(self, targetPos, turretYaw=None, gunPitch=None):
global dataHor, dataVert, scaleHor, scaleVert, yHor, yVert, cameraMode
verticalFov = FovExtended.instance().actualDefaultVerticalFov
horizontalFov = FovExtended.calcHorizontalFov(verticalFov)
yHor = - screenHeight * 0.0775
yVert = yHor
scaleHor = screenWidth / horizontalFov if horizontalFov else screenWidth
scaleVert = screenHeight / verticalFov if verticalFov else screenHeight
dataHor, dataVert = coordinate(yaw, pitch)
cameraMode = 'arc'
as_event('ON_ANGLES_AIMING')
def __restorePreviousFov(self):
if self.__prevVerticalFov is None:
return
else:
if math.fabs(self.__currentVerticalFov -
self.__nativeVerticalFov) > 1e-06:
FovExtended.instance().resetFov()
else:
BigWorld.projection().fov = self.__prevVerticalFov
self.__prevVerticalFov = None
self.__currentVerticalFov = None
self.__nativeVerticalFov = None
return
def disable(self):
self.__scrollSmoother.stop()
if self.__aimingSystem is not None:
self.__aimingSystem.disable()
self.__switchers.clear()
self.stopCallback(self.__cameraUpdate)
positionControl = BigWorld.player().positionControl
if positionControl is not None:
positionControl.followCamera(False)
self.__positionOscillator.reset()
FovExtended.instance().resetFov()
FovExtended.instance().enabled = True
return
def disable(self):
BigWorld.camera(None)
if self.__waitVehicleCallbackId is not None:
BigWorld.cancelCallback(self.__waitVehicleCallbackId)
self.__waitVehicleCallbackId = None
self.__showVehicle(True)
self.stopCallback(self.__cameraUpdate)
self.__aimingSystem.disable()
self.__movementOscillator.reset()
self.__impulseOscillator.reset()
self.__noiseOscillator.reset()
self.__accelerationSmoother.reset()
self.__autoUpdateDxDyDz.set(0)
FovExtended.instance().resetFov()
def disable(self):
BigWorld.camera(None)
if self.__waitVehicleCallbackId is not None:
BigWorld.cancelCallback(self.__waitVehicleCallbackId)
self.__waitVehicleCallbackId = None
self.__showVehicle(True)
self.stopCallback(self.__cameraUpdate)
self.__aimingSystem.disable()
self.__movementOscillator.reset()
self.__impulseOscillator.reset()
self.__noiseOscillator.reset()
self.__accelerationSmoother.reset()
self.__autoUpdateDxDyDz.set(0)
FovExtended.instance().resetFov()
def deactivate(self):
if not self.__isActive:
return
else:
self.__isActive = False
FovExtended.instance(
).onSetFovSettingEvent -= self.__onSetFovSetting
FovExtended.instance().onRefreshFovEvent -= self.__onRefreshFov
if self.__prevCam is not None:
if self.__prevCam.spaceID != BigWorld.camera().spaceID:
return
BigWorld.camera(self.__prevCam)
self.__prevCam = None
self.__restorePreviousFov()
return
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
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 = math_utils.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
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 __updateDynamicFOV(self, time):
if not self.__goalFov or not self.__startFov:
return
if time > self.__easeInDuration:
return
time /= self.__easeInDuration
fov = math_utils.lerp(self.__startFov, self.__goalFov, time)
BigWorld.callback(0.0, partial(FovExtended.instance().setFovByAbsoluteValue, fov, 0.1))
def disable(self):
from gui import g_guiResetters
if self.__onRecreateDevice in g_guiResetters:
g_guiResetters.remove(self.__onRecreateDevice)
self.__setModelsToCollideWith([])
self.__cam.speedTreeTarget = None
BigWorld.camera(None)
if self.__shiftKeySensor is not None:
self.__shiftKeySensor.reset(Math.Vector3())
self.stopCallback(self.__cameraUpdate)
self.__movementOscillator.reset()
self.__impulseOscillator.reset()
self.__noiseOscillator.reset()
self.__accelerationSmoother.reset()
self.__autoUpdateDxDyDz.set(0)
self.__inputInertia.teleport(self.__calcRelativeDist())
FovExtended.instance().resetFov()
def __updateDynamicFov(self, dist, rampTime):
minDist, maxDist = self.__camConstraints[2]
if not self.settingsCore.getSetting('dynamicFov') or abs(maxDist - minDist) <= 0.001:
return
relativeDist = (dist - minDist) / (maxDist - minDist)
_, minFov, maxFov = self.settingsCore.getSetting('fov')
fov = math_utils.lerp(minFov, maxFov, relativeDist)
BigWorld.callback(0.0, partial(FovExtended.instance().setFovByAbsoluteValue, horizontalFov=fov, rampTime=rampTime))
def activate(self):
space = self.hangarSpace.space
if space is None:
return
else:
self.__initialCam = space.camera
if self.__initialCam is None:
return
if self.__flightCam is None:
self.__flightCam = BigWorld.TransitionCamera()
self.__flightCam.spaceID = self.__initialCam.spaceID
FovExtended.instance(
).onSetFovSettingEvent += self.__onSetFovSetting
g_eventBus.addListener(CameraRelatedEvents.LOBBY_VIEW_MOUSE_MOVE,
self.__handleLobbyViewMouseEvent)
self.delayCallback(0.01, self.__checkFlightCamera)
self.__isActive = True
return
def SniperAimingSystem_enable(self, targetPos, playerGunMatFunction=AimingSystems.getPlayerGunMat):
global dataHor, dataVert, scaleHor, scaleVert, yHor, yVert, cameraMode
verticalFov = BigWorld.projection().fov * 2
horizontalFov = FovExtended.calcVerticalFov(verticalFov)
yHor = 0
yVert = 0
scaleHor = screenWidth / horizontalFov if horizontalFov else screenWidth
scaleVert = screenHeight / verticalFov if verticalFov else screenHeight
dataHor, dataVert = coordinate(yaw, pitch)
cameraMode = 'sn'
as_event('ON_ANGLES_AIMING')
def disable(self):
from gui import g_guiResetters
if self.__onRecreateDevice in g_guiResetters:
g_guiResetters.remove(self.__onRecreateDevice)
self.__setDynamicCollisions(False)
self.__cam.speedTreeTarget = None
if self.__shiftKeySensor is not None:
self.__shiftKeySensor.reset(Math.Vector3())
self.stopCallback(self.__cameraUpdate)
self.__movementOscillator.reset()
self.__impulseOscillator.reset()
self.__noiseOscillator.reset()
self.__accelerationSmoother.reset()
self.__autoUpdateDxDyDz.set(0)
self.__updatedByKeyboard = False
dist = self.__calcRelativeDist()
if dist is not None:
self.__inputInertia.teleport(dist)
FovExtended.instance().resetFov()
return
def moveToGameObject(self, gameObject=None, instantly=False):
if not self.__isActive:
return
else:
self.__instantly = instantly
self.__prevParams = deepcopy(self.__currentParams)
if gameObject:
self.__readCameraParamsFromGameObject(gameObject)
self.__setupCamera()
else:
self.__currentParams = deepcopy(self.__defaultParams)
if self.__currentParams.dofParams:
self.__dofHelper = BigWorld.PyCustomizationHelper(
None, 0, False, None)
self.__dofHelper.setDOFparams(*self.__currentParams.dofParams)
self.__dofHelper.setDOFenabled(True)
elif self.__dofHelper is not None:
self.__dofHelper.setDOFenabled(False)
self.__dofHelper = None
if self.__flightCam.isInTransition():
tempCam = BigWorld.FreeCamera()
tempCam.set(self.__flightCam.matrix)
BigWorld.camera(tempCam)
self.__flightCam.finish()
if gameObject:
self.__moveToCamera()
else:
point = self.__initialCam.target.translation + Math.Vector3(
0, self.__initialCam.pivotMaxDist, 0)
self.__moveToCamera(point)
else:
self.__moveThroughFlightPoint()
self.__prevHorizontalFov = FovExtended.instance(
).getLastSetHorizontalFov()
self.__currentHorizontalFov = self.__currentParams.fov
if not self.__currentHorizontalFov:
self.__currentHorizontalFov = FovExtended.instance(
).horizontalFov
if self.__instantly:
self.__setHorizontalFov(self.__currentHorizontalFov)
return
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 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
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
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 __updateCameraByMouseMove(self, dx, dy, dz):
if self.__cam is None:
return
elif self.__cam != BigWorld.camera() and not self.__handleInactiveCamera:
return
else:
from gui.ClientHangarSpace import hangarCFG
cfg = hangarCFG()
self.__cam.movementMode = FAST_CAMERA_MOVEMENT_MODE
if self.__rotationEnabled:
sourceMat = Math.Matrix(self.__cam.source)
yaw = sourceMat.yaw
pitch = sourceMat.pitch
currentMatrix = Math.Matrix(self.__cam.invViewMatrix)
currentYaw = currentMatrix.yaw
yaw = self.__yawCameraFilter.getNextYaw(currentYaw, yaw, dx)
pitch -= dy * cfg['cam_sens']
camPitchConstr = self.__camConstraints[0]
startPitch, endPitch = camPitchConstr
pitch = math_utils.clamp(math.radians(startPitch), math.radians(endPitch), pitch)
mat = Math.Matrix()
mat.setRotateYPR((yaw, pitch, 0.0))
self.__cam.source = mat
if self.__zoomEnabled:
if dz < 0.0:
dist = self.__cam.pivotMaxDist
else:
dist = self.__cam.targetMaxDist
dist -= dz * cfg['cam_dist_sens']
minDist, maxDist = self.__camConstraints[2]
dist = math_utils.clamp(minDist, maxDist, dist)
self.__cam.pivotMaxDist = dist
if self.settingsCore.getSetting('dynamicFov') and abs(maxDist - minDist) > 0.001:
relativeDist = (dist - minDist) / (maxDist - minDist)
_, minFov, maxFov = self.settingsCore.getSetting('fov')
fov = math_utils.lerp(minFov, maxFov, relativeDist)
BigWorld.callback(0, partial(FovExtended.instance().setFovByAbsoluteValue, math.radians(fov), 0.1))
return
def enable(self, targetPos, saveDist, switchToPos=None, switchToPlace=None):
self.__prevTime = BigWorld.time()
self.__aimingSystem.enable(targetPos)
self.__activeDistRangeSettings = self.__getActiveDistRangeForArena()
if self.__activeDistRangeSettings is not None:
self.__aimingSystem.height = self.__getDistRange()[0]
minDist, maxDist = self.__getDistRange()
maxPivotHeight = maxDist - minDist
self.__updateCameraYaw()
if switchToPlace == SwitchToPlaces.TO_TRANSITION_DIST:
self.__camDist = self.__getTransitionCamDist()
elif switchToPlace == SwitchToPlaces.TO_RELATIVE_POS and switchToPos is not None:
self.__camDist = maxPivotHeight * switchToPos
elif switchToPlace == SwitchToPlaces.TO_NEAR_POS and switchToPos is not None:
switchToPos = math_utils.clamp(minDist, maxDist, switchToPos)
self.__camDist = switchToPos - minDist
elif self.settingsCore.getSetting(settings_constants.SPGAim.AUTO_CHANGE_AIM_MODE):
self.__camDist = math_utils.clamp(self.__getTransitionCamDist(), maxPivotHeight, self.__camDist)
self.__saveDist = saveDist
self.__camDist = math_utils.clamp(0, maxPivotHeight, self.__camDist)
self.__cam.pivotPosition = Math.Vector3(0.0, self.__camDist, 0.0)
self.__scrollSmoother.start(self.__camDist)
self.__enableSwitchers()
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
def resetFov(value):
FovExtended.instance().defaultHorizontalFov = value
def setFov(value, multiplier, dynamicFOVEnabled):
if not dynamicFOVEnabled:
FovExtended.instance().resetFov()
FovExtended.instance().defaultHorizontalFov = value
def init(scriptConfig, engineConfig, userPreferences, loadingScreenGUI=None):
global g_replayCtrl
global g_onBeforeSendEvent
try:
log.config.setupFromXML()
if constants.IS_DEVELOPMENT:
autoFlushPythonLog()
from development_features import initDevBonusTypes
initDevBonusTypes()
import Event
g_onBeforeSendEvent = Event.Event()
BigWorld.wg_initCustomSettings()
Settings.g_instance = Settings.Settings(scriptConfig, engineConfig, userPreferences)
CommandMapping.g_instance = CommandMapping.CommandMapping()
from helpers import DecalMap
DecalMap.g_instance = DecalMap.DecalMap(scriptConfig['decal'])
from helpers import EdgeDetectColorController
EdgeDetectColorController.g_instance = EdgeDetectColorController.EdgeDetectColorController(scriptConfig['silhouetteColors'])
SoundGroups.g_instance = SoundGroups.SoundGroups()
import BattleReplay
g_replayCtrl = BattleReplay.g_replayCtrl = BattleReplay.BattleReplay()
g_replayCtrl.registerWotReplayFileExtension()
g_bootcamp.replayCallbackSubscribe()
try:
from Vibroeffects import VibroManager
VibroManager.g_instance = VibroManager.VibroManager()
VibroManager.g_instance.connect()
except Exception:
LOG_CURRENT_EXCEPTION()
tutorialLoaderInit()
BigWorld.callback(0.1, asyncore_call)
import items
items.init(True, None if not constants.IS_DEVELOPMENT else {})
import win_points
win_points.init()
import rage
rage.init()
import ArenaType
ArenaType.init()
import dossiers2
dossiers2.init()
import personal_missions
personal_missions.init()
import motivation_quests
motivation_quests.init()
BigWorld.worldDrawEnabled(False)
dependency.configure(services_config.getClientServicesConfig)
gui_personality.init(loadingScreenGUI=loadingScreenGUI)
EdgeDetectColorController.g_instance.create()
g_replayCtrl.subscribe()
MessengerEntry.g_instance.init()
AreaDestructibles.init()
MusicControllerWWISE.create()
TriggersManager.init()
RSSDownloader.init()
items.clearXMLCache()
SoundGroups.loadLightSoundsDB()
import player_ranks
player_ranks.init()
import destructible_entities
destructible_entities.init()
try:
from LightFx import LightManager
LightManager.g_instance = LightManager.LightManager()
import AuxiliaryFx
AuxiliaryFx.g_instance = AuxiliaryFx.AuxiliaryFxManager()
except Exception:
LOG_CURRENT_EXCEPTION()
from AvatarInputHandler.cameras import FovExtended
FovExtended.instance().resetFov()
BigWorld.pauseDRRAutoscaling(True)
except Exception:
LOG_CURRENT_EXCEPTION()
BigWorld.quit()
return
def setFov(value, isDynamicFov):
FovExtended.instance().applyHorizontalFovSetting(
value, not isDynamicFov)
def setFov(value, multiplier, dynamicFOVEnabled):
if not dynamicFOVEnabled:
FovExtended.instance().resetFov()
FovExtended.instance().defaultHorizontalFov = value
def init(scriptConfig, engineConfig, userPreferences, loadingScreenGUI = None):
global g_replayCtrl
try:
if constants.IS_DEVELOPMENT:
autoFlushPythonLog()
LOG_DEBUG('init')
BigWorld.wg_initCustomSettings()
Settings.g_instance = Settings.Settings(scriptConfig, engineConfig, userPreferences)
CommandMapping.g_instance = CommandMapping.CommandMapping()
from helpers import DecalMap
DecalMap.g_instance = DecalMap.DecalMap(scriptConfig['decal'])
from helpers import EdgeDetectColorController
EdgeDetectColorController.g_instance = EdgeDetectColorController.EdgeDetectColorController(scriptConfig['silhouetteColors'])
import SoundGroups
SoundGroups.g_instance = SoundGroups.SoundGroups()
import BattleReplay
g_replayCtrl = BattleReplay.g_replayCtrl = BattleReplay.BattleReplay()
g_replayCtrl.registerWotReplayFileExtension()
try:
import Vibroeffects
Vibroeffects.VibroManager.g_instance = Vibroeffects.VibroManager.VibroManager()
Vibroeffects.VibroManager.g_instance.connect()
except:
LOG_CURRENT_EXCEPTION()
tutorialLoaderInit()
BigWorld.callback(0.1, asyncore_call)
MessengerEntry.g_instance.init()
import items
items.init(True, None if not constants.IS_DEVELOPMENT else {})
import ArenaType
ArenaType.init()
import dossiers1
dossiers1.init()
import dossiers2
dossiers2.init()
import fortified_regions
fortified_regions.init()
import potapov_quests
potapov_quests.init()
BigWorld.worldDrawEnabled(False)
import LcdKeyboard
LcdKeyboard.enableLcdKeyboardSpecificKeys(True)
gui_personality.init(loadingScreenGUI=loadingScreenGUI)
AreaDestructibles.init()
MusicController.init()
TriggersManager.init()
RSSDownloader.init()
g_postProcessing.init()
SoundGroups.loadLightSoundsDB()
try:
from LightFx import LightManager
LightManager.g_instance = LightManager.LightManager()
import AuxiliaryFx
AuxiliaryFx.g_instance = AuxiliaryFx.AuxiliaryFxManager()
except:
LOG_CURRENT_EXCEPTION()
from AvatarInputHandler.cameras import FovExtended
FovExtended.instance().resetFov()
SoundGroups.loadPluginDB()
except Exception:
LOG_CURRENT_EXCEPTION()
BigWorld.quit()
def __calcAimMatrix(self):
endMult = self.__inputInertia.endZoomMultiplier
fov = FovExtended.instance().actualDefaultVerticalFov * endMult
offset = self.__defaultAimOffset
return cameras.getAimMatrix(-offset[0], -offset[1], fov)
def __applyZoom(self, zoomFactor):
FovExtended.instance().setFovByMultiplier(1 / zoomFactor)
def __calcAimMatrix(self):
endMult = self.__inputInertia.endZoomMultiplier
fov = FovExtended.instance().actualDefaultVerticalFov * endMult
offset = self.__defaultAimOffset
return cameras.getAimMatrix(-offset[0], -offset[1], fov)
def resetFov(value):
FovExtended.instance().defaultHorizontalFov = value
def __applyZoom(self, zoomFactor):
BigWorld.player().inputHandler.aim._setZoom(zoomFactor)
if BattleReplay.g_replayCtrl.isRecording:
BattleReplay.g_replayCtrl.serializeCallbackData('applyZoom', (zoomFactor,))
FovExtended.instance().setFovByMultiplier(1 / zoomFactor)
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
def __applyZoom(self, zoomFactor):
self.__zoomFactor = zoomFactor
if BattleReplay.g_replayCtrl.isRecording:
BattleReplay.g_replayCtrl.serializeCallbackData('applyZoom', (zoomFactor,))
FovExtended.instance().setFovByMultiplier(1 / zoomFactor)
def init(scriptConfig, engineConfig, userPreferences, loadingScreenGUI=None):
global g_replayCtrl
try:
if constants.IS_DEVELOPMENT:
autoFlushPythonLog()
BigWorld.wg_initCustomSettings()
g_postProcessing.init()
Settings.g_instance = Settings.Settings(scriptConfig, engineConfig,
userPreferences)
CommandMapping.g_instance = CommandMapping.CommandMapping()
from helpers import DecalMap
DecalMap.g_instance = DecalMap.DecalMap(scriptConfig['decal'])
from helpers import EdgeDetectColorController
EdgeDetectColorController.g_instance = EdgeDetectColorController.EdgeDetectColorController(
scriptConfig['silhouetteColors'])
import SoundGroups
SoundGroups.g_instance = SoundGroups.SoundGroups()
import BattleReplay
g_replayCtrl = BattleReplay.g_replayCtrl = BattleReplay.BattleReplay()
g_replayCtrl.registerWotReplayFileExtension()
try:
from Vibroeffects import VibroManager
VibroManager.g_instance = VibroManager.VibroManager()
VibroManager.g_instance.connect()
except:
LOG_CURRENT_EXCEPTION()
tutorialLoaderInit()
BigWorld.callback(0.1, asyncore_call)
import items
items.init(True, None if not constants.IS_DEVELOPMENT else {})
import win_points
win_points.init()
import rage
rage.init()
import ArenaType
ArenaType.init()
import dossiers2
dossiers2.init()
import fortified_regions
fortified_regions.init()
import clubs_settings
clubs_settings.init()
import potapov_quests
potapov_quests.init()
import clubs_quests
clubs_quests.init()
import motivation_quests
motivation_quests.init()
BigWorld.worldDrawEnabled(False)
import LcdKeyboard
LcdKeyboard.enableLcdKeyboardSpecificKeys(True)
dependency.configure(services_config.getClientServicesConfig)
gui_personality.init(loadingScreenGUI=loadingScreenGUI)
EdgeDetectColorController.g_instance.create()
g_replayCtrl.subscribe()
MessengerEntry.g_instance.init()
AreaDestructibles.init()
MusicControllerWWISE.create()
TriggersManager.init()
RSSDownloader.init()
SoundGroups.loadLightSoundsDB()
try:
from LightFx import LightManager
LightManager.g_instance = LightManager.LightManager()
import AuxiliaryFx
AuxiliaryFx.g_instance = AuxiliaryFx.AuxiliaryFxManager()
except:
LOG_CURRENT_EXCEPTION()
from AvatarInputHandler.cameras import FovExtended
FovExtended.instance().resetFov()
BigWorld.pauseDRRAutoscaling(True)
except Exception:
LOG_CURRENT_EXCEPTION()
BigWorld.quit()
return
def setFov(value, multiplier):
if self.__multiplier is not None:
self.__multiplier.setSystemValue(multiplier)
FovExtended.instance().resetFov()
FovExtended.instance().defaultHorizontalFov = value
return
