It is recommended that the two methods, the first is to use the mouse to slide, and the second is a panoramic view of the gyroscope phone
first:
1, create a Sphere, and then give them a material, note material Shader type: Mobile / particles / Alpha Blended, and then do the panorama posted up
2, the following additional script on camera
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
GyroController_01 class public: MonoBehaviour
{
public = MoveSpeed a float. 1; the rotational speed of the object //
public GameObject target;
private Vector2 oldPosition;
private Vector2 oldPosition1;
private Vector2 oldPosition2;
private float distance = 0;
private bool flag = false;
//摄像头的位置
private float x = 0f;
private float y = 0f;
//左右滑动移动速度
public float xSpeed = 250f;
public float ySpeed = 120f;
//缩放限制系数
public float yMinLimit = -360;
public float yMaxLimit = 360;
//是否旋转
private bool isRotate = true;
//计数器
private float count = 0;
//初始化游戏信息设置
void Start()
{
Vector3 angles = transform.eulerAngles;
x = angles.y;
y = angles.x;
if (GetComponent<Rigidbody>())
GetComponent<Rigidbody>().freezeRotation = true;
}
// Update is called once per frame
void Update()
{
if (isRotate)
{
target.transform.Rotate(Vector3.down, Time.deltaTime * moveSpeed, Space.World);
}
if (!isRotate)
{
count += Time.deltaTime;
if (count > 5)
{
count = 0;
isRotate = true;
}
}
//触摸类型为移动触摸
if (Input.GetMouseButton(0))
{
//根据触摸点计算X与Y位置
x += Input.GetAxis("Mouse X") * xSpeed * Time.deltaTime;
y -= Input.GetAxis("Mouse Y") * ySpeed * Time.deltaTime;
isRotate = false;
}
//判断鼠标滑轮是否输入
float temp = Input.GetAxis("Mouse ScrollWheel");
if (temp != 0)
{
if (temp > 0)
{
// 这里的数据是根据我项目中的模型而调节的，大家可以自己任意修改
if (distance > -15)
{
distance -= 0.5f;
}
}
if (temp < 0)
{
// 这里的数据是根据我项目中的模型而调节的，大家可以自己任意修改
if (distance < 20)
{
distance += 0.5f;
}
}
}
}
//计算距离，判断放大还是缩小。放大返回true，缩小返回false
bool IsEnlarge(Vector2 oP1, Vector2 oP2, Vector2 nP1, Vector2 nP2)
{
//old distance
float oldDistance = Mathf.Sqrt((oP1.x - oP2.x) * (oP1.x - oP2.x) + (oP1.y - oP2.y) * (oP1.y - oP2.y));
//new distance
float newDistance = Mathf.Sqrt((nP1.x - nP2.x) * (nP1.x - nP2.x) + (nP1.y - nP2.y) * (nP1.y - nP2.y));
if (oldDistance < newDistance)
{
//zoom+
return true;
}
else
{
//zoom-
return false;
}
}
//每帧执行，在Update后
void LateUpdate()
{
if (target)
{
//重置摄像机的位置
y = ClampAngle(y, yMinLimit, yMaxLimit);
var rotation = Quaternion.Euler(y, x, 0);
var position = rotation * (new Vector3(0.0f, 0.0f, -distance)) + target.transform.position;
transform.rotation = rotation;
transform.position = position;
}
}
float ClampAngle(float angle, float min, float max)
{
if (angle < -360)
angle += 360;
if (angle > 360)
angle -= 360;
return Mathf.Clamp(angle, min, max);
}
}
3, then when the game is running around, slide up and down the mouse, you can scroll the mouse wheel
The second: I do not have a test, do not have Andrews Machine, conditions can be tested out.
1. First, let's understand the direction vector end mobile phone gyroscope.
When the range Unity gravity induced ~ 1.0 -1.0
X-axis: home phone keys facing the day next
rotated clockwise 90 degrees to 1.0 gravitational component
is rotated 90 degrees to the left of the gravity component -1.0
Y-axis: Home keys on the back of the phone towards their gravity component is 1.0
Home key face below their gravity component handsets -1.0
Z axis: Mobile terrestrial gravitational component facing 1.0
facing the sky gravitational component handsets 1.0
2, a new Sphere, and then give them a material, the material Shader note type: Mobile / particles / Alpha Blended, then make up paste panorama
3, the following additional script on the camera, and the camera as a child object to Sphere
// ***********************************************************
// Written by Heyworks Unity Studio http://unity.heyworks.com/
// ***********************************************************
using UnityEngine;
/// <summary>
/// Gyroscope controller that works with any device orientation.
/// </summary>
public class GyroController : MonoBehaviour
{
#region [Private fields]
private bool gyroEnabled = true;
private const float lowPassFilterFactor = 0.2f;
private readonly Quaternion baseIdentity = Quaternion.Euler(90, 0, 0);
private readonly Quaternion landscapeRight = Quaternion.Euler(0, 0, 90);
private readonly Quaternion landscapeLeft = Quaternion.Euler(0, 0, -90);
private readonly Quaternion upsideDown = Quaternion.Euler(0, 0, 180);
private Quaternion cameraBase = Quaternion.identity;
private Quaternion calibration = Quaternion.identity;
private Quaternion baseOrientation = Quaternion.Euler(90, 0, 0);
private Quaternion baseOrientationRotationFix = Quaternion.identity;
private Quaternion referanceRotation = Quaternion.identity;
private bool debug = true;
#endregion
#region [Unity events]
protected void Start ()
{
AttachGyro();
}
protected void Update()
{
if (!gyroEnabled)
return;
transform.rotation = Quaternion.Slerp(transform.rotation,
cameraBase * ( ConvertRotation(referanceRotation * Input.gyro.attitude) * GetRotFix()), lowPassFilterFactor);
}
protected void OnGUI()
{
if (!debug)
return;
GUILayout.Label("Orientation: " + Screen.orientation);
GUILayout.Label("Calibration: " + calibration);
GUILayout.Label("Camera base: " + cameraBase);
GUILayout.Label("input.gyro.attitude: " + Input.gyro.attitude);
GUILayout.Label("transform.rotation: " + transform.rotation);
if (GUILayout.Button("On/off gyro: " + Input.gyro.enabled, GUILayout.Height(100)))
{
Input.gyro.enabled = !Input.gyro.enabled;
}
if (GUILayout.Button("On/off gyro controller: " + gyroEnabled, GUILayout.Height(100)))
{
if (gyroEnabled)
{
DetachGyro();
}
else
{
AttachGyro();
}
}
if (GUILayout.Button("Update gyro calibration (Horizontal only)", GUILayout.Height(80)))
{
UpdateCalibration(true);
}
if (GUILayout.Button("Update camera base rotation (Horizontal only)", GUILayout.Height(80)))
{
UpdateCameraBaseRotation(true);
}
if (GUILayout.Button("Reset base orientation", GUILayout.Height(80)))
{
ResetBaseOrientation();
}
if (GUILayout.Button("Reset camera rotation", GUILayout.Height(80)))
{
transform.rotation = Quaternion.identity;
}
}
#endregion
#region [Public methods]
/// <summary>
/// Attaches gyro controller to the transform.
/// </summary>
private void AttachGyro()
{
gyroEnabled = true;
ResetBaseOrientation();
UpdateCalibration(true);
UpdateCameraBaseRotation(true);
RecalculateReferenceRotation();
}
/// <summary>
/// Detaches gyro controller from the transform
/// </summary>
private void DetachGyro()
{
gyroEnabled = false;
}
#endregion
#region [Private methods]
/// <summary>
/// Update the gyro calibration.
/// </summary>
private void UpdateCalibration(bool onlyHorizontal)
{
if (onlyHorizontal)
{
var fw = (Input.gyro.attitude) * (-Vector3.forward);
fw.z = 0;
if (fw == Vector3.zero)
{
calibration = Quaternion.identity;
}
else
{
calibration = (Quaternion.FromToRotation(baseOrientationRotationFix * Vector3.up, fw));
}
}
else
{
calibration = Input.gyro.attitude;
}
}
/// <summary>
/// Update the camera base rotation.
/// </summary>
/// <param name='onlyHorizontal'>
/// Only y rotation.
/// </param>
private void UpdateCameraBaseRotation(bool onlyHorizontal)
{
if (onlyHorizontal)
{
var fw = transform.forward;
fw.y = 0;
if (fw == Vector3.zero)
{
cameraBase = Quaternion.identity;
}
else
{
cameraBase = Quaternion.FromToRotation(Vector3.forward, fw);
}
}
else
{
cameraBase = transform.rotation;
}
}
/// <summary>
/// Converts the rotation from right handed to left handed.
/// </summary>
/// <returns>
/// The result rotation.
/// </returns>
/// <param name='q'>
/// The rotation to convert.
/// </param>
private static Quaternion ConvertRotation(Quaternion q)
{
return new Quaternion(q.x, q.y, -q.z, -q.w);
}
/// <summary>
/// Gets the rot fix for different orientations.
/// </summary>
/// <returns>
/// The rot fix.
/// </returns>
private Quaternion GetRotFix()
{
if UNITY_3_5
if (Screen.orientation == ScreenOrientation.Portrait)
return Quaternion.identity;
if (Screen.orientation == ScreenOrientation.LandscapeLeft || Screen.orientation == ScreenOrientation.Landscape)
return landscapeLeft;
if (Screen.orientation == ScreenOrientation.LandscapeRight)
return landscapeRight;
if (Screen.orientation == ScreenOrientation.PortraitUpsideDown)
return upsideDown;
return Quaternion.identity;
else
return Quaternion.identity;
endif
}
/// <summary>
/// Recalculates reference system.
/// </summary>
private void ResetBaseOrientation()
{
baseOrientationRotationFix = GetRotFix();
baseOrientation = baseOrientationRotationFix * baseIdentity;
}
/// <summary>
/// Recalculates reference rotation.
/// </summary>
private void RecalculateReferenceRotation()
{
referanceRotation = Quaternion.Inverse(baseOrientation)*Quaternion.Inverse(calibration);
}
#endregion
}