def __calculateIdealState(self, deltaTime): aimPoint = self.__aimingSystem.aimPoint direction = self.__aimingSystem.direction impactPitch = max(direction.pitch, self.__cfg['minimalPitch']) self.__rotation = max(self.__rotation, impactPitch) distRange = self.__cfg['distRange'] distanceCurSq = ( aimPoint - BigWorld.player().getVehicleAttached().position).lengthSquared distanceMinSq = distRange[0]**2.0 forcedPitch = impactPitch if distanceCurSq < distanceMinSq: forcedPitch = atan2(sqrt(distanceMinSq - distanceCurSq), sqrt(distanceCurSq)) angularShift = self.__cfg['angularSpeed'] * deltaTime angularShift = angularShift if self.__choosePitchLevel( aimPoint) else -angularShift minPitch = max(forcedPitch, impactPitch) maxPitch = max(forcedPitch, self.__cfg['maximalPitch']) self.__rotation = mathUtils.clamp(minPitch, maxPitch, self.__rotation + angularShift) desiredDistance = self.__getDesiredCameraDistance() cameraDirection = self.__getCameraDirection() desiredDistance = self.__resolveCollisions(aimPoint, desiredDistance, cameraDirection) desiredDistance = mathUtils.clamp(distRange[0], distRange[1], desiredDistance) translation = aimPoint - cameraDirection.scale(desiredDistance) rotation = Vector3(cameraDirection.yaw, -cameraDirection.pitch, 0.0) return (translation, rotation)
def setCameraLocation(self, targetPos = None, pivotPos = None, yaw = None, pitch = None, dist = None, ignoreConstraints = False): sourceMat = Math.Matrix(self.__cam.source) if yaw is None: yaw = sourceMat.yaw if pitch is None: pitch = sourceMat.pitch if dist is None: dist = self.__cam.pivotMaxDist if not ignoreConstraints: yaw = self.__yawCameraFilter.toLimit(yaw) pitch = mathUtils.clamp(math.radians(_CFG['cam_pitch_constr'][0]), math.radians(_CFG['cam_pitch_constr'][1]), pitch) if self.__selectedEmblemInfo is not None: dist = mathUtils.clamp(self.__camDistConstr[1][0], self.__camDistConstr[1][1], dist) else: dist = mathUtils.clamp(self.__camDistConstr[0][0], self.__camDistConstr[0][1], dist) if self.__boundingRadius is not None: dist = dist if dist > self.__boundingRadius else self.__boundingRadius mat = Math.Matrix() pitch = mathUtils.clamp(-math.pi / 2 * 0.99, math.pi / 2 * 0.99, pitch) mat.setRotateYPR((yaw, pitch, 0.0)) self.__cam.source = mat self.__cam.pivotMaxDist = dist if targetPos is not None: self.__cam.target.setTranslate(targetPos) if pivotPos is not None: self.__cam.pivotPosition = pivotPos return
def updateCameraByMouseMove(self, dx, dy, dz): sourceMat = Math.Matrix(self.__cam.source) yaw = sourceMat.yaw pitch = sourceMat.pitch dist = self.__cam.pivotMaxDist yaw += dx * _CFG['cam_sens'] pitch -= dy * _CFG['cam_sens'] dist -= dz * _CFG['cam_sens'] if yaw > 2.0 * math.pi: yaw -= 2.0 * math.pi elif yaw < -2.0 * math.pi: yaw += 2.0 * math.pi pitch = mathUtils.clamp(math.radians(_CFG['cam_pitch_constr'][0]), math.radians(_CFG['cam_pitch_constr'][1]), pitch) prevDist = dist dist = mathUtils.clamp(_CFG['cam_dist_constr'][0], _CFG['cam_dist_constr'][1], dist) if self.__boundingRadius is not None: dist = dist if dist > self.__boundingRadius else self.__boundingRadius if dist > prevDist and dz > 0: if self.__selectedEmblemInfo is not None: self.locateCameraOnEmblem(*self.__selectedEmblemInfo) return mat = Math.Matrix() mat.setRotateYPR((yaw, pitch, 0.0)) self.__cam.source = mat self.__cam.pivotMaxDist = dist return
def setCameraLocation(self, targetPos = None, pivotPos = None, yaw = None, pitch = None, dist = None, ignoreConstraints = False): sourceMat = Math.Matrix(self.__cam.source) if yaw is None: yaw = sourceMat.yaw if pitch is None: pitch = sourceMat.pitch if dist is None: dist = self.__cam.pivotMaxDist if not ignoreConstraints: if yaw > 2.0 * math.pi: yaw -= 2.0 * math.pi elif yaw < -2.0 * math.pi: yaw += 2.0 * math.pi pitch = mathUtils.clamp(math.radians(_CFG['cam_pitch_constr'][0]), math.radians(_CFG['cam_pitch_constr'][1]), pitch) dist = mathUtils.clamp(_CFG['cam_dist_constr'][0], _CFG['cam_dist_constr'][1], dist) if self.__boundingRadius is not None: dist = dist if dist > self.__boundingRadius else self.__boundingRadius mat = Math.Matrix() pitch = mathUtils.clamp(-math.pi / 2 * 0.99, math.pi / 2 * 0.99, pitch) mat.setRotateYPR((yaw, pitch, 0.0)) self.__cam.source = mat self.__cam.pivotMaxDist = dist if targetPos is not None: self.__cam.target.setTranslate(targetPos) if pivotPos is not None: self.__cam.pivotPosition = pivotPos
def updateCameraByMouseMove(self, dx, dy, dz): if self.__selectedEmblemInfo is not None: self.__cam.target.setTranslate(_CFG['preview_cam_start_target_pos']) self.__cam.pivotPosition = _CFG['preview_cam_pivot_pos'] sourceMat = Math.Matrix(self.__cam.source) yaw = sourceMat.yaw pitch = sourceMat.pitch dist = self.__cam.pivotMaxDist yaw += dx * _CFG['cam_sens'] pitch -= dy * _CFG['cam_sens'] dist -= dz * _CFG['cam_sens'] if yaw > 2.0 * math.pi: yaw -= 2.0 * math.pi elif yaw < -2.0 * math.pi: yaw += 2.0 * math.pi pitch = mathUtils.clamp(math.radians(_CFG['cam_pitch_constr'][0]), math.radians(_CFG['cam_pitch_constr'][1]), pitch) prevDist = dist dist = mathUtils.clamp(_CFG['cam_dist_constr'][0], _CFG['cam_dist_constr'][1], dist) if self.__boundingRadius is not None: dist = dist if dist > self.__boundingRadius else self.__boundingRadius if dist > prevDist and dz > 0: if self.__selectedEmblemInfo is not None: self.locateCameraOnEmblem(*self.__selectedEmblemInfo) return mat = Math.Matrix() mat.setRotateYPR((yaw, pitch, 0.0)) self.__cam.source = mat self.__cam.pivotMaxDist = dist
def __updateCameraByMouseMove(self, dx, dy, dz): if self.__cam is not BigWorld.camera(): return sourceMat = Math.Matrix(self.__cam.source) yaw = sourceMat.yaw pitch = sourceMat.pitch dist = self.__cam.pivotMaxDist currentMatrix = Math.Matrix(self.__cam.invViewMatrix) currentYaw = currentMatrix.yaw yaw = self.__yawCameraFilter.getNextYaw(currentYaw, yaw, dx) from gui.ClientHangarSpace import hangarCFG cfg = hangarCFG() pitch -= dy * cfg['cam_sens'] dist -= dz * cfg['cam_dist_sens'] camPitchConstr = self.__camConstraints[0] startPitch, endPitch = camPitchConstr pitch = mathUtils.clamp(math.radians(startPitch), math.radians(endPitch), pitch) distConstr = cfg['preview_cam_dist_constr'] if self.__selectedEmblemInfo else self.__camConstraints[2] minDist, maxDist = distConstr dist = mathUtils.clamp(minDist, maxDist, dist) self.__locatedOnEmbelem = False mat = Math.Matrix() mat.setRotateYPR((yaw, pitch, 0.0)) self.__cam.source = mat self.__cam.pivotMaxDist = dist if self.settingsCore.getSetting('dynamicFov') and abs(distConstr[1] - distConstr[0]) > 0.001: relativeDist = (dist - distConstr[0]) / (distConstr[1] - distConstr[0]) _, minFov, maxFov = self.settingsCore.getSetting('fov') fov = mathUtils.lerp(minFov, maxFov, relativeDist) BigWorld.callback(0, partial(FovExtended.instance().setFovByAbsoluteValue, math.radians(fov), 0.1))
def __inLimit(self, prevYaw, newYaw, newPitch): if self.__yawLimits is not None: prevYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], prevYaw) newYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], newYaw) prevPitchLimits = calcPitchLimitsFromDesc(prevYaw, self.__pitchLimits) pitchLimits = calcPitchLimitsFromDesc(newYaw, self.__pitchLimits) if SniperAimingSystem.__FILTER_ENABLED: pitchLimitsMin = pitchLimits[0] + self.__pitchDeviation[0] pitchLimitsMax = pitchLimits[1] + self.__pitchDeviation[1] prevLimMin = prevPitchLimits[0] + self.__pitchDeviation[0] prevLimMax = prevPitchLimits[1] + self.__pitchDeviation[1] else: pitchLimitsMin = pitchLimits[0] pitchLimitsMax = pitchLimits[1] prevLimMin = prevPitchLimits[0] prevLimMax = prevPitchLimits[1] prevLimitedPitch = mathUtils.clamp(prevLimMin, prevLimMax, newPitch) limitedPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax, newPitch) dp = limitedPitch - prevLimitedPitch return (newYaw, limitedPitch, pitchLimitsMin <= newPitch <= pitchLimitsMax, pitchLimitsMin, dp)
def __calcAimOffset(self, aimLocalTransform = None): worldCrosshair = Matrix(self.__crosshairMatrix) aimingSystemMatrix = self.__aimingSystem.matrix if aimLocalTransform is not None: worldCrosshair.postMultiply(aimLocalTransform) worldCrosshair.postMultiply(aimingSystemMatrix) aimOffset = cameras.projectPoint(worldCrosshair.translation) return Vector2(mathUtils.clamp(-0.95, 0.95, aimOffset.x), mathUtils.clamp(-0.95, 0.95, aimOffset.y))
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 __clampToLimits(self, turretYaw, gunPitch): if self.__yawLimits is not None: turretYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], turretYaw) desc = BigWorld.player().vehicleTypeDescriptor pitchLimits = calcPitchLimitsFromDesc(turretYaw, desc.gun['pitchLimits']) pitchLimitsMin = pitchLimits[0] pitchLimitsMax = pitchLimits[1] gunPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax, gunPitch) return (turretYaw, gunPitch)
def __clampToLimits(self, turretYaw, gunPitch): if self.__yawLimits is not None: turretYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], turretYaw) pitchLimits = calcPitchLimitsFromDesc(turretYaw, self.getPitchLimits()) adjustment = max(0, self.__returningOscillator.deviation.y) pitchLimits[0] -= adjustment pitchLimits[1] += adjustment gunPitch = mathUtils.clamp(pitchLimits[0], pitchLimits[1] + self.__pitchCompensating, gunPitch) return (turretYaw, gunPitch)
def __getClampedCursor(self): cursorPosition = GUI.mcursor().position cursorPosition.x = mathUtils.clamp(-self.CURSOR_POSITION_CLAMP_VALUE, self.CURSOR_POSITION_CLAMP_VALUE, cursorPosition.x) cursorPosition.y = mathUtils.clamp(-self.CURSOR_POSITION_CLAMP_VALUE, self.CURSOR_POSITION_CLAMP_VALUE, cursorPosition.y) return cursorPosition
def setCameraLocation(self, targetPos=None, pivotPos=None, yaw=None, pitch=None, dist=None, camConstraints=None, ignoreConstraints=False, smothiedTransition=True, previewMode=False, verticalOffset=0.0): from gui.ClientHangarSpace import hangarCFG cfg = hangarCFG() sourceMat = Math.Matrix(self.__cam.source) if yaw is None: yaw = sourceMat.yaw if pitch is None: pitch = sourceMat.pitch if dist is None: dist = self.__cam.pivotMaxDist self.__cam.screenSpaceVerticalOffset = verticalOffset if camConstraints is not None: self.__camConstraints = camConstraints else: self.__camConstraints[0] = cfg['cam_pitch_constr'] self.__camConstraints[1] = cfg['cam_yaw_constr'] camYawConstr = self.__camConstraints[1] startYaw, endYaw = camYawConstr self.__yawCameraFilter.setConstraints(math.radians(startYaw), math.radians(endYaw)) self.__yawCameraFilter.setYawLimits(camYawConstr) if not ignoreConstraints: yaw = self.__yawCameraFilter.toLimit(yaw) pitchOffset = self.__cam.pitchOffset camPitchConstr = self.__camConstraints[0] startPitch, endPitch = (math.radians(pc) - pitchOffset for pc in camPitchConstr) pitch = mathUtils.clamp(startPitch, endPitch, pitch) distConstr = cfg[ 'preview_cam_dist_constr'] if self.__isPreviewMode else self.__camConstraints[ 2] minDist, maxDist = distConstr dist = mathUtils.clamp(minDist, maxDist, dist) mat = Math.Matrix() pitch = mathUtils.clamp(-math.pi / 2 * 0.99, math.pi / 2 * 0.99, pitch) mat.setRotateYPR((yaw, pitch, 0.0)) self.__cam.source = mat self.__cam.pivotMaxDist = dist if targetPos is not None: self.__cam.target.setTranslate(targetPos) if pivotPos is not None: self.__cam.pivotPosition = pivotPos if not smothiedTransition: self.__cam.forceUpdate() self.setPreviewMode(previewMode) return
def __calculateAimOffset(self, aimWorldPos): replayCtrl = BattleReplay.g_replayCtrl if replayCtrl.isPlaying and replayCtrl.isControllingCamera: aimOffset = replayCtrl.getAimClipPosition() else: aimOffset = cameras.projectPoint(aimWorldPos) aimOffset = Vector2(mathUtils.clamp(-0.95, 0.95, aimOffset.x), mathUtils.clamp(-0.95, 0.95, aimOffset.y)) if replayCtrl.isRecording: replayCtrl.setAimClipPosition(aimOffset) return aimOffset
def __clampToLimits(self, turretYaw, gunPitch, withDeviation = False): if self.__yawLimits is not None: turretYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], turretYaw) pitchLimits = calcPitchLimitsFromDesc(turretYaw, self.__pitchLimits) if withDeviation: pitchLimitsMin = min(pitchLimits[0] + self.__pitchDeviation[0], _MAX_DEVIATION) pitchLimitsMax = max(pitchLimits[1] + self.__pitchDeviation[1], -_MAX_DEVIATION) else: pitchLimitsMin = pitchLimits[0] pitchLimitsMax = pitchLimits[1] gunPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax, gunPitch) return (turretYaw, gunPitch)
def __clampToLimits(self, turretYaw, gunPitch): if self.__yawLimits is not None: turretYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], turretYaw) pitchLimits = calcPitchLimitsFromDesc(turretYaw, self.__pitchLimits) if SniperAimingSystem.__FILTER_ENABLED: pitchLimitsMin = min(pitchLimits[0] + self.__pitchDeviation[0], _MAX_DEVIATION) pitchLimitsMax = max(pitchLimits[1] + self.__pitchDeviation[1], -_MAX_DEVIATION) else: pitchLimitsMin = pitchLimits[0] pitchLimitsMax = pitchLimits[1] gunPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax + self.__pitchCompensating, gunPitch) return (turretYaw, gunPitch)
def clampToLimits(base, self, turretYaw, gunPitch): if config.get('battle/camera/enabled') and config.get('battle/camera/sniper/noCameraLimit/enabled'): if not BigWorld.isKeyDown(KEY_RIGHTMOUSE) and self._SniperAimingSystem__yawLimits is not None and config.get('battle/camera/sniper/noCameraLimit/mode') == "hotkey": turretYaw = mathUtils.clamp(self._SniperAimingSystem__yawLimits[0], self._SniperAimingSystem__yawLimits[1], turretYaw) getPitchLimits = avatar_getter.getVehicleTypeDescriptor().gun.combinedPitchLimits pitchLimits = calcPitchLimitsFromDesc(turretYaw, getPitchLimits) adjustment = max(0, self._SniperAimingSystem__returningOscillator.deviation.y) pitchLimits[0] -= adjustment pitchLimits[1] += adjustment gunPitch = mathUtils.clamp(pitchLimits[0], pitchLimits[1] + self._SniperAimingSystem__pitchCompensating, gunPitch) return (turretYaw, gunPitch) return base(self, turretYaw, gunPitch)
def __inLimit(self, yaw, pitch, withDeviation = False): if self.__yawLimits is not None: yaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], yaw) pitchLimits = calcPitchLimitsFromDesc(yaw, self.__pitchLimits) if withDeviation: pitchLimitsMin = pitchLimits[0] + self.__pitchDeviation[0] pitchLimitsMax = pitchLimits[1] + self.__pitchDeviation[1] else: pitchLimitsMin = pitchLimits[0] pitchLimitsMax = pitchLimits[1] limitedPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax, pitch) return (pitchLimitsMin <= pitch <= pitchLimitsMax, limitedPitch)
def __inLimit(self, yaw, pitch, withDeviation=False): if self.__yawLimits is not None: yaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], yaw) pitchLimits = calcPitchLimitsFromDesc(yaw, self.__pitchLimits) if withDeviation: pitchLimitsMin = pitchLimits[0] + self.__pitchDeviation[0] pitchLimitsMax = pitchLimits[1] + self.__pitchDeviation[1] else: pitchLimitsMin = pitchLimits[0] pitchLimitsMax = pitchLimits[1] limitedPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax, pitch) return (pitchLimitsMin <= pitch <= pitchLimitsMax, limitedPitch)
def updateCameraByMouseMove(self, dx, dy, dz): if self.__selectedEmblemInfo is not None: self.__cam.target.setTranslate( _CFG['preview_cam_start_target_pos']) self.__cam.pivotPosition = _CFG['preview_cam_pivot_pos'] if self.__locatedOnEmbelem: self.__cam.maxDistHalfLife = 0.0 else: self.__cam.maxDistHalfLife = _CFG['cam_fluency'] sourceMat = Math.Matrix(self.__cam.source) yaw = sourceMat.yaw pitch = sourceMat.pitch dist = self.__cam.pivotMaxDist currentMatrix = Math.Matrix(self.__cam.invViewMatrix) currentYaw = currentMatrix.yaw yaw = self.__yawCameraFilter.getNextYaw(currentYaw, yaw, dx) pitch -= dy * _CFG['cam_sens'] dist -= dz * _CFG['cam_sens'] pitch = mathUtils.clamp(math.radians(_CFG['cam_pitch_constr'][0]), math.radians(_CFG['cam_pitch_constr'][1]), pitch) prevDist = dist distConstr = self.__camDistConstr[ 1] if self.__selectedEmblemInfo is not None else self.__camDistConstr[ 0] dist = mathUtils.clamp(distConstr[0], distConstr[1], dist) if self.__boundingRadius is not None: boundingRadius = self.__boundingRadius if self.__boundingRadius < distConstr[ 1] else distConstr[1] dist = dist if dist > boundingRadius else boundingRadius if dist > prevDist and dz > 0: if self.__selectedEmblemInfo is not None: self.locateCameraOnEmblem(*self.__selectedEmblemInfo) return self.__locatedOnEmbelem = False mat = Math.Matrix() mat.setRotateYPR((yaw, pitch, 0.0)) self.__cam.source = mat self.__cam.pivotMaxDist = dist if self.settingsCore.getSetting( 'dynamicFov') and abs(distConstr[1] - distConstr[0]) > 0.001: relativeDist = (dist - distConstr[0]) / (distConstr[1] - distConstr[0]) _, minFov, maxFov = self.settingsCore.getSetting('fov') fov = mathUtils.lerp(minFov, maxFov, relativeDist) BigWorld.callback( 0, functools.partial(FovExtended.instance().setFovByAbsoluteValue, math.radians(fov), 0.1)) return
def __calcAimOffset(self, aimLocalTransform=None): player = BigWorld.player() vehicle = player.getVehicleAttached() if self.__isRemoteCamera and vehicle is not None: aimingSystemMatrix = self.__getRemoteAim(False) aimingSystemMatrix.invert() else: aimingSystemMatrix = self.__aimingSystem.matrix worldCrosshair = Matrix(self.__crosshairMatrix) if aimLocalTransform is not None: worldCrosshair.postMultiply(aimLocalTransform) worldCrosshair.postMultiply(aimingSystemMatrix) aimOffset = cameras.projectPoint(worldCrosshair.translation) return Vector2(mathUtils.clamp(-0.95, 0.95, aimOffset.x), mathUtils.clamp(-0.95, 0.95, aimOffset.y))
def __clampToLimits(self, turretYaw, gunPitch, withDeviation=False): if self.__yawLimits is not None: turretYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], turretYaw) pitchLimits = calcPitchLimitsFromDesc(turretYaw, self.__pitchLimits) if withDeviation: pitchLimitsMin = min(pitchLimits[0] + self.__pitchDeviation[0], _MAX_DEVIATION) pitchLimitsMax = max(pitchLimits[1] + self.__pitchDeviation[1], -_MAX_DEVIATION) else: pitchLimitsMin = pitchLimits[0] pitchLimitsMax = pitchLimits[1] gunPitch = mathUtils.clamp(pitchLimitsMin, pitchLimitsMax, gunPitch) return (turretYaw, gunPitch)
def setCameraLocation(self, targetPos=None, pivotPos=None, yaw=None, pitch=None, dist=None, camConstraints=None, ignoreConstraints=False, smothiedTransition=True): from gui.ClientHangarSpace import hangarCFG cfg = hangarCFG() sourceMat = Math.Matrix(self.__cam.source) if yaw is None: yaw = sourceMat.yaw if pitch is None: pitch = sourceMat.pitch if dist is None: dist = self.__cam.pivotMaxDist if camConstraints is not None: self.__camConstraints = camConstraints else: self.__camConstraints[0] = cfg['cam_pitch_constr'] self.__camConstraints[1] = cfg['cam_yaw_constr'] self.__yawCameraFilter.setConstraints( math.radians(self.__camConstraints[1][0]), math.radians(self.__camConstraints[1][1])) self.__yawCameraFilter.setYawLimits(self.__camConstraints[1]) if not ignoreConstraints: yaw = self.__yawCameraFilter.toLimit(yaw) pitch = mathUtils.clamp(math.radians(self.__camConstraints[0][0]), math.radians(self.__camConstraints[0][1]), pitch) distConstr = cfg[ 'preview_cam_dist_constr'] if self.__selectedEmblemInfo else self.__camConstraints[ 2] dist = mathUtils.clamp(distConstr[0], distConstr[1], dist) mat = Math.Matrix() pitch = mathUtils.clamp(-math.pi / 2 * 0.99, math.pi / 2 * 0.99, pitch) mat.setRotateYPR((yaw, pitch, 0.0)) self.__cam.source = mat self.__cam.pivotMaxDist = dist if targetPos is not None: self.__cam.target.setTranslate(targetPos) if pivotPos is not None: self.__cam.pivotPosition = pivotPos if not smothiedTransition: self.__cam.forceUpdate() return
def handleMovement(self, dx, dy): self.__idealTurretYaw, self.__idealGunPitch = self.__worldYawPitchToTurret( self.__worldYaw, self.__worldPitch) pitchExcess = self.__calcPitchExcess(self.__idealTurretYaw + dx, self.__idealGunPitch + dy) if pitchExcess * dy < 0: dy = 0 self.__idealTurretYaw, self.__idealGunPitch = self.__clampToLimits( self.__idealTurretYaw + dx, self.__idealGunPitch + dy) if pitchExcess != 0.0: self.__adjustPitchLimitExtension(abs(pitchExcess), True) currentGunMat = self.__getPlayerGunMat(self.__idealTurretYaw, self.__idealGunPitch) self.__worldYaw = currentGunMat.yaw self.__worldPitch = currentGunMat.pitch self._matrix.set(currentGunMat) self.__oscillator.velocity = Vector3(0.0, 0.0, 0.0) self.__returningOscillator.velocity = Vector3(0.0, 0.0, 0.0) _, uncompensatedPitch = self.__getTurretYawGunPitch( self.getDesiredShotPoint()) self.__pitchCompensating = mathUtils.clamp( math.radians(-2.0), math.radians(2.0), self.__idealGunPitch - uncompensatedPitch) if abs(self.__pitchCompensating) < 0.01: self.__pitchCompensating = 0.0
def readFloat(dataSec, name, minVal, maxVal, defaultVal): if dataSec is None: return defaultVal else: value = dataSec.readFloat(name, defaultVal) value = mathUtils.clamp(minVal, maxVal, value) return value
def __cameraUpdate(self): currentTime = BigWorld.timeExact() self.__elapsedTime += currentTime - self.__prevTime self.__prevTime = currentTime interpolationCoefficient = self.__easingMethod( self.__elapsedTime, 1.0, self.__totalInterpolationTime) interpolationCoefficient = mathUtils.clamp(0.0, 1.0, interpolationCoefficient) iSource = self.__initialState.source iTarget = self.__initialState.target.b.translation iPivotPosition = self.__initialState.pivotPosition fSource = self.__finalState.source fTarget = self.__finalState.target.b.translation fPivotPosition = self.__finalState.pivotPosition self.__cam.source = Math.slerp(iSource, fSource, interpolationCoefficient) self.__cam.target.b.translation = mathUtils.lerp( iTarget, fTarget, interpolationCoefficient) self.__cam.pivotPosition = mathUtils.lerp(iPivotPosition, fPivotPosition, interpolationCoefficient) BigWorld.projection().fov = mathUtils.lerp(self.__initialFov, self.__finalFov, interpolationCoefficient) if self.__elapsedTime > self.__totalInterpolationTime: self.delayCallback(0.0, self.disable) return 10.0
def __setupCamera(self): from gui.ClientHangarSpace import hangarCFG cfg = hangarCFG() self.__cam = BigWorld.CursorCamera() self.__cam.isHangar = True self.__cam.spaceID = self.__spaceId self.__cam.pivotMaxDist = mathUtils.clamp(cfg['cam_dist_constr'][0], cfg['cam_dist_constr'][1], cfg['cam_start_dist']) self.__cam.pivotMinDist = 0.0 self.__cam.maxDistHalfLife = cfg['cam_fluency'] self.__cam.turningHalfLife = cfg['cam_fluency'] self.__cam.movementHalfLife = cfg['cam_fluency'] self.__cam.pivotPosition = cfg['cam_pivot_pos'] self.__camConstraints[0] = cfg['cam_pitch_constr'] self.__camConstraints[1] = cfg['cam_yaw_constr'] self.__camConstraints[2] = (0.0, 0.0) self.__yawCameraFilter = HangarCameraYawFilter( math.radians(cfg['cam_yaw_constr'][0]), math.radians(cfg['cam_yaw_constr'][1]), cfg['cam_sens']) self.__yawCameraFilter.setYawLimits(self.__camConstraints[1]) mat = Math.Matrix() yaw = self.__yawCameraFilter.toLimit( math.radians(cfg['cam_start_angles'][0])) mat.setRotateYPR((yaw, math.radians(cfg['cam_start_angles'][1]), 0.0)) self.__cam.source = mat mat = Math.Matrix() mat.setTranslate(cfg['cam_start_target_pos']) self.__cam.target = mat self.__cam.wg_applyParams() BigWorld.camera(self.__cam) self.__cameraIdle = HangarCameraIdle(self.__cam) self.__cameraParallax = HangarCameraParallax(self.__cam) self.__cam.setDynamicCollisions(True)
def handleMovement(self, dx, dy): self.__idealYaw, self.__idealPitch = self.__worldYawPitchToTurret(self.__g_curYaw, self.__pitchfilter.value()) newPitch = self.__idealPitch + dy newYaw = self.__idealYaw + dx self.__idealYaw, idealPitch, inLimit, pitchMin, dp = self.__inLimit(self.__idealYaw, newYaw, newPitch) newPitch += dp if not inLimit: d1 = pitchMin - self.__idealPitch d2 = pitchMin - newPitch if math.fabs(d1) >= math.fabs(d2): self.__idealPitch = idealPitch currentGunMat = AimingSystems.getPlayerGunMat(self.__idealYaw, self.__idealPitch) self.__pitchfilter.adjust(currentGunMat.pitch - self.__pitchfilter.value()) else: currentGunMat = AimingSystems.getPlayerGunMat(self.__idealYaw, idealPitch) self.__pitchfilter.reset(currentGunMat.pitch) self.__g_curYaw = currentGunMat.yaw self.__g_curPitch = currentGunMat.pitch self._matrix.set(currentGunMat) self.__oscillator.velocity = Vector3(0.0, 0.0, 0.0) _, uncompensatedPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleTypeDescriptor, BigWorld.player().getOwnVehicleStabilisedMatrix(), self.getDesiredShotPoint()) if inLimit: self.__pitchCompensating = mathUtils.clamp(math.radians(-2.0), math.radians(2.0), idealPitch - uncompensatedPitch) else: self.__pitchCompensating = 0.0
def getNextGunPitch(self, curAngle, shotAngle, timeDiff, angleLimits): replayCtrl = BattleReplay.g_replayCtrl if replayCtrl.isPlaying: gunPitch = replayCtrl.getGunPitch() if gunPitch > -100000: return gunPitch if self.__maxGunRotationSpeed == 0.0: shotAngle = curAngle shotDiff = 0.0 descr = self.__avatar.getVehicleDescriptor() speedLimit = descr.gun.rotationSpeed * timeDiff else: if math.fabs(curAngle - shotAngle) < VehicleGunRotator.__ANGLE_EPS: if angleLimits is not None: return mathUtils.clamp(angleLimits[0], angleLimits[1], shotAngle) return shotAngle shotDiff = shotAngle - curAngle speedLimit = self.__maxGunRotationSpeed * timeDiff if angleLimits is not None: if shotAngle < angleLimits[0]: shotDiff = angleLimits[0] - curAngle elif shotAngle > angleLimits[1]: shotDiff = angleLimits[1] - curAngle staticPitch = self.__getGunStaticPitch() if staticPitch is not None and shotDiff * (curAngle - staticPitch) < 0.0: speedLimit *= 2.0 if staticPitch is not None and self.estimatedTurretRotationTime > 0.0: idealYawSpeed = abs(shotDiff) / self.estimatedTurretRotationTime speedLimit = min(speedLimit, idealYawSpeed * timeDiff) return curAngle + min( shotDiff, speedLimit) if shotDiff > 0.0 else curAngle + max( shotDiff, -speedLimit)
def __getDesiredCameraDistance(self): distRange = self.__cfg['distRange'] self.__desiredCamDist -= self.__dxdydz.z * self.__curSense self.__desiredCamDist = mathUtils.clamp(distRange[0], distRange[1], self.__desiredCamDist) self.__desiredCamDist = self.__aimingSystem.overrideCamDist(self.__desiredCamDist) self.__cfg['camDist'] = self.__camDist return self.__desiredCamDist
def __update(self, dx, dy, dz, rotateMode = True, zoomMode = True, isCallback = False): prevPos = self.__inputInertia.calcWorldPos(self.__aimingSystem.matrix) distChanged = False if zoomMode and dz != 0: prevDist = self.__aimingSystem.distanceFromFocus distDelta = dz * float(self.__curScrollSense) distMinMax = self.__cfg['distRange'] newDist = mathUtils.clamp(distMinMax.min, distMinMax.max, prevDist - distDelta) if abs(newDist - prevDist) > 0.001: self.__aimingSystem.distanceFromFocus = newDist self.__userCfg['startDist'] = newDist self.__inputInertia.glideFov(self.__calcRelativeDist()) self.__aimingSystem.aimMatrix = self.__calcAimMatrix() distChanged = True changeControlMode = prevDist == newDist and mathUtils.almostZero(newDist - distMinMax.min) if changeControlMode and self.__onChangeControlMode is not None: self.__onChangeControlMode() return if rotateMode: self.__updateAngles(dx, dy) if ENABLE_INPUT_ROTATION_INERTIA and not distChanged: self.__aimingSystem.update(0.0) if ENABLE_INPUT_ROTATION_INERTIA or distChanged: worldDeltaPos = prevPos - self.__aimingSystem.matrix.translation matInv = Matrix(self.__aimingSystem.matrix) matInv.invert() self.__inputInertia.glide(matInv.applyVector(worldDeltaPos))
def __getNextGunPitch(self, curAngle, shotAngle, timeDiff, angleLimits): replayCtrl = BattleReplay.g_replayCtrl if replayCtrl.isPlaying: gunPitch = replayCtrl.getGunPitch() if gunPitch > -100000: return gunPitch if self.__maxGunRotationSpeed == 0.0: shotAngle = curAngle shotDiff = 0.0 descr = self.__avatar.vehicleTypeDescriptor speedLimit = descr.gun['rotationSpeed'] * timeDiff else: if math.fabs(curAngle - shotAngle) < VehicleGunRotator.__ANGLE_EPS: if angleLimits is not None: return mathUtils.clamp(angleLimits[0], angleLimits[1], shotAngle) else: return shotAngle shotDiff = shotAngle - curAngle speedLimit = self.__maxGunRotationSpeed * timeDiff if angleLimits is not None: if shotAngle < angleLimits[0]: shotDiff = angleLimits[0] - curAngle elif shotAngle > angleLimits[1]: shotDiff = angleLimits[1] - curAngle if shotDiff > 0.0: return curAngle + min(shotDiff, speedLimit) else: return curAngle + max(shotDiff, -speedLimit) return
def __setStartParams(self, params): a = params.minValue b = params.maxValue - params.minValue clampedValue = mathUtils.clamp(params.minValue, params.maxValue, params.startValue) dArg = -1.0 + (clampedValue - a) * 2.0 / b if b != 0.0 else 0.0 params.startTime = math.asin(dArg)
def __update(self, dx, dy, dz, rotateMode = True, zoomMode = True, isCallback = False): prevPos = self.__inputInertia.calcWorldPos(self.__aimingSystem.matrix) distChanged = False if zoomMode and dz != 0: prevDist = self.__aimingSystem.distanceFromFocus distDelta = dz * float(self.__curScrollSense) distMinMax = self.__cfg['distRange'] newDist = mathUtils.clamp(distMinMax.min, distMinMax.max, prevDist - distDelta) if abs(newDist - prevDist) > 0.001: self.__aimingSystem.distanceFromFocus = newDist self.__userCfg['startDist'] = newDist self.__inputInertia.glideFov(self.__calcRelativeDist()) self.__aimingSystem.aimMatrix = self.__calcAimMatrix() distChanged = True changeControlMode = prevDist == newDist and mathUtils.almostZero(newDist - distMinMax.min) if changeControlMode and self.__onChangeControlMode is not None: self.__onChangeControlMode() return if rotateMode: self.__updateAngles(dx, dy) if ENABLE_INPUT_ROTATION_INERTIA and not distChanged: self.__aimingSystem.update(0.0) if ENABLE_INPUT_ROTATION_INERTIA or distChanged: worldDeltaPos = prevPos - self.__aimingSystem.matrix.translation matInv = Matrix(self.__aimingSystem.matrix) matInv.invert() self.__inputInertia.glide(matInv.applyVector(worldDeltaPos)) return
def __interpolateStates(self, deltaTime, translation, rotation): lerpParam = mathUtils.clamp( 0.0, 1.0, deltaTime * self.__cfg['interpolationSpeed']) self.__sourceMatrix = slerp(self.__sourceMatrix, rotation, lerpParam) self.__targetMatrix.translation = mathUtils.lerp( self.__targetMatrix.translation, translation, lerpParam) return (self.__sourceMatrix, self.__targetMatrix)
def __init__(self): ClientSelectableObject.__init__(self) CallbackDelayer.__init__(self) TimeDeltaMeter.__init__(self) self.__state = CameraMovementStates.FROM_OBJECT self.__camera = cameras.FreeCamera() self.cameraPitch = mathUtils.clamp(-math.pi / 2 * 0.99, math.pi / 2 * 0.99, self.cameraPitch) self.cameraYaw = normalizeAngle(self.cameraYaw) self.__goalPosition = Math.Vector3(0.0, 0.0, 0.0) self.__goalDistance = None self.__goalTarget = Math.Vector3(0.0, 0.0, 0.0) self.__startPosition = Math.Vector3(0.0, 0.0, 0.0) self.__startYaw = 0.0 self.__startPitch = 0.0 self.__curTime = None self.__easedInYaw = 0.0 self.__easedInPitch = 0.0 self.__easeInDuration = 0.0 self.__startFov = None self.__goalFov = None if self.enableYawLimits: self.__yawLimits = Math.Vector2(self.yawLimitMin, self.yawLimitMax) else: self.__yawLimits = None self.__pitchLimits = Math.Vector2(math.degrees(self.pitchLimitMin), math.degrees(self.pitchLimitMax)) self.__p1 = Math.Vector3(0.0, 0.0, 0.0) self.__p2 = Math.Vector3(0.0, 0.0, 0.0) self.__wasPreviousUpdateSkipped = False return
def refresh(self, delta): vehicleTypeDescriptor = self._vehicle.typeDescriptor vehicleSpeed = self._vehicle.speedInfo.value[0] if vehicleSpeed > 0.0: self._relativeSpeed = vehicleSpeed / vehicleTypeDescriptor.physics['speedLimits'][0] else: self._relativeSpeed = vehicleSpeed / vehicleTypeDescriptor.physics['speedLimits'][1] self._relativeSpeed = clamp(-1.0, 1.0, self._relativeSpeed)
def readVec3(dataSec, name, minVal, maxVal, defaultVal): if dataSec is None: return Math.Vector3(defaultVal) value = dataSec.readVector3(name, Math.Vector3(defaultVal)) for i in xrange(3): value[i] = mathUtils.clamp(minVal[i], maxVal[i], value[i]) return value
def handleMovement(self, dx, dy): self.__idealTurretYaw, self.__idealGunPitch = self.__worldYawPitchToTurret(self.__worldYaw, self.__worldPitch) self.__idealTurretYaw, self.__idealGunPitch = self.__clampToLimits(self.__idealTurretYaw + dx, self.__idealGunPitch + dy) currentGunMat = AimingSystems.getPlayerGunMat(self.__idealTurretYaw, self.__idealGunPitch) self.__worldYaw = currentGunMat.yaw self.__worldPitch = currentGunMat.pitch self._matrix.set(currentGunMat) self.__oscillator.velocity = Vector3(0.0, 0.0, 0.0) _, uncompensatedPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleTypeDescriptor, BigWorld.player().getOwnVehicleMatrix(), self.getDesiredShotPoint()) self.__pitchCompensating = mathUtils.clamp(math.radians(-2.0), math.radians(2.0), self.__idealGunPitch - uncompensatedPitch)
def adjustImpulse(self, impulse, reason): impulseSensitivity = self['impulseSensitivities'].get(reason, 0.0) noiseImpulseSensitivity = self['noiseSensitivities'].get(reason, 0.0) resultImpulse = impulse * impulseSensitivity impulseMinMax = self['impulseLimits'].get(reason, None) if impulseMinMax is not None: resultImpulse = mathUtils.clampVectorLength(impulseMinMax[0], impulseMinMax[1], resultImpulse) noiseMagnitude = impulse.length * noiseImpulseSensitivity noiseMinMax = self['noiseLimits'].get(reason, None) if noiseMinMax is not None: noiseMagnitude = mathUtils.clamp(noiseMinMax[0], noiseMinMax[1], noiseMagnitude) return (resultImpulse, noiseMagnitude)
def updateCameraByMouseMove(self, dx, dy, dz): if self.__selectedEmblemInfo is not None: self.__cam.target.setTranslate(_CFG['preview_cam_start_target_pos']) self.__cam.pivotPosition = _CFG['preview_cam_pivot_pos'] if self.__locatedOnEmbelem: self.__cam.maxDistHalfLife = 0.0 else: self.__cam.maxDistHalfLife = _CFG['cam_fluency'] sourceMat = Math.Matrix(self.__cam.source) yaw = sourceMat.yaw pitch = sourceMat.pitch dist = self.__cam.pivotMaxDist currentMatrix = Math.Matrix(self.__cam.invViewMatrix) currentYaw = currentMatrix.yaw yaw = self.__yawCameraFilter.getNextYaw(currentYaw, yaw, dx) pitch -= dy * _CFG['cam_sens'] dist -= dz * _CFG['cam_sens'] pitch = mathUtils.clamp(math.radians(_CFG['cam_pitch_constr'][0]), math.radians(_CFG['cam_pitch_constr'][1]), pitch) prevDist = dist distConstr = self.__camDistConstr[1] if self.__selectedEmblemInfo is not None else self.__camDistConstr[0] dist = mathUtils.clamp(distConstr[0], distConstr[1], dist) if self.__boundingRadius is not None: boundingRadius = self.__boundingRadius if self.__boundingRadius < distConstr[1] else distConstr[1] dist = dist if dist > boundingRadius else boundingRadius if dist > prevDist and dz > 0: if self.__selectedEmblemInfo is not None: self.locateCameraOnEmblem(*self.__selectedEmblemInfo) return self.__locatedOnEmbelem = False mat = Math.Matrix() mat.setRotateYPR((yaw, pitch, 0.0)) self.__cam.source = mat self.__cam.pivotMaxDist = dist if g_settingsCore.getSetting('dynamicFov') and abs(distConstr[1] - distConstr[0]) > 0.001: relativeDist = (dist - distConstr[0]) / (distConstr[1] - distConstr[0]) _, minFov, maxFov = g_settingsCore.getSetting('fov') fov = mathUtils.lerp(minFov, maxFov, relativeDist) BigWorld.callback(0, functools.partial(FovExtended.instance().setFovByAbsoluteValue, math.radians(fov), 0.1)) return
def __setupCamera(self): self.__cam = BigWorld.CursorCamera() self.__cam.spaceID = self.__spaceId self.__cam.pivotMaxDist = mathUtils.clamp(_CFG['cam_dist_constr'][0], _CFG['cam_dist_constr'][1], _CFG['cam_start_dist']) self.__cam.pivotMinDist = 0.0 self.__cam.maxDistHalfLife = _CFG['cam_fluency'] self.__cam.turningHalfLife = _CFG['cam_fluency'] self.__cam.movementHalfLife = 0.0 self.__cam.pivotPosition = _CFG['cam_pivot_pos'] mat = Math.Matrix() yaw = self.__yawCameraFilter.toLimit(math.radians(_CFG['cam_start_angles'][0])) mat.setRotateYPR((yaw, math.radians(_CFG['cam_start_angles'][1]), 0.0)) self.__cam.source = mat mat = Math.Matrix() mat.setTranslate(_CFG['cam_start_target_pos']) self.__cam.target = mat BigWorld.camera(self.__cam)
def __cameraUpdate(self): replayCtrl = BattleReplay.g_replayCtrl if replayCtrl.isPlaying and replayCtrl.isControllingCamera: aimOffset = replayCtrl.getAimClipPosition() else: aimOffset = self.__calcAimOffset() if replayCtrl.isRecording: replayCtrl.setAimClipPosition(aimOffset) self.__aimOffsetFunc(aimOffset) shotDescr = BigWorld.player().vehicleTypeDescriptor.shot BigWorld.wg_trajectory_drawer().setParams(shotDescr['maxDistance'], Math.Vector3(0, -shotDescr['gravity'], 0), self.__aimOffsetFunc()) curTime = BigWorld.time() deltaTime = curTime - self.__prevTime self.__prevTime = curTime if replayCtrl.isPlaying: if self.__needReset != 0: if self.__needReset > 1: from helpers import isPlayerAvatar player = BigWorld.player() if isPlayerAvatar(): if player.inputHandler.ctrl is not None: player.inputHandler.ctrl.resetGunMarkers() self.__needReset = 0 else: self.__needReset += 1 if replayCtrl.isControllingCamera: self.__aimingSystem.updateTargetPos(replayCtrl.getGunRotatorTargetPoint()) else: self.__aimingSystem.handleMovement(self.__dxdydz.x * self.__curSense, -self.__dxdydz.y * self.__curSense) if self.__dxdydz.x != 0 or self.__dxdydz.y != 0 or self.__dxdydz.z != 0: self.__needReset = 2 else: self.__aimingSystem.handleMovement(self.__dxdydz.x * self.__curSense, -self.__dxdydz.y * self.__curSense) distRange = self.__cfg['distRange'] self.__camDist -= self.__dxdydz.z * float(self.__curSense) maxPivotHeight = distRange[1] - distRange[0] self.__camDist = mathUtils.clamp(0, maxPivotHeight, self.__camDist) self.__cfg['camDist'] = self.__camDist self.__cam.pivotPosition = Math.Vector3(0.0, self.__camDist, 0.0) if self.__dxdydz.z != 0 and self.__onChangeControlMode is not None and mathUtils.almostZero(self.__camDist - maxPivotHeight): self.__onChangeControlMode() self.__updateOscillator(deltaTime) if not self.__autoUpdatePosition: self.__dxdydz = Vector3(0, 0, 0) return 0.0
def update(self, dt): remainedDt = dt remainedDt = mathUtils.clamp(0.0, Oscillator._STEP_LENGTH * 3, remainedDt) while remainedDt > 0.0: deltaTime = Oscillator._STEP_LENGTH if deltaTime > remainedDt: deltaTime = remainedDt remainedDt -= deltaTime force = self.__calcForce() acc = force / self.mass self.velocity += acc * deltaTime self.deviation += self.velocity * deltaTime unclampedPos = self.deviation self.deviation = mathUtils.clampVector3(-self.constraints, self.constraints, self.deviation) if unclampedPos.x != self.deviation.x: self.velocity.x = 0.0 if unclampedPos.y != self.deviation.y: self.velocity.y = 0.0 if unclampedPos.z != self.deviation.z: self.velocity.z = 0.0
def update(self): vehicleSpeed = self.__vehicle.speedInfo.value[2] appearance = self.__appearance self.__variableArgs['speed'] = vehicleSpeed self.__variableArgs['isPC'] = self.__vehicle.isPlayerVehicle direction = 1 if vehicleSpeed >= 0.0 else -1 self.__variableArgs['direction'] = direction self.__variableArgs['rotSpeed'] = self.__vehicle.speedInfo.value[1] matKindsUnderTracks = getCorrectedMatKinds(appearance) self.__variableArgs['deltaR'], self.__variableArgs['directionR'], self.__variableArgs['matkindR'] = self.__getScrollParams(appearance.trackScrollController.rightScroll(), appearance.trackScrollController.rightContact(), matKindsUnderTracks[CustomEffectManager._RIGHT_TRACK], direction) self.__variableArgs['deltaL'], self.__variableArgs['directionL'], self.__variableArgs['matkindL'] = self.__getScrollParams(appearance.trackScrollController.leftScroll(), appearance.trackScrollController.leftContact(), matKindsUnderTracks[CustomEffectManager._LEFT_TRACK], direction) matInv = Math.Matrix(self.__vehicle.matrix) matInv.invert() velocityLocal = matInv.applyVector(self.__vehicle.filter.velocity) velLen = velocityLocal.length if velLen > 1.0: vehicleDir = Math.Vector3(0.0, 0.0, 1.0) velocityLocal = Math.Vector2(velocityLocal.z, velocityLocal.x) cosA = velocityLocal.dot(Math.Vector2(vehicleDir.z, vehicleDir.x)) / velLen self.__variableArgs['hullAngle'] = math.acos(mathUtils.clamp(0.0, 1.0, math.fabs(cosA))) else: self.__variableArgs['hullAngle'] = 0.0 self.__variableArgs['isUnderWater'] = 1 if appearance.isUnderwater else 0 self.__correctWaterNodes() self.__variableArgs['gearUp'] = self.__gearUP self.__variableArgs['RPM'] = self.__engineState.relativeRPM self.__gearUP = False self.__variableArgs['engineLoad'] = self.__engineState.mode self.__variableArgs['engineStart'] = self.__engineState.starting self.__variableArgs['physicLoad'] = self.__engineState.physicLoad for effectSelector in self.__selectors: effectSelector.update(self.__variableArgs) if _ENABLE_VALUE_TRACKER: self.__vt.addValue2('speed', self.__variableArgs['speed']) self.__vt.addValue2('direction', self.__variableArgs['direction']) self.__vt.addValue2('rotSpeed', self.__variableArgs['rotSpeed']) self.__vt.addValue2('deltaR', self.__variableArgs['deltaR']) self.__vt.addValue2('deltaL', self.__variableArgs['deltaL']) self.__vt.addValue2('hullAngle', self.__variableArgs['hullAngle']) self.__vt.addValue2('isUnderWater', self.__variableArgs['isUnderWater']) self.__vt.addValue2('directionR', self.__variableArgs['directionR']) self.__vt.addValue2('directionL', self.__variableArgs['directionL']) if self.__variableArgs['matkindL'] > -1: materialL = material_kinds.EFFECT_MATERIAL_INDEXES_BY_IDS[self.__variableArgs['matkindL']] self.__vt.addValue('materialL', material_kinds.EFFECT_MATERIALS[materialL]) else: self.__vt.addValue('materialL', 'No') if self.__variableArgs['matkindR'] > -1: materialR = material_kinds.EFFECT_MATERIAL_INDEXES_BY_IDS[self.__variableArgs['matkindR']] self.__vt.addValue('materialR', material_kinds.EFFECT_MATERIALS[materialR]) else: self.__vt.addValue('materialR', 'No') if _ENABLE_VALUE_TRACKER_ENGINE: self.__vt.addValue2('engineStart', self.__variableArgs['engineStart']) self.__vt.addValue2('gearUP', self.__variableArgs['gearUp']) self.__vt.addValue2('RPM', self.__variableArgs['RPM']) self.__vt.addValue2('engineLoad', self.__engineState.mode) self.__vt.addValue2('physicLoad', self.__engineState.physicLoad) if _ENABLE_PIXIE_TRACKER: self.__vt.addValue2('Pixie Count', PixieCache.pixiesCount)
def __clampToLimits(self, turretYaw, gunPitch): if self.__yawLimits is not None: turretYaw = mathUtils.clamp(self.__yawLimits[0], self.__yawLimits[1], turretYaw) pitchLimits = calcPitchLimitsFromDesc(turretYaw, self.__pitchLimits) gunPitch = mathUtils.clamp(pitchLimits[0], pitchLimits[1] + self.__pitchCompensating, gunPitch) return (turretYaw, gunPitch)
def __calcFov(self): fov = BigWorld.projection().fov + self.__zoomSensor.currentVelocity return mathUtils.clamp(0.1, math.pi - 0.1, fov)
def refresh(self, delta): super(DetailedEngineStateWWISE, self).refresh(delta) self.calculateRPM() self.calculateGear() if not self._vehicle.isPlayerVehicle or self._vehicle.physicsMode == VEHICLE_PHYSICS_MODE.STANDARD: speed = self._vehicle.speedInfo.value[0] self.__speed = (speed - self.__speed) * 0.2 * delta speedRange = self._vehicle.typeDescriptor.physics['speedLimits'][0] + self._vehicle.typeDescriptor.physics['speedLimits'][1] speedRangeGear = speedRange / 3 self._gearNum = math.ceil(math.floor(math.fabs(self.__speed) * 50) / 50 / speedRangeGear) if self.__prevGearNum2 != self._gearNum: self.__prevGearNum = self.__prevGearNum2 self._gearUp = self.__prevGearNum2 < self._gearNum and self._engineLoad > self._IDLE if self._gearUp and self._gearUpCbk is not None: self._gearUpCbk() if self._gearNum == 2 and self.__prevGearNum < self._gearNum: self.__gear_2 = 100 else: self.__gear_2 = 0 if self._gearNum == 3 and self.__prevGearNum < self._gearNum: self.__gear_3 = 100 else: self.__gear_3 = 0 self.__prevGearNum2 = self._gearNum if self._gearNum != 0 and self._engineLoad > self._IDLE: self._reativelRPM = math.fabs(1 + (self.__speed - self._gearNum * speedRangeGear) / speedRangeGear) self._reativelRPM = self._reativelRPM * (1.0 - self._GEAR_DELTA * self._gearNum) + self._GEAR_DELTA * self._gearNum else: self._reativelRPM = 0.0 self._rpm = self._reativelRPM * 100.0 else: self._gearUp = self.__newPhysicGear > self._gearNum if self._gearUp and self._gearUpCbk is not None: self._gearUpCbk() self._gearNum = self.__newPhysicGear self.__rotationSpeed = self._vehicle.speedInfo.value[1] self.__roatationRelSpeed = self.__rotationSpeed / self._vehicle.typeDescriptor.physics['rotationSpeedLimit'] self._engineLoad = 2 if self._mode == 3 else self._mode self._roughnessValue = -(self._vehicle.pitch - self.__prevPitch) / delta self.__prevPitch = self._vehicle.pitch if self._mode >= 2: absRelSpeed = abs(self._relativeSpeed) if absRelSpeed > 0.01: k_mg = -abs(self._vehicle.pitch) / self._maxClimbAngle if self._relativeSpeed * self._vehicle.pitch > 0.0 else abs(self._vehicle.pitch) / self._maxClimbAngle self._physicLoad = (1.0 + k_mg) * 0.5 if self._relativeSpeed > 0.0: speedImpactK = 1.0 / 0.33 else: speedImpactK = 1.0 / 0.9 speedImpact = clamp(0.01, 1.0, absRelSpeed * speedImpactK) speedImpact = clamp(0.0, 2.0, 1.0 / speedImpact) self._physicLoad = clamp(0.0, 1.0, self._physicLoad * speedImpact) self._physicLoad += self._roughnessValue if self._roughnessValue > 0 else 0 self._physicLoad += clamp(0.0, 1.0, absRelSpeed - 0.9) self._physicLoad = clamp(0.0, 1.0, self._physicLoad) self._physicLoad = max(self._physicLoad, abs(self.__roatationRelSpeed)) else: self._physicLoad = 1.0 else: self._physicLoad = self._mode - 1 return
def clampFov(fov): return mathUtils.clamp(0.017, 3.12, fov)
def __setPitch(self, value): self.__cursor.pitch = mathUtils.clamp(self.__anglesRange[0], self.__anglesRange[1], value)
def __calcAimOffset(self): aimWorldPos = self.__aimingSystem.matrix.applyPoint(Vector3(0, -self.__aimingSystem.height, 0)) aimOffset = cameras.projectPoint(aimWorldPos) return Vector2(mathUtils.clamp(-0.95, 0.95, aimOffset.x), mathUtils.clamp(-0.95, 0.95, aimOffset.y))
def setCameraDistance(self, distance): distRange = self.__cfg['distRange'] clampedDist = mathUtils.clamp(distRange[0], distRange[1], distance) self.__aimingSystem.distanceFromFocus = clampedDist self.__inputInertia.teleport(self.__calcRelativeDist())