def adjustFOV(diff): newFov = BigWorld.projection().fov + diff newFov = min(max(newFov, FOV_MIN), FOV_MAX) BigWorld.projection().rampFov(newFov, 0.1) BigWorld.player = lambda : g_fakeAvatar if WWISE.enabled: WWISE.WG_loadBanks('', False)
def __calcPitchAngle(self, distanceFromFocus, dir): fov = BigWorld.projection().fov near = BigWorld.projection().nearPlane yLength = near * math.tan(fov * 0.5) alpha = -self.__aimMatrix.pitch a = distanceFromFocus b = dir.length A = 2.0 * a * math.cos(alpha) B = a * a - b * b D = A * A - 4.0 * B if D > 0.0: c1 = (A + math.sqrt(D)) * 0.5 c2 = (A - math.sqrt(D)) * 0.5 c = c1 if c1 > c2 else c2 cosValue = (a * a + b * b - c * c) / (2.0 * a * b) if a * b != 0.0 else 2.0 if cosValue < -1.0 or cosValue > 1.0: LOG_WARNING( "Invalid arg for acos: %f; distanceFromFocus: %f, dir: %s" % (cosValue, distanceFromFocus, dir) ) return -dir.pitch beta = math.acos(cosValue) eta = math.pi - beta return -dir.pitch - eta else: return -dir.pitch
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 onStrategicCameraDisable(self, camera): BigWorld.projection().nearPlane = self._prevNearPlane BigWorld.projection().farPlane = self._prevFarPlane if self.enabled: camera._StrategicCamera__aimingSystem._StrategicAimingSystem__planePosition.x = camera._StrategicCamera__aimingSystem._matrix.translation.x camera._StrategicCamera__aimingSystem._StrategicAimingSystem__planePosition.y = 0.0 camera._StrategicCamera__aimingSystem._StrategicAimingSystem__planePosition.z = camera._StrategicCamera__aimingSystem._matrix.translation.z self._lastModeWasSniper = False self.enabled = False
def setFovByMultiplier(self, multiplier, rampTime = None): self.__multiplier = multiplier if not self.__enabled: return defaultFov = self.actualDefaultVerticalFov finalFov = FovExtended.clampFov(defaultFov * self.__multiplier) if rampTime is None: BigWorld.projection().fov = finalFov else: BigWorld.projection().rampFov(finalFov, rampTime)
def getWorldRayAndPoint(x, y): fov = BigWorld.projection().fov near = BigWorld.projection().nearPlane aspect = getScreenAspectRatio() yLength = near * math.tan(fov * 0.5) xLength = yLength * aspect point = Math.Vector3(xLength * x, yLength * y, near) inv = Math.Matrix(BigWorld.camera().invViewMatrix) ray = inv.applyVector(point) wPoint = inv.applyPoint(point) return (ray, wPoint)
def __update(self): prevPos = Math.Vector3(self.__position) delta = self.__calcCurrentDelta() self.__movementSensor.update(delta) self.__rotationSensor.update(delta) self.__zoomSensor.update(delta) self.__targetRadiusSensor.update(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.__alignerToLand.enabled and abs(self.__velocity.y) > 0.1: self.__alignerToLand.enable(self.__position) self.__position = self.__alignerToLand.getAlignedPosition(self.__position) if self.__boundVehicleMProv is not None: self.__ypr = self.__getLookAtYPR(Matrix(self.__boundVehicleMProv).translation) self.__ypr[0] = math.fmod(self.__ypr[0], 2 * math.pi) self.__ypr[1] = max(-0.9 * math.pi / 2, min(0.9 * math.pi / 2, self.__ypr[1])) self.__ypr[2] = math.fmod(self.__ypr[2], 2 * math.pi) camMat = Math.Matrix() camMat.setRotateYPR(self.__ypr) if self.__rotateAroundPointEnabled: self.__position = self.__getAlignedToPointPosition(camMat) moveDir = self.__position - prevPos moveDir.normalise() collisionPointWithBorders = BigWorld.player().arena.collideWithSpaceBB(prevPos - moveDir, self.__position + moveDir) if collisionPointWithBorders is not None: self.__position = collisionPointWithBorders camMat.translation = self.__position camMat.invert() self.__cam.set(camMat) fov = BigWorld.projection().fov + self.__zoomSensor.currentVelocity if fov <= 0.1: fov = 0.1 if fov >= math.pi - 0.1: fov = math.pi - 0.1 BigWorld.projection().fov = fov self.__movementSensor.currentVelocity = Math.Vector3() self.__verticalMovementSensor.currentVelocity = 0.0 self.__rotationSensor.currentVelocity = Math.Vector3() self.__zoomSensor.currentVelocity = 0.0 self.__targetRadiusSensor.currentVelocity = 0.0 return 0.0
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 __init__(self, configDataSec): CallbackDelayer.__init__(self) TimeDeltaMeter.__init__(self) self.__cam = BigWorld.FreeCamera() self.__cam.invViewProvider = Math.MatrixProduct() self.__ypr = Math.Vector3() self.__position = Math.Vector3() self.__defaultFov = BigWorld.projection().fov self.__velocity = Math.Vector3() self.__isVerticalVelocitySeparated = False self.__yprVelocity = Math.Vector3() self.__zoomVelocity = 0.0 self.__inertiaEnabled = False self.__movementInertia = None self.__rotationInertia = None self.__movementSensor = None self.__verticalMovementSensor = None self.__rotationSensor = None self.__zoomSensor = None self.__targetRadiusSensor = None self.__mouseSensitivity = 0.0 self.__scrollSensitivity = 0.0 self.__rotateAroundPointEnabled = False self.__rotationRadius = 40.0 self.__alignerToLand = _AlignerToLand() self.__predefinedVelocities = {} self.__predefinedVerticalVelocities = {} self.__keySwitches = {} self.__readCfg(configDataSec) self.__aim = None self.__basisMProv = _VehicleBounder() self.__entityPicker = _VehiclePicker() return
def launch(spaceName): global g_enablePostProcessing global g_offlineModeEnabled print 'Entering offline space', spaceName BigWorld.clearAllSpaces() BigWorld.worldDrawEnabled(False) _displayGUI(spaceName) spaceID = BigWorld.createSpace() BigWorld.addSpaceGeometryMapping(spaceID, None, spaceName) _loadCameraTransforms() camera = BigWorld.FreeCamera() camera.spaceID = spaceID BigWorld.camera(camera) _setCameraTransform(g_curCameraTransform) BigWorld.camera().fixed = True BigWorld.projection().fov = math.radians(75.0) BigWorld.setWatcher('Client Settings/Strafe Rate', 175.0) BigWorld.setWatcher('Client Settings/Camera Mass', 5.0) BigWorld.setCursor(GUI.mcursor()) GUI.mcursor().visible = True GUI.mcursor().clipped = False g_offlineModeEnabled = True BigWorld.callback(1.0, _offlineLoadCheck) g_postProcessing.init() _enablePostProcessing(g_enablePostProcessing, 'arcade') return
def disable(self): self.stopCallback(self.__update) BigWorld.projection().fov = self.__defaultFov BigWorld.camera(None) self.__alignerToLand.disable() BigWorld.player().positionControl.followCamera(False) return
def __onDistanceChanged(self, distance): farPlane = 1.0 / BigWorld.projection().farPlane offset = 2.5 zNear = (distance - offset) * farPlane zFar = (distance + offset) * farPlane DepthOfFieldUnit.zNear.set(zNear, 0.1, True) DepthOfFieldUnit.zFar.set(zFar, 0.1, True)
def handleKeyEvent(self, key, isDown): if key is None: return False else: if isDown: if self.__keySwitches["keySwitchInertia"] == key: self.__inertiaEnabled = not self.__inertiaEnabled return True if self.__keySwitches["keySwitchRotateAroundPoint"] == key: self.__rotateAroundPointEnabled = not self.__rotateAroundPointEnabled return True if self.__keySwitches["keySwitchLandCamera"] == key: if self.__alignerToLand.enabled or self.__basisMProv.isBound: self.__alignerToLand.disable() else: self.__alignerToLand.enable( self.__position, BigWorld.isKeyDown(Keys.KEY_LALT) or BigWorld.isKeyDown(Keys.KEY_RALT) ) return True if self.__keySwitches["keySetDefaultFov"] == key: BigWorld.projection().fov = self.__defaultFov return True if self.__keySwitches["keySetDefaultRoll"] == key: self.__ypr.z = 0.0 return True if self.__keySwitches["keyRevertVerticalVelocity"] == key: self.__isVerticalVelocitySeparated = False return True if self.__keySwitches["keyBindToVehicle"] == key: self.__processBindToVehicleKey() return True if BigWorld.isKeyDown(Keys.KEY_LSHIFT) or BigWorld.isKeyDown(Keys.KEY_RSHIFT): if ( self.__verticalMovementSensor.handleKeyEvent(key, isDown) and key not in self.__verticalMovementSensor.keyMappings ): self.__isVerticalVelocitySeparated = True return True for velocityKey, velocity in self.__predefinedVerticalVelocities.iteritems(): if velocityKey == key: self.__verticalMovementSensor.sensitivity = velocity self.__isVerticalVelocitySeparated = True return True for velocityKey, velocity in self.__predefinedVelocities.iteritems(): if velocityKey == key: self.__movementSensor.sensitivity = velocity return True if key in self.__verticalMovementSensor.keyMappings: self.__verticalMovementSensor.handleKeyEvent(key, isDown) return ( self.__movementSensor.handleKeyEvent(key, isDown) or self.__rotationSensor.handleKeyEvent(key, isDown) or self.__zoomSensor.handleKeyEvent(key, isDown) or self.__targetRadiusSensor.handleKeyEvent(key, isDown) )
def disable(self): self.stopCallback(self.__update) BigWorld.projection().fov = self.__defaultFov BigWorld.camera(None) self.__alignerToLand.disable() if isPlayerAvatar(): BigWorld.player().positionControl.followCamera(False) self.__isModeOverride = False return
def enable(self, doEnable): if self.__isEnabled == doEnable: return from cameras import FovExtended if not doEnable: self.__isEnabled = False BigWorld.camera(self.__savedCamera) BigWorld.wg_enableSuperShot(False, False) for k, v in self.__savedWatchers.iteritems(): BigWorld.setWatcher(k, v) FovExtended.instance().enabled = True LOG_DEBUG('Vertical screenshot camera is disabled') return self.__isEnabled = True self.__savedCamera = BigWorld.camera() FovExtended.instance().enabled = False arenaBB = BigWorld.wg_getSpaceBounds() centerXZ = Math.Vector2(0.5 * (arenaBB[0] + arenaBB[2]), 0.5 * (arenaBB[1] + arenaBB[3])) halfSizesXZ = Math.Vector2(0.5 * (arenaBB[2] - arenaBB[0]), 0.5 * (arenaBB[3] - arenaBB[1])) camFov = math.radians(15.0) camPos = Math.Vector3(centerXZ.x, 0, centerXZ.z) aspectRatio = 1.0 if not BigWorld.isVideoWindowed(): aspectRatio = BigWorld.getFullScreenAspectRatio() else: aspectRatio = BigWorld.screenWidth() / BigWorld.screenHeight() camPos.y = max(halfSizesXZ.x / math.sin(0.5 * camFov * aspectRatio), halfSizesXZ.y / math.sin(0.5 * camFov)) camMatr = Math.Matrix() camMatr.setRotateYPR(Math.Vector3(0.0, math.pi * 0.5, 0.0)) camMatr.translation = camPos camMatr.invert() self.__cam = BigWorld.FreeCamera() self.__cam.set(camMatr) BigWorld.camera(self.__cam) BigWorld.wg_enableSuperShot(True, False) self.__savedWatchers = {} for name in self.__watcherNames: try: self.__savedWatchers[name] = BigWorld.getWatcher(name) if name.startswith('Visibility'): BigWorld.setWatcher(name, False) except TypeError: LOG_WARNING('Failed to get/set watcher', name) BigWorld.setWatcher('Client Settings/std fog/enabled', False) BigWorld.projection().fov = camFov BigWorld.setWatcher('Render/Fov', camFov) BigWorld.setWatcher('Render/Near Plane', max(0.1, camPos.y - 1000.0)) BigWorld.setWatcher('Render/Far Plane', camPos.y + 1000.0) BigWorld.setWatcher('Render/Objects Far Plane/Enabled', False) BigWorld.setWatcher('Render/Shadows/qualityPreset', 7) BigWorld.setWatcher('Client Settings/Script tick', False) LOG_DEBUG('Vertical screenshot camera is enabled')
def SniperAimingSystem_enable(self, targetPos, playerGunMatFunction=AimingSystems.getPlayerGunMat): global dataHor, dataVert, scaleHor, scaleVert, yHor, yVert, cameraMode verticalFov = BigWorld.projection().fov * 2 horizontalFov = FovExtended.calcVerticalFov(verticalFov) yHor = 0 yVert = 0 scaleHor = screenWidth / horizontalFov if horizontalFov else screenWidth scaleVert = screenHeight / verticalFov if verticalFov else screenHeight dataHor, dataVert = coordinate(yaw, pitch) cameraMode = 'sn' as_event('ON_ANGLES_AIMING')
def handleKeyEvent(self, key, isDown): if key is None: return False else: if isDown: if self.__keySwitches['keySwitchInertia'] == key: self.__inertiaEnabled = not self.__inertiaEnabled return True if self.__keySwitches['keySwitchRotateAroundPoint'] == key: self.__rotateAroundPointEnabled = not self.__rotateAroundPointEnabled self.__boundVehicleMProv = None return True if self.__keySwitches['keySwitchLandCamera'] == key: if self.__alignerToLand.enabled: self.__alignerToLand.disable() else: self.__alignerToLand.enable(self.__position) return True if self.__keySwitches['keySetDefaultFov'] == key: BigWorld.projection().fov = self.__defaultFov return True if self.__keySwitches['keySetDefaultRoll'] == key: self.__ypr.z = 0.0 return True if self.__keySwitches['keyRevertVerticalVelocity'] == key: self.__isVerticalVelocitySeparated = False return True if self.__keySwitches['keyBindToVehicle'] == key: if BigWorld.isKeyDown(Keys.KEY_LSHIFT) or BigWorld.isKeyDown(Keys.KEY_RSHIFT): self.__showAim(True if self.__aim is None else not self.__aim.isActive) else: self.__boundVehicleMProv = self.__pickVehicle() self.__rotateAroundPointEnabled = False return True if BigWorld.isKeyDown(Keys.KEY_LSHIFT) or BigWorld.isKeyDown(Keys.KEY_RSHIFT): if self.__verticalMovementSensor.handleKeyEvent(key, isDown) and key not in self.__verticalMovementSensor.keyMappings: self.__isVerticalVelocitySeparated = True return True for velocityKey, velocity in self.__predefinedVerticalVelocities.iteritems(): if velocityKey == key: self.__verticalMovementSensor.sensitivity = velocity self.__isVerticalVelocitySeparated = True return True for velocityKey, velocity in self.__predefinedVelocities.iteritems(): if velocityKey == key: self.__movementSensor.sensitivity = velocity return True if key in self.__verticalMovementSensor.keyMappings: self.__verticalMovementSensor.handleKeyEvent(key, isDown) return self.__movementSensor.handleKeyEvent(key, isDown) or self.__rotationSensor.handleKeyEvent(key, isDown) or self.__zoomSensor.handleKeyEvent(key, isDown) or self.__targetRadiusSensor.handleKeyEvent(key, isDown)
def __update(self): from AvatarInputHandler.control_modes import getFocalPoint pos = getFocalPoint() if pos is None: pos = 0 else: pos = (BigWorld.camera().position - pos).length farPlane = 1.0 / BigWorld.projection().farPlane offset = 2.5 zNear = (pos - offset) * farPlane zFar = (pos + offset) * farPlane DepthOfField.zNear.set(zNear, self.__relaxTime, True) DepthOfField.zFar.set(zFar, self.__relaxTime, True)
def __calcAimOffset(self, oscillationsZoomMultiplier): fov = BigWorld.projection().fov aspect = cameras.getScreenAspectRatio() yTan = math.tan(fov * 0.5) xTan = yTan * aspect defaultX = self.__defaultAimOffset[0] defaultY = self.__defaultAimOffset[1] yawFromImpulse = self.__impulseOscillator.deviation.x * self.__dynamicCfg['sideImpulseToYawRatio'] xImpulseDeviationTan = math.tan(-(yawFromImpulse + self.__noiseOscillator.deviation.x) * oscillationsZoomMultiplier) pitchFromImpulse = self.__impulseOscillator.deviation.z * self.__dynamicCfg['frontImpulseToPitchRatio'] yImpulseDeviationTan = math.tan((pitchFromImpulse + self.__noiseOscillator.deviation.y) * oscillationsZoomMultiplier) totalOffset = Vector2((defaultX * xTan + xImpulseDeviationTan) / (xTan * (1 - defaultX * xTan * xImpulseDeviationTan)), (defaultY * yTan + yImpulseDeviationTan) / (yTan * (1 - defaultY * yTan * yImpulseDeviationTan))) return totalOffset
def locateCameraOnEmblem(self, onHull, emblemType, emblemIdx, relativeSize = 0.5): self.__selectedEmblemInfo = (onHull, emblemType, emblemIdx, relativeSize) targetPosDirEmblem = self.__vAppearance.getEmblemPos(onHull, emblemType, emblemIdx) if targetPosDirEmblem is None: return False targetPos, dir, emblemDesc = targetPosDirEmblem emblemSize = emblemDesc[3] * _CFG['v_scale'] halfF = emblemSize / (2 * relativeSize) dist = halfF / math.tan(BigWorld.projection().fov / 2) self.setCameraLocation(targetPos, Math.Vector3(0, 0, 0), dir.yaw, -dir.pitch, dist, True) return True
def __init__(self, dataSec): self.__readCfg(dataSec) self.__cam = BigWorld.FreeCamera() self.__angles = [0.0, 0.0] self.__dxdydz = [0.0, 0.0, 0.0] self.__zoom = self.__cfg['zoom'] self.__fov = BigWorld.projection().fov self.__curSense = 0 self.__curScrollSense = 0 self.__autoUpdate = False self.__autoUpdateCallbackId = None self.__waitVehicleCallbackId = None self.__onChangeControlMode = None self.__pitchCompensation = 0 self.__pitchCompensationTimestamp = BigWorld.time() return
def enable(self, targetPos, saveZoom): player = BigWorld.player() if not saveZoom: self.__zoom = self.__cfg['zoom'] self.__fov = BigWorld.projection().fov self.__dxdydz = [0, 0, 0] self.__applyFOV(self.__fov / self.__zoom) self.__setupCamera(targetPos) vehicle = BigWorld.entity(player.playerVehicleID) if vehicle is None: self.__whiteVehicleCallbackId = BigWorld.callback(0.1, self.__waitVehicle) else: self.__showVehicle(False) BigWorld.camera(self.__cam) self.__cameraUpdate() return
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 __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 __init__(self, dataSec, aim, binoculars): CallbackDelayer.__init__(self) self.__impulseOscillator = None self.__movementOscillator = None self.__noiseOscillator = None self.__dynamicCfg = CameraDynamicConfig() self.__accelerationSmoother = None self.__readCfg(dataSec) self.__cam = BigWorld.FreeCamera() self.__zoom = self.__cfg['zoom'] self.__fov = BigWorld.projection().fov self.__curSense = 0 self.__curScrollSense = 0 self.__waitVehicleCallbackId = None self.__onChangeControlMode = None self.__aimingSystem = SniperAimingSystem() self.__aim = weakref.proxy(aim) self.__binoculars = binoculars self.__defaultAimOffset = self.__aim.offset() self.__defaultAimOffset = (self.__defaultAimOffset[0], self.__defaultAimOffset[1]) self.__crosshairMatrix = createCrosshairMatrix(offsetFromNearPlane=self.__dynamicCfg['aimMarkerDistance']) self.__prevTime = BigWorld.time() self.__autoUpdateDxDyDz = Vector3(0, 0, 0) return
def _getFov(self): if IS_CLIENT: return BigWorld.projection().fov else: import WorldEditor return WorldEditor.getCameraFOV()
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 getProjectionMatrix(): proj = BigWorld.projection() aspect = getScreenAspectRatio() result = Math.Matrix() result.perspectiveProjection(proj.fov, aspect, proj.nearPlane, proj.farPlane) return result
def createCrosshairMatrix(offsetFromNearPlane): nearPlane = BigWorld.projection().nearPlane return mathUtils.createTranslationMatrix(Vector3(0, 0, nearPlane + offsetFromNearPlane))
def adjustFOV(diff): newFov = BigWorld.projection().fov + diff newFov = min(max(newFov, FOV_MIN), FOV_MAX) BigWorld.projection().rampFov(newFov, 0.1) if WWISE.enabled: WWISE.WG_loadBanks('', False)
def getMouseTargettingRay(): mtm = Math.Matrix(BigWorld.MouseTargettingMatrix()) src = mtm.applyToOrigin() far = BigWorld.projection().farPlane dst = src + mtm.applyToAxis(2).scale(far) return (src, dst)
def StrategicCamera_disable(self): oldStrategicCamera_disable(self) spgAim.onStrategicCameraDisable(self) BigWorld.projection().nearPlane = spgAim._prevNearPlane BigWorld.projection().farPlane = spgAim._prevFarPlane
def StrategicCamera_create(self, onChangeControlMode): spgAim._prevNearPlane = BigWorld.projection().nearPlane spgAim._prevFarPlane = BigWorld.projection().farPlane oldStrategicCamera_create(self, onChangeControlMode) spgAim.onStrategicCameraCreate(self)
def onCameraChange(oldCamera): BigWorld.clearTextureStreamingViewpoints() BigWorld.registerTextureStreamingViewpoint(BigWorld.camera(), BigWorld.projection())
def StrategicCamera_enable(self, targetPos, saveDist): spgAim._prevNearPlane = BigWorld.projection().nearPlane spgAim._prevFarPlane = BigWorld.projection().farPlane spgAim.onStrategicCameraEnable(self) oldStrategicCamera_enable(self, targetPos, saveDist)
def locateCameraToStyleInfoPreview(self, forceLocate=False): if self.__hangarCameraManager is None or self.__hangarCameraManager.camera is None: return else: self.__savePitch() from gui.ClientHangarSpace import customizationHangarCFG, hangarCFG cfg = customizationHangarCFG() hangarConfig = hangarCFG() if self.__tankCentralPoint is None: self.__tankCentralPoint = self.__getTankCentralPoint() dist = cfg['cam_start_dist'] targetPos = copy(self.__tankCentralPoint) distConstraints = copy(cfg['cam_dist_constr']) if self.vEntity is not None and self.vEntity.appearance is not None and self.vEntity.appearance.compoundModel is not None: appearance = self.vEntity.appearance mat = Math.Matrix() mat.setRotateYPR((_STYLE_INFO_YAW, -_STYLE_INFO_PITCH, 0.0)) pivotDir = mat.applyVector(Math.Vector3(1, 0, 0)) pivotDir = Math.Vector3(pivotDir.x, 0, pivotDir.z) pivotDir.normalise() hullAABB = appearance.collisions.getBoundingBox( TankPartIndexes.HULL) width = hullAABB[1].x - hullAABB[0].x length = hullAABB[1].z - hullAABB[0].z height = hullAABB[1].y - hullAABB[0].y hullViewSpaceX = width * abs(math.cos( _STYLE_INFO_YAW)) + length * abs(math.sin(_STYLE_INFO_YAW)) hullViewSpaceZ = width * abs(math.sin( _STYLE_INFO_YAW)) + length * abs(math.cos(_STYLE_INFO_YAW)) aspect = BigWorld.getAspectRatio() halfFOVTan = math.tan(BigWorld.projection().fov * 0.5) distW = hullViewSpaceX / (_STYLE_INFO_MAX_VEHICLE_WIDTH * 2 * halfFOVTan * aspect) distH = height / (_STYLE_INFO_MAX_VEHICLE_HEIGHT * 2 * halfFOVTan) + hullViewSpaceZ * 0.5 dist = max(distH, distW) distConstraints.y = _STYLE_INFO_MAX_CAMERA_DIST halfHeight = dist * halfFOVTan halfWidth = halfHeight * aspect targetPos += pivotDir * halfWidth * _STYLE_INFO_VEHICLE_SCREEN_X_SHIFT futureCamDir = mat.applyVector(Math.Vector3(0, 0, 1)) futureCamPos = targetPos - futureCamDir * dist paramsDOF = None if isRendererPipelineDeferred(): paramsDOF = self.__getStyleInfoDOFParams(futureCamPos) self.__ctx.events.onUpdateStyleInfoDOF(paramsDOF) self._setCameraLocation(targetPos=targetPos, pivotPos=-Math.Vector3(0, 0, 0), yaw=_STYLE_INFO_YAW, pitch=_STYLE_INFO_PITCH, dist=dist, camConstraints=[ hangarConfig['cam_pitch_constr'], hangarConfig['cam_yaw_constr'], distConstraints ], forceLocate=forceLocate, forceRotate=True) self.__currentMode = C11nCameraModes.STYLE_INFO self.enableMovementByMouse(enableRotation=False, enableZoom=False) return
def onStrategicCameraUpdate(self, camera): replayCtrl = BattleReplay.g_replayCtrl distRange = camera._StrategicCamera__cfg['distRange'][:] if distRange[0] < 20: distRange[0] = 20 distRange[1] = 600 player = BigWorld.player() descr = player.vehicleTypeDescriptor shotEnd = camera._StrategicCamera__aimingSystem.matrix.translation shellVelocity = Math.Vector3(self._shellVelocity) shellVelocity.normalise() srcMat = Math.Matrix() srcMat.setRotateYPR((shellVelocity.yaw, -shellVelocity.pitch, 0)) shift = srcMat.applyVector( Math.Vector3(camera._StrategicCamera__dxdydz.x, 0, -camera._StrategicCamera__dxdydz.y) ) * camera._StrategicCamera__curSense if replayCtrl.isPlaying and replayCtrl.isControllingCamera: aimOffset = replayCtrl.getAimClipPosition() else: aimWorldPos = camera._StrategicCamera__aimingSystem.matrix.translation aimOffset = cameras.projectPoint(aimWorldPos) if replayCtrl.isRecording: replayCtrl.setAimClipPosition( Math.Vector2(aimOffset.x, aimOffset.y)) camera._StrategicCamera__aimOffsetFunc((aimOffset.x, aimOffset.y)) shotDescr = BigWorld.player().vehicleTypeDescriptor.shot BigWorld.wg_trajectory_drawer().setParams( shotDescr['maxDistance'], Math.Vector3(0, -shotDescr['gravity'], 0), camera._StrategicCamera__aimOffsetFunc()) curTime = BigWorld.time() deltaTime = curTime - camera._StrategicCamera__prevTime camera._StrategicCamera__prevTime = curTime if replayCtrl.isPlaying: if camera._StrategicCamera__needReset != 0: if camera._StrategicCamera__needReset > 1: player = BigWorld.player() if player.inputHandler.ctrl is not None: player.inputHandler.ctrl.resetGunMarkers() camera._StrategicCamera__needReset = 0 else: camera._StrategicCamera__needReset += 1 if replayCtrl.isControllingCamera: camera._StrategicCamera__aimingSystem.updateTargetPos( replayCtrl.getGunRotatorTargetPoint()) else: camera._StrategicCamera__aimingSystem.handleMovement( shift.x, shift.z) if shift.x != 0 and shift.z != 0 or camera._StrategicCamera__dxdydz.z != 0: self._StrategicCamera__needReset = 2 camera._StrategicCamera__aimingSystem.handleMovement(shift.x, shift.z) camera._StrategicCamera__camDist -= camera._StrategicCamera__dxdydz.z * float( camera._StrategicCamera__curSense) maxPivotHeight = (distRange[1] - distRange[0] ) / BigWorld._ba_config['spg']['zoomSpeed'] camera._StrategicCamera__camDist = mathUtils.clamp( 0, maxPivotHeight, camera._StrategicCamera__camDist) camera._StrategicCamera__cfg[ 'camDist'] = camera._StrategicCamera__camDist if camera._StrategicCamera__dxdydz.z != 0 and camera._StrategicCamera__onChangeControlMode is not None and mathUtils.almostZero( camera._StrategicCamera__camDist - maxPivotHeight): camera._StrategicCamera__onChangeControlMode() camera._StrategicCamera__updateOscillator(deltaTime) if not camera._StrategicCamera__autoUpdatePosition: camera._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 zoomDistance = distRange[0] * zoomFactor fovFactor = camera._StrategicCamera__camDist / maxPivotHeight fov = fov * (1.0 - fovFactor) + math.radians(20.0) * fovFactor cameraOffset = -shellVelocity.scale(zoomDistance) cameraPosition = shotEnd + cameraOffset collPoint = None if BigWorld._ba_config['spg'][ 'ignoreObstacles'] else 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 trgMat = Math.Matrix() trgMat.setTranslate(cameraPosition) camera._StrategicCamera__cam.source = srcMat camera._StrategicCamera__cam.target.b = trgMat camera._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) if BigWorld._ba_config['spg'][ 'alwaysFollowProjectile'] or BigWorld.isKeyDown( self._followProjectileKey): if self._trackProjectile: time = BigWorld.time() - self._trackProjectileStartTime if time > 0: shotDescr = descr.shot gravity = Math.Vector3(0.0, -shotDescr['gravity'], 0.0) shellVelocity = self._trackProjectileVelocity + gravity.scale( time) srcMat.setRotateYPR( (shellVelocity.yaw, -shellVelocity.pitch, 0)) camera._StrategicCamera__cam.source = srcMat camera._StrategicCamera__cam.target.b.setTranslate( self._trackProjectileStartPoint + self._trackProjectileVelocity.scale(time) + gravity.scale(time * time * 0.5)) BigWorld.projection().fov = math.pi * 0.4 elif player._PlayerAvatar__projectileMover._ProjectileMover__projectiles.get( self._projectileID): shellVelocity = Math.Matrix(self._projectileMP).applyVector( Math.Vector3(0.0, 0.0, 1.0)) srcMat.setRotateYPR( (shellVelocity.yaw, -shellVelocity.pitch, 0)) camera._StrategicCamera__cam.source = srcMat camera._StrategicCamera__cam.target.b = self._projectileMP BigWorld.projection().fov = math.pi * 0.4 return 0
def __updateVisibleAxis(self): if not self._notControlledByUser and EntityStates.inState(BigWorld.player(), EntityStates.GAME): player = BigWorld.player() direction = self.__camDirection fmRotation = BigWorld.player().getRotation() rotation = Math.Quaternion(fmRotation) rotation.invert() norm = Math.Vector3(direction) norm.normalise() yawAngle = math.pi / 2.0 - math.acos(clamp(-1.0, fmRotation.getAxisX().dot(norm), 1.0)) pitchAngle = math.pi / 2.0 - math.acos(clamp(-1.0, fmRotation.getAxisY().dot(norm), 1.0)) mouseRoll = -sign(yawAngle) * clamp(-1.0, max(0.0, (abs(yawAngle) - math.radians(5.0)) / math.radians(5.0)), 1.0) hAxis = clamp(-1.0, yawAngle / math.radians(5.0) * 8.0, 1.0) * (1 - abs(self.__axisKeyBoard[HORIZONTAL_AXIS])) + self.__axisKeyBoard[HORIZONTAL_AXIS] vAxis = clamp(-1.0, pitchAngle / math.radians(10.0), 1.0) * (1 - abs(self.__axisKeyBoard[VERTICAL_AXIS])) + self.__axisKeyBoard[VERTICAL_AXIS] roll_cfc = bool(InputMapping.g_instance.mouseSettings.ROLL_SPEED_CFC) * max(0.25, 1.0 - (1.0 - InputMapping.g_instance.mouseSettings.ROLL_SPEED_CFC) ** 3) rAxis = roll_cfc * mouseRoll * (1 - abs(self.__axisKeyBoard[ROLL_AXIS])) + self.__axisKeyBoard[ROLL_AXIS] speedDirection = player.getWorldVector() speedDirection.normalise() dotX = clamp(-1.0, fmRotation.getAxisX().dot(speedDirection), 1.0) dotY = clamp(-1.0, fmRotation.getAxisY().dot(speedDirection), 1.0) angleX = abs(math.pi / 2.0 - math.acos(dotX)) / math.radians(10.0) angleY = abs(math.pi / 2.0 - math.acos(dotY)) / math.radians(35.0 / 2.0) signX = sign(dotX) signY = sign(dotY) hAxis = clamp(-1.0, hAxis - (1.0 - abs(hAxis)) * clamp(-1.0, signX * angleX, 1.0), 1.0) vAxis = clamp(-1.0, vAxis - (1.0 - abs(vAxis)) * clamp(-1.0, signY * angleY, 1.0), 1.0) mouseAngle = math.acos(clamp(-1.0, fmRotation.getAxisZ().dot(norm), 1.0)) equalizerAngle = 0.5 * (0.3 + 0.7 * InputMapping.g_instance.mouseSettings.RADIUS_OF_CONDUCTING) * BigWorld.projection().fov * InputMapping.g_instance.mouseSettings.EQUALIZER_ZONE_SIZE equalizer = max(0.0, 1.0 - mouseAngle / equalizerAngle) * clamp(-1.0, InputMapping.g_instance.mouseSettings.EQUALIZER_FORCE * player.roll / player.rollRudderNorma, 1.0) if equalizerAngle else 0.0 rAxis = clamp(-1.0, rAxis - (1.0 - abs(rAxis)) * equalizer, 1.0) self.__applyInputAxis(HORIZONTAL_AXIS, clamp(-1.0, hAxis, 1.0)) self.__applyInputAxis(ROLL_AXIS, clamp(-1.0, rAxis, 1.0)) self.__applyInputAxis(VERTICAL_AXIS, clamp(-1.0, vAxis, 1.0)) self.__applyInputAxis(FORCE_AXIS, self.__lastKeyBoardAxis[FORCE_AXIS]) automaticFlaps = False if InputMapping.g_instance.mouseSettings.AUTOMATIC_FLAPS: automaticFlaps = int(max(0.0, player.asymptoteVMaxPitch - abs(player.getRotationSpeed().y)) < 0.25 * player.asymptoteVMaxPitch) self.__applyInputAxis(FLAPS_AXIS, self.__axisKeyBoard[FLAPS_AXIS] or automaticFlaps)
def __calcFov(self): fov = BigWorld.projection().fov + self.__zoomSensor.currentVelocity return mathUtils.clamp(0.1, math.pi - 0.1, fov)
def handleKeyEvent(self, key, isDown): if key is None: return False else: if isDown: if self.__keySwitches['keySwitchInertia'] == key: self.__inertiaEnabled = not self.__inertiaEnabled return True if self.__keySwitches['keySwitchRotateAroundPoint'] == key: self.__rotateAroundPointEnabled = not self.__rotateAroundPointEnabled self.__boundVehicleMProv = None return True if self.__keySwitches['keySwitchLandCamera'] == key: if self.__alignerToLand.enabled: self.__alignerToLand.disable() else: self.__alignerToLand.enable(self.__position) return True if self.__keySwitches['keySetDefaultFov'] == key: BigWorld.projection().fov = self.__defaultFov return True if self.__keySwitches['keySetDefaultRoll'] == key: self.__ypr.z = 0.0 return True if self.__keySwitches['keyRevertVerticalVelocity'] == key: self.__isVerticalVelocitySeparated = False return True if self.__keySwitches['keyBindToVehicle'] == key: if BigWorld.isKeyDown( Keys.KEY_LSHIFT) or BigWorld.isKeyDown( Keys.KEY_RSHIFT): self.__showAim(True if self.__aim is None else not self.__aim.isActive) else: self.__boundVehicleMProv = self.__pickVehicle() self.__rotateAroundPointEnabled = False return True if BigWorld.isKeyDown(Keys.KEY_LSHIFT) or BigWorld.isKeyDown( Keys.KEY_RSHIFT): if self.__verticalMovementSensor.handleKeyEvent( key, isDown ) and key not in self.__verticalMovementSensor.keyMappings: self.__isVerticalVelocitySeparated = True return True for velocityKey, velocity in self.__predefinedVerticalVelocities.iteritems( ): if velocityKey == key: self.__verticalMovementSensor.sensitivity = velocity self.__isVerticalVelocitySeparated = True return True for velocityKey, velocity in self.__predefinedVelocities.iteritems( ): if velocityKey == key: self.__movementSensor.sensitivity = velocity return True if key in self.__verticalMovementSensor.keyMappings: self.__verticalMovementSensor.handleKeyEvent(key, isDown) return self.__movementSensor.handleKeyEvent( key, isDown) or self.__rotationSensor.handleKeyEvent( key, isDown) or self.__zoomSensor.handleKeyEvent( key, isDown) or self.__targetRadiusSensor.handleKeyEvent( key, isDown)
def createCrosshairMatrix(offsetFromNearPlane): nearPlane = BigWorld.projection().nearPlane return mathUtils.createTranslationMatrix( Vector3(0, 0, nearPlane + offsetFromNearPlane))