def __setColorGradingTechnique(self, value=None):
colorSettingsSelectedTab = AccountSettings.getSettings(COLOR_SETTINGS_TAB_IDX)
if colorSettingsSelectedTab is None or not graphics.isRendererPipelineDeferred():
colorSettingsSelectedTab = 0
label = SETTINGS.GRAPHICSSETTINGSOPTIONS_NONE
image = RES_ICONS.MAPS_ICONS_SETTINGS_COLOR_GRADING_TECHNIQUE_NONE
if colorSettingsSelectedTab == 2:
label = SETTINGS.COLORSETTINGS_TAB_CUSTOMSETTINGS
image = RES_ICONS.MAPS_ICONS_SETTINGS_COLOR_GRADING_TECHNIQUE_RANDOM
elif colorSettingsSelectedTab == 1:
setting = self.settingsCore.options.getSetting(settings_constants.GRAPHICS.COLOR_GRADING_TECHNIQUE)
images = graphics.getGraphicSettingImages(settings_constants.GRAPHICS.COLOR_GRADING_TECHNIQUE)
label = SETTINGS.GRAPHICSSETTINGSOPTIONS_NONE
image = None
filterIdx = setting.get() if value is None else value
if setting is not None:
for option in setting.getOptions():
currentIdx = option.get('data', 0)
if currentIdx == filterIdx:
label = option.get('label')
image = images.get(option.get('data', 0))
break
if image is None:
image = RES_ICONS.MAPS_ICONS_SETTINGS_COLOR_GRADING_TECHNIQUE_NONE
self.as_setColorGradingTechniqueS(image, label)
return
def _carouseItemWrapper(self, itemCD):
isBuy = self.__ctx.isBuy
item = self.service.getItemByCD(itemCD)
itemInventoryCount = self.__ctx.getItemInventoryCount(item)
purchaseLimit = self.__ctx.getPurchaseLimit(item)
showUnsupportedAlert = item.itemTypeID == GUI_ITEM_TYPE.MODIFICATION and not isRendererPipelineDeferred(
)
isCurrentlyApplied = itemCD in self._carouselDP.getCurrentlyApplied()
if item.itemTypeID == GUI_ITEM_TYPE.STYLE:
isApplied = self.__ctx.modifiedStyle == item
else:
isApplied = any((self.__ctx.getModifiedOutfit(season).has(item)
for season in SeasonType.COMMON_SEASONS))
noPrice = isBuy and item.buyCount <= 0
isDarked = isBuy and purchaseLimit == 0 and itemInventoryCount == 0
isAlreadyUsed = isDarked and not isApplied
forceLocked = isAlreadyUsed
autoRentEnabled = self.__ctx.autoRentEnabled()
return buildCustomizationItemDataVO(
isBuy,
item,
itemInventoryCount,
showUnsupportedAlert=showUnsupportedAlert,
isCurrentlyApplied=isCurrentlyApplied,
isAlreadyUsed=isAlreadyUsed,
forceLocked=forceLocked,
isDarked=isDarked,
noPrice=noPrice,
autoRentEnabled=autoRentEnabled,
vehicle=g_currentVehicle.item)
def _parseEffectSubsection(dataSection, sectionKey):
if dataSection is not None:
effectSection = dataSection[sectionKey]
if effectSection is not None:
effPathPropName = 'path' if isRendererPipelineDeferred() else 'path_fwd'
return _createScenarioEffect(effectSection, effPathPropName)
return
def _packItemBlocks(self):
topBlocks = [self._packTitleBlock(), self._packIconBlock()]
items = [formatters.packBuildUpBlockData(blocks=topBlocks, gap=10)]
camo = None
if self._item.itemTypeID != GUI_ITEM_TYPE.STYLE:
bonus = self._item.bonus
else:
for container in (self._item.getOutfit(season).hull
for season in SeasonType.SEASONS):
camo = container.slotFor(GUI_ITEM_TYPE.CAMOUFLAGE).getItem()
if camo and camo.bonus:
bonus = camo.bonus
break
else:
bonus = None
if bonus:
camo = self._item if not camo else camo
items.append(self._packBonusBlock(bonus, camo))
if not self._item.isHistorical() or self._item.fullDescription:
items.append(self._packDescriptionBlock())
if not self._isQuestReward:
items.append(self._packInventoryBlock())
if not self._item.isUnlocked:
items.append(self._packLockedBlock())
if self._item.descriptor.filter:
block = self._packSuitableBlock()
if block:
items.append(block)
if self._item.itemTypeID == GUI_ITEM_TYPE.MODIFICATION and not isRendererPipelineDeferred(
):
items.append(self._packUnsupportedBlock())
return items
def __isNeedToShowAlert(item):
if isRendererPipelineDeferred():
return False
if item.itemTypeID == GUI_ITEM_TYPE.MODIFICATION:
return True
return bool(
item.descriptor.glossTexture
) if item.itemTypeID == GUI_ITEM_TYPE.PROJECTION_DECAL else False
def _carouseItemWrapper(self, itemCD):
item = self.service.getItemByCD(itemCD)
itemInventoryCount = self.__ctx.getItemInventoryCount(item)
if item.itemTypeID == GUI_ITEM_TYPE.MODIFICATION:
showUnsupportedAlert = not isRendererPipelineDeferred()
else:
showUnsupportedAlert = False
isCurrentlyApplied = itemCD in self._carouselDP.getCurrentlyApplied()
return buildCustomizationItemDataVO(item, itemInventoryCount, showUnsupportedAlert=showUnsupportedAlert, isCurrentlyApplied=isCurrentlyApplied)
def __getSequenceResourceMapping(desc, effectName, spaceID):
effectDesc = getattr(desc, effectName, None)
if effectDesc is not None:
if isRendererPipelineDeferred():
effectPath = effectDesc.path
else:
effectPath = effectDesc.path_fwd
return {'sequence': Loader(AnimationSequence.Loader(effectPath, spaceID))}
else:
return {}
def _packUnsupportedBlock(self):
if isRendererPipelineDeferred():
return None
else:
hasGMTexture = self._item.itemTypeID == GUI_ITEM_TYPE.PROJECTION_DECAL and self._item.descriptor.glossTexture
if self._item.itemTypeID == GUI_ITEM_TYPE.MODIFICATION or hasGMTexture:
desc = backport.text(R.strings.vehicle_customization.
customization.tooltip.warning.title())
return formatters.packImageTextBlockData(
img=backport.image(
R.images.gui.maps.icons.library.alertIcon()),
imgPadding=formatters.packPadding(top=3, right=3),
desc=text_styles.alert(desc))
return None
def _onLoading(self, *args, **kwargs):
self._vehicle = g_currentVehicle.item
self._possibleItems = self._getPossibleItemsForVehicle()
self._itemsProgressData = self.__itemsCache.items.inventory.getC11nProgressionDataForVehicle(
self._vehicle.intCD)
itemIntCD = kwargs.get('itemIntCD')
with self.getViewModel().transaction() as model:
model.setTankName(self._vehicle.userName)
model.setTankLevel(int2roman(self._vehicle.level))
model.setTankType(self._vehicle.typeBigIconResource())
self.__setItems(model)
model.setIsRendererPipelineDeferred(isRendererPipelineDeferred())
model.setItemToScroll(0 if itemIntCD is None else itemIntCD)
return
def _loadLoot(typeID, radius, callback, desc):
loot = LootObject(radius, typeID)
loaders = {}
if hasattr(desc, 'model'):
modelName = desc.model.name
offset = getattr(desc.model, 'overTerrainHeight', 0.0)
if modelName is None:
_logger.warning('Model for loot %s not set', typeID)
else:
modelAssembler = BigWorld.CompoundAssembler(
'model',
BigWorld.player().spaceID)
modelAssembler.addRootPart(modelName, 'root')
borderName = getattr(desc.model, 'border', None)
if borderName is not None:
borderMatrix = Math.Matrix()
modelAssembler.addPart(borderName, 'root', 'border',
borderMatrix)
loaders['model'] = Loader(modelAssembler, offset=offset)
if hasattr(desc, 'effect'):
if isRendererPipelineDeferred():
effectPath = desc.effect.path
else:
effectPath = desc.effect.path_fwd
loaders['markingSmoke'] = Loader(
AnimationSequence.Loader(effectPath,
BigWorld.player().spaceID))
if hasattr(desc, 'pickupEffect'):
if isRendererPipelineDeferred():
effectPath = desc.pickupEffect.path
else:
effectPath = desc.pickupEffect.path_fwd
loaders['pickupEffect'] = Loader(
AnimationSequence.Loader(effectPath,
BigWorld.player().spaceID))
loadComponentSystem(loot, callback, loaders)
return loot
def _getSequenceResourceMapping(desc, effectName, spaceID, includePaths=False):
effectDesc = getattr(desc, effectName, None)
if effectDesc is not None:
if isRendererPipelineDeferred():
effectPath = effectDesc.path
else:
effectPath = effectDesc.path_fwd
res = {
'sequence': Loader(AnimationSequence.Loader(effectPath, spaceID))
}
if includePaths:
res['path'] = effectPath
return res
else:
return {}
def locateCameraToStyleInfoPreview(self, forceLocate=False):
if self.__hangarCameraManager is None or self.__hangarCameraManager.camera is None:
return
else:
self.__savePitch()
from gui.ClientHangarSpace import customizationHangarCFG, hangarCFG
cfg = customizationHangarCFG()
hangarConfig = hangarCFG()
if self.__tankCentralPoint is None:
self.__tankCentralPoint = self.__getTankCentralPoint()
dist = cfg['cam_start_dist']
targetPos = copy(self.__tankCentralPoint)
distConstraints = copy(cfg['cam_dist_constr'])
if self.vEntity is not None and self.vEntity.appearance is not None and self.vEntity.appearance.compoundModel is not None:
appearance = self.vEntity.appearance
mat = Math.Matrix()
mat.setRotateYPR((_STYLE_INFO_YAW, -_STYLE_INFO_PITCH, 0.0))
pivotDir = mat.applyVector(Math.Vector3(1, 0, 0))
pivotDir = Math.Vector3(pivotDir.x, 0, pivotDir.z)
pivotDir.normalise()
hullAABB = appearance.collisions.getBoundingBox(TankPartIndexes.HULL)
width = hullAABB[1].x - hullAABB[0].x
length = hullAABB[1].z - hullAABB[0].z
height = hullAABB[1].y - hullAABB[0].y
hullViewSpaceX = width * abs(math.cos(_STYLE_INFO_YAW)) + length * abs(math.sin(_STYLE_INFO_YAW))
hullViewSpaceZ = width * abs(math.sin(_STYLE_INFO_YAW)) + length * abs(math.cos(_STYLE_INFO_YAW))
aspect = BigWorld.getAspectRatio()
halfFOVTan = math.tan(BigWorld.projection().fov * 0.5)
distW = hullViewSpaceX / (_STYLE_INFO_MAX_VEHICLE_WIDTH * 2 * halfFOVTan * aspect)
distH = height / (_STYLE_INFO_MAX_VEHICLE_HEIGHT * 2 * halfFOVTan) + hullViewSpaceZ * 0.5
dist = max(distH, distW)
distConstraints.y = _STYLE_INFO_MAX_CAMERA_DIST
halfHeight = dist * halfFOVTan
halfWidth = halfHeight * aspect
targetPos += pivotDir * halfWidth * _STYLE_INFO_VEHICLE_SCREEN_X_SHIFT
futureCamDir = mat.applyVector(Math.Vector3(0, 0, 1))
futureCamPos = targetPos - futureCamDir * dist
paramsDOF = None
if isRendererPipelineDeferred():
paramsDOF = self.__getStyleInfoDOFParams(futureCamPos)
self.__ctx.events.onUpdateStyleInfoDOF(paramsDOF)
self._setCameraLocation(targetPos=targetPos, pivotPos=-Math.Vector3(0, 0, 0), yaw=_STYLE_INFO_YAW, pitch=_STYLE_INFO_PITCH, dist=dist, camConstraints=[hangarConfig['cam_pitch_constr'], hangarConfig['cam_yaw_constr'], distConstraints], forceLocate=forceLocate, forceRotate=True)
self.__currentMode = C11nCameraModes.STYLE_INFO
self.enableMovementByMouse(enableRotation=False, enableZoom=False)
return
def _carouseItemWrapper(self, itemCD):
item = self.service.getItemByCD(itemCD)
itemInventoryCount = self.__ctx.getItemInventoryCount(item)
purchaseLimit = self.__ctx.getPurchaseLimit(item)
if item.itemTypeID == GUI_ITEM_TYPE.MODIFICATION:
showUnsupportedAlert = not isRendererPipelineDeferred()
else:
showUnsupportedAlert = False
isCurrentlyApplied = itemCD in self._carouselDP.getCurrentlyApplied()
noPrice = item.buyCount <= 0
isDarked = purchaseLimit == 0 and itemInventoryCount == 0
isAlreadyUsed = isDarked and not isCurrentlyApplied
return buildCustomizationItemDataVO(
item,
itemInventoryCount,
showUnsupportedAlert=showUnsupportedAlert,
isCurrentlyApplied=isCurrentlyApplied,
isAlreadyUsed=isAlreadyUsed,
forceLocked=isAlreadyUsed,
isDarked=isDarked,
noPrice=noPrice)
def __setBackgroundAlpha(self):
alpha = BACKGROUND_ALPHA_DEFERRED if isRendererPipelineDeferred(
) else BACKGROUND_ALPHA_FORWARD
self.as_setBackgroundAlphaS(alpha)
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]
else:
fashions = [
BigWorld.WGVehicleFashion(),
BigWorld.WGBaseFashion(),
BigWorld.WGBaseFashion(),
BigWorld.WGBaseFashion()
]
return VehiclePartsTuple(*fashions)
def _packItemBlocks(self):
self.bonusDescription = VEHICLE_CUSTOMIZATION.BONUS_CONDITION_SEASON
topBlocks = []
topBlocks.append(self._packTitleBlock())
topBlocks.append(self._packIconBlock(self._item.isHistorical()))
items = [formatters.packBuildUpBlockData(blocks=topBlocks, gap=10)]
self.currentVehicle = g_currentVehicle.item
self.boundVehs = [
vehicleCD for vehicleCD in self._item.boundInventoryCount
if vehicleCD != -1
]
self.installedToVehs = self._item.getInstalledVehicles()
self.installedCount = self._item.getInstalledOnVehicleCount(
self.currentVehicle.intCD)
c11nContext = self.service.getCtx()
camo = None
self.appliedCount = 0
if self._item.itemTypeID != GUI_ITEM_TYPE.STYLE:
self.appliedCount = getItemAppliedCount(
self._item, c11nContext.getOutfitsInfo())
bonus = self._item.bonus
hullContainer = self.service.getCtx().currentOutfit.hull
isApplied = hullContainer.slotFor(
GUI_ITEM_TYPE.CAMOUFLAGE).getItem() == self._item
else:
self.bonusDescription = VEHICLE_CUSTOMIZATION.BONUS_STYLE
for container in (self._item.getOutfit(season).hull
for season in SeasonType.SEASONS
if self._item.getOutfit(season)):
camo = container.slotFor(GUI_ITEM_TYPE.CAMOUFLAGE).getItem()
if camo and camo.bonus:
bonus = camo.bonus
break
else:
bonus = None
originalStyle = self.service.getCtx().originalStyle
modifiedStyle = self.service.getCtx().modifiedStyle
if modifiedStyle:
isApplied = self._item == modifiedStyle
else:
isApplied = self._item == originalStyle
self.appliedCount = int(isApplied)
if bonus:
camo = self._item if not camo else camo
items.append(self._packBonusBlock(bonus, camo, isApplied))
if not self._item.isHistorical() or self._item.fullDescription:
block = self._packDescriptionBlock()
if block:
items.append(block)
if self._isShowPrice:
items.append(self._packInventoryBlock())
if not self._item.isUnlocked:
items.append(self._packLockedBlock())
if self._item.descriptor.filter:
block = self._packSuitableBlock()
if block:
items.append(block)
if not self._item.isVehicleBound and (self._item.isHidden
or self._item.isLimited):
block = self._packAppliedBlock()
if block:
items.append(block)
if self._item.isVehicleBound or self._item.isLimited:
block = self._packSpecialBlock()
if block:
items.append(block)
if self._item.itemTypeID == GUI_ITEM_TYPE.MODIFICATION and not isRendererPipelineDeferred(
):
items.append(self._packUnsupportedBlock())
return items
def __init__(self, ctx=None):
super(ColorSettingsTipPanel, self).__init__()
battlesCount = AccountSettings.getSettings(COLOR_SETTINGS_SHOWS_COUNT)
self.__isActive = battlesCount <= self.MAX_BATTLES_COUNT and isRendererPipelineDeferred()
if self.__isActive:
AccountSettings.setSettings(COLOR_SETTINGS_SHOWS_COUNT, battlesCount + 1)
