def isVehicleInAOI(matrix): ownPos = Math.Matrix(BigWorld.camera().invViewMatrix).translation entryPos = Math.Matrix(matrix).translation return (ownPos.x - entryPos.x)**2 + (ownPos.z - entryPos.z)**2 < AOI_ESTIMATE**2
def getVehicleSpaceMatrix(vehicle): toVehSpace = Math.Matrix(vehicle.mover.matrix) toVehSpace.invert() return toVehSpace
def __init__(self, modelName='helpers/models/position_gizmo.model'): self.model = BigWorld.Model(modelName) BigWorld.player().addModel(self.model) self.motor = BigWorld.Servo(Math.Matrix()) self.model.addMotor(self.motor)
def fromHangarVehicleToWorldCoords(hangarVehicleCoords): compoundModel = g_currentVehicle.hangarSpace.space.getVehicleEntity().appearance.compoundModel modelMatrix = Math.Matrix(compoundModel.matrix) return modelMatrix.applyPoint(hangarVehicleCoords)
def testPoint(pos, color): matrix = Math.Matrix() matrix.translation = pos BigWorld.addPoint('Test', matrix, color, True)
def __getAlignedToPointPosition(self, rotationMat): dirVector = Math.Vector3(0, 0, self.__rotationRadius) camMat = Math.Matrix(self.__cam.invViewProvider.a) point = camMat.applyPoint(dirVector) return point + rotationMat.applyVector(-dirVector)
def __init__(self): userPrefs = Settings.g_instance.userPrefs if not userPrefs.has_key(Settings.KEY_REPLAY_PREFERENCES): userPrefs.write(Settings.KEY_REPLAY_PREFERENCES, '') self.__settings = userPrefs[Settings.KEY_REPLAY_PREFERENCES] self.__fileName = None self.__replayCtrl = BigWorld.WGReplayController() self.__replayCtrl.replayFinishedCallback = self.onReplayFinished self.__replayCtrl.controlModeChangedCallback = self.onControlModeChanged self.__replayCtrl.ammoButtonPressedCallback = self.__onAmmoButtonPressed self.__replayCtrl.playerVehicleIDChangedCallback = self.onPlayerVehicleIDChanged self.__replayCtrl.clientVersionDiffersCallback = self.onClientVersionDiffers self.__replayCtrl.battleChatMessageCallback = self.onBattleChatMessage self.__replayCtrl.lockTargetCallback = self.onLockTarget self.__replayCtrl.cruiseModeCallback = self.onSetCruiseMode self.__replayCtrl.equipmentIdCallback = self.onSetEquipmentId self.__replayCtrl.warpFinishedCallback = self.__onTimeWarpFinished self.__replayCtrl.sniperModeCallback = self.onSniperModeChanged self.__isAutoRecordingEnabled = False self.__quitAfterStop = False self.__isPlayingPlayList = False self.__playList = [] self.__isFinished = False self.__isMenuShowed = False self.__updateGunOnTimeWarp = False self.__isBattleSimulation = False battleSimulationSection = userPrefs[_BATTLE_SIMULATION_KEY_PATH] if battleSimulationSection is not None: self.__isBattleSimulation = battleSimulationSection.asBool self.__playerDatabaseID = 0 self.__serverSettings = dict() if isPlayerAccount(): self.__playerDatabaseID = BigWorld.player().databaseID self.__playbackSpeedModifiers = (0.0, 0.0625, 0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0) self.__playbackSpeedModifiersStr = ('0', '1/16', '1/8', '1/4', '1/2', '1', '2', '4', '8', '16') self.__playbackSpeedIdx = self.__playbackSpeedModifiers.index(1.0) self.__savedPlaybackSpeedIdx = self.__playbackSpeedIdx self.__gunWasLockedBeforePause = False self.__wasVideoBeforeRewind = False self.__videoCameraMatrix = Math.Matrix() self.__replayDir = './replays' self.__replayCtrl.clientVersion = BigWorld.wg_getProductVersion() self.__enableTimeWarp = False self.__isChatPlaybackEnabled = True self.__warpTime = -1.0 self.__equipmentId = None self.__rewind = False self.replayTimeout = 0 self.__arenaPeriod = -1 self.enableAutoRecordingBattles(True) self.onCommandReceived = Event.Event() self.onAmmoSettingChanged = Event.Event() self.onStopped = Event.Event() if constants.IS_DEVELOPMENT: try: import development.replay_override except: pass return
def update(self, matrix, time): self.__animMat.keyframes = ((0.0, Math.Matrix(self.__animMat)), (time, matrix)) self.__animMat.time = 0.0
def lockSoundMatrix(self): if self.__manualSound is not None: provider = self.__manualSound.matrixProvider self.__manualSound.matrixProvider = Math.Matrix(provider) return
def overridePose(self, pos, rot): transform = Math.Matrix() transform.setRotateYPR(rot) transform.translation = self._cam._checkSpaceBounds( BigWorld.camera().position, pos) self._cam.setViewMatrix(transform)
def __init__(self, avatar): m = Math.Matrix() m.setIdentity() self.__animMat = Math.MatrixAnimation() self.__animMat.keyframes = ((0.0, m),)
def setupSplineTracks(fashion, vDesc, chassisModel, prereqs): splineDesc = vDesc.chassis.splineDesc resultTracks = None if splineDesc is not None: leftSpline = None rightSpline = None segmentModelLeft = segmentModelRight = segment2ModelLeft = segment2ModelRight = None modelName = splineDesc.segmentModelLeft try: segmentModelLeft = prereqs[modelName] except Exception: debug_utils.LOG_ERROR("can't load track segment model <%s>" % modelName) modelName = splineDesc.segmentModelRight try: segmentModelRight = prereqs[modelName] except Exception: debug_utils.LOG_ERROR("can't load track segment model <%s>" % modelName) modelName = splineDesc.segment2ModelLeft if modelName is not None: try: segment2ModelLeft = prereqs[modelName] except Exception: debug_utils.LOG_ERROR("can't load track segment 2 model <%s>" % modelName) modelName = splineDesc.segment2ModelRight if modelName is not None: try: segment2ModelRight = prereqs[modelName] except Exception: debug_utils.LOG_ERROR("can't load track segment 2 model <%s>" % modelName) if segmentModelLeft is not None and segmentModelRight is not None: identityMatrix = Math.Matrix() identityMatrix.setIdentity() if splineDesc.leftDesc is not None: leftSpline = BigWorld.wg_createSplineTrack( fashion, chassisModel, splineDesc.leftDesc, splineDesc.segmentLength, segmentModelLeft, splineDesc.segmentOffset, segment2ModelLeft, splineDesc.segment2Offset, _ROOT_NODE_NAME, splineDesc.atlasUTiles, splineDesc.atlasVTiles) if leftSpline is not None: chassisModel.root.attach(leftSpline, identityMatrix, True) if splineDesc.rightDesc is not None: rightSpline = BigWorld.wg_createSplineTrack( fashion, chassisModel, splineDesc.rightDesc, splineDesc.segmentLength, segmentModelRight, splineDesc.segmentOffset, segment2ModelRight, splineDesc.segment2Offset, _ROOT_NODE_NAME, splineDesc.atlasUTiles, splineDesc.atlasVTiles) if rightSpline is not None: chassisModel.root.attach(rightSpline, identityMatrix, True) fashion.setSplineTrack(leftSpline, rightSpline) resultTracks = SplineTracks(leftSpline, rightSpline) return resultTracks
def makePositionMatrix(position): matrix = Math.Matrix() matrix.setTranslate(position) return matrix
def isVehicleInAOI(matrix): ownPos = Math.Matrix(BigWorld.camera().invViewMatrix).translation entryPos = Math.Matrix(matrix).translation return bool( abs(ownPos.x - entryPos.x) < AOI_ESTIMATE and abs(ownPos.z - entryPos.z) < AOI_ESTIMATE)
def makePositionMP(position): provider = Math.WGReplayAwaredSmoothTranslationOnlyMP() matrix = Math.Matrix() matrix.setTranslate(position) provider.source = matrix return provider
def setToVehicleDirection(self): matrix = Math.Matrix(self.getTargetMProv()) self.setYawPitch(matrix.yaw, matrix.pitch)
def convertToLastSpottedVehicleMP(matrix): converted = Math.WGReplayAwaredSmoothTranslationOnlyMP() converted.source = Math.Matrix(matrix.source) return converted
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.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 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 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 __applyScale(self, transformComponent, radius): scaleMatrix = Math.Matrix() scaleMatrix.setScale(Math.Vector3(radius, 1.0, radius)) matrix = transformComponent.transform matrix.preMultiply(scaleMatrix) transformComponent.transform = matrix
def __addPointEntry(self, symbol, sectorBase): matrix = Math.Matrix() matrix.setTranslate(sectorBase.position) return self._addEntryEx(sectorBase.baseID, symbol, _EPIC_TEAM_POINTS, matrix, True)
def fromWorldCoordsToHangarVehicle(worldCoords): compoundModel = g_currentVehicle.hangarSpace.space.getVehicleEntity().appearance.compoundModel modelMat = Math.Matrix(compoundModel.matrix) modelMat.invert() return modelMat.applyPoint(worldCoords)
def __addRPEntry(self, symbol, pos): position = (pos.x, 0, pos.y) matrix = Math.Matrix() matrix.setTranslate(position) return self._addEntry(symbol, _EPIC_TEAM_POINTS, matrix=matrix, active=True)
def readCurrentSettings(self, quiet=True): super(ConfigInterface, self).readCurrentSettings(quiet) self.settings = loadJson(self.ID, 'settings', self.settings, self.configPath) self.modelsData['models'].clear() self.modelsData['selected'] = selectedData = loadJson( self.ID, 'remodsCache', self.modelsData['selected'], self.configPath) remodTanks = set() for root, _, fNames in os.walk(self.configPath + 'remods/'): for fName in fnmatch.filter(fNames, '*.json'): sName = fName.split('.')[0] confDict = loadJson(self.ID, sName, {}, root, encrypted=True) if not confDict: print self.ID + ': error while reading', fName + '.' continue settingsDict = self.settings.setdefault( sName, {team: confDict[team] for team in self.teams}) self.modelsData['models'][ sName] = pRecord = self.modelDescriptor pRecord['name'] = sName pRecord['message'] = confDict.get('message', '') settingsDict['whitelist'] = pRecord[ 'whitelist'] = whitelist = remDups( x.strip() for x in settingsDict.get( 'whitelist', confDict['whitelist']) if x.strip()) for xmlName in whitelist: remodTanks.add(xmlName) for team in selectedData: if xmlName not in selectedData[ team] or selectedData[team][xmlName] is None: if settingsDict[team]: selectedData[team][xmlName] = sName else: selectedData[team][xmlName] = None if self.data['isDebug']: if not whitelist: print self.ID + ': empty whitelist for', sName + '.' else: print self.ID + ': whitelist for', sName + ':', whitelist for key, data in pRecord.iteritems(): if key in ('name', 'message', 'whitelist'): continue if key == 'common': confSubDict = confDict else: confSubDict = confDict.get(key) if not confSubDict: continue if 'undamaged' in data: data['undamaged'] = confSubDict['undamaged'] if 'AODecals' in data and 'AODecals' in confSubDict and 'hullPosition' in confSubDict: data['AODecals'] = [] for subList in confSubDict['AODecals']: m = Math.Matrix() for strNum, row in enumerate(subList): for colNum, elemNum in enumerate(row): m.setElement(strNum, colNum, elemNum) data['AODecals'].append(m) data['hullPosition'] = confSubDict['hullPosition'] if 'camouflage' in data and 'exclusionMask' in confSubDict.get( 'camouflage', {}): data['camouflage']['exclusionMask'] = confSubDict[ 'camouflage']['exclusionMask'] if 'tiling' in confSubDict['camouflage']: data['camouflage']['tiling'] = confSubDict[ 'camouflage']['tiling'] elif key == 'common' and self.data['isDebug']: print self.ID + ': default camomask not found for', sName if 'emblemSlots' in data: data['emblemSlots'] = slots = [] for subDict in confSubDict.get('emblemSlots', []): if subDict['type'] not in AES: print g_config.ID + ': not supported emblem slot type:', subDict[ 'type'] + ', expected:', AES continue descr = EmblemSlot( Math.Vector3(tuple(subDict['rayStart'])), Math.Vector3(tuple(subDict['rayEnd'])), Math.Vector3(tuple(subDict['rayUp'])), subDict['size'], subDict.get('hideIfDamaged', False), subDict['type'], subDict.get('isMirrored', False), subDict.get('isUVProportional', True), subDict.get('emblemId', None), subDict.get( 'slotId', c11n_constants.customizationSlotIds[key][ subDict['type']][0]), subDict.get('applyToFabric', True)) slots.append(descr) if 'exhaust' in data and 'exhaust' in confSubDict: if 'nodes' in confSubDict['exhaust']: data['exhaust']['nodes'] = confSubDict['exhaust'][ 'nodes'] if 'pixie' in confSubDict['exhaust']: data['exhaust']['pixie'] = confSubDict['exhaust'][ 'pixie'] if key == 'chassis': for k in chassis_params + ('chassisLodDistance', ): data[k] = confSubDict[k] for k in ('soundID', 'drivenJoints'): if k in data and k in confSubDict: data[k] = confSubDict[k] if self.data['isDebug']: print self.ID + ': config for', sName, 'loaded.' for sName in self.settings.keys(): if sName not in self.modelsData['models']: del self.settings[sName] if not self.modelsData['models']: if not quiet: print self.ID + ': no configs found, model module standing down.' for team in self.teams: for xmlName in selectedData[team].keys(): if xmlName not in remodTanks: del selectedData[team][xmlName] continue if selectedData[team][xmlName] is None or ( selectedData[team][xmlName] and selectedData[team][xmlName] not in self.modelsData['models']): selectedData[team][xmlName] = next( (sName for sName in sorted(self.modelsData['models']) if xmlName in self.settings[sName]['whitelist'] and self.settings[sName][team]), None) or '' loadJson(self.ID, 'remodsCache', selectedData, self.configPath, True, quiet=quiet) loadJson(self.ID, 'settings', self.settings, self.configPath, True, quiet=quiet)
def __addRPEntry(self, symbol, position): matrix = Math.Matrix() matrix.setTranslate(position) entryID = self._addEntry(symbol, _EPIC_ICONS, matrix=matrix, active=True) return entryID
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 and isChassis: # wheeled placed = node.split('_')[-1] place, side = placed[:1], placed[1:] template = 'HP_Wheel_%s_0%s_%s' % (place, '%s', side) edge = None if side == 'Front': edge = nodeWatcher(sourcesDict[TankPartNames.CHASSIS], template % 1) else: for idx in xrange(1, 10): found = nodeWatcher(sourcesDict[TankPartNames.CHASSIS], template % idx) if found is None: break edge = found if edge is not None: wheels = nodeListML if place == 'L' else nodeListMR sign = 1 if side == 'Front' else -1 center = max(wheels, key=lambda x: x.translation.z * sign) rotator = Math.Matrix() rotator.setRotateX(-sign * 3.1415 * 3 / 4) transMat = Math.Matrix() transMat.setTranslate( center.applyPoint( rotator.applyPoint(edge.translation - center.translation))) 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 __addProtectionZoneEntry(self, symbol, position): matrix = Math.Matrix() matrix.setTranslate(position) entryID = self._addEntry(symbol, _EPIC_PROTECTION_ZONE, matrix=matrix, active=True) self._parentObj.setEntryParameters(entryID, doClip=False, scaleType=MINIMAP_SCALE_TYPES.REAL_SCALE) return entryID
def __init__(self, templateTree): self.input = {} self.templateTree = templateTree for id, node in self.templateTree.nodeList.items(): self.input[id] = Math.Matrix() self.input[id].set(node.localMatrix)
def makeVehicleEntityMPCopy(vehicle): provider = Math.WGTranslationOnlyMP() provider.source = Math.Matrix(vehicle.matrix) return provider
def isPointInsideBox(self, point): if not isinstance(point, Math.Vector3): raise TypeError('point argument must be Vector3, not {!s}'.format( type(point).__name__)) return self.boundingBox._isPointInsideBox( Math.Matrix(self.invBounds).applyPoint(point))
def __updateNodePosition(self, node, vehiclePos, waterHeight): if waterHeight is not None: toCenterShift = vehiclePos.y - (Math.Matrix(node).translation.y - node.local.translation.y) node.local.translation = Math.Vector3(0, waterHeight + toCenterShift, 0) else: node.local.translation = Math.Vector3(0, 0, 0)