def __init__(self):
self.__attachedVehicleMatrix = Math.WGAdaptiveMatrixProvider()
self.__attachedVehicleMatrix.target = math_utils.createIdentityMatrix()
self.__ownVehicleMProv = Math.WGAdaptiveMatrixProvider()
self.__ownVehicleMProv.target = math_utils.createIdentityMatrix()
self.__ownVehicleTurretMProv = Math.WGAdaptiveMatrixProvider()
self.__ownVehicleTurretMProv.target = math_utils.createIdentityMatrix()
self.onVehicleMatrixBindingChanged = Event()
def enable(self, **args):
self.measureDeltaTime()
self.delayCallback(0.0, self._update)
camMatrix = args.get('camMatrix', BigWorld.camera().matrix)
self._cam.set(camMatrix)
self._cam.invViewProvider.a = camMatrix
self._cam.invViewProvider.b = math_utils.createIdentityMatrix()
cameraTransitionDuration = args.get('transitionDuration', -1)
if cameraTransitionDuration > 0:
self.__cameraTransition.start(BigWorld.camera().matrix, self._cam,
cameraTransitionDuration)
BigWorld.camera(self.__cameraTransition)
else:
BigWorld.camera(self._cam)
worldMat = Math.Matrix(self._cam.invViewMatrix)
self.__ypr = Math.Vector3(worldMat.yaw, worldMat.pitch, worldMat.roll)
self.__position = worldMat.translation
self.__velocity = Math.Vector3()
self.__yprVelocity = Math.Vector3()
self.__zoomVelocity = 0.0
self.__resetSenses()
self.__basisMProv.bind(None)
self.__rotateAroundPointEnabled = False
self._alignerToLand.disable()
self._cam.speedTreeTarget = self._cam.invViewMatrix
self.resetMovement()
if isPlayerAvatar() and self.guiSessionProvider.getCtx(
).isPlayerObserver():
BigWorld.player().positionControl.moveTo(self.__position)
BigWorld.player().positionControl.followCamera(True)
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 = math_utils.createIdentityMatrix()
self.__lookAtProvider = math_utils.MatrixProviders.product(
math_utils.createTranslationMatrix(self.__boundLocalPos),
self.__vehicle.matrix)
return
def __refineVehicleMProv(self, vehicleMProv):
vehicleTranslationOnly = Math.WGTranslationOnlyMP()
vehicleTranslationOnly.source = vehicleMProv
refinedMatrixProvider = Math.MatrixProduct()
refinedMatrixProvider.a = math_utils.createIdentityMatrix()
refinedMatrixProvider.b = vehicleTranslationOnly
return refinedMatrixProvider
def __init__(self):
self.matrix = math_utils.createIdentityMatrix()
self.__boundLocalPos = None
self.__vehicle = None
self.__lookAtProvider = None
self.__placement = _VehicleBounder.SELECT_CHASSIS
return
def __init__(self, model, nodeToAttach):
self.__model = model
self.__stickerModel = BigWorld.WGStickerModel()
self.__stickerModel.setLODDistance(1000.0)
self.__stickerModel.setupSuperModel(model,
math_utils.createIdentityMatrix())
nodeToAttach.attach(self.__stickerModel)
self.__damageStickers = {}
def __generateDestructionEffect(self, debris):
debrisDesc = debris.debrisDesc
effectData = debrisDesc.destructionEffectData
if effectData is not None:
keyPoints, effects, _ = random.choice(effectData)
debris.boundEffects.addNewToNode(
tankStructure.TankPartNames.CHASSIS,
math_utils.createIdentityMatrix(),
effects,
keyPoints,
isPlayerVehicle=debris.isPlayer)
return
def computeTransform(confDict):
matDict = {
'preRotate': math_utils.createIdentityMatrix(),
'postRotate': math_utils.createIdentityMatrix(),
'vect': math_utils.createIdentityMatrix()
}
if any(
isinstance(confDict[confKey][0], tuple)
for confKey in matDict.keys()):
for confKey in matDict.keys():
if isinstance(confDict[confKey][0], tuple):
keyframes = []
for keyframe in confDict[confKey]:
timeStamp, value = keyframe
if 'vect' in confKey:
Mat = math_utils.createTranslationMatrix(value)
else:
Mat = math_utils.createRotationMatrix(value)
keyframes.append((timeStamp, Mat))
MatAn = Math.MatrixAnimation()
MatAn.keyframes = keyframes
MatAn.time = 0.0
MatAn.loop = True
elif 'vect' in confKey:
MatAn = math_utils.createTranslationMatrix(confDict[confKey])
else:
MatAn = math_utils.createRotationMatrix(confDict[confKey])
matDict[confKey] = MatAn
matProd = math_utils.MatrixProviders.product(matDict['vect'],
matDict['postRotate'])
LightMat = math_utils.MatrixProviders.product(matDict['preRotate'],
matProd)
else:
preRotate = math_utils.createRotationMatrix(confDict['preRotate'])
postRotate = math_utils.createRotationMatrix(confDict['postRotate'])
LightMat = math_utils.createTranslationMatrix(confDict['vect'])
LightMat.postMultiply(postRotate)
LightMat.preMultiply(preRotate)
return LightMat
def createSwingingAnimator(gameObject, vehicleDesc, basisMatrix=None, worldMProv=None, lodLink=None):
swingingAnimator = gameObject.createComponent(Vehicular.SwingingAnimator)
swingingAnimator.basisMatrix = basisMatrix
swingingCfg = vehicleDesc.hull.swinging
pp = tuple((p * m for p, m in zip(swingingCfg.pitchParams, (0.9, 1.88, 0.3, 4.0, 1.0, 1.0))))
swingingAnimator.setupPitchSwinging(*pp)
swingingAnimator.setupRollSwinging(*swingingCfg.rollParams)
swingingAnimator.setupShotSwinging(swingingCfg.sensitivityToImpulse)
swingingAnimator.maxMovementSpeed = vehicleDesc.physics['speedLimits'][0]
swingingAnimator.lodSetting = swingingCfg.lodDist
swingingAnimator.worldMatrix = worldMProv if worldMProv is not None else math_utils.createIdentityMatrix()
swingingAnimator.lodLink = lodLink
return swingingAnimator
def bind(self, vehicle, bindWorldPos=None):
self.__vehicle = vehicle
if vehicle is None:
self.matrix = math_utils.createIdentityMatrix()
self.__lookAtProvider = None
return
else:
toLocalMat = Matrix(vehicle.matrix)
toLocalMat.invert()
self.__boundLocalPos = None if bindWorldPos is None else toLocalMat.applyPoint(
bindWorldPos)
self.selectPlacement(_VehicleBounder.SELECT_CHASSIS)
return
def nodeWatcher(section, nodeName, upperMat=math_utils.createIdentityMatrix()):
retMat = None
for curName, curSect in section.items():
if curName == 'node':
returnMat = Math.Matrix()
returnMat.set(upperMat)
returnMat.postMultiply(curSect['transform'].asMatrix)
if curSect['identifier'].asString == nodeName:
return returnMat
retMat = nodeWatcher(curSect, nodeName, returnMat)
if retMat is not None:
return retMat
return retMat
def __getInsigniaAttachNode(self, insigniaType, isDamaged, compoundModel):
if isDamaged:
toPartRoot = math_utils.createIdentityMatrix()
gunNode = compoundModel.node(TankPartNames.GUN)
else:
if self.__animateGunInsignia:
idx = Insignia.Types.ALL.index(insigniaType)
gunNode = compoundModel.node(Insignia.NodeNames.ALL[idx])
else:
gunNode = compoundModel.node(TankNodeNames.GUN_INCLINATION)
if gunNode is None:
return (None, None)
toPartRoot = Math.Matrix(gunNode)
toPartRoot.invert()
toPartRoot.preMultiply(compoundModel.node(TankNodeNames.GUN_INCLINATION))
return (gunNode, toPartRoot)
def __init__(self, componentIdx, stickerPacks, vDesc, emblemSlots):
self.__componentIdx = componentIdx
self.__stickerPacks = stickerPacks
for slot in emblemSlots:
if slot.type in self.__stickerPacks:
stickerPackTuple = self.__stickerPacks[slot.type]
for stickerPack in stickerPackTuple:
stickerPack.bind(componentIdx, slot)
self.__model = None
self.__toPartRootMatrix = math_utils.createIdentityMatrix()
self.__parentNode = None
self.__isDamaged = False
self.__stickerModel = BigWorld.WGStickerModel()
self.__stickerModel.setLODDistance(vDesc.type.emblemsLodDist)
return
def attach(vehicleID, modID=None, visible=False):
if vehicleID not in dynamic_db:
return
for mod, dyn in dynamic_db[vehicleID].iteritems():
if modID is not None and modID != mod:
continue
dyn['entered'] = True
if not dyn['loaded']:
return
vEntity = BigWorld.entity(vehicleID)
if vEntity is None:
return
compoundModel = vEntity.model
scaleMat = math_utils.createIdentityMatrix()
attachMode = dyn['mode']
if 'scale' in attachMode:
scaleMat.setScale(Math.Vector3(1.025))
for modelDict in dyn['models'].itervalues():
model = modelDict['model']
if model is not None:
if 'attach' in attachMode:
try:
compoundModel.node(modelDict['nodeName']).attach(
model, scaleMat)
except StandardError:
if g_config.data['isDebug']:
traceback.print_exc()
elif 'motor' in attachMode:
if model not in BigWorld.models():
modelDict['motor'] = motor = BigWorld.Servo(
math_utils.MatrixProviders.product(
compoundModel.node(modelDict['nodeName']),
scaleMat))
model.addMotor(motor)
BigWorld.addModel(model)
model.visible = visible and dyn['visible']
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 = math_utils.createTranslationMatrix(
vDesc.chassis.hullPosition)
self.modifiedModelsDesc[TankPartNames.CHASSIS][
'matrix'] = fullChassisMP = math_utils.createIdentityMatrix()
hullMP = math_utils.MatrixProviders.product(
math_utils.createIdentityMatrix(), hullOffset)
self.modifiedModelsDesc[TankPartNames.HULL][
'matrix'] = fullHullMP = math_utils.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 = math_utils.createTranslationMatrix(
vDesc.hull.turretPositions[idx])
gunOffset = math_utils.createTranslationMatrix(
vDesc.turret.gunPosition)
# Getting local transform matrices
turretMP = math_utils.MatrixProviders.product(
math_utils.createIdentityMatrix(), turretOffset)
gunMP = math_utils.MatrixProviders.product(
math_utils.createIdentityMatrix(), gunOffset)
# turretMP = math_utils.MatrixProviders.product(vEntity.appearance.turretMatrix, turretOffset)
# gunMP = math_utils.MatrixProviders.product(vEntity.appearance.gunMatrix, gunOffset)
# Getting full transform matrices relative to vehicle coordinate system
self.modifiedModelsDesc[TankPartNames.TURRET][
'matrix'] = fullTurretMP = math_utils.MatrixProviders.product(
turretMP, fullHullMP)
self.modifiedModelsDesc[TankPartNames.GUN][
'matrix'] = math_utils.MatrixProviders.product(
gunMP, fullTurretMP)
for moduleDict in self.modifiedModelsDesc.itervalues():
motor = BigWorld.Servo(
math_utils.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'
Math.Vector4(DEFAULT_GLOSS),
Math.Vector4(DEFAULT_METALLIC), False, '')
ProjectionDecalGenericParams = namedtuple(
'ProjectionDecalGenericParams',
('tintColor', 'position', 'rotation', 'scale', 'decalMap', 'glossDecalMap',
'applyAreas', 'clipAngle', 'mirroredHorizontally', 'mirroredVertically',
'doubleSided', 'scaleBySlotSize'))
ProjectionDecalGenericParams.__new__.__defaults__ = (Math.Vector4(0.0),
Math.Vector3(0.0),
Math.Vector3(
0.0, 1.0, 0.0), 1.0,
'', '', 0.0, 0.0, False,
False, False, True)
ModelAnimatorParams = namedtuple('ModelAnimatorParams',
('transform', 'attachNode', 'animatorName'))
ModelAnimatorParams.__new__.__defaults__ = (math_utils.createIdentityMatrix(),
'', '')
LoadedModelAnimator = namedtuple('LoadedModelAnimator',
('animator', 'node', 'attachmentPartNode'))
AttachmentParams = namedtuple(
'AttachmentParams',
('transform', 'attachNode', 'modelName', 'sequenceId', 'attachmentLogic',
'initialVisibility', 'partNodeAlias'))
AttachmentParams.__new__.__defaults__ = (math_utils.createIdentityMatrix(), '',
'', None, '', True, '')
_isDeferredRenderer = isRendererPipelineDeferred()
def prepareFashions(isDamaged):
if isDamaged:
fashions = [None, None, None, None]
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 = math_utils.createIdentityMatrix()
deHullMat = math_utils.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 = math_utils.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(
'', math_utils.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']:
# noinspection PyUnboundLocalVariable
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 __init__(self):
self._matrix = math_utils.createIdentityMatrix()
def __relinkToIdentity(self):
self.__outputMProv.rotationSrc = math_utils.createIdentityMatrix()
self.__outputMProv.translationSrc = self.__outputMProv.rotationSrc
self.__stabilisedMProv.target = self.__outputMProv.rotationSrc
