def __cameraUpdate(self, allowModeChange = True):
curTime = BigWorld.time()
deltaTime = curTime - self.__prevTime
self.__prevTime = curTime
if not self.__autoUpdateDxDyDz.x == self.__autoUpdateDxDyDz.y == self.__autoUpdateDxDyDz.z == 0.0:
self.__rotateAndZoom(self.__autoUpdateDxDyDz.x, self.__autoUpdateDxDyDz.y, self.__autoUpdateDxDyDz.z)
self.__aimingSystem.update(deltaTime)
localTransform, impulseTransform = self.__updateOscillators(deltaTime)
aimMatrix = cameras.getAimMatrix(*self.__defaultAimOffset)
camMat = Matrix(aimMatrix)
rodMat = mathUtils.createTranslationMatrix(-self.__dynamicCfg['pivotShift'])
antiRodMat = mathUtils.createTranslationMatrix(self.__dynamicCfg['pivotShift'])
camMat.postMultiply(rodMat)
camMat.postMultiply(localTransform)
camMat.postMultiply(antiRodMat)
camMat.postMultiply(self.__aimingSystem.matrix)
camMat.invert()
self.__cam.set(camMat)
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
aimOffset = replayCtrl.getAimClipPosition()
binocularsOffset = aimOffset
else:
aimOffset = self.__calcAimOffset(impulseTransform)
binocularsOffset = self.__calcAimOffset()
if replayCtrl.isRecording:
replayCtrl.setAimClipPosition(aimOffset)
self.__aim.offset(aimOffset)
self.__binoculars.setMaskCenter(binocularsOffset.x, binocularsOffset.y)
player = BigWorld.player()
if allowModeChange and (self.__isPositionUnderwater(self.__aimingSystem.matrix.translation) or player.isGunLocked):
self.__onChangeControlMode(False)
return -1
return 0.0
def __cameraUpdate(self):
curTime = BigWorld.time()
deltaTime = curTime - self.__prevTime
self.__prevTime = curTime
if not self.__autoUpdateDxDyDz.x == self.__autoUpdateDxDyDz.y == self.__autoUpdateDxDyDz.z == 0.0:
self.__rotateAndZoom(self.__autoUpdateDxDyDz.x, self.__autoUpdateDxDyDz.y, self.__autoUpdateDxDyDz.z)
self.__aimingSystem.update(deltaTime)
localTransform, impulseTransform = self.__updateOscillators(deltaTime)
ownVehicle = BigWorld.entity(BigWorld.player().playerVehicleID)
if ownVehicle is not None and ownVehicle.isStarted and ownVehicle.appearance.isUnderwater:
self.__onChangeControlMode()
return 0.0
else:
aimMatrix = cameras.getAimMatrix(*self.__defaultAimOffset)
camMat = Matrix(aimMatrix)
rodMat = mathUtils.createTranslationMatrix(-self.__dynamicCfg['pivotShift'])
antiRodMat = mathUtils.createTranslationMatrix(self.__dynamicCfg['pivotShift'])
camMat.postMultiply(rodMat)
camMat.postMultiply(localTransform)
camMat.postMultiply(antiRodMat)
camMat.postMultiply(self.__aimingSystem.matrix)
camMat.invert()
self.__cam.set(camMat)
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
aimOffset = replayCtrl.getAimClipPosition()
binocularsOffset = aimOffset
else:
aimOffset = self.__calcAimOffset(impulseTransform)
binocularsOffset = self.__calcAimOffset()
if replayCtrl.isRecording:
replayCtrl.setAimClipPosition(aimOffset)
self.__aim.offset((aimOffset.x, aimOffset.y))
self.__binoculars.setMaskCenter(binocularsOffset.x, binocularsOffset.y)
return 0.0
def prepareCompoundAssembler(vehicleDesc,
modelsSetParams,
spaceID,
isTurretDetached=False):
if constants.IS_DEVELOPMENT and modelsSetParams.state not in VehicleDamageState.MODEL_STATE_NAMES:
raise SoftException(
'Invalid modelStateName %s, must be in %s' %
(modelsSetParams.state, VehicleDamageState.MODEL_STATE_NAMES))
if spaceID is None:
spaceID = BigWorld.player().spaceID
partModels = getPartModelsFromDesc(vehicleDesc, modelsSetParams)
chassis, hull, turret, gun = partModels
assembler = BigWorld.CompoundAssembler()
assembler.addRootPart(chassis, TankPartNames.CHASSIS)
assembler.emplacePart(hull, 'V', TankPartNames.HULL)
turretJointName = vehicleDesc.hull.turretHardPoints[0]
assembler.addNodeAlias(turretJointName, TankNodeNames.TURRET_JOINT)
if not isTurretDetached:
assembler.addPart(turret, turretJointName, TankPartNames.TURRET)
assembler.addPart(gun, TankNodeNames.GUN_JOINT, TankPartNames.GUN)
cornerPoint = vehicleDesc.chassis.topRightCarryingPoint
assembler.addNode(
TankNodeNames.TRACK_LEFT_MID, TankPartNames.CHASSIS,
mathUtils.createTranslationMatrix((-cornerPoint[0], 0, 0)))
assembler.addNode(
TankNodeNames.TRACK_RIGHT_MID, TankPartNames.CHASSIS,
mathUtils.createTranslationMatrix((cornerPoint[0], 0, 0)))
assembler.addNode(TankNodeNames.CHASSIS_MID_TRAIL, TankPartNames.CHASSIS)
assembler.name = vehicleDesc.name
assembler.spaceID = spaceID
return assembler
def __init__(self, vehicleEffect, cameraEffect, centerPosition):
self.__vehicleTM = Math.WGTranslationOnlyMP()
self.__vehicleDirMatrix = BigWorld.DiffDirProvider(self.__vehicleTM, mathUtils.createTranslationMatrix(centerPosition))
self.__cameraTM = Math.WGTranslationOnlyMP()
self.__cameraDirMatrix = BigWorld.DiffDirProvider(self.__cameraTM, mathUtils.createTranslationMatrix(centerPosition))
self.__vehicleFakeModel = BigWorld.Model('')
self.__vehicleFakeModel.addMotor(BigWorld.Servo(self.__vehicleDirMatrix))
self.__cameraFakeModel = BigWorld.Model('')
self.__cameraFakeModel.addMotor(BigWorld.Servo(self.__cameraDirMatrix))
self.__vehicleEffects = vehicleEffect
self.__vehicleEffectsPlayer = None
self.__cameraEffects = cameraEffect
self.__cameraEffectsPlayer = None
return
def getGunMatrixProvider(vehicleTypeDescriptor, turretMatrixProvider,
gunPitchMatrixProvider):
gunOffset = vehicleTypeDescriptor.turret['gunPosition']
return MatrixProviders.product(
gunPitchMatrixProvider,
MatrixProviders.product(mathUtils.createTranslationMatrix(gunOffset),
turretMatrixProvider))
def set(self, start, end):
self.start = start
self.end = end
direction = end - start
m = mathUtils.createSRTMatrix((self.__thickness, self.__thickness, direction.length), (direction.yaw, direction.pitch, 0), start + direction / 2)
m.preMultiply(mathUtils.createTranslationMatrix(Vector3(-0.5, -0.5, -0.5)))
self.motor.signal = m
def launch(spaceName):
global g_offlineModeEnabled
global g_spaceID
global g_videoCamera
print 'Entering offline space', spaceName
BigWorld.clearAllSpaces()
BigWorld.worldDrawEnabled(False)
_displayGUI(spaceName)
g_spaceID = BigWorld.createSpace()
BigWorld.addSpaceGeometryMapping(g_spaceID, None, spaceName)
BigWorld.setCursor(GUI.mcursor())
GUI.mcursor().visible = False
GUI.mcursor().clipped = True
g_offlineModeEnabled = True
BigWorld.callback(1.0, _offlineLoadCheck)
rootSection = ResMgr.openSection(AvatarInputHandler._INPUT_HANDLER_CFG)
videoSection = rootSection['videoMode']
videoCameraSection = videoSection['camera']
g_videoCamera = VideoCamera(videoCameraSection)
g_videoCamera.enable(camMatrix=mathUtils.createTranslationMatrix((0.0, 0.0, 0.0)))
BigWorld.camera().spaceID = g_spaceID
import game
game.handleKeyEvent = handleKeyEvent
game.handleMouseEvent = handleMouseEvent
BigWorld.player = lambda : g_fakeAvatar
return
def set(self, start, end):
self.start = start
self.end = end
direction = end - start
m = mathUtils.createSRTMatrix((self.__thickness, self.__thickness, direction.length), (direction.yaw, direction.pitch, 0), start + direction / 2)
m.preMultiply(mathUtils.createTranslationMatrix(Vector3(-0.5, -0.5, -0.5)))
self.motor.signal = m
def selectPlacement(self, placement):
if self.__vehicle is None:
return
else:
self.__placement = placement
self.__lookAtProvider = None
if placement == _VehicleBounder.SELECT_CHASSIS:
self.matrix = self.__vehicle.matrix
elif placement == _VehicleBounder.SELECT_TURRET:
self.matrix = AimingSystems.getTurretMatrixProvider(
self.__vehicle.typeDescriptor, self.__vehicle.matrix,
self.__vehicle.appearance.turretMatrix)
elif placement == _VehicleBounder.SELECT_GUN:
turretMatrixProv = AimingSystems.getTurretMatrixProvider(
self.__vehicle.typeDescriptor, self.__vehicle.matrix,
self.__vehicle.appearance.turretMatrix)
self.matrix = AimingSystems.getGunMatrixProvider(
self.__vehicle.typeDescriptor, turretMatrixProv,
self.__vehicle.appearance.gunMatrix)
elif placement == _VehicleBounder.SELECT_LOOK_AT:
self.matrix = mathUtils.createIdentityMatrix()
self.__lookAtProvider = mathUtils.MatrixProviders.product(
mathUtils.createTranslationMatrix(self.__boundLocalPos),
self.__vehicle.matrix)
return
def selectPlacement(self, placement):
if self.__vehicle is None:
return
else:
self.__placement = placement
self.__lookAtProvider = None
if placement == _VehicleBounder.SELECT_CHASSIS:
self.matrix = self.__vehicle.matrix
elif placement == _VehicleBounder.SELECT_TURRET:
self.matrix = AimingSystems.getTurretMatrixProvider(
self.__vehicle.typeDescriptor, self.__vehicle.matrix, self.__vehicle.appearance.turretMatrix
)
elif placement == _VehicleBounder.SELECT_GUN:
turretMatrixProv = AimingSystems.getTurretMatrixProvider(
self.__vehicle.typeDescriptor, self.__vehicle.matrix, self.__vehicle.appearance.turretMatrix
)
self.matrix = AimingSystems.getGunMatrixProvider(
self.__vehicle.typeDescriptor, turretMatrixProv, self.__vehicle.appearance.gunMatrix
)
elif placement == _VehicleBounder.SELECT_LOOK_AT:
self.matrix = mathUtils.createIdentityMatrix()
self.__lookAtProvider = mathUtils.MatrixProviders.product(
mathUtils.createTranslationMatrix(self.__boundLocalPos), self.__vehicle.matrix
)
return
def launch(spaceName):
global g_offlineModeEnabled
global g_spaceID
global g_videoCamera
print 'Entering offline space', spaceName
BigWorld.clearAllSpaces()
BigWorld.worldDrawEnabled(False)
_displayGUI(spaceName)
g_spaceID = BigWorld.createSpace()
BigWorld.addSpaceGeometryMapping(g_spaceID, None, spaceName)
BigWorld.setCursor(GUI.mcursor())
GUI.mcursor().visible = False
GUI.mcursor().clipped = True
g_offlineModeEnabled = True
BigWorld.callback(1.0, _offlineLoadCheck)
rootSection = ResMgr.openSection(AvatarInputHandler._INPUT_HANDLER_CFG)
videoSection = rootSection['videoMode']
videoCameraSection = videoSection['camera']
g_videoCamera = VideoCamera(videoCameraSection)
g_videoCamera.enable(camMatrix=mathUtils.createTranslationMatrix((0.0, 0.0,
0.0)))
BigWorld.camera().spaceID = g_spaceID
import game
game.handleKeyEvent = handleKeyEvent
game.handleMouseEvent = handleMouseEvent
BigWorld.player = lambda: g_fakeAvatar
def __cameraUpdate(self, allowModeChange=True):
curTime = BigWorld.time()
deltaTime = curTime - self.__prevTime
self.__prevTime = curTime
if not self.__autoUpdateDxDyDz.x == self.__autoUpdateDxDyDz.y == self.__autoUpdateDxDyDz.z == 0.0:
self.__rotateAndZoom(self.__autoUpdateDxDyDz.x,
self.__autoUpdateDxDyDz.y,
self.__autoUpdateDxDyDz.z)
self.__aimingSystem.update(deltaTime)
localTransform, impulseTransform = self.__updateOscillators(deltaTime)
zoom = self.__aimingSystem.overrideZoom(self.__zoom)
aimMatrix = cameras.getAimMatrix(self.__defaultAimOffset.x,
self.__defaultAimOffset.y)
camMat = Matrix(aimMatrix)
rodMat = mathUtils.createTranslationMatrix(
-self.__dynamicCfg['pivotShift'])
antiRodMat = mathUtils.createTranslationMatrix(
self.__dynamicCfg['pivotShift'])
camMat.postMultiply(rodMat)
camMat.postMultiply(localTransform)
camMat.postMultiply(antiRodMat)
camMat.postMultiply(self.__aimingSystem.matrix)
camMat.invert()
self.__cam.set(camMat)
if zoom != self.__zoom:
self.__zoom = zoom
self.__applyZoom(self.__zoom)
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
aimOffset = replayCtrl.getAimClipPosition()
binocularsOffset = aimOffset
if not BigWorld.player().isForcedGuiControlMode() and GUI.mcursor(
).inFocus:
GUI.mcursor().position = aimOffset
else:
aimOffset = self.__calcAimOffset(impulseTransform)
binocularsOffset = self.__calcAimOffset()
if replayCtrl.isRecording:
replayCtrl.setAimClipPosition(aimOffset)
self.__aimOffset = aimOffset
self.__binoculars.setMaskCenter(binocularsOffset.x, binocularsOffset.y)
player = BigWorld.player()
if allowModeChange and (self.__isPositionUnderwater(
self.__aimingSystem.matrix.translation) or player.isGunLocked
and not player.isObserverFPV):
self.__onChangeControlMode(False)
return -1
def __updateOscillator(self, deltaTime):
if StrategicCamera.isCameraDynamic():
self.__positionOscillator.update(deltaTime)
self.__positionNoiseOscillator.update(deltaTime)
else:
self.__positionOscillator.reset()
self.__positionNoiseOscillator.reset()
self.__cam.target.a = mathUtils.createTranslationMatrix(self.__positionOscillator.deviation + self.__positionNoiseOscillator.deviation)
def __createCube(self, position, size):
modelName = self.CUBE_MODEL
model, motor = self.__getModel(modelName)
m = mathUtils.createSRTMatrix(size, (0, 0, 0), position)
m.preMultiply(
mathUtils.createTranslationMatrix(Vector3(0.0, -0.5, 0.0)))
motor.signal = m
return (modelName, model, motor)
def __updateOscillator(self, deltaTime):
if ArtyCamera.isCameraDynamic():
self.__positionOscillator.update(deltaTime)
self.__positionNoiseOscillator.update(deltaTime)
else:
self.__positionOscillator.reset()
self.__positionNoiseOscillator.reset()
self.__cam.target.a = mathUtils.createTranslationMatrix(self.__positionOscillator.deviation + self.__positionNoiseOscillator.deviation)
def getTurretMatrixProvider(vehicleTypeDescriptor, vehicleMatrixProvider,
turretYawMatrixProvider):
turretOffset = vehicleTypeDescriptor.chassis[
'hullPosition'] + vehicleTypeDescriptor.hull['turretPositions'][0]
return MatrixProviders.product(
turretYawMatrixProvider,
MatrixProviders.product(
mathUtils.createTranslationMatrix(turretOffset),
vehicleMatrixProvider))
def assembleCompoundModel2(models, position, vehicleDesc):
worldMatrix = mathUtils.createTranslationMatrix(position)
chassisFashion = BigWorld.WGVehicleFashion()
VehicleAppearance.setupTracksFashion(chassisFashion, vehicleDesc)
fashions.append(chassisFashion)
gunFashion = BigWorld.WGGunRecoil('G')
fashions.append(gunFashion)
assembler = prepareCompoundAssembler(vehicleDesc, ModelStates.UNDAMAGED, BigWorld.camera().spaceID if BigWorld.player().spaceID == 0 else BigWorld.player().spaceID)
BigWorld.loadResourceListBG((assembler,), functools.partial(setupTank, chassisFashion, gunFashion, vehicleDesc, worldMatrix))
def assembleCompoundModel2(models, position, vehicleDesc):
worldMatrix = mathUtils.createTranslationMatrix(position)
chassisFashion = BigWorld.WGVehicleFashion()
VehicleAppearance.setupTracksFashion(chassisFashion, vehicleDesc)
fashions.append(chassisFashion)
gunFashion = BigWorld.WGGunRecoil('G')
fashions.append(gunFashion)
assembler = prepareCompoundAssembler(vehicleDesc, ModelStates.UNDAMAGED, BigWorld.camera().spaceID if BigWorld.player().spaceID == 0 else BigWorld.player().spaceID)
BigWorld.loadResourceListBG((assembler,), functools.partial(setupTank, chassisFashion, gunFashion, vehicleDesc, worldMatrix))
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 __init__(self, beginExplosionPos, endExplosionPos, areaWidth, velocity):
CallbackDelayer.__init__(self)
self.model = BigWorld.Model('helpers/models/unit_cube.model')
BigWorld.addModel(self.model)
self.model.position = beginExplosionPos
linearHomer = BigWorld.LinearHomer()
self.model.addMotor(linearHomer)
linearHomer.align = mathUtils.createSRTMatrix((areaWidth, 5, 1), (0.0, 0, 0), Vector3(0, 0, 0))
linearHomer.acceleration = 0
linearHomer.velocity = velocity
linearHomer.target = mathUtils.createTranslationMatrix(endExplosionPos)
linearHomer.proximityCallback = self.__onDeath
def __init__(self, beginExplosionPos, endExplosionPos, areaWidth, velocity):
CallbackDelayer.__init__(self)
self.model = BigWorld.Model("helpers/models/unit_cube.model")
BigWorld.addModel(self.model)
self.model.position = beginExplosionPos
linearHomer = BigWorld.LinearHomer()
self.model.addMotor(linearHomer)
linearHomer.align = mathUtils.createSRTMatrix((areaWidth, 5, 1), (0.0, 0, 0), Vector3(0, 0, 0))
linearHomer.acceleration = 0
linearHomer.velocity = velocity
linearHomer.target = mathUtils.createTranslationMatrix(endExplosionPos)
linearHomer.proximityCallback = self.__onDeath
def __createDirectedLine(self, pointA, pointB, width):
modelName = self.CUBE_MODEL
model, motor = self.__getModel(modelName)
direction = pointB - pointA
scale = (width, width, direction.length)
rotation = (direction.yaw, direction.pitch, 0)
translation = pointA + direction * 0.5
m = mathUtils.createSRTMatrix(scale, rotation, translation)
m.preMultiply(
mathUtils.createTranslationMatrix(Vector3(0.0, -0.5, 0.0)))
motor.signal = m
return (modelName, model, motor)
def computeTransform(confDict):
matDict = {
'preRotate': mathUtils.createIdentityMatrix(),
'postRotate': mathUtils.createIdentityMatrix(),
'vect': mathUtils.createIdentityMatrix()
}
if any(
isinstance(confDict[confKey][0], tuple)
for confKey in matDict.keys()):
for confKey in matDict.keys():
if isinstance(confDict[confKey][0], tuple):
keyframes = []
for keyframe in confDict[confKey]:
timeStamp, value = keyframe
if 'vect' in confKey:
Mat = mathUtils.createTranslationMatrix(value)
else:
Mat = mathUtils.createRotationMatrix(value)
keyframes.append((timeStamp, Mat))
MatAn = Math.MatrixAnimation()
MatAn.keyframes = keyframes
MatAn.time = 0.0
MatAn.loop = True
elif 'vect' in confKey:
MatAn = mathUtils.createTranslationMatrix(confDict[confKey])
else:
MatAn = mathUtils.createRotationMatrix(confDict[confKey])
matDict[confKey] = MatAn
matProd = mathUtils.MatrixProviders.product(matDict['vect'],
matDict['postRotate'])
LightMat = mathUtils.MatrixProviders.product(matDict['preRotate'],
matProd)
else:
preRotate = mathUtils.createRotationMatrix(confDict['preRotate'])
postRotate = mathUtils.createRotationMatrix(confDict['postRotate'])
LightMat = mathUtils.createTranslationMatrix(confDict['vect'])
LightMat.postMultiply(postRotate)
LightMat.preMultiply(preRotate)
return LightMat
def setup(self, position, direction, size, visualPath, color, marker):
self.__fakeModel = model = BigWorld.player().newFakeModel()
model.position = position
model.yaw = direction.yaw
BigWorld.addModel(model)
rootNode = model.node('')
self.__terrainSelectedArea = area = BigWorld.PyTerrainSelectedArea()
area.setup(visualPath, size, OVER_TERRAIN_HEIGHT, color)
rootNode.attach(area)
markerTranslation = mathUtils.MatrixProviders.product(rootNode, mathUtils.createTranslationMatrix(Math.Vector3(0.0, MARKER_HEIGHT, 0.0)))
self.__nextPosition = position
self.__speed = Math.Vector3(0.0, 0.0, 0.0)
self.__time = 0.0
def __create3DText(self, position, text, color, textSize):
if self.reuse3DTexts:
model, motor, component = self.reuse3DTexts.pop()
else:
attachment = GUI.Attachment()
component = GUI.Text(text)
attachment.component = component
attachment.faceCamera = True
motor = BigWorld.Servo(mathUtils.createTranslationMatrix(position))
model = BigWorld.Model('')
model.addMotor(motor)
BigWorld.addModel(model, self.spaceID)
model.root.attach(attachment)
component.visible = True
component.multiline = True
component.explicitSize = True
component.filterType = 'LINEAR'
component.verticalAnchor = 'BOTTOM'
component.text = text
component.size = (0, textSize)
component.colour = color
motor.signal = mathUtils.createTranslationMatrix(position)
return (model, motor, component)
def prepareCompoundAssembler(vehicleDesc, modelStateName, spaceID, isTurretDetached = False):
if constants.IS_DEVELOPMENT and modelStateName not in VehicleDamageState.MODEL_STATE_NAMES:
raise Exception('Invalid modelStateName %s, must be in %s' % (modelStateName, VehicleDamageState.MODEL_STATE_NAMES))
if spaceID is None:
spaceID = BigWorld.player().spaceID
partModels = getPartModelsFromDesc(vehicleDesc, modelStateName)
chassis, hull, turret, gun = partModels
assembler = BigWorld.CompoundAssembler()
skeleton = getSkeleton(vehicleDesc, modelStateName)
assembler.addRootPart(chassis, TankPartNames.CHASSIS, skeleton.chassis, mathUtils.createIdentityMatrix())
assembler.emplacePart(hull, 'V', TankPartNames.HULL, skeleton.hull)
turretJointName = vehicleDesc.hull['turretHardPoints'][0]
assembler.renameNode(turretJointName, TankNodeNames.TURRET_JOINT)
if not isTurretDetached:
assembler.addPart(turret, TankNodeNames.TURRET_JOINT, TankPartNames.TURRET, skeleton.turret, mathUtils.createIdentityMatrix())
assembler.addPart(gun, TankNodeNames.GUN_JOINT, TankPartNames.GUN, skeleton.gun, mathUtils.createIdentityMatrix())
cornerPoint = vehicleDesc.chassis['topRightCarryingPoint']
assembler.addDummyNode(TankPartNames.CHASSIS, TankNodeNames.TRACK_LEFT_MID, mathUtils.createTranslationMatrix((-cornerPoint[0], 0, 0)))
assembler.addDummyNode(TankPartNames.CHASSIS, TankNodeNames.TRACK_RIGHT_MID, mathUtils.createTranslationMatrix((cornerPoint[0], 0, 0)))
assembler.addDummyNode(TankPartNames.CHASSIS, TankNodeNames.CHASSIS_MID_TRAIL)
assembler.assemblerName = vehicleDesc.name
assembler.spaceID = spaceID
return assembler
def prepareCompoundAssembler(vehicleDesc,
modelStateName,
spaceID,
isTurretDetached=False):
if constants.IS_DEVELOPMENT and modelStateName not in VehicleDamageState.MODEL_STATE_NAMES:
raise Exception('Invalid modelStateName %s, must be in %s' %
(modelStateName, VehicleDamageState.MODEL_STATE_NAMES))
if spaceID is None:
spaceID = BigWorld.player().spaceID
partModels = getPartModelsFromDesc(vehicleDesc, modelStateName)
chassis, hull, turret, gun = partModels
assembler = BigWorld.CompoundAssembler()
skeleton = getSkeleton(vehicleDesc, modelStateName)
assembler.addRootPart(chassis, TankPartNames.CHASSIS, skeleton.chassis,
mathUtils.createIdentityMatrix())
assembler.emplacePart(hull, 'V', TankPartNames.HULL, skeleton.hull)
turretJointName = vehicleDesc.hull['turretHardPoints'][0]
assembler.renameNode(turretJointName, TankNodeNames.TURRET_JOINT)
if not isTurretDetached:
assembler.addPart(turret, TankNodeNames.TURRET_JOINT,
TankPartNames.TURRET, skeleton.turret,
mathUtils.createIdentityMatrix())
assembler.addPart(gun, TankNodeNames.GUN_JOINT, TankPartNames.GUN,
skeleton.gun, mathUtils.createIdentityMatrix())
cornerPoint = vehicleDesc.chassis['topRightCarryingPoint']
assembler.addDummyNode(
TankPartNames.CHASSIS, TankNodeNames.TRACK_LEFT_MID,
mathUtils.createTranslationMatrix((-cornerPoint[0], 0, 0)))
assembler.addDummyNode(
TankPartNames.CHASSIS, TankNodeNames.TRACK_RIGHT_MID,
mathUtils.createTranslationMatrix((cornerPoint[0], 0, 0)))
assembler.addDummyNode(TankPartNames.CHASSIS,
TankNodeNames.CHASSIS_MID_TRAIL)
assembler.assemblerName = vehicleDesc.name
assembler.spaceID = spaceID
return assembler
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 setupTank(chassisFashion, gunFashion, vehicleDesc, worldMatrix, resources):
print resources
tank = resources[vehicleDesc.name]
tank.matrix = worldMatrix
tanks.append(tank)
effect = Pixie.create('particles/Tank/exhaust/large_gas_gear.xml')
tank.node('HP_gunFire').attach(effect)
tank.node('HP_gunFire').attach(
BigWorld.Model('helpers/models/position_gizmo.model'))
tank.node('HP_Track_Exhaus_1').attach(
BigWorld.Model('helpers/models/unit_cube.model'))
m = mathUtils.createTranslationMatrix(Vector3(0, 10, 5))
fakeMatrixes.append(m)
tank.node('gun').attach(effect.clone(), m)
BigWorld.addModel(tank)
recoilDescr = vehicleDesc.gun['recoil']
recoil = BigWorld.RecoilAnimator(recoilDescr['backoffTime'],
recoilDescr['returnTime'],
recoilDescr['amplitude'],
recoilDescr['lodDist'])
recoil.basisMatrix = tank.node('G').localMatrix
recoil = assemblerModule.createGunAnimator(vehicleDesc,
tank.node('G').localMatrix)
recoil.lodSetting = 10
tank.node('G', recoil)
gunFashion.gunLocalMatrix = recoil
recoil.lodLink = DataLinks.createFloatLink(chassisFashion, 'lastLod')
swingingAnimator = assemblerModule.createSwingingAnimator(
vehicleDesc,
tank.node('hull').localMatrix, worldMatrix)
chassisFashion.setupSwinging(swingingAnimator, 'hull')
swingingAnimator.lodLink = DataLinks.createFloatLink(
chassisFashion, 'lastLod')
tank.setupFashions([chassisFashion, None, None, gunFashion])
fashions.append(swingingAnimator)
tank.node('hull', swingingAnimator)
animMatrix = Math.MatrixAnimation()
keys = []
for x in xrange(100):
angle = math.pi * 0.5 * (1 if x & 1 else -1)
keys.append((x * 3, mathUtils.createRotationMatrix((angle, 0, 0))))
animMatrix.keyframes = tuple(keys)
tank.node('turret', animMatrix)
return
def __getRemoteAim(self, allowModeChange=True):
player = BigWorld.player()
vehicle = player.getVehicleAttached()
pos = Math.Vector3(vehicle.position)
pos += player.remoteCameraSniper.camMatrixTranslation
camMat = mathUtils.createTranslationMatrix(-pos)
dir = player.remoteCameraSniper.camMatrixRotation
getVector3 = getattr(player.filter, 'getVector3', None)
if getVector3 is not None:
time = BigWorld.serverTime()
dirFiltered = getVector3(AVATAR_SUBFILTERS.CAMERA_SNIPER_ROTATION,
time)
dir = dirFiltered
else:
LOG_WARNING(
"SniperCamera.__getRemoteAim, the filter doesn't have getVector3 method!"
)
camMat.postMultiply(mathUtils.createRotationMatrix(dir))
return camMat
def setupTank(chassisFashion, gunFashion, vehicleDesc, worldMatrix, resources):
print resources
tank = resources[vehicleDesc.name]
tank.matrix = worldMatrix
tanks.append(tank)
effect = Pixie.create('particles/Tank/exhaust/large_gas_gear.xml')
tank.node('HP_gunFire').attach(effect)
tank.node('HP_gunFire').attach(BigWorld.Model('helpers/models/position_gizmo.model'))
tank.node('HP_Track_Exhaus_1').attach(BigWorld.Model('helpers/models/unit_cube.model'))
m = mathUtils.createTranslationMatrix(Vector3(0, 10, 5))
fakeMatrixes.append(m)
tank.node('gun').attach(effect.clone(), m)
BigWorld.addModel(tank)
recoilDescr = vehicleDesc.gun['recoil']
recoil = BigWorld.RecoilAnimator(recoilDescr['backoffTime'], recoilDescr['returnTime'], recoilDescr['amplitude'], recoilDescr['lodDist'])
recoil.basisMatrix = tank.node('G').localMatrix
recoil = assemblerModule.createGunAnimator(vehicleDesc, tank.node('G').localMatrix)
recoil.lodSetting = 10
tank.node('G', recoil)
gunFashion.gunLocalMatrix = recoil
recoil.lodLink = DataLinks.createFloatLink(chassisFashion, 'lastLod')
swingingAnimator = assemblerModule.createSwingingAnimator(vehicleDesc, tank.node('hull').localMatrix, worldMatrix)
chassisFashion.setupSwinging(swingingAnimator, 'hull')
swingingAnimator.lodLink = DataLinks.createFloatLink(chassisFashion, 'lastLod')
tank.setupFashions([chassisFashion,
None,
None,
gunFashion])
fashions.append(swingingAnimator)
tank.node('hull', swingingAnimator)
animMatrix = Math.MatrixAnimation()
keys = []
for x in xrange(100):
angle = math.pi * 0.5 * (1 if x & 1 else -1)
keys.append((x * 3, mathUtils.createRotationMatrix((angle, 0, 0))))
animMatrix.keyframes = tuple(keys)
tank.node('turret', animMatrix)
return
def __onFarPosUpdated(self):
entries = self.__entries
arena = BigWorld.player().arena
vehicles = arena.vehicles
for id, pos in arena.positions.iteritems():
entry = entries.get(id)
if entry is not None:
location = entry['location']
if location == VehicleLocation.FAR:
entry['matrix'] = mathUtils.createTranslationMatrix(pos)
elif location == VehicleLocation.AOI_TO_FAR:
self.__delEntry(id)
self.__addEntry(id, VehicleLocation.FAR, False)
elif vehicles[id]['isAlive']:
self.__addEntry(id, VehicleLocation.FAR, True)
for id in set(entries).difference(set(arena.positions)):
location = entries[id]['location']
if location == VehicleLocation.FAR:
self.__delEntry(id)
elif location == VehicleLocation.AOI_TO_FAR:
self.__delEntry(id)
def notifyViewPointChanged(self, avatar, staticPosition = None):
if staticPosition is not None:
self.__setTarget(mathUtils.createTranslationMatrix(staticPosition))
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)
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 getTurretMatrixProvider(vehicleTypeDescriptor, vehicleMatrixProvider, turretYawMatrixProvider):
turretOffset = vehicleTypeDescriptor.chassis['hullPosition'] + vehicleTypeDescriptor.hull['turretPositions'][0]
return MatrixProviders.product(turretYawMatrixProvider, MatrixProviders.product(mathUtils.createTranslationMatrix(turretOffset), vehicleMatrixProvider))
def getGunMatrixProvider(vehicleTypeDescriptor, turretMatrixProvider, gunPitchMatrixProvider):
gunOffset = vehicleTypeDescriptor.turret['gunPosition']
return MatrixProviders.product(gunPitchMatrixProvider, MatrixProviders.product(mathUtils.createTranslationMatrix(gunOffset), turretMatrixProvider))
def createCrosshairMatrix(offsetFromNearPlane):
nearPlane = BigWorld.projection().nearPlane
return mathUtils.createTranslationMatrix(Vector3(0, 0, nearPlane + offsetFromNearPlane))
def notifyViewPointChanged(self, avatar, staticPosition=None):
if staticPosition is not None:
self.__setTarget(mathUtils.createTranslationMatrix(staticPosition))
return
def new_setupModel(base, self, buildIdx):
base(self, buildIdx)
if not g_config.data['enabled']:
return
vEntityId = self._VehicleAppearance__vEntityId
vEntity = BigWorld.entity(vEntityId)
vDesc = self._VehicleAppearance__vDesc
compoundModel = vEntity.model
self.collisionLoaded = True
self.modifiedModelsDesc = dict([(partName, {'model': None, 'matrix': None}) for partName in TankPartNames.ALL])
self.modifiedModelsDesc.update([(
'%s%d' % ((TankPartNames.ADDITIONAL_TURRET if idx % 2 == 0 else TankPartNames.ADDITIONAL_GUN), (idx + 2)/2),
{'model': None, 'matrix': None})
for idx in xrange(len(vDesc.turrets[1:]) * 2)])
failList = []
for partName in self.modifiedModelsDesc.keys():
modelName = ''
try:
if 'additional' not in partName:
modelName = getattr(vDesc, partName).hitTester.bspModelName
else:
_, addPartName, idxStr = partName.split('_')
modelName = getattr(vDesc.turrets[int(idxStr)], addPartName).hitTester.bspModelName
self.modifiedModelsDesc[partName]['model'] = model = BigWorld.Model(modelName)
model.visible = False
except StandardError:
self.collisionLoaded = False
failList.append(modelName if modelName else partName)
if failList:
print 'RemodEnabler: collision load failed: models not found'
print failList
if not self.collisionLoaded:
return
if any((g_config.data['collisionEnabled'], g_config.data['collisionComparisonEnabled'])):
# Getting offset matrices
hullOffset = mathUtils.createTranslationMatrix(vDesc.chassis.hullPosition)
self.modifiedModelsDesc[TankPartNames.CHASSIS]['matrix'] = fullChassisMP = mathUtils.createIdentityMatrix()
hullMP = mathUtils.MatrixProviders.product(mathUtils.createIdentityMatrix(), hullOffset)
self.modifiedModelsDesc[TankPartNames.HULL]['matrix'] = fullHullMP = mathUtils.MatrixProviders.product(
hullMP, fullChassisMP)
for idx, turretPosition in enumerate(vDesc.hull.turretPositions):
turretOffset = mathUtils.createTranslationMatrix(vDesc.hull.turretPositions[idx])
gunOffset = mathUtils.createTranslationMatrix(vDesc.turrets[idx].turret.gunPosition)
# Getting local transform matrices
turretMP = mathUtils.MatrixProviders.product(mathUtils.createIdentityMatrix(), turretOffset)
gunMP = mathUtils.MatrixProviders.product(mathUtils.createIdentityMatrix(), gunOffset)
# turretMP = mathUtils.MatrixProviders.product(vEntity.appearance.turretMatrix, turretOffset)
# gunMP = mathUtils.MatrixProviders.product(vEntity.appearance.gunMatrix, gunOffset)
# Getting full transform matrices relative to vehicle coordinate system
self.modifiedModelsDesc[TankPartNames.TURRET if not idx else '%s%d' % (TankPartNames.ADDITIONAL_TURRET, idx)][
'matrix'] = fullTurretMP = mathUtils.MatrixProviders.product(turretMP, fullHullMP)
self.modifiedModelsDesc[TankPartNames.GUN if not idx else '%s%d' % (TankPartNames.ADDITIONAL_GUN, idx)][
'matrix'] = mathUtils.MatrixProviders.product(gunMP, fullTurretMP)
for moduleName, moduleDict in self.modifiedModelsDesc.items():
motor = BigWorld.Servo(mathUtils.MatrixProviders.product(moduleDict['matrix'], vEntity.matrix))
moduleDict['model'].addMotor(motor)
if moduleDict['model'] not in tuple(vEntity.models):
try:
vEntity.addModel(moduleDict['model'])
except StandardError:
pass
moduleDict['model'].visible = True
addCollisionGUI(self)
if g_config.data['collisionEnabled']:
for moduleName in TankPartNames.ALL:
if compoundModel.node(moduleName) is not None:
scaleMat = Math.Matrix()
scaleMat.setScale((0.001, 0.001, 0.001))
compoundModel.node(moduleName, scaleMat)
else:
print 'RemodEnabler: model rescale for %s failed' % moduleName
def __cameraUpdate(self, allowModeChange=True):
curTime = BigWorld.time()
deltaTime = curTime - self.__prevTime
self.__prevTime = curTime
if not self.__autoUpdateDxDyDz.x == self.__autoUpdateDxDyDz.y == self.__autoUpdateDxDyDz.z == 0.0:
self.__rotateAndZoom(self.__autoUpdateDxDyDz.x,
self.__autoUpdateDxDyDz.y,
self.__autoUpdateDxDyDz.z)
self.__aimingSystem.update(deltaTime)
localTransform, impulseTransform = self.__updateOscillators(deltaTime)
player = BigWorld.player()
vehicle = player.getVehicleAttached()
zoom = self.__zoom
if self.__isRemoteCamera and vehicle is not None:
camMat = self.__getRemoteAim(allowModeChange)
if camMat is None:
return 0.0
zoom = float(player.remoteCameraSniper.zoom)
else:
aimMatrix = cameras.getAimMatrix(self.__defaultAimOffset.x,
self.__defaultAimOffset.y)
camMat = Matrix(aimMatrix)
rodMat = mathUtils.createTranslationMatrix(
-self.__dynamicCfg['pivotShift'])
antiRodMat = mathUtils.createTranslationMatrix(
self.__dynamicCfg['pivotShift'])
camMat.postMultiply(rodMat)
camMat.postMultiply(localTransform)
camMat.postMultiply(antiRodMat)
camMat.postMultiply(self.__aimingSystem.matrix)
camMat.invert()
if not player.isObserver() and vehicle is not None:
relTranslation = self.__cam.position - vehicle.position
rot = Math.Vector3(camMat.yaw, camMat.pitch, camMat.roll)
vehicle.setSniperCameraDataForObservers(relTranslation, rot, zoom)
self.__cam.set(camMat)
if zoom != self.__zoom:
self.__zoom = zoom
self.__applyZoom(self.__zoom)
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
aimOffset = replayCtrl.getAimClipPosition()
binocularsOffset = aimOffset
if not BigWorld.player().isForcedGuiControlMode() and GUI.mcursor(
).inFocus:
GUI.mcursor().position = aimOffset
else:
aimOffset = self.__calcAimOffset(impulseTransform)
binocularsOffset = self.__calcAimOffset()
if replayCtrl.isRecording:
replayCtrl.setAimClipPosition(aimOffset)
self.__aimOffset = aimOffset
self.__binoculars.setMaskCenter(binocularsOffset.x, binocularsOffset.y)
if not self.__isRemoteCamera and allowModeChange and (
self.__isPositionUnderwater(
self.__aimingSystem.matrix.translation)
or player.isGunLocked):
self.__onChangeControlMode(False)
return -1
else:
return 0.0
def new_setupModel(base, self, buildIdx):
base(self, buildIdx)
if not g_config.data['enabled']:
return
if g_config.collisionMode:
vEntity = self._HangarVehicleAppearance__vEntity
vDesc = self._HangarVehicleAppearance__vDesc
compoundModel = vEntity.model
self.collisionLoaded = True
self.modifiedModelsDesc = {}
failList = []
for partName in TankPartNames.ALL:
modelName = ''
try:
modelName = getattr(vDesc, partName).hitTester.bspModelName
model = BigWorld.Model(modelName)
model.visible = False
self.modifiedModelsDesc[partName] = {
'model': model,
'matrix': None
}
except StandardError:
self.collisionLoaded = False
failList.append(modelName if modelName else partName)
if failList:
print g_config.ID + ': collision load failed: models not found', failList
if not self.collisionLoaded:
return
# Getting offset matrices
hullOffset = mathUtils.createTranslationMatrix(
vDesc.chassis.hullPosition)
self.modifiedModelsDesc[TankPartNames.CHASSIS][
'matrix'] = fullChassisMP = mathUtils.createIdentityMatrix()
hullMP = mathUtils.MatrixProviders.product(
mathUtils.createIdentityMatrix(), hullOffset)
self.modifiedModelsDesc[TankPartNames.HULL][
'matrix'] = fullHullMP = mathUtils.MatrixProviders.product(
hullMP, fullChassisMP)
for idx in xrange(len(vDesc.hull.turretPositions)):
if idx:
print g_config.ID + ': WARNING: multiple turrets are present!', vDesc.name
break
turretOffset = mathUtils.createTranslationMatrix(
vDesc.hull.turretPositions[idx])
gunOffset = mathUtils.createTranslationMatrix(
vDesc.turret.gunPosition)
# Getting local transform matrices
turretMP = mathUtils.MatrixProviders.product(
mathUtils.createIdentityMatrix(), turretOffset)
gunMP = mathUtils.MatrixProviders.product(
mathUtils.createIdentityMatrix(), gunOffset)
# turretMP = mathUtils.MatrixProviders.product(vEntity.appearance.turretMatrix, turretOffset)
# gunMP = mathUtils.MatrixProviders.product(vEntity.appearance.gunMatrix, gunOffset)
# Getting full transform matrices relative to vehicle coordinate system
self.modifiedModelsDesc[TankPartNames.TURRET][
'matrix'] = fullTurretMP = mathUtils.MatrixProviders.product(
turretMP, fullHullMP)
self.modifiedModelsDesc[TankPartNames.GUN][
'matrix'] = mathUtils.MatrixProviders.product(
gunMP, fullTurretMP)
for moduleDict in self.modifiedModelsDesc.itervalues():
motor = BigWorld.Servo(
mathUtils.MatrixProviders.product(moduleDict['matrix'],
vEntity.matrix))
moduleDict['model'].addMotor(motor)
if moduleDict['model'] not in tuple(vEntity.models):
try:
vEntity.addModel(moduleDict['model'])
except StandardError:
pass
moduleDict['model'].visible = True
addCollisionGUI(self)
if g_config.collisionMode == 1:
for moduleName in TankPartNames.ALL:
# noinspection PyUnboundLocalVariable
if compoundModel.node(moduleName) is not None:
scaleMat = Math.Matrix()
scaleMat.setScale((0.001, 0.001, 0.001))
compoundModel.node(moduleName, scaleMat)
else:
print g_config.ID + ': model rescale for', moduleName, 'failed'
def lightsCreate(vehicleID, callPlace=''):
try:
vehicle = BigWorld.player().arena.vehicles[vehicleID]
vEntity = BigWorld.entity(vehicleID)
if vEntity is None:
return
vDesc = vEntity.typeDescriptor
if vehicleID == BigWorld.player().playerVehicleID:
print 'LampLights: Create at %s' % callPlace
constNodesList = [
TankNodeNames.TRACK_LEFT_UP_FRONT,
TankNodeNames.TRACK_LEFT_UP_REAR,
TankNodeNames.TRACK_RIGHT_UP_FRONT,
TankNodeNames.TRACK_RIGHT_UP_REAR
]
compoundModel = vEntity.appearance.compoundModel
nodeListML, nodeListNL = findWheelNodes(vehicleID, 'L')
nodeListMR, nodeListNR = findWheelNodes(vehicleID, 'R')
fakesDict[vehicleID] = fakeDict = {}
fakeMotorsDict[vehicleID] = fakeMotorDict = {}
sourcesDict = {TankPartNames.CHASSIS: None, TankPartNames.HULL: None}
for tankPartName in sourcesDict.keys():
curSource = getattr(vDesc, tankPartName).models.undamaged
modelSec = ResMgr.openSection(curSource)
if modelSec is None:
print 'LampLights: file not found:', curSource
sourceSecStr = modelSec['nodefullVisual'].asString
sourceSec = ResMgr.openSection(sourceSecStr + '.visual')
if sourceSec is None:
sourceSec = ResMgr.openSection(sourceSecStr +
'.visual_processed')
if sourceSec is None:
print 'LampLights: visual not found for', curSource
print callPlace
else:
sourcesDict[tankPartName] = sourceSec
HullMat = mathUtils.createIdentityMatrix()
deHullMat = mathUtils.createIdentityMatrix()
if sourcesDict[TankPartNames.CHASSIS] is not None:
deHullMat = nodeWatcher(sourcesDict[TankPartNames.CHASSIS], 'V')
deHullMat.invert()
for tankPartName in (TankPartNames.CHASSIS, TankPartNames.HULL):
fakeDict[tankPartName] = BigWorld.Model('objects/fake_model.model')
fakeDict[tankPartName +
'Root'] = BigWorld.Model('objects/fake_model.model')
compoundModel.node(TankPartNames.HULL).attach(
fakeDict[tankPartName + 'Root'],
HullMat if 'hull' in tankPartName else deHullMat)
if fakeMotorDict.get(tankPartName) not in tuple(
fakeDict[tankPartName].motors):
fakeMotorDict[tankPartName] = BigWorld.Servo(
fakeDict[tankPartName + 'Root'].matrix)
fakeDict[tankPartName].addMotor(fakeMotorDict[tankPartName])
if fakeDict[tankPartName] not in tuple(BigWorld.models()):
BigWorld.addModel(fakeDict[tankPartName])
for idx, node in enumerate(nodeListNL):
fakeDict[node] = BigWorld.Model('objects/fake_model.model')
fakeDict[TankPartNames.CHASSIS].node('', nodeListML[idx]).attach(
fakeDict[node])
for idx, node in enumerate(nodeListNR):
fakeDict[node] = BigWorld.Model('objects/fake_model.model')
fakeDict[TankPartNames.CHASSIS].node('', nodeListMR[idx]).attach(
fakeDict[node])
for node in constNodesList:
fakeDict[node] = BigWorld.Model('objects/fake_model.model')
restoreMat = mathUtils.createIdentityMatrix()
transMat = None
isChassis = False
if sourcesDict[TankPartNames.HULL] is not None:
transMat = nodeWatcher(sourcesDict[TankPartNames.HULL], node)
if transMat is None and sourcesDict[
TankPartNames.CHASSIS] is not None:
transMat = nodeWatcher(sourcesDict[TankPartNames.CHASSIS],
node)
if transMat is None:
transMat = nodeWatcher(sourcesDict[TankPartNames.CHASSIS],
node.replace('Up', ''))
isChassis = True
if transMat is None:
print _config.ID + ': restore Matrix not found for node', node, 'in', vDesc.hull.models.undamaged
print callPlace
else:
restoreMat.setTranslate(transMat.translation)
fakeDict[TankPartNames.HULL if not isChassis else TankPartNames.
CHASSIS].node('', restoreMat).attach(fakeDict[node])
fakeDict[TankPartNames.GUN +
'Root'] = BigWorld.Model('objects/fake_model.model')
compoundModel.node(TankPartNames.GUN).attach(
fakeDict[TankPartNames.GUN + 'Root'])
fakeDict[TankPartNames.GUN] = BigWorld.Model(
'objects/fake_model.model')
if fakeMotorDict.get(TankPartNames.GUN) not in tuple(
fakeDict[TankPartNames.GUN].motors):
fakeMotorDict[TankPartNames.GUN] = BigWorld.Servo(
fakeDict[TankPartNames.GUN + 'Root'].matrix)
fakeDict[TankPartNames.GUN].addMotor(
fakeMotorDict[TankPartNames.GUN])
if fakeDict[TankPartNames.GUN] not in tuple(BigWorld.models()):
BigWorld.addModel(fakeDict[TankPartNames.GUN])
fakeDict[TankPartNames.TURRET] = BigWorld.Model(
'objects/fake_model.model')
fakeDict[TankPartNames.TURRET +
'Root'] = BigWorld.Model('objects/fake_model.model')
fakeDict[TankPartNames.TURRET +
'RootRoot'] = BigWorld.Model('objects/fake_model.model')
hull_bbox_min, hull_bbox_max, _ = vDesc.hull.hitTester.bbox
turret_pos_on_hull = vDesc.hull.turretPositions[0]
turret_bbox_max = vDesc.turret.hitTester.bbox[1]
gun_pos_on_turret = vDesc.turret.gunPosition
gun_pos_on_hull = gun_pos_on_turret + turret_pos_on_hull
gun_bbox_max = vDesc.gun.hitTester.bbox[1]
if hull_bbox_max.y >= turret_pos_on_hull.y + turret_bbox_max.y:
observer_pos = Math.Vector3(0, hull_bbox_max.y, 0)
node = TankPartNames.HULL
elif gun_pos_on_turret.y + gun_bbox_max.y >= turret_bbox_max.y:
observer_pos = Math.Vector3(0, gun_bbox_max.y, 0)
node = TankPartNames.GUN
else:
observer_pos = Math.Vector3(0, turret_bbox_max.y, 0)
node = TankPartNames.TURRET
mat = Math.Matrix()
mat.setTranslate(observer_pos)
compoundModel.node(node).attach(fakeDict[TankPartNames.TURRET +
'RootRoot'])
if fakeMotorDict.get(TankPartNames.TURRET + 'Root') not in tuple(
fakeDict[TankPartNames.TURRET + 'Root'].motors):
fakeMotorDict[TankPartNames.TURRET + 'Root'] = BigWorld.Servo(
fakeDict[TankPartNames.TURRET + 'RootRoot'].matrix)
fakeDict[TankPartNames.TURRET + 'Root'].addMotor(
fakeMotorDict[TankPartNames.TURRET + 'Root'])
if fakeDict[TankPartNames.TURRET + 'Root'] not in tuple(
BigWorld.models()):
BigWorld.addModel(fakeDict[TankPartNames.TURRET + 'Root'])
fakeDict[TankPartNames.TURRET + 'Root'].node('', mat).attach(
fakeDict[TankPartNames.TURRET])
hullLocalCenterY = (hull_bbox_min.y + hull_bbox_max.y) / 2.0
hullLocalCenterZ = (hull_bbox_min.z + hull_bbox_max.z) / 2.0
nodes = {
'hullLocalPt1':
Math.Vector3(0.0, hullLocalCenterY, hull_bbox_max.z),
'hullLocalPt2':
Math.Vector3(0.0, hullLocalCenterY, hull_bbox_min.z),
'hullLocalPt3':
Math.Vector3(hull_bbox_max.x, gun_pos_on_hull.y, hullLocalCenterZ),
'hullLocalPt4':
Math.Vector3(hull_bbox_min.x, gun_pos_on_hull.y, hullLocalCenterZ),
'hullGunLocal':
gun_pos_on_hull
}
for node in nodes:
fakeDict[node] = BigWorld.Model('objects/fake_model.model')
fakeDict[TankPartNames.HULL].node(
'', mathUtils.createTranslationMatrix(nodes[node])).attach(
fakeDict[node])
lightDBDict.setdefault(vehicleID, {})
for configDict in _config.configsDict.values():
for name in sorted(configDict.keys()):
try:
if name in ('enable', 'meta', 'attachToPlayer',
'attachToAlly', 'attachToEnemy'):
continue
confDict = configDict[name]
needToAttach = \
confDict['attachToPlayer'] and vehicleID == BigWorld.player().playerVehicleID or \
confDict['attachToEnemy'] and vehicle['team'] != BigWorld.player().team or \
confDict['attachToAlly'] and vehicleID != BigWorld.player().playerVehicleID and \
vehicle['team'] == BigWorld.player().team
if not needToAttach:
continue
nodeL = []
if '.' in name:
nodeL.append(confDict['place'])
elif confDict['place'] == 'leftFront':
nodeL.append(TankNodeNames.TRACK_LEFT_UP_FRONT)
elif confDict['place'] == 'rightFront':
nodeL.append(TankNodeNames.TRACK_RIGHT_UP_FRONT)
elif confDict['place'] == 'leftRear':
nodeL.append(TankNodeNames.TRACK_LEFT_UP_REAR)
elif confDict['place'] == 'rightRear':
nodeL.append(TankNodeNames.TRACK_RIGHT_UP_REAR)
elif confDict['place'] == 'hull':
nodeL.append(TankPartNames.HULL)
elif confDict['place'] == 'turret':
nodeL.append(TankPartNames.TURRET)
elif confDict['place'] == 'spot':
nodeL.extend([TankPartNames.TURRET, TankPartNames.GUN])
nodeL.extend(
['hullLocalPt%s' % num for num in xrange(1, 5)])
nodeL.append('hullGunLocal')
elif 'wheels' in confDict['place']:
if 'left' in confDict['place']:
nodeL.extend(nodeListNL)
else:
nodeL.extend(nodeListNR)
nameTree = name.split('.')[:-1]
namesList = []
for curKey in lightDBDict[vehicleID].keys():
curTree = curKey.split('.')
if len(curTree) != len(nameTree) or any(
upperName not in curTree[depth]
for depth, upperName in enumerate(nameTree)):
continue
namesList.append(curKey + '.' + name.split('.')[-1])
if not namesList:
namesList = [name]
for fullName in namesList:
for node in nodeL:
curName = fullName + ':' + node
if 'model' not in confDict['type']:
if confDict['type'] == 'spotLight':
LightSource = BigWorld.PySpotLight()
LightSource.coneAngle = confDict['ca']
else:
LightSource = BigWorld.PyOmniLight()
if confDict['type'] != 'omniLight':
LOG_ERROR(
'Unknown type of %s: %s. Set to omniLight'
% (name, confDict['type']))
LightSource.innerRadius = confDict[
'innerRadius']
LightSource.outerRadius = confDict[
'outerRadius']
LightSource.castShadows = confDict['cs']
LightSource.multiplier = confDict['bright']
if isinstance(confDict['colour'][0], tuple):
if confDict['type'] != 'spotLight':
FrontLightShader = Math.Vector4Animation(
)
FrontLightShader.duration = confDict[
'dur']
FrontLightShader.keyframes = confDict[
'colour']
LightSource.colorAnimator = FrontLightShader
else:
LightSource.colour = confDict[
'colour'][0][1]
else:
LightSource.colour = confDict['colour']
else:
LightSource = BigWorld.Model(confDict['path'])
if '.' not in name:
if node in fakeDict:
fakeNode = fakeDict[node].node(
'', computeTransform(confDict))
else:
if curName not in fakeDict:
fakeDict[curName] = BigWorld.Model(
'objects/fake_model.model')
lightDBDict[vehicleID][curName.rsplit(
'.', 1)[0]].node(node).attach(
fakeDict[curName])
fakeNode = fakeDict[curName].node(
'', computeTransform(confDict))
if 'model' not in confDict['type']:
LightSource.source = fakeNode
elif not LightSource.attached:
fakeNode.attach(LightSource)
lightVisible(
LightSource, _config.isLampsVisible
and name in _config.modes['constant'])
lightDBDict[vehicleID][curName] = LightSource
except StandardError:
traceback.print_exc()
print name
print callPlace
print vDesc.name
except StandardError:
traceback.print_exc()
print callPlace
def createCrosshairMatrix(offsetFromNearPlane):
nearPlane = BigWorld.projection().nearPlane
return mathUtils.createTranslationMatrix(
Vector3(0, 0, nearPlane + offsetFromNearPlane))
