def __updateOscillators(self, deltaTime): if not SniperCamera.isCameraDynamic(): self.__impulseOscillator.reset() self.__movementOscillator.reset() self.__noiseOscillator.reset() return (mathUtils.createRotationMatrix(Vector3(0, 0, 0)), mathUtils.createRotationMatrix(Vector3(0, 0, 0))) oscillatorAcceleration = self.__calcCurOscillatorAcceleration(deltaTime) self.__movementOscillator.externalForce += oscillatorAcceleration self.__impulseOscillator.update(deltaTime) self.__movementOscillator.update(deltaTime) self.__noiseOscillator.update(deltaTime) noiseDeviation = Vector3(self.__noiseOscillator.deviation) deviation = self.__impulseOscillator.deviation + self.__movementOscillator.deviation + noiseDeviation oscVelocity = self.__impulseOscillator.velocity + self.__movementOscillator.velocity + self.__noiseOscillator.velocity if abs(deviation.x) < 1e-05 and abs(oscVelocity.x) < 0.0001: deviation.x = 0 if abs(deviation.y) < 1e-05 and abs(oscVelocity.y) < 0.0001: deviation.y = 0 if abs(deviation.z) < 1e-05 and abs(oscVelocity.z) < 0.0001: deviation.z = 0 curZoomIdx = 0 zooms = self.__cfg['zooms'] for idx in xrange(len(zooms)): if self.__zoom == zooms[idx]: curZoomIdx = idx break zoomExposure = self.__zoom * self.__dynamicCfg['zoomExposure'][curZoomIdx] deviation /= zoomExposure impulseDeviation = (self.__impulseOscillator.deviation + noiseDeviation) / zoomExposure self.__impulseOscillator.externalForce = Vector3(0) self.__movementOscillator.externalForce = Vector3(0) self.__noiseOscillator.externalForce = Vector3(0) return (mathUtils.createRotationMatrix(Vector3(deviation.x, deviation.y, deviation.z)), mathUtils.createRotationMatrix(impulseDeviation))
def __updateOscillators(self, deltaTime): if not SniperCamera.isCameraDynamic(): self.__impulseOscillator.reset() self.__movementOscillator.reset() self.__noiseOscillator.reset() return (mathUtils.createRotationMatrix(Vector3(0, 0, 0)), mathUtils.createRotationMatrix(Vector3(0, 0, 0))) oscillatorAcceleration = self.__calcCurOscillatorAcceleration(deltaTime) self.__movementOscillator.externalForce += oscillatorAcceleration self.__impulseOscillator.update(deltaTime) self.__movementOscillator.update(deltaTime) self.__noiseOscillator.update(deltaTime) noiseDeviation = Vector3(self.__noiseOscillator.deviation) deviation = self.__impulseOscillator.deviation + self.__movementOscillator.deviation + noiseDeviation oscVelocity = self.__impulseOscillator.velocity + self.__movementOscillator.velocity + self.__noiseOscillator.velocity if abs(deviation.x) < 1e-05 and abs(oscVelocity.x) < 0.0001: deviation.x = 0 if abs(deviation.y) < 1e-05 and abs(oscVelocity.y) < 0.0001: deviation.y = 0 if abs(deviation.z) < 1e-05 and abs(oscVelocity.z) < 0.0001: deviation.z = 0 curZoomIdx = 0 zooms = self.__cfg['zooms'] for idx in xrange(len(zooms)): if self.__zoom == zooms[idx]: curZoomIdx = idx break zoomExposure = self.__zoom * self.__dynamicCfg['zoomExposure'][curZoomIdx] deviation /= zoomExposure impulseDeviation = (self.__impulseOscillator.deviation + noiseDeviation) / zoomExposure self.__impulseOscillator.externalForce.set(0, 0, 0) self.__movementOscillator.externalForce.set(0, 0, 0) self.__noiseOscillator.externalForce.set(0, 0, 0) return (mathUtils.createRotationMatrix(Vector3(deviation.x, deviation.y, deviation.z)), mathUtils.createRotationMatrix(impulseDeviation))
def __assembleModel(self): from vehicle_systems import model_assembler resources = self.__resources self.__vEntity.model = resources[self.__vDesc.name] if not self.__isVehicleDestroyed: self.__fashions = VehiclePartsTuple(BigWorld.WGVehicleFashion(False), BigWorld.WGBaseFashion(), BigWorld.WGBaseFashion(), BigWorld.WGBaseFashion()) model_assembler.setupTracksFashion(self.__vDesc, self.__fashions.chassis) self.__vEntity.model.setupFashions(self.__fashions) self.__initMaterialHandlers() model_assembler.assembleCollisionObstaclesCollector(self, None) model_assembler.assembleTessellationCollisionSensor(self, None) self.wheelsAnimator = model_assembler.createWheelsAnimator(self.__vEntity.model, self.__vDesc, None) self.trackNodesAnimator = model_assembler.createTrackNodesAnimator(self.__vEntity.model, self.__vDesc, self.wheelsAnimator) chassisFashion = self.__fashions.chassis splineTracksImpl = model_assembler.setupSplineTracks(chassisFashion, self.__vDesc, self.__vEntity.model, self.__resources) model_assembler.assembleTracks(self.__resources, self.__vDesc, self, splineTracksImpl, True) self.updateCustomization(self.__outfit) dirtEnabled = BigWorld.WG_dirtEnabled() and 'HD' in self.__vDesc.type.tags if dirtEnabled: dirtHandlers = [BigWorld.PyDirtHandler(True, self.__vEntity.model.node(TankPartNames.CHASSIS).position.y), BigWorld.PyDirtHandler(False, self.__vEntity.model.node(TankPartNames.HULL).position.y), BigWorld.PyDirtHandler(False, self.__vEntity.model.node(TankPartNames.TURRET).position.y), BigWorld.PyDirtHandler(False, self.__vEntity.model.node(TankPartNames.GUN).position.y)] modelHeight, _ = self.computeVehicleHeight() self.dirtComponent = Vehicular.DirtComponent(dirtHandlers, modelHeight) for fashionIdx, _ in enumerate(TankPartNames.ALL): self.__fashions[fashionIdx].addMaterialHandler(dirtHandlers[fashionIdx]) self.dirtComponent.setBase() else: self.__fashions = VehiclePartsTuple(BigWorld.WGBaseFashion(), BigWorld.WGBaseFashion(), BigWorld.WGBaseFashion(), BigWorld.WGBaseFashion()) self.__vEntity.model.setupFashions(self.__fashions) self.wheelsAnimator = None self.trackNodesAnimator = None self.dirtComponent = None cfg = hangarCFG() turretYaw = self.__vDesc.gun.staticTurretYaw gunPitch = self.__vDesc.gun.staticPitch if not ('AT-SPG' in self.__vDesc.type.tags or 'SPG' in self.__vDesc.type.tags): if turretYaw is None: turretYaw = cfg['vehicle_turret_yaw'] turretYawLimits = self.__vDesc.gun.turretYawLimits if turretYawLimits is not None: turretYaw = mathUtils.clamp(turretYawLimits[0], turretYawLimits[1], turretYaw) if gunPitch is None: gunPitch = cfg['vehicle_gun_pitch'] gunPitchLimits = self.__vDesc.gun.pitchLimits['absolute'] gunPitch = mathUtils.clamp(gunPitchLimits[0], gunPitchLimits[1], gunPitch) else: if turretYaw is None: turretYaw = 0.0 if gunPitch is None: gunPitch = 0.0 turretYawMatrix = mathUtils.createRotationMatrix((turretYaw, 0.0, 0.0)) self.__vEntity.model.node(TankPartNames.TURRET, turretYawMatrix) gunPitchMatrix = mathUtils.createRotationMatrix((0.0, gunPitch, 0.0)) self.__vEntity.model.node(TankPartNames.GUN, gunPitchMatrix) 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) 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 __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 __getMovementDirections(self): m = mathUtils.createRotationMatrix(self.__ypr) result = (m.applyVector(Vector3(1, 0, 0)), Vector3(0, 1, 0), m.applyVector(Vector3(0, 0, 1))) if self.__alignerToLand.enabled: result[0].y = 0.0 result[2].y = 0.0 return result
def enable(self, targetPos, saveDist): self.__prevTime = BigWorld.time() self.__aimingSystem.enable(targetPos) self.__activeDistRangeSettings = self.__getActiveDistRangeForArena() if self.__activeDistRangeSettings is not None: self.__aimingSystem.height = self.__getDistRange()[0] srcMat = mathUtils.createRotationMatrix((self.__cameraYaw, -math.pi * 0.499, 0.0)) self.__cam.source = srcMat if not saveDist: self.__updateCamDistCfg() self.__camDist = self.__cfg['camDist'] self.__cam.pivotPosition = Math.Vector3(0.0, self.__camDist, 0.0) camTarget = Math.MatrixProduct() camTarget.b = self.__aimingSystem.matrix self.__cam.target = camTarget self.__cam.forceUpdate() BigWorld.camera(self.__cam) BigWorld.player().positionControl.moveTo(self.__aimingSystem.matrix.translation) BigWorld.player().positionControl.followCamera(True) FovExtended.instance().enabled = False BigWorld.projection().fov = StrategicCamera.ABSOLUTE_VERTICAL_FOV self.__cameraUpdate() self.delayCallback(0.0, self.__cameraUpdate) self.__needReset = 1 return
def __init__(self, height, yaw): super(StrategicAimingSystem, self).__init__() self._matrix = mathUtils.createRotationMatrix((yaw, 0, 0)) self._planePosition = Vector3(0, 0, 0) self.__camDist = 0.0 self.__height = height self.__heightFromPlane = 0.0
def getAimMatrix(x, y): fov = BigWorld.projection().fov near = BigWorld.projection().nearPlane aspect = getScreenAspectRatio() yLength = near * math.tan(fov * 0.5) xLength = yLength * aspect result = mathUtils.createRotationMatrix(Math.Vector3(math.atan2(xLength * x, near), math.atan2(yLength * y, near), 0)) return result
def applyImpulse(self, position, impulse, reason=ImpulseReason.ME_HIT): adjustedImpulse, noiseMagnitude = self.__dynamicCfg.adjustImpulse( impulse, reason) yawMat = mathUtils.createRotationMatrix( (-self.__aimingSystem.yaw, 0, 0)) impulseLocal = yawMat.applyVector(adjustedImpulse) self.__impulseOscillator.applyImpulse(impulseLocal) self.__applyNoiseImpulse(noiseMagnitude)
def applyImpulse(self, position, impulse, reason=ImpulseReason.ME_HIT): adjustedImpulse, noiseMagnitude = self.__dynamicCfg.adjustImpulse(impulse, reason) impulseFlatDir = Vector3(adjustedImpulse.x, 0, adjustedImpulse.z) impulseFlatDir.normalise() cameraYawMat = mathUtils.createRotationMatrix(Vector3(-self.__cameraYaw, 0.0, 0.0)) impulseLocal = cameraYawMat.applyVector(impulseFlatDir * (-1 * adjustedImpulse.length)) self.__positionOscillator.applyImpulse(impulseLocal) self.__applyNoiseImpulse(noiseMagnitude)
def applyImpulse(self, position, impulse, reason = ImpulseReason.ME_HIT): adjustedImpulse, noiseMagnitude = self.__dynamicCfg.adjustImpulse(impulse, reason) impulseFlatDir = Vector3(adjustedImpulse.x, 0, adjustedImpulse.z) impulseFlatDir.normalise() cameraYawMat = mathUtils.createRotationMatrix(Vector3(-StrategicCamera._CAMERA_YAW, 0.0, 0.0)) impulseLocal = cameraYawMat.applyVector(impulseFlatDir * (-1 * adjustedImpulse.length)) self.__positionOscillator.applyImpulse(impulseLocal) self.__applyNoiseImpulse(noiseMagnitude)
def getAimMatrix(x, y, fov = None): if fov is None: fov = BigWorld.projection().fov near = BigWorld.projection().nearPlane aspect = getScreenAspectRatio() yLength = near * math.tan(fov * 0.5) xLength = yLength * aspect result = mathUtils.createRotationMatrix(Math.Vector3(math.atan2(xLength * x, near), math.atan2(yLength * y, near), 0)) return result
def __getTurretYawGunPitch(self, targetPos, compensateGravity=False): player = BigWorld.player() stabilisedMatrix = Math.Matrix(player.inputHandler.steadyVehicleMatrixCalculator.stabilisedMProv) turretYaw, gunPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleTypeDescriptor, stabilisedMatrix, targetPos, compensateGravity) rotation = mathUtils.createRotationMatrix((turretYaw, gunPitch, 0.0)) rotation.postMultiply(stabilisedMatrix) invertSteady = Math.Matrix(self.__vehicleMProv) invertSteady.invert() rotation.postMultiply(invertSteady) return (rotation.yaw, rotation.pitch)
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 StrategicCamera__cameraUpdate( self, *args ): replayCtrl = BattleReplay.g_replayCtrl if not spgAim.enabled: srcMat = mathUtils.createRotationMatrix((0, -math.pi * 0.499, 0)) self._StrategicCamera__cam.source = srcMat self._StrategicCamera__cam.target.b = self._StrategicCamera__aimingSystem.matrix BigWorld.projection().nearPlane = spgAim._prevNearPlane BigWorld.projection().farPlane = spgAim._prevFarPlane BigWorld.projection().fov = StrategicCamera.StrategicCamera.ABSOLUTE_VERTICAL_FOV return oldStrategicCamera__cameraUpdate( self ) return spgAim.onStrategicCameraUpdate(self, *args)
def StrategicCamera__cameraUpdate(self, *args): replayCtrl = BattleReplay.g_replayCtrl if not spgAim.enabled: srcMat = mathUtils.createRotationMatrix((0, -math.pi * 0.499, 0)) self._StrategicCamera__cam.source = srcMat self._StrategicCamera__cam.target.b = self._StrategicCamera__aimingSystem.matrix BigWorld.projection().nearPlane = spgAim._prevNearPlane BigWorld.projection().farPlane = spgAim._prevFarPlane BigWorld.projection( ).fov = StrategicCamera.StrategicCamera.ABSOLUTE_VERTICAL_FOV return oldStrategicCamera__cameraUpdate(self) return spgAim.onStrategicCameraUpdate(self, *args)
def __calcCurOscillatorAcceleration(self, deltaTime): vehicle = BigWorld.player().getVehicleAttached() if vehicle is None: return Vector3(0, 0, 0) vehFilter = vehicle.filter curVelocity = getattr(vehFilter, 'velocity', Vector3(0.0)) relativeSpeed = curVelocity.length / vehicle.typeDescriptor.physics['speedLimits'][0] if relativeSpeed >= ArcadeCamera._MIN_REL_SPEED_ACC_SMOOTHING: self.__accelerationSmoother.maxAllowedAcceleration = self.__dynamicCfg['accelerationThreshold'] else: self.__accelerationSmoother.maxAllowedAcceleration = self.__dynamicCfg['accelerationMax'] acceleration = self.__accelerationSmoother.update(vehicle, deltaTime) yawMat = mathUtils.createRotationMatrix((-self.__aimingSystem.yaw, 0, 0)) acceleration = yawMat.applyVector(-acceleration) oscillatorAcceleration = Vector3(acceleration.x, acceleration.y, acceleration.z) return oscillatorAcceleration * self.__dynamicCfg['accelerationSensitivity']
def _update(self): worldMatrix = Matrix(self._cam.invViewMatrix) desiredPosition = self.__basisMProv.checkTurretDetachment( worldMatrix.translation) if desiredPosition is not None: self.__position = desiredPosition prevPos = Math.Vector3(self.__position) delta = self.__calcCurrentDeltaAdjusted() self.__updateSenses(delta) if self._targetRadiusSensor: self.__rotationRadius += self._targetRadiusSensor.currentVelocity * delta if self.__isVerticalVelocitySeparated: self._verticalMovementSensor.update(delta) else: self._verticalMovementSensor.currentVelocity = self._movementSensor.currentVelocity.y self._verticalMovementSensor.sensitivity = self._movementSensor.sensitivity if self._inertiaEnabled: self.__inertialMovement(delta) else: self.__simpleMovement(delta) self.__ypr += self.__yprVelocity * delta self.__position += self.__velocity * delta if self.__rotateAroundPointEnabled: self.__position = self.__getAlignedToPointPosition( mathUtils.createRotationMatrix(self.__ypr)) if self._alignerToLand.enabled and not self.__basisMProv.isBound: if abs(self.__velocity.y) > 0.1: self._alignerToLand.enable(self.__position, self._alignerToLand.ignoreTerrain) self.__position = self._alignerToLand.getAlignedPosition( self.__position) lookAtPosition = self.__basisMProv.lookAtPosition if lookAtPosition is not None: self.__ypr = self.__getLookAtYPR(lookAtPosition) if self.__cameraInterpolator.active: self.__ypr = self.__clampPR(self.__ypr) else: self.__ypr = self.__clampYPR(self.__ypr) self.__position = self._checkSpaceBounds(prevPos, self.__position) self._cam.invViewProvider.a = mathUtils.createRTMatrix( self.__ypr, self.__position) self._cam.invViewProvider.b = self.__basisMProv.matrix if self.__cameraInterpolator.active: self.__cameraInterpolator.tick() BigWorld.projection().fov = self.__calcFov() self.__resetSenses() 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 __cameraUpdate(self): deltaTime = self.__updateTime() self.__handleMovement() aimPoint = Vector3(self.__aimingSystem.aimPoint) self.__aimOffset = self.__calculateAimOffset(aimPoint) self.__updateTrajectoryDrawer() translation, rotation = self.__calculateIdealState(deltaTime) self.__interpolateStates(deltaTime, translation, mathUtils.createRotationMatrix(rotation)) self.__camDist = aimPoint - self.__targetMatrix.translation self.__camDist = self.__camDist.length self.__cam.source = self.__sourceMatrix self.__cam.target.b = self.__targetMatrix self.__cam.pivotPosition = Vector3(0, 0, 0) BigWorld.player().positionControl.moveTo(aimPoint) self.__updateOscillator(deltaTime) self.__aimingSystem.update(deltaTime) if not self.__autoUpdatePosition: self.__dxdydz = Vector3(0, 0, 0)
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 enable(self, targetPos, saveDist): self.__prevTime = BigWorld.time() self.__aimingSystem.enable(targetPos) srcMat = mathUtils.createRotationMatrix((0.0, -math.pi * 0.499, 0.0)) self.__cam.source = srcMat if not saveDist: self.__camDist = self.__cfg['camDist'] self.__cam.pivotPosition = Math.Vector3(0.0, self.__camDist, 0.0) camTarget = Math.MatrixProduct() camTarget.b = self.__aimingSystem.matrix self.__cam.target = camTarget BigWorld.camera(self.__cam) BigWorld.player().positionControl.moveTo(self.__aimingSystem.matrix.translation) BigWorld.player().positionControl.followCamera(True) FovExtended.instance().enabled = False BigWorld.projection().fov = StrategicCamera.ABSOLUTE_VERTICAL_FOV self.__cameraUpdate() self.delayCallback(0.0, self.__cameraUpdate) self.__needReset = 1
def enable(self, targetPos, saveDist): self.__prevTime = BigWorld.time() self.__aimingSystem.enable(targetPos) srcMat = mathUtils.createRotationMatrix((0.0, -math.pi * 0.499, 0.0)) self.__cam.source = srcMat if not saveDist: self.__camDist = self.__cfg['camDist'] self.__cam.pivotPosition = Math.Vector3(0.0, self.__camDist, 0.0) camTarget = Math.MatrixProduct() camTarget.b = self.__aimingSystem.matrix self.__cam.target = camTarget self.__cam.wg_applyParams() BigWorld.camera(self.__cam) BigWorld.player().positionControl.moveTo(self.__aimingSystem.matrix.translation) BigWorld.player().positionControl.followCamera(True) FovExtended.instance().enabled = False BigWorld.projection().fov = StrategicCamera.ABSOLUTE_VERTICAL_FOV self.__cameraUpdate() self.delayCallback(0.0, self.__cameraUpdate) self.__needReset = 1
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 __update(self): worldMatrix = Matrix(self.__cam.invViewMatrix) desiredPosition = self.__basisMProv.checkTurretDetachment(worldMatrix.translation) if desiredPosition is not None: self.__position = desiredPosition prevPos = Math.Vector3(self.__position) delta = self.__calcCurrentDeltaAdjusted() self.__updateSenses(delta) self.__rotationRadius += self.__targetRadiusSensor.currentVelocity * delta if self.__isVerticalVelocitySeparated: self.__verticalMovementSensor.update(delta) else: self.__verticalMovementSensor.currentVelocity = self.__movementSensor.currentVelocity.y self.__verticalMovementSensor.sensitivity = self.__movementSensor.sensitivity if self.__inertiaEnabled: self.__inertialMovement(delta) else: self.__simpleMovement(delta) self.__ypr += self.__yprVelocity * delta self.__position += self.__velocity * delta if self.__rotateAroundPointEnabled: self.__position = self.__getAlignedToPointPosition(mathUtils.createRotationMatrix(self.__ypr)) if self.__alignerToLand.enabled and not self.__basisMProv.isBound: if abs(self.__velocity.y) > 0.1: self.__alignerToLand.enable(self.__position, self.__alignerToLand.ignoreTerrain) self.__position = self.__alignerToLand.getAlignedPosition(self.__position) lookAtPosition = self.__basisMProv.lookAtPosition if lookAtPosition is not None: self.__ypr = self.__getLookAtYPR(lookAtPosition) self.__ypr = self.__clampYPR(self.__ypr) self.__position = self.__checkSpaceBounds(prevPos, self.__position) self.__cam.invViewProvider.a = mathUtils.createRTMatrix(self.__ypr, self.__position) self.__cam.invViewProvider.b = self.__basisMProv.matrix BigWorld.projection().fov = self.__calcFov() self.__resetSenses() return 0.0
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 __init__(self, height, yaw): self._matrix = mathUtils.createRotationMatrix((yaw, 0, 0)) self.__planePosition = Vector3(0, 0, 0) self.__height = height
def __worldYawPitchToTurret(self, worldYaw, worldPitch): worldToTurret = Matrix(self.__vehicleMProv) worldToTurret.invert() worldToTurret.preMultiply( mathUtils.createRotationMatrix((worldYaw, worldPitch, 0.0))) return (worldToTurret.yaw, worldToTurret.pitch)
def __worldYawPitchToTurret(self, worldYaw, worldPitch): worldToTurret = Matrix(self.__vehicleMProv) worldToTurret.invert() worldToTurret.preMultiply(mathUtils.createRotationMatrix((worldYaw, worldPitch, 0.0))) return (worldToTurret.yaw, worldToTurret.pitch)
def __init__(self): BigWorld.UserDataObject.__init__(self) launchDir = mathUtils.createRotationMatrix((self.__dict__['yaw'], self.__dict__['pitch'], 0)).applyToAxis(2) launchDir.normalise() self.launchVelocity = launchDir * self.speed
def __init__(self, height, yaw): self._matrix = mathUtils.createRotationMatrix((yaw, 0, 0)) self.__planePosition = Vector3(0, 0, 0) self.__height = height self.__heightFromPlane = 0.0
def setYaw(self, yaw): self._matrix = mathUtils.createRotationMatrix((yaw, 0, 0)) self._updateMatrix()
def StrategicCamera__cameraUpdate(self): replayCtrl = BattleReplay.g_replayCtrl global gSPGSniperEnabled if not gSPGSniperEnabled: srcMat = mathUtils.createRotationMatrix((0, -math.pi * 0.49, 0)) self._StrategicCamera__cam.source = srcMat self._StrategicCamera__cam.target.b = self._StrategicCamera__aimingSystem.matrix if not replayCtrl.isPlaying: BigWorld.projection().nearPlane = self._prevNearPlane BigWorld.projection().farPlane = self._prevFarPlane BigWorld.projection( ).fov = StrategicCamera.StrategicCamera.ABSOLUTE_VERTICAL_FOV return oldStrategicCamera__cameraUpdate(self) distRange = self._StrategicCamera__cfg['distRange'][:] if distRange[0] < 20: distRange[0] = 20 distRange[1] = 600 player = BigWorld.player() descr = player.vehicleTypeDescriptor shotEnd = self._StrategicCamera__aimingSystem.matrix.translation shellVelocity = Math.Vector3( self._StrategicCamera__aimingSystem._shellVelocity) shellVelocity.normalise() srcMat = Math.Matrix() srcMat.setRotateYPR((shellVelocity.yaw, -shellVelocity.pitch, 0)) shift = srcMat.applyVector( Math.Vector3(self._StrategicCamera__dxdydz.x, 0, -self._StrategicCamera__dxdydz.y) ) * self._StrategicCamera__curSense if replayCtrl.isPlaying and replayCtrl.isControllingCamera: aimOffset = replayCtrl.getAimClipPosition() else: aimWorldPos = self._StrategicCamera__aimingSystem.matrix.applyPoint( Math.Vector3(0, 0, 0)) aimOffset = cameras.projectPoint(aimWorldPos) if replayCtrl.isRecording: replayCtrl.setAimClipPosition( Math.Vector2(aimOffset.x, aimOffset.y)) self._StrategicCamera__aim.offset((aimOffset.x, aimOffset.y)) shotDescr = BigWorld.player().vehicleTypeDescriptor.shot BigWorld.wg_trajectory_drawer().setParams( shotDescr['maxDistance'], Math.Vector3(0, -shotDescr['gravity'], 0), self._StrategicCamera__aim.offset()) curTime = BigWorld.time() deltaTime = curTime - self._StrategicCamera__prevTime self._StrategicCamera__prevTime = curTime if replayCtrl.isPlaying: if self._StrategicCamera__needReset != 0: if self._StrategicCamera__needReset > 1: player = BigWorld.player() if player.inputHandler.ctrl is not None: player.inputHandler.ctrl.resetGunMarkers() self._StrategicCamera__needReset = 0 else: self._StrategicCamera__needReset += 1 if replayCtrl.isControllingCamera: self._StrategicCamera__aimingSystem.updateTargetPos( replayCtrl.getGunRotatorTargetPoint()) else: self._StrategicCamera__aimingSystem.handleMovement( shift.x, shift.z) if shift.x != 0 and shift.z != 0 or self._StrategicCamera__dxdydz.z != 0: self._StrategicCamera__needReset = 2 self._StrategicCamera__aimingSystem.handleMovement(shift.x, shift.z) self._StrategicCamera__camDist -= self._StrategicCamera__dxdydz.z * float( self._StrategicCamera__curSense) maxPivotHeight = (distRange[1] - distRange[0]) / BigWorld._ba_config['spg']['zoomSpeed'] self._StrategicCamera__camDist = mathUtils.clamp( 0, maxPivotHeight, self._StrategicCamera__camDist) self._StrategicCamera__cfg['camDist'] = self._StrategicCamera__camDist if self._StrategicCamera__dxdydz.z != 0 and self._StrategicCamera__onChangeControlMode is not None and mathUtils.almostZero( self._StrategicCamera__camDist - maxPivotHeight): self._StrategicCamera__onChangeControlMode() self._StrategicCamera__updateOscillator(deltaTime) if not self._StrategicCamera__autoUpdatePosition: self._StrategicCamera__dxdydz = Math.Vector3(0, 0, 0) fov = min(6.0 * descr.gun['shotDispersionAngle'], math.pi * 0.5) zoomFactor = 1.0 / math.tan(fov * 0.5) / 5.0 #old scheme #zoomDistance = ( self._StrategicCamera__camDist + distRange[0] ) * zoomFactor #new scheme zoomDistance = distRange[0] * zoomFactor fovFactor = self._StrategicCamera__camDist / maxPivotHeight fov = fov * (1.0 - fovFactor) + math.radians(20.0) * fovFactor cameraOffset = -shellVelocity.scale(zoomDistance) cameraPosition = shotEnd + cameraOffset collPoint = None collPoint = BigWorld.wg_collideSegment( player.spaceID, shotEnd - shellVelocity.scale(1.0 if shellVelocity.y > 0.0 else distRange[0] * zoomFactor * 0.25), cameraPosition, 128) if collPoint is None: collPoint = player.arena.collideWithSpaceBB(shotEnd, cameraPosition) if collPoint is not None: collPoint += shellVelocity else: collPoint = collPoint[0] recalculateDist = False if collPoint is not None: cameraPosition = collPoint cameraOffset = cameraPosition - shotEnd recalculateDist = True if cameraOffset.length > 700.0: cameraOffset.normalise() cameraOffset = cameraOffset.scale(700.0) cameraPosition = shotEnd + cameraOffset recalculateDist = True #if recalculateDist: # self._StrategicCamera__camDist = cameraOffset.length / zoomFactor - distRange[0] #bb = BigWorld.player().arena.arenaType.boundingBox #cameraPositionClamped = _clampPoint2DInBox2D(bb[0] - Math.Vector2( 50.0, 50.0 ), bb[1] + Math.Vector2( 50.0, 50.0 ), Math.Vector2(cameraPosition.x, cameraPosition.z)) #if abs( cameraPositionClamped.x - cameraPosition.x ) > 0.1 or abs( cameraPositionClamped.y - cameraPosition.z ) > 0.1: # clampFactor = min( ( cameraPositionClamped.x - shotEnd.x ) / cameraOffset.x if abs( cameraOffset.x ) > 0.001 else 1.0, ( cameraPositionClamped.y - shotEnd.z ) / cameraOffset.z if abs( cameraOffset.z ) > 0.001 else 1.0 ) #else: # clampFactor = 1.0 #if clampFactor < 0.99: # cameraOffset *= clampFactor # cameraPosition = shotEnd + cameraOffset # self._StrategicCamera__camDist = cameraOffset.length / zoomFactor - distRange[0] trgMat = Math.Matrix() trgMat.setTranslate(cameraPosition) self._StrategicCamera__cam.source = srcMat self._StrategicCamera__cam.target.b = trgMat self._StrategicCamera__cam.pivotPosition = Math.Vector3(0, 0, 0) delta = self._prevFarPlane - self._prevNearPlane BigWorld.projection().nearPlane = max(cameraOffset.length - delta * 0.5, 1.0) BigWorld.projection().farPlane = max(cameraOffset.length + delta * 0.5, self._prevFarPlane) BigWorld.projection().fov = fov BigWorld.player().positionControl.moveTo(shotEnd) #LOG_ERROR( '{0} {1}'.format( cameraPosition, self._StrategicCamera__camDist ) ) #FLUSH_LOG( ) return 0
def applyImpulse(self, position, impulse, reason = ImpulseReason.ME_HIT): adjustedImpulse, noiseMagnitude = self.__dynamicCfg.adjustImpulse(impulse, reason) yawMat = mathUtils.createRotationMatrix((-self.__aimingSystem.yaw, 0, 0)) impulseLocal = yawMat.applyVector(adjustedImpulse) self.__impulseOscillator.applyImpulse(impulseLocal) self.__applyNoiseImpulse(noiseMagnitude)