def prerequisites(self, typeDescriptor, vID, health, isCrewActive, isTurretDetached, outfitCD, renderMode=None):
self.damageState.update(health, isCrewActive, False)
self.__typeDesc = typeDescriptor
self.__vID = vID
self._isTurretDetached = isTurretDetached
self.__updateModelStatus()
self.__outfit = self._prepareOutfit(outfitCD)
if self.damageState.isCurrentModelUndamaged:
self.__attachments = camouflages.getAttachments(self.outfit, self.typeDescriptor)
self.__renderMode = renderMode
prereqs = self.typeDescriptor.prerequisites(True)
prereqs.extend(camouflages.getCamoPrereqs(self.outfit, self.typeDescriptor))
prereqs.extend(camouflages.getModelAnimatorsPrereqs(self.outfit, self.spaceID))
prereqs.extend(camouflages.getAttachmentsAnimatorsPrereqs(self.__attachments, self.spaceID))
splineDesc = self.typeDescriptor.chassis.splineDesc
modelsSet = self.outfit.modelsSet
if splineDesc is not None:
for _, trackDesc in splineDesc.trackPairs.iteritems():
prereqs += trackDesc.prerequisites(modelsSet)
modelsSetParams = self.modelsSetParams
compoundAssembler = model_assembler.prepareCompoundAssembler(self.typeDescriptor, modelsSetParams, self.spaceID, self.isTurretDetached, renderMode=self.renderMode)
prereqs.append(compoundAssembler)
if renderMode == TankRenderMode.OVERLAY_COLLISION:
self.damageState.update(0, isCrewActive, False)
collisionAssembler = model_assembler.prepareCollisionAssembler(self.typeDescriptor, self.isTurretDetached, self.spaceID)
prereqs.append(collisionAssembler)
physicalTracksBuilders = self.typeDescriptor.chassis.physicalTracks
for name, builders in physicalTracksBuilders.iteritems():
for index, builder in enumerate(builders):
prereqs.append(builder.createLoader(self.spaceID, '{0}{1}PhysicalTrack'.format(name, index), modelsSetParams.skin))
return prereqs
def __startBuild(self, vDesc, vState):
self.__curBuildInd += 1
self.__vDesc = vDesc
self.__vState = vState
self.__resources = {}
self.__vehicleStickers = None
camouflageResources = {'camouflageExclusionMask': vDesc.type.camouflageExclusionMask}
customization = items.vehicles.g_cache.customization(vDesc.type.customizationNationID)
if customization is not None and vDesc.camouflages is not None:
activeCamo = g_tankActiveCamouflage['historical'].get(vDesc.type.compactDescr)
if activeCamo is None:
activeCamo = g_tankActiveCamouflage.get(vDesc.type.compactDescr, 0)
camouflageID = vDesc.camouflages[activeCamo][0]
camouflageDesc = customization['camouflages'].get(camouflageID)
if camouflageDesc is not None:
camouflageResources['camouflageTexture'] = camouflageDesc['texture']
if vState == 'undamaged':
self.__emblemsAlpha = _CFG['emblems_alpha_undamaged']
self.__isVehicleDestroyed = False
else:
self.__emblemsAlpha = _CFG['emblems_alpha_damaged']
self.__isVehicleDestroyed = True
resources = camouflageResources.values()
splineDesc = vDesc.chassis['splineDesc']
if splineDesc is not None:
resources.extend(splineDesc.values())
from vehicle_systems import model_assembler
resources.append(model_assembler.prepareCompoundAssembler(self.__vDesc, self.__vState, self.__spaceId))
BigWorld.loadResourceListBG(tuple(resources), partial(self.__onResourcesLoaded, self.__curBuildInd))
return
def __loadVehicleCompound(self, vehicleDescr):
vehicleName = vehicleDescr.name
layout = self.__layouts.get(vehicleName, self.__layouts['default'])
if vehicleName in self.__cachedCompound:
_logger.debug('Loaded vehicle compound of "%s" from cache',
vehicleName)
BigWorld.buildBlueprint(self.__cachedCompound[vehicleName],
_BLUEPRINT_BG_TEXTURE, layout.projections)
self.__inProgress = None
return
elif vehicleName in self.__pendingCompound:
_logger.debug('Vehicle compound of "%s" is loading at the moment.',
vehicleName)
return
else:
_logger.debug('Loading vehicle compound of "%s".', vehicleName)
self.__pendingCompound.add(vehicleName)
resources = (ma.prepareCompoundAssembler(vehicleDescr,
ModelsSetParams(
'', 'undamaged', []),
BigWorld.camera().spaceID,
lodIdx=layout.lodIdx,
skipMaterials=True), )
BigWorld.loadResourceListBG(
resources,
makeCallbackWeak(self.__onResourcesLoaded, vehicleName))
return
def prerequisites(self,
typeDescriptor,
vID,
health=1,
isCrewActive=True,
isTurretDetached=False,
outfitCD=''):
prereqs = self.__appearance.prerequisites(typeDescriptor, vID, health,
isCrewActive,
isTurretDetached, outfitCD)
compoundAssembler = prepareCompoundAssembler(
typeDescriptor, self.__appearance.modelsSetParams,
BigWorld.player().spaceID, isTurretDetached)
if not isTurretDetached:
bspModels = ((TankPartNames.getIdx(TankPartNames.CHASSIS),
typeDescriptor.chassis.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.HULL),
typeDescriptor.hull.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.TURRET),
typeDescriptor.turret.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.GUN),
typeDescriptor.gun.hitTester.bspModelName))
else:
bspModels = ((TankPartNames.getIdx(TankPartNames.CHASSIS),
typeDescriptor.chassis.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.HULL),
typeDescriptor.hull.hitTester.bspModelName))
collisionAssembler = BigWorld.CollisionAssembler(
bspModels,
BigWorld.player().spaceID)
prereqs += [compoundAssembler, collisionAssembler]
return (compoundAssembler, prereqs)
def __requestModelsRefresh(self):
currentModelState = self.__currentDamageState.modelState
assembler = model_assembler.prepareCompoundAssembler(
self.__typeDesc, currentModelState, self.__vehicle.spaceID,
self.__vehicle.isTurretDetached)
BigWorld.loadResourceListBG([assembler],
functools.partial(self.__onModelsRefresh,
currentModelState))
def __requestModelsRefresh(self):
currentModelState = self.__currentDamageState.modelState
assembler = model_assembler.prepareCompoundAssembler(
self.__typeDesc, currentModelState, self.__vehicle.spaceID,
self.__vehicle.isTurretDetached)
BigWorld.loadResourceListBG((assembler, ),
makeCallbackWeak(self.__onModelsRefresh,
currentModelState))
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 __requestModelsRefresh(self):
modelsSetParams = self.modelsSetParams
assembler = model_assembler.prepareCompoundAssembler(
self.__typeDesc, modelsSetParams, self.__vehicle.spaceID,
self.__vehicle.isTurretDetached)
BigWorld.loadResourceListBG((assembler, ),
makeCallbackWeak(self.__onModelsRefresh,
modelsSetParams.state),
loadingPriority(self.__vehicle.id))
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 simpleLoad():
import CurrentVehicle
a = assemblerModule.prepareCompoundAssembler(CurrentVehicle.g_currentVehicle.item.descriptor, 'undamaged', BigWorld.camera().spaceID)
a.assemblerName = 'a'
def f(r):
global tanks
tanks.append(r['a'])
BigWorld.loadResourceListBG([a], f)
def simpleLoad():
import CurrentVehicle
a = assemblerModule.prepareCompoundAssembler(CurrentVehicle.g_currentVehicle.item.descriptor, 'undamaged', BigWorld.camera().spaceID)
a.assemblerName = 'a'
def f(r):
global tanks
tanks.append(r['a'])
BigWorld.loadResourceListBG([a], f)
def __startBuild(self, vDesc, vState):
self.__curBuildInd += 1
self.__vState = vState
self.__resources = {}
self.__vehicleStickers = None
cfg = hangarCFG()
if vState == 'undamaged':
self.__currentEmblemsAlpha = cfg['emblems_alpha_undamaged']
self.__isVehicleDestroyed = False
else:
self.__currentEmblemsAlpha = cfg['emblems_alpha_damaged']
self.__isVehicleDestroyed = True
self.__vDesc = vDesc
resources = camouflages.getCamoPrereqs(self.__outfit, vDesc)
splineDesc = vDesc.chassis.splineDesc
if splineDesc is not None:
resources.append(splineDesc.segmentModelLeft)
resources.append(splineDesc.segmentModelRight)
if splineDesc.leftDesc is not None:
resources.append(splineDesc.leftDesc)
if splineDesc.rightDesc is not None:
resources.append(splineDesc.rightDesc)
if splineDesc.segment2ModelLeft is not None:
resources.append(splineDesc.segment2ModelLeft)
if splineDesc.segment2ModelRight is not None:
resources.append(splineDesc.segment2ModelRight)
from vehicle_systems import model_assembler
resources.append(model_assembler.prepareCompoundAssembler(self.__vDesc, ModelsSetParams(self.__outfit.modelsSet, self.__vState), self.__spaceId))
g_eventBus.handleEvent(CameraRelatedEvents(CameraRelatedEvents.VEHICLE_LOADING, ctx={'started': True,
'vEntityId': self.__vEntity.id}), scope=EVENT_BUS_SCOPE.DEFAULT)
cfg = hangarCFG()
gunScale = Math.Vector3(1.0, 1.0, 1.1)
capsuleScale = Math.Vector3(1.5, 1.5, 1.5)
loadedGunScale = cfg.get('cam_capsule_gun_scale', gunScale)
if loadedGunScale is not None:
gunScale = loadedGunScale
loadedCapsuleScale = cfg.get('cam_capsule_scale', capsuleScale)
if loadedCapsuleScale is not None:
capsuleScale = loadedCapsuleScale
bspModels = ((TankPartNames.getIdx(TankPartNames.CHASSIS), vDesc.chassis.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.HULL), vDesc.hull.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.TURRET), vDesc.turret.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.GUN), vDesc.gun.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.GUN) + 1, vDesc.hull.hitTester.bspModelName, capsuleScale),
(TankPartNames.getIdx(TankPartNames.GUN) + 2, vDesc.turret.hitTester.bspModelName, capsuleScale),
(TankPartNames.getIdx(TankPartNames.GUN) + 3, vDesc.gun.hitTester.bspModelName, gunScale))
collisionAssembler = BigWorld.CollisionAssembler(bspModels, self.__spaceId)
resources.append(collisionAssembler)
physicalTracksBuilders = vDesc.chassis.physicalTracks
for name, builder in physicalTracksBuilders.iteritems():
resources.append(builder.createLoader('{0}PhysicalTrack'.format(name)))
BigWorld.loadResourceListBG(tuple(resources), makeCallbackWeak(self.__onResourcesLoaded, self.__curBuildInd))
return
def __requestModelsRefresh(self):
self._onRequestModelsRefresh()
self._isTurretDetached = self._vehicle.isTurretDetached
modelsSetParams = self.modelsSetParams
assembler = model_assembler.prepareCompoundAssembler(
self.typeDescriptor, modelsSetParams, self.spaceID,
self.isTurretDetached)
collisionAssembler = model_assembler.prepareCollisionAssembler(
self.typeDescriptor, self.isTurretDetached, self.spaceID)
BigWorld.loadResourceListBG((assembler, collisionAssembler),
makeCallbackWeak(self.__onModelsRefresh,
modelsSetParams.state),
loadingPriority(self._vehicle.id))
def prerequisites(self,
typeDescriptor,
id,
health=1,
isCrewActive=True,
isTurretDetached=False):
prereqs = self.__appearance.prerequisites(typeDescriptor, id, health,
isCrewActive,
isTurretDetached)
compoundAssembler = prepareCompoundAssembler(
typeDescriptor, self.__appearance.damageState.modelState,
BigWorld.player().spaceID, isTurretDetached)
prereqs += [compoundAssembler]
return (compoundAssembler, prereqs)
def prerequisites(self,
typeDescriptor,
id,
health=1,
isCrewActive=True,
isTurretDetached=False):
raise 'pillbox' not in typeDescriptor.type.tags or AssertionError(
'Pillboxes are not supported and have never been')
prereqs = self.__appearance.prerequisites(typeDescriptor, id, health,
isCrewActive,
isTurretDetached)
compoundAssembler = prepareCompoundAssembler(
typeDescriptor, self.__appearance.damageState.modelState,
BigWorld.player().spaceID, isTurretDetached)
prereqs += [compoundAssembler]
return (compoundAssembler, prereqs)
def prerequisites(self, typeDescriptor, vID, health, isCrewActive, isTurretDetached, outfitCD, renderState=None):
self.damageState.update(health, isCrewActive, False)
self.__typeDesc = typeDescriptor
self.__vID = vID
self._isTurretDetached = isTurretDetached
self.__outfit = self._prepareOutfit(outfitCD)
if self.damageState.isCurrentModelUndamaged:
self.__attachments = camouflages.getAttachments(self.outfit, self.typeDescriptor)
self.__renderState = renderState
prereqs = self.typeDescriptor.prerequisites(True)
prereqs.extend(camouflages.getCamoPrereqs(self.outfit, self.typeDescriptor))
prereqs.extend(camouflages.getModelAnimatorsPrereqs(self.outfit, self.worldID))
prereqs.extend(camouflages.getAttachmentsAnimatorsPrereqs(self.__attachments, self.worldID))
splineDesc = self.typeDescriptor.chassis.splineDesc
if splineDesc is not None:
modelsSet = self.outfit.modelsSet
prereqs.append(splineDesc.segmentModelLeft(modelsSet))
prereqs.append(splineDesc.segmentModelRight(modelsSet))
segment2ModelLeft = splineDesc.segment2ModelLeft(modelsSet)
if segment2ModelLeft is not None:
prereqs.append(segment2ModelLeft)
segment2ModelRight = splineDesc.segment2ModelRight(modelsSet)
if segment2ModelRight is not None:
prereqs.append(segment2ModelRight)
modelsSetParams = self.modelsSetParams
compoundAssembler = model_assembler.prepareCompoundAssembler(self.typeDescriptor, modelsSetParams, self.worldID, self.isTurretDetached, renderState=self.renderState)
prereqs.append(compoundAssembler)
if renderState == RenderStates.OVERLAY_COLLISION:
self.damageState.update(0, isCrewActive, False)
if not isTurretDetached:
bspModels = ((TankPartNames.getIdx(TankPartNames.CHASSIS), typeDescriptor.chassis.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.HULL), typeDescriptor.hull.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.TURRET), typeDescriptor.turret.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.GUN), typeDescriptor.gun.hitTester.bspModelName))
else:
bspModels = ((TankPartNames.getIdx(TankPartNames.CHASSIS), typeDescriptor.chassis.hitTester.bspModelName), (TankPartNames.getIdx(TankPartNames.HULL), typeDescriptor.hull.hitTester.bspModelName))
collisionAssembler = BigWorld.CollisionAssembler(bspModels, self.worldID)
prereqs.append(collisionAssembler)
physicalTracksBuilders = self.typeDescriptor.chassis.physicalTracks
for name, builders in physicalTracksBuilders.iteritems():
for index, builder in enumerate(builders):
prereqs.append(builder.createLoader(self.worldID, '{0}{1}PhysicalTrack'.format(name, index), modelsSetParams.skin))
return prereqs
def updateSpawnList(self, spawnListData):
toAdd = spawnListData.difference(self._spawnList)
toRemove = self._spawnList.difference(spawnListData)
for data in toAdd:
vDesc = VehicleDescriptor(compactDescr=data.vehicleCD)
prereqs = set(vDesc.prerequisites())
outfit = Outfit(component=getOutfitComponent(data.outfitCD),
vehicleCD=data.vehicleCD)
modelsSetParams = ModelsSetParams(outfit.modelsSet,
ModelStates.UNDAMAGED, [])
compoundAssembler = model_assembler.prepareCompoundAssembler(
vDesc, modelsSetParams,
BigWorld.camera().spaceID)
prereqs.add(compoundAssembler)
self._appearanceCache.loadResources(data.vehicleCD, list(prereqs))
for data in toRemove:
self._appearanceCache.unloadResources(data.vehicleCD)
self._spawnList = spawnListData
_logger.debug('SpawnList cache updated=%s', spawnListData)
def prerequisites(self,
typeDescriptor,
vID,
health=1,
isCrewActive=True,
isTurretDetached=False,
outfitCD=''):
prereqs = self.__appearance.prerequisites(typeDescriptor, vID, health,
isCrewActive,
isTurretDetached, outfitCD)
compoundAssembler = prepareCompoundAssembler(
typeDescriptor, self.__appearance.modelsSetParams,
BigWorld.player().spaceID, isTurretDetached)
if not isTurretDetached:
bspModels = ((TankPartNames.getIdx(TankPartNames.CHASSIS),
typeDescriptor.chassis.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.HULL),
typeDescriptor.hull.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.TURRET),
typeDescriptor.turret.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.GUN),
typeDescriptor.gun.hitTester.bspModelName))
else:
bspModels = ((TankPartNames.getIdx(TankPartNames.CHASSIS),
typeDescriptor.chassis.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.HULL),
typeDescriptor.hull.hitTester.bspModelName))
collisionAssembler = BigWorld.CollisionAssembler(
bspModels,
BigWorld.player().spaceID)
prereqs += [compoundAssembler, collisionAssembler]
physicalTracksBuilders = typeDescriptor.chassis.physicalTracks
for name, builder in physicalTracksBuilders.iteritems():
prereqs.append(
builder.createLoader('{0}PhysicalTrack'.format(name)))
return (compoundAssembler, prereqs)
def __requestModelsRefresh(self):
currentModelState = self.__currentDamageState.modelState
assembler = model_assembler.prepareCompoundAssembler(self.__typeDesc, currentModelState, self.__vehicle.spaceID, self.__vehicle.isTurretDetached)
BigWorld.loadResourceListBG([assembler], functools.partial(self.__onModelsRefresh, currentModelState))
def prerequisites(self, typeDescriptor, id, health = 1, isCrewActive = True, isTurretDetached = False):
prereqs = self.__appearance.prerequisites(typeDescriptor, id, health, isCrewActive, isTurretDetached)
compoundAssembler = prepareCompoundAssembler(typeDescriptor, self.__appearance.damageState.modelState, BigWorld.player().spaceID, isTurretDetached)
prereqs += [compoundAssembler]
return (compoundAssembler, prereqs)
def prerequisites(self):
vehicle = self.__vehicleRef()
prereqs = self.__appearance.prerequisites(vehicle)
compoundAssembler = prepareCompoundAssembler(vehicle.typeDescriptor, self.__appearance.damageState.modelState, BigWorld.player().spaceID, vehicle.isTurretDetached)
return prereqs + [compoundAssembler]
def prerequisites(self):
vehicle = self.__vehicleRef()
prereqs = self.__appearance.prerequisites(vehicle)
compoundAssembler = prepareCompoundAssembler(vehicle.typeDescriptor, self.__appearance.damageState.modelState, BigWorld.player().spaceID, vehicle.isTurretDetached)
return prereqs + [compoundAssembler]
def __startBuild(self, vDesc, vState):
self.__curBuildInd += 1
self.__vState = vState
self.__resources = {}
self.__vehicleStickers = None
cfg = hangarCFG()
if vState == 'undamaged':
self.__currentEmblemsAlpha = cfg['emblems_alpha_undamaged']
self.__isVehicleDestroyed = False
else:
self.__currentEmblemsAlpha = cfg['emblems_alpha_damaged']
self.__isVehicleDestroyed = True
self.__vDesc = vDesc
resources = camouflages.getCamoPrereqs(self.__outfit, vDesc)
if not self.__isVehicleDestroyed:
self.__attachments = camouflages.getAttachments(self.__outfit, vDesc)
modelsSet = self.__outfit.modelsSet
splineDesc = vDesc.chassis.splineDesc
if splineDesc is not None:
for _, trackDesc in splineDesc.trackPairs.iteritems():
resources += trackDesc.prerequisites(modelsSet)
from vehicle_systems import model_assembler
resources.append(model_assembler.prepareCompoundAssembler(self.__vDesc, ModelsSetParams(modelsSet, self.__vState, self.__attachments), self.__spaceId))
g_eventBus.handleEvent(CameraRelatedEvents(CameraRelatedEvents.VEHICLE_LOADING, ctx={'started': True,
'vEntityId': self.__vEntity.id,
'intCD': self.__vDesc.type.compactDescr}), scope=EVENT_BUS_SCOPE.DEFAULT)
cfg = hangarCFG()
gunScale = Math.Vector3(1.0, 1.0, 1.1)
capsuleScale = Math.Vector3(1.5, 1.5, 1.5)
loadedGunScale = cfg.get('cam_capsule_gun_scale', gunScale)
if loadedGunScale is not None:
gunScale = loadedGunScale
loadedCapsuleScale = cfg.get('cam_capsule_scale', capsuleScale)
if loadedCapsuleScale is not None:
capsuleScale = loadedCapsuleScale
hitTesterManagers = {TankPartNames.CHASSIS: vDesc.chassis.hitTesterManager,
TankPartNames.HULL: vDesc.hull.hitTesterManager,
TankPartNames.TURRET: vDesc.turret.hitTesterManager,
TankPartNames.GUN: vDesc.gun.hitTesterManager}
bspModels = ()
crashedBspModels = ()
for partName, htManager in hitTesterManagers.iteritems():
partId = TankPartNames.getIdx(partName)
bspModel = (partId, htManager.modelHitTester.bspModelName)
bspModels = bspModels + (bspModel,)
if htManager.crashedModelHitTester:
crashedBspModel = (partId, htManager.crashedModelHitTester.bspModelName)
crashedBspModels = crashedBspModels + (crashedBspModel,)
bspModels = bspModels + ((TankPartNames.getIdx(TankPartNames.GUN) + 1, vDesc.hull.hitTesterManager.modelHitTester.bspModelName, capsuleScale), (TankPartNames.getIdx(TankPartNames.GUN) + 2, vDesc.turret.hitTesterManager.modelHitTester.bspModelName, capsuleScale), (TankPartNames.getIdx(TankPartNames.GUN) + 3, vDesc.gun.hitTesterManager.modelHitTester.bspModelName, gunScale))
if vDesc.hull.hitTesterManager.crashedModelHitTester:
crashedBspModels = crashedBspModels + ((TankPartNames.getIdx(TankPartNames.GUN) + 1, vDesc.hull.hitTesterManager.crashedModelHitTester.bspModelName, capsuleScale),)
if vDesc.turret.hitTesterManager.crashedModelHitTester:
crashedBspModels = crashedBspModels + ((TankPartNames.getIdx(TankPartNames.GUN) + 2, vDesc.turret.hitTesterManager.crashedModelHitTester.bspModelName, capsuleScale),)
if vDesc.gun.hitTesterManager.crashedModelHitTester:
crashedBspModels = crashedBspModels + ((TankPartNames.getIdx(TankPartNames.GUN) + 3, vDesc.gun.hitTesterManager.crashedModelHitTester.bspModelName, gunScale),)
modelCA = BigWorld.CollisionAssembler(bspModels, self.__spaceId)
modelCA.name = 'ModelCollisions'
resources.append(modelCA)
if crashedBspModels:
crashedModelCA = BigWorld.CollisionAssembler(crashedBspModels, self.__spaceId)
crashedModelCA.name = 'CrashedModelCollisions'
resources.append(crashedModelCA)
physicalTracksBuilders = vDesc.chassis.physicalTracks
for name, builders in physicalTracksBuilders.iteritems():
for index, builder in enumerate(builders):
resources.append(builder.createLoader(self.__spaceId, '{0}{1}PhysicalTrack'.format(name, index), modelsSet))
BigWorld.loadResourceListBG(tuple(resources), makeCallbackWeak(self.__onResourcesLoaded, self.__curBuildInd))
return
