using UnityEngine;
using System.Collections;
public class CameraControl : MonoBehaviour {
public Transform target;
[ System.Serializable]
public class PositionSettings
{
public Vector3 targetPosOffset = new Vector3(0, 3.4f,0);
public float lookSmooth = 100f;
public float distanceFromTarget = -8;
public float zoomSmooth = 10;
public float maxZoom = -2;
public float minZoom = -15;
public bool smoothFollow = true;
public float smooth = 0.05f;
[HideInInspector]
public float newDistance = -8;
[HideInInspector]
public float adjustmentDistance = -8;
}
[ System.Serializable]
public class OrbitSettings
{
public float xRotation = -20;
public float yRotation = -180;
public float maxXRotation = 25;
public float minXRotation = -85;
public float vOrbitSmooth = 150;
public float hOrbitSmooth = 150;
}
[ System.Serializable]
public class InputSettings
{
public string ORBIT_HORIZONTAL_SNAP = "OrbitHorizontalSnap";
public string ORBIT_HORIZONTAL = "OrbitHorizontal";
public string ORBIT_VERTICAL = "OrbitVertical";
public string ZOOM = "Mouse ScrollWheel";
}
[System.Serializable]
public class DebuggSettings
{
public bool drawDesiredCollisionLines = true;
public bool drawAdjustedCollisionLines = true;
}
public PositionSettings position = new PositionSettings ();
public OrbitSettings orbit = new OrbitSettings ();
public InputSettings input = new InputSettings();
public DebuggSettings debug = new DebuggSettings ();
public CollisionHandler collision = new CollisionHandler ();
Vector3 targetPos = Vector3.zero;
Vector3 destination = Vector3.zero;
Vector3 adjustedDestination = Vector3.zero;
Vector3 camVel = Vector3.zero;
PlayerMovement charController;
float vOrbitInput, hOrbitInput, zoomInput, hOrbitSnapInput;
void Start()
{
SetCameraTarget(target);
vOrbitInput = hOrbitInput = zoomInput = hOrbitSnapInput;
MoveToTarget ();
collision.Initialize (Camera.main);
collision.UpdateCameraClipPoints (transform.position, transform.rotation, ref collision.adjustedCmaeraClipPoints);
collision.UpdateCameraClipPoints (destination, transform.rotation, ref collision.desiredCameraClipPoints);
targetPos = target.position + position.targetPosOffset;
destination = Quaternion.Euler (orbit.xRotation, orbit.yRotation + target.eulerAngles.y, 0) * -Vector3.forward * position.distanceFromTarget;
destination += targetPos;
transform.position = destination;
}
void SetCameraTarget(Transform target)
{
if (target.GetComponent<PlayerMovement> ()) {
charController = target.GetComponent<PlayerMovement> ();
}
}
void LateUpdate()
{
OrbitTarget ();
LookAtTarget ();
MoveToTarget ();
collision.UpdateCameraClipPoints (transform.position, transform.rotation, ref collision.adjustedCmaeraClipPoints);
collision.UpdateCameraClipPoints (destination, transform.rotation, ref collision.desiredCameraClipPoints);
for (int i = 0; i < 5; i++) {
if (debug.drawDesiredCollisionLines) {
Debug.DrawLine (targetPos, collision.desiredCameraClipPoints *, Color.white);*
-
}* -
if (debug.drawAdjustedCollisionLines)* -
{*
_ Debug.DrawLine (targetPos, collision.adjustedCmaeraClipPoints , Color.green);_
* }*
* }*
* collision.CheckColliding (targetPos);*
* position.adjustmentDistance = collision.GetAdjustedDistanceWithRayFrom(targetPos);*
* }*
* void Update(){*
* ZoomInOnTarget();*
* GetInput();*
* }*
* void GetInput(){*
* vOrbitInput = Input.GetAxisRaw (input.ORBIT_VERTICAL);
hOrbitInput = Input.GetAxisRaw (input.ORBIT_HORIZONTAL);
hOrbitSnapInput = Input.GetAxisRaw (input.ORBIT_HORIZONTAL_SNAP);
_ zoomInput = Input.GetAxisRaw (input.ZOOM);*_
* }*
* void MoveToTarget()*
* {*
* targetPos = target.position + position.targetPosOffset;*
_ destination = Quaternion.Euler (orbit.xRotation, orbit.yRotation + target.eulerAngles.y, 0) * -Vector3.forward * position.distanceFromTarget;
* destination += targetPos;*
* if (collision.colliding)*
* {*
adjustedDestination = Quaternion.Euler (orbit.xRotation, orbit.yRotation + target.eulerAngles.y, 0) * Vector3.forward * position.adjustmentDistance;_
* adjustedDestination += targetPos;*
* if (position.smoothFollow) {*
* transform.position = Vector3.SmoothDamp (transform.position, adjustedDestination, ref camVel, position.smooth);*
* }*
* else*
* transform.position = adjustedDestination;*
* }*
* else*
* if (position.smoothFollow) {*
* transform.position = Vector3.SmoothDamp (transform.position, destination, ref camVel, position.smooth);*
* } else*
* transform.position = destination;*
* }*
* void LookAtTarget(){*
* Quaternion targetRotation = Quaternion.LookRotation (targetPos - transform.position);*
_ transform.rotation = Quaternion.Lerp (transform.rotation, targetRotation, position.lookSmooth * Time.deltaTime);
* }*
* void OrbitTarget(){*
* if (hOrbitSnapInput > 0)*
* {*
* orbit.yRotation = -180;*
* }*
orbit.xRotation += -vOrbitInput * orbit.vOrbitSmooth * Time.deltaTime;
orbit.yRotation += -hOrbitInput * orbit.hOrbitSmooth * Time.deltaTime;_
* if (orbit.xRotation > orbit.maxXRotation) {*
* orbit.xRotation = orbit.maxXRotation;*
* }*
* if (orbit.xRotation < orbit.minXRotation) {*
* orbit.xRotation = orbit.minXRotation;*
* }*
* }*
* void ZoomInOnTarget(){*
_ position.distanceFromTarget += zoomInput * position.zoomSmooth * Time.deltaTime;_
* if (position.distanceFromTarget > position.maxZoom) {*
* position.distanceFromTarget = position.maxZoom;*
* }*
* if (position.distanceFromTarget < position.minZoom) {*
* position.distanceFromTarget = position.minZoom;*
* }*
* }*
* [System.Serializable]*
* public class CollisionHandler*
* {*
* public LayerMask collisionLayer;*
* [HideInInspector]*
* public bool colliding = false;*
* [HideInInspector]*
* public Vector3[] adjustedCmaeraClipPoints;*
* [HideInInspector]*
* public Vector3 [] desiredCameraClipPoints;*
* Camera camera;*
* public void Initialize(Camera cam)*
* {*
* camera = cam;*
* adjustedCmaeraClipPoints = new Vector3[5];*
* desiredCameraClipPoints = new Vector3[5];*
* }*
* public void UpdateCameraClipPoints(Vector3 cameraPosition, Quaternion atRotation, ref Vector3[] intoArray){*
* if (!camera)*
* return;*
* intoArray = new Vector3[5];*
* float z = camera.nearClipPlane;*
_ float x = Mathf.Tan (camera.fieldOfView / 3.41f) * z;
* float y = x / camera.aspect;*
* //top left*
intoArray[0] = (atRotation * new Vector3(-x, y, z)) + cameraPosition;
* //top right*
intoArray[1] = (atRotation * new Vector3(x, y, z)) + cameraPosition;
* //bottom left*
intoArray[2] = (atRotation * new Vector3(-x, -y, z)) + cameraPosition;
* //bottom right*
intoArray[3] = (atRotation * new Vector3(x, -y, z)) + cameraPosition;
* //camera’s position*
* intoArray[4] = cameraPosition - camera.transform.forward;*
* }*
* bool CollisionDetectedAtClipPoints(Vector3[] clipPoints, Vector3 fromPosition)*
* {*
* for (int i = 0; i < clipPoints.Length; i++){*
Ray ray = new Ray (fromPosition, clipPoints = fromPosition);
float distance = Vector3.Distance(clipPoints , fromPosition);
* if (Physics.Raycast(ray, distance, collisionLayer))*_
* return true;*
* }*
* return false;*
* }*
* public float GetAdjustedDistanceWithRayFrom(Vector3 from)*
* {*
* float distance = -1;*
* for (int i = 0; i < desiredCameraClipPoints.Length; i++);*
* {*
* Ray ray = new Ray (from, desiredCameraClipPoints [0] - from);*
* RaycastHit hit;*
* if (Physics.Raycast (ray, out hit)) {*
* if (distance == -1)*
* distance = hit.distance;*
* else {*
* if (hit.distance < distance)*
* distance = hit.distance;*
* }*
* }*
* }*
* if (distance == -1)*
* return 0;*
* else*
* return distance;*
* }*
* public void CheckColliding(Vector3 targetPosition)*
* {*
* if (CollisionDetectedAtClipPoints (desiredCameraClipPoints, targetPosition))*
* {*
* colliding = true;*
* } else*
* {*
* colliding = false;*
* }*
* }*
* }*
}