using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// Moves/rotates the attached object using the keyboard or, if the
/// Oculus/SteamVR plugins are imported, by buttons on the VR controllers.
/// To use VR controllers, you must also have a ZEDControllerTracker component in the scene
/// that's set to track the controller you want to use.
/// Used in the ZED Planetarium and Movie Screen example scenes to move the solar system/screen.
/// </summary>
public class ZEDTransformController : MonoBehaviour
{
//Public variables
/// <summary>
/// Rotational reference point for moving forward, backward, left, right, etc.
/// </summary>
[Header("Object motion relative to:")]
[Tooltip("Rotational reference point for moving forward, backward, left, right, etc.")]
public RelativeMotion motion;
/// <summary>
/// Whether to rotate in the opposite direction specified, eg rotating 'right' means counter-clockwise.
/// </summary>
[Tooltip("Whether to rotate in the opposite direction specified, eg rotating 'right' means counter-clockwise.")]
public bool invertRotation;
/// <summary>
/// If true, the object will teleport to a meter in front of the ZED once it's finished initializing.
/// </summary>
[Tooltip("If true, the object will teleport to a meter in front of the ZED once it's finished initializing.")]
public bool repositionAtStart = true;
/// <summary>
/// Reference to the scene's ZEDManager component.
/// Used when RelativeMotion is set to Camera, for finding the current position of the ZED.
/// </summary>
[Tooltip("Reference to the scene's ZEDManager component. Used when RelativeMotion is set to Camera, " +
"and also for positioning it at start. If left blank, the first ZED camera indexed will be set.")]
public ZEDManager zedManager = null;
/// <summary>
/// How fast the object moves/translates, in meters per second.
/// </summary>
[Space(5)]
[Header("Motion Options")]
[Tooltip("How fast the object moves/translates, in meters per second. ")]
public float movementSpeed = 0.5F;
/// <summary>
/// How fast the object rotates, in revolutions per second.
/// </summary>
[Tooltip("How fast the object rotates, in revolutions per second.")]
public float rotationSpeed = 0.1f;
/// <summary>
/// How quickly an object gets bigger or smaller.
/// Scale increases/decreases by this factor every second.
/// </summary>
[Tooltip("How quickly an object gets bigger or smaller. Scale increases/decreases by this factor every second.")]
public float scaleSpeed = 0.25F;
/// <summary>
/// The largest amount to which the object can scale.
/// </summary>
[Tooltip("The largest amount to which the object can scale.")]
public float maxScale = 2.0F;
/// <summary>
/// The smallest amount down to which the object can scale.
/// </summary>
[Tooltip("The smallest amount down to which the object can scale. ")]
public float minScale = 0.25F;
/// <summary>
/// Optional reference to a light that is enabled only when moving.
/// Used in the ZED Movie Screen sample to project a light underneath the screen when moved.
/// </summary>
[Space(5)]
[Tooltip("Optional reference to a light that is enabled only when moving.")]
public Light spotLight;
//Private variables
/// <summary>
/// List of all ZEDControllerTrackers in the scene. Used to get input in an SDK/agnostic way.
/// </summary>
private List<ZEDControllerTracker_DemoInputs> objectTrackers = new List<ZEDControllerTracker_DemoInputs>();
/// <summary>
/// Left Camera component in the ZED rig, that represents the ZED's left sensor.
/// Used when RelativeMotion is set to Camera for providing relative values.
/// </summary>
private Camera leftCamera;
/// <summary>
/// Whether the object is moving/translating.
/// </summary>
private bool isMoving;
private IEnumerator Start()
{
isMoving = false;
if (!zedManager)
{
zedManager = FindObjectOfType<ZEDManager>();
if (ZEDManager.GetInstances().Count > 1) //They let the plugin auto-assign a ZED but there are multiple ZED's. Warn the user.
{
Debug.Log("Warning: ZEDTransformController's zedManager field was not specified, but there are multiple ZEDManagers in the scene " +
"so first available ZED was assigned. This can cause the object to move relative to the wrong camera. " +
"It's recommended to assign the desired ZEDManager in the Inspector.");
}
}
//Find the available VR controllers and assigning them to our List.
yield return new WaitForSeconds(1f);
var trackers = FindObjectsOfType<ZEDControllerTracker>();
foreach (ZEDControllerTracker_DemoInputs tracker in trackers)
{
objectTrackers.Add(tracker);
}
if (repositionAtStart) //If the user wants, move the object in front of the ZED once it's initialized.
{
zedManager.OnZEDReady += RepositionInFrontOfZED;
}
}
private void Update()
{
Vector3 moveAxis = Vector3.zero; //Translation. Used by keyboard only.
float inputRotation = 0f; //Applied rotation, between -1 and 1. Cumulative between keyboard and controllers.
float inputScale = 0f; //Applied scale change, either -1, 0 or 1. Cumulative between keyboard and controllers.
//Keyboard inputs.
if (Input.GetKey(KeyCode.LeftArrow) || Input.GetKey(KeyCode.Q))
{
inputRotation = -1 * (rotationSpeed * 360) * Time.deltaTime;
}
if (Input.GetKey(KeyCode.RightArrow) || Input.GetKey(KeyCode.E))
{
inputRotation = 1 * (rotationSpeed * 360) * Time.deltaTime;
}
if (Input.GetKey(KeyCode.UpArrow) || Input.GetKey(KeyCode.W))
{
moveAxis = Vector3.forward * movementSpeed * Time.deltaTime;
}
if (Input.GetKey(KeyCode.DownArrow) || Input.GetKey(KeyCode.S))
{
moveAxis = Vector3.back * movementSpeed * Time.deltaTime;
}
if (Input.GetKey(KeyCode.A))
{
moveAxis = Vector3.left * movementSpeed * Time.deltaTime;
}
if (Input.GetKey(KeyCode.D))
{
moveAxis = Vector3.right * movementSpeed * Time.deltaTime;
}
if (Input.GetKey(KeyCode.R))
{
moveAxis = Vector3.up * movementSpeed * Time.deltaTime;
}
if (Input.GetKey(KeyCode.F))
{
moveAxis = Vector3.down * movementSpeed * Time.deltaTime;
}
Quaternion gravity = Quaternion.identity;
if (moveAxis != Vector3.zero)
{
isMoving = true;
if (motion == RelativeMotion.Itself)
{
transform.Translate(moveAxis.x, moveAxis.y, moveAxis.z);
}
else if (motion == RelativeMotion.Camera)
{
gravity = Quaternion.FromToRotation(zedManager.GetZedRootTansform().up, Vector3.up);
transform.localPosition += zedManager.GetMainCameraTransform().right * moveAxis.x;
transform.localPosition += zedManager.GetMainCameraTransform().forward * moveAxis.z;
transform.localPosition += gravity * zedManager.GetMainCameraTransform().up * moveAxis.y;
}
}
else
{
isMoving = false;
}
if (Input.GetKey(KeyCode.Mouse0))
inputScale = 1f;
else if (Input.GetKey(KeyCode.Mouse1))
inputScale = -1f;
if (zedManager)
{
Vector3 moveaxis = new Vector3(); //Position change by controller. Added to keyboard version if both are applied.
//Looks for any input from this controller through SteamVR.
//Left controller controls rotation and increasing scale.
if (objectTrackers.Count > 0)
{
moveaxis = objectTrackers[0].CheckNavigateUIAxis();
if (Mathf.Abs(moveaxis.x) < 0.1f) moveaxis.x = 0; //Add slight deadzone.
if (Mathf.Abs(moveaxis.y) < 0.1f) moveaxis.y = 0;
inputRotation += moveaxis.x * rotationSpeed * 360f * Time.deltaTime;
gravity = Quaternion.FromToRotation(zedManager.GetZedRootTansform().up, Vector3.up);
transform.localPosition += gravity * zedManager.GetMainCameraTransform().up * moveaxis.y * movementSpeed * Time.deltaTime;
if (objectTrackers[0].CheckClickButton(ControllerButtonState.Held))
{
inputScale = 1f;
}
}
//Right controller controls translation and lowering scale.
if (objectTrackers.Count > 1)
{
moveaxis = objectTrackers[1].CheckNavigateUIAxis();
if (Mathf.Abs(moveaxis.x) < 0.1f) moveaxis.x = 0; //Add slight deadzone.
if (Mathf.Abs(moveaxis.y) < 0.1f) moveaxis.y = 0;
if (moveaxis.x != 0 || moveaxis.y != 0)
{
isMoving = true;
gravity = Quaternion.FromToRotation(zedManager.GetZedRootTansform().up, Vector3.up);
transform.localPosition += zedManager.GetMainCameraTransform().right * moveaxis.x * movementSpeed * Time.deltaTime;
transform.localPosition += gravity * zedManager.GetMainCameraTransform().forward * moveaxis.y * movementSpeed * Time.deltaTime;
}
else
isMoving = false;
if (objectTrackers[1].CheckClickButton(ControllerButtonState.Held))
{
inputScale = -1f;
}
}
}
//Rotation
float h = inputRotation;
if (invertRotation)
transform.Rotate(0, h, 0);
else
transform.Rotate(0, -h, 0);
//Scale
float s = scaleSpeed * (inputScale * Time.deltaTime);
transform.localScale = new Vector3(transform.localScale.x + s,
transform.localScale.y + s,
transform.localScale.z + s);
if (transform.localScale.x > maxScale)
transform.localScale = new Vector3(maxScale, maxScale, maxScale);
else if (transform.localScale.x < minScale)
transform.localScale = new Vector3(minScale, minScale, minScale);
//Enable/disable light if moving.
if (spotLight != null)
{
SetMovementLight();
}
}
/// <summary>
/// Turns the optional spotLight on or off depending on if the object is moving/translating.
/// Also scales the light to match the object's own scale.
/// </summary>
void SetMovementLight()
{
//Enable/disable Light if the object is moving.
if (!spotLight.enabled && isMoving)
{
spotLight.enabled = true;
}
else if (spotLight.enabled && !isMoving)
{
spotLight.enabled = false;
}
//Scale light with object size.
if (spotLight.enabled && spotLight.type == LightType.Spot)
{
spotLight.spotAngle = transform.localScale.x * 180 * 2;
spotLight.range = transform.localScale.x * 4f;
if (spotLight.range > 2)
spotLight.range = 2;
}
}
/// <summary>
/// Repositions the object to a meter in front of the ZED.
/// Called by ZEDManager.OnZEDReady if repositionAtStart is enabled.
/// </summary>
void RepositionInFrontOfZED()
{
//If the ZEDManager uses Estimate Initial Position and tracking, then the position will change shortly after OnZEDReady.
//We'll make a non-async call to EstimateInitialPosition to determine what the angle will be.
if (zedManager.estimateInitialPosition && zedManager.enableTracking)
{
Vector3 initpos = Vector3.zero;
Quaternion initrot = Quaternion.identity;
zedManager.zedCamera.EstimateInitialPosition(ref initrot, ref initpos);
transform.position = initpos + (initrot * Vector3.forward);
Quaternion newRot = Quaternion.LookRotation(initpos - transform.position, Vector3.up);
transform.eulerAngles = new Vector3(0, newRot.eulerAngles.y + 180, 0);
}
else
{
transform.position = zedManager.OriginPosition + zedManager.OriginRotation * (Vector3.forward);
Quaternion newRot = Quaternion.LookRotation(zedManager.OriginPosition - transform.position, Vector3.up);
transform.eulerAngles = new Vector3(0, newRot.eulerAngles.y + 180, 0);
}
//If we're going to know where the floor is, then make sure the object doesn't spawn in the floor if the user is looking down.
if(zedManager.estimateInitialPosition)
{
if (transform.position.y < 0.5f) transform.position = new Vector3(transform.position.x, 0.5f, transform.position.z);
}
}
IEnumerator RepositionAfterZEDReady()
{
for (int i = 0; i < 50; i++)
{
print(zedManager.GetZedRootTansform().position);
yield return null;
}
}
/// <summary>
/// Options for what movement will be relevant to.
/// </summary>
public enum RelativeMotion
{
Itself, //Relative to its own rotation, eg. moving forward moves where the object is facing.
Camera //Relative to the camera's rotation, eg. moving forward moves where the camera/player is facing.
}
}