/// <summary> /// Applies the properties of this VirtualTransform to the given VirtualTransform. /// Scale isn't applied unless set to true. /// </summary> /// <param name="virtualTransform">VirtualTransform you want to apply this VirtualTransform's properties to.</param> /// <param name="applyScale">If you also want to apply scale.</param> public void ApplyTo(VirtualTransform virtualTransform, bool applyScale = false) { virtualTransform.Position = this.Position; virtualTransform.Rotation = this.Rotation; if (applyScale) { virtualTransform.LocalScale = this.LocalScale; } }
/// <summary> /// Switches the active camera to the given index. /// </summary> /// <param name="index">Index in the list of cameras.</param> /// <param name="copyComponents">Whether or not components fields will be copied from the current camera to the next.</param> public void SwitchCamera(int index, bool copyComponents = false) { if (index < 0 || index > CameraControllers.Count - 1) { throw new ArgumentOutOfRangeException("The index: " + index + " is not a valid index for a Camera."); } Typo.Utilities.Cameras.CameraController previousCameraController = CameraControllers[_currentCameraIndex]; // Setup out new index, and the position we left off of _switchTransform = new VirtualTransform(CameraTransform); _currentCameraIndex = index; _switchBeginTime = Time.time; // Copy the fields before we initialize if (copyComponents) { CameraControllers[_currentCameraIndex].CopyPublicFields(previousCameraController); } // We want the camera to initialize, but we don't want it actually updating. Enabling and disabling will do that. Debug.Log(CameraControllers[_currentCameraIndex].gameObject.name); CameraControllers[_currentCameraIndex].enabled = true; CameraControllers[_currentCameraIndex].enabled = false; // Setting up the speed after the new camera has been initialized so that we have the correct position for measurements. // If we're at 0 or less, then set our position to the new camera's position immediately. if (SwitchSpeed <= 0) { // Snap if equal or less than 0 _switchSpeed = float.MaxValue; CameraControllers[_currentCameraIndex].CameraTransform.ApplyTo(CameraTransform); } // Otherwise, we set up the speed. else { _switchSpeed = SwitchSpeed; if (ConstantSwitchSpeedInit) { _switchSpeed = Vector3.Distance(_switchTransform.Position, CameraControllers[_currentCameraIndex].CameraTransform.Position) / SwitchSpeed; } } }
public override void UpdateCamera() { // This was a public variable can switch the camera. if (CurrentIndex != _currentCameraIndex) { SwitchCamera(CurrentIndex); } Typo.Utilities.Cameras.CameraController cam = CameraControllers[_currentCameraIndex]; cam.UpdateCamera(); // Lerping, we have to calculate between positions. if (Time.time - _switchBeginTime < _switchSpeed) { float t = (Time.time - _switchBeginTime) / _switchSpeed; float pt = PositionLerpTransformer.Process(t); float rt = RotationLerpTransformer.Process(t); var lerpVirtualTransform = new VirtualTransform(); // Lerp position lerpVirtualTransform.Position = Vector3.Lerp(_switchTransform.Position, cam.CameraTransform.Position, pt); // Lerp rotation lerpVirtualTransform.Rotation = SwitchSlerpRotation ? Quaternion.Slerp(_switchTransform.Rotation, cam.CameraTransform.Rotation, rt) : Quaternion.Lerp(_switchTransform.Rotation, cam.CameraTransform.Rotation, rt); lerpVirtualTransform.ApplyTo(CameraTransform); } // Not Lerping, we just set the position. else { cam.CameraTransform.ApplyTo(CameraTransform); } }
/// <summary> /// If you override the Awake method, be sure to call the base.Awake() in the new awake method. /// </summary> protected virtual void Awake() { IsInitialized = false; if (Camera != null) { CameraTransform = new VirtualTransform(); } else { throw new MissingMemberException("The Camera was not set on this CameraController. Please add a Camera reference to this CameraController."); } if (!ComponentsAdded) { _components = new Dictionary <Type, CameraComponent>(); AddCameraComponents(); ComponentsAdded = true; } InitializeComponents(); }
/// <summary> /// Finds the local rotation of this VirtualTransform using the given parent VirtualTransform rotation. /// </summary> /// <param name="parentTransform">Transform of the parent.</param> /// <returns>Local rotation of this VirtualTransform relative to the parent rotation.</returns> public Quaternion GetLocalRotation(VirtualTransform parentTransform) { return(GetLocalRotation(parentTransform.Rotation)); }
/// <summary> /// Finds the local position of this VirtualTransform using the given parent VirtualTransform's position. /// </summary> /// <param name="parentTransform">The VirtualTransform of the parent.</param> /// <returns>The local position relative to the given parent position.</returns> public Vector3 GetLocalPosition(VirtualTransform parentTransform) { return(GetLocalPosition(parentTransform.Position)); }
/// <summary> /// Rotates the VirtualTransform to look at the position of the given VirtualTransform. /// </summary> /// <param name="virtualTransform">The VirtualTransform whose position in world space to look at.</param> /// <param name="worldUp">Upwards vector.</param> public void LookAt(VirtualTransform virtualTransform, Vector3 worldUp) { LookAt(virtualTransform.Position, worldUp); }
/// <summary> /// Rotates the VirtualTransform to look at the position of the given VirtualTransform. /// Uses Vector3.up as the worldUp vector. /// </summary> /// <param name="virtualTransform">The VirtualTransform whose position in world space to look at.</param> public void LookAt(VirtualTransform virtualTransform) { LookAt(virtualTransform.Position, Vector3.up); }
/// <summary> /// Rotates around the position of the VirtualTransform by the given amount of degrees on the Vector3.Up axis. /// </summary> /// <param name="virtualTransform">VirtualTransform whose position to rotate around.</param> /// <param name="angle">Degrees.</param> /// <param name="axis">Axis to rotate on.</param> public void RotateAround(VirtualTransform virtualTransform, float angle, Vector3 axis) { RotateAround(virtualTransform, angle, axis); }
/// <summary> /// Applies the position, rotation, and localScale properties of the VirtualTransform to this VirtualTransform. /// </summary> /// <param name="virtualTransform">The VirtualTransform whose properties you want to apply to this VirtualTransform.</param> public void Apply(VirtualTransform virtualTransform) { this.Position = virtualTransform.Position; this.Rotation = virtualTransform.Rotation; this.LocalScale = virtualTransform.LocalScale; }
/// <summary> /// Constructs a VirtualTransform setting the position, rotation, and local scale to the values of the given VirtualTransform. /// </summary> /// <param name="virtualTransform">VirtualTransform whose properties you want to copy.</param> public VirtualTransform(VirtualTransform virtualTransform) { Position = virtualTransform.Position; Rotation = virtualTransform.Rotation; LocalScale = virtualTransform.LocalScale; }