maxCamera.cs

Go to the documentation of this file.

// $Id: maxCamera.cs 798 2015-05-05 14:26:43Z s.doutreligne $
// Filename: maxCamera.cs
//
// original: http://www.unifycommunity.com/wiki/index.php?title=MouseOrbitZoom
//
// --01-18-2010 - create temporary target, if none supplied at start
using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using System.Collections.Generic;
using UI;
using Molecule.Model;
using System;
using UnityEngine.EventSystems;
using GuidedNav;

//[AddComponentMenu("Camera-Control/3dsMax Camera Style")]



public class maxCamera : MonoBehaviour
{
    public static bool cameraStop = false;
    public bool automove = false;

    public float xSpeed = 400.0f;
    public float ySpeed = 400.0f;

    public static int zoomRate = 200;
    public float panSpeed = 2.0f;
    public float zoomDampening = 20.0f ;
    public float rotationFactor = 50.0f ;
    public float strength = 0.5f; // for camera translation

    public Vector3 originalCamPosition;
    public bool centerChanged = false; // for camera rotation;

    public Vector3 newposition;
    public Vector3 cameraLocalPositionSave;
    public GameObject newUIToggle; 

    public bool cameraTranslation = false;
    public float joypadDeadzone = 0.01f;
    private float xDeg = 0.0f;
    private float yDeg = 0.0f;
    private float zDeg = 0.0f;

    private Quaternion currentRotation;
    private Quaternion desiredRotation;
    private Quaternion rotation;
    private Vector3 position;
    public static bool guiControl = false;
    private GameObject LoadBox;

    public static GameObject LocCamera;
    private Camera mainCamera;

    private Molecule3D Molecule3DComp;

    public static Transform target;
    public static Vector3 targetOffset;
    
    public static float currentDistance;
    public static float desiredDistance;
    
    public float distance = 20.0f;

    public static float weight_cam = 0.0f;

    
    //Nouvelle variable

    void Awake ()
    {
        Init ();
    }

    void OnEnable ()
    {
        Init ();
    }
    
    public void Init ()
    {
        LoadBox = GameObject.Find ("LoadBox");

        mainCamera = Camera.main;
        LocCamera = mainCamera.gameObject;


        Molecule3DComp = LoadBox.GetComponent<Molecule3D> ();

        //If there is no target, create a temporary target at 'distance' from the cameras current viewpoint
        if (!target) {
            GameObject go = new GameObject ("Cam Target");
            //transform.position = go.transform.position + (transform.forward * distance);
            target = go.transform;
        }

        distance = Vector3.Distance (transform.position, target.position);
        currentDistance = distance;
        desiredDistance = distance;
        
        //be sure to grab the current rotations as starting points.
        position = transform.position;
        rotation = transform.rotation;
        // position = Vector3.zero;
        // rotation = Quaternion.identity;
        currentRotation = transform.rotation;
        desiredRotation = transform.rotation;
        
        xDeg = Vector3.Angle (Vector3.right, transform.right);
        yDeg = Vector3.Angle (Vector3.up, transform.up);

        newUIToggle = GameObject.Find("New UI Toggle Canvas/Toggle New GUI");
    }
    
    public void upxDeg ()
    {
        xDeg = 1;
        guiControl = true;
    }

    public void upyDeg ()
    {
        yDeg = -1;
        guiControl = true;
    }

    public void downxDeg ()
    {
        xDeg = -1;
        guiControl = true;
    }

    public void downyDeg ()
    {
        yDeg = 1;
        guiControl = true;
    }
    
    public void downzDeg ()
    {
        zDeg = 1;
        guiControl = true;
    }

    public void upzDeg ()
    {
        zDeg = -1;
        guiControl = true;
    }

    void Update ()
    {

        UIData.newUIActivated = newUIToggle.GetComponent<Toggle>().isOn;

        if (Input.GetButtonUp ("Spin Molecule")) {
            Debug.Log ("Space push");
            automove = !automove;
            GUIMoleculeController.toggle_NA_AUTOMOVE = !GUIMoleculeController.toggle_NA_AUTOMOVE;
        }

        //Camera sliding and re-center on a atom or a group of atoms
        if (Input.GetKeyUp (KeyCode.R)) {
            cameraTranslation = true;
            centerChanged = true;
            newposition = Vector3.zero;
        }

        if (Input.GetKeyUp (KeyCode.C)) {

                if (UI.GUIMoleculeController.toggle_NA_CLICK) {

                    /*if just one atom is selected, we center the camera (CAM TARGEt!!! THE CAMERA FOLLOW CAM TARGET)
                    on this atom*/

                    if (mainCamera.GetComponent<ClickAtom> ().objList.Count == 1) {
                        
                        int atomnumber = (int)mainCamera.GetComponent<ClickAtom> ().objList [0].GetComponent<BallUpdate> ().number;

                        newposition = new Vector3 (MoleculeModel.atomsLocationlist [atomnumber] [0],
                                                  MoleculeModel.atomsLocationlist [atomnumber] [1],
                                                  MoleculeModel.atomsLocationlist [atomnumber] [2]);

                        cameraTranslation = true;
                        centerChanged = true;
                        /* if multiple atom is selected, we calcul the barycenter*/

                    } else if (mainCamera.GetComponent<ClickAtom> ().objList.Count > 1) {

                        //barycenter of all atom selection calculation
                        Vector3 barycenter = new Vector3 ();
                        float xTot = 0.0f, yTot = 0.0f, zTot = 0.0f;

                        for (int i=0; i<mainCamera.GetComponent<ClickAtom>().objList.Count; i++) {
                            int atomnumber = (int)mainCamera.GetComponent<ClickAtom> ().objList [i].GetComponent<BallUpdate> ().number;

                            xTot = xTot + MoleculeModel.atomsLocationlist [atomnumber] [0];
                            yTot = yTot + MoleculeModel.atomsLocationlist [atomnumber] [1];
                            zTot = zTot + MoleculeModel.atomsLocationlist [atomnumber] [2];
                        }

                        barycenter.x = xTot / mainCamera.GetComponent<ClickAtom> ().objList.Count;
                        barycenter.y = yTot / mainCamera.GetComponent<ClickAtom> ().objList.Count;
                        barycenter.z = zTot / mainCamera.GetComponent<ClickAtom> ().objList.Count;
                    
                        newposition = barycenter;

                        cameraTranslation = true;
                        centerChanged = true;
                    }
                }
        }


    }

    /*
     * Camera logic on LateUpdate to only update after all character movement logic has been handled. 
     */
    void LateUpdate ()
    {
        if (!cameraStop) {
            keyboardOperate ();
            if (!guiControl)
                joypadOperate ();

            // Check if guided navigation is on, if yes, no mouse interactions
            if (!UIData.guided) {
                // If Control and Alt and Middle button? ZOOM!
                if (Input.GetMouseButton (1) && !(UIData.newUIActivated & EventSystem.current.IsPointerOverGameObject())) {

                    //
                    // ???????
                    //
                    if (UIData.switchmode)
                        Molecule3DComp.ToParticle ();
                    desiredDistance -= Input.GetAxis ("Mouse Y") * Time.deltaTime * zoomRate;//* Mathf.Abs(desiredDistance);
                }
                // If middle mouse and left alt are selected? ORBIT
                else if (Input.GetMouseButton (0) 
                    && !guiControl && !(UIData.newUIActivated & EventSystem.current.IsPointerOverGameObject())) { //Click on UI parts (not canvas) 

                    if (UIData.switchmode)
                        Molecule3DComp.ToParticle ();
                    if (Input.mousePosition.x < Screen.width * 0.85f && Input.mousePosition.y < Screen.height * 0.85f && Input.mousePosition.y > Screen.height * 0.15f) {   
                        xDeg = Input.GetAxis ("Mouse X") * xSpeed * 0.02f;
                        yDeg = -Input.GetAxis ("Mouse Y") * ySpeed * 0.02f;
                    } else if (Input.mousePosition.x > Screen.width * 0.85f) {
                        yDeg = -Input.GetAxis ("Mouse Y") * xSpeed * 0.02f;
                        xDeg = 0;
                    } else if (Input.mousePosition.y > Screen.height * 0.85f) {
                        xDeg = Input.GetAxis ("Mouse X") * xSpeed * 0.02f;
                        yDeg = 0;
                    } else {
                        zDeg = Input.GetAxis ("Mouse X") * ySpeed * 0.02f;
                        yDeg = 0;                   
                    }


                }
                // otherwise if middle mouse is selected, we pan by way of transforming the target in screenspace
                else if (Input.GetMouseButton (2) && !(UIData.newUIActivated & EventSystem.current.IsPointerOverGameObject()) ) {

                    if (UIData.switchmode)
                        Molecule3DComp.ToParticle ();
                    Vector3 v = LocCamera.transform.localPosition;
                    v.x -= Input.GetAxis ("Mouse X") * panSpeed;
                    v.y -= Input.GetAxis ("Mouse Y") * panSpeed;
                    LocCamera.transform.localPosition = v;
                }   
                else {
                    if (UIData.switchmode)
                        Molecule3DComp.ToNotParticle ();

                }
            } //End if guided ????????????

            // get the desired Zoom distance if we roll the scrollwheel
            //if (!UIData.hiddenCamera)

            if(mainCamera.orthographic && !(UIData.newUIActivated & EventSystem.current.IsPointerOverGameObject())){ // orthographic mode we can achieve the same effet by making the camera bigger/smaller

                    float tmp_size = mainCamera.orthographicSize - Input.GetAxis ("Mouse ScrollWheel") * Time.deltaTime * zoomRate;
                    if (tmp_size <= LoadTypeGUI.maxOrthoSize && tmp_size >= LoadTypeGUI.minOrthoSize)
                        mainCamera.orthographicSize = tmp_size;
                
            }
            else if(!mainCamera.orthographic && !(UIData.newUIActivated & EventSystem.current.IsPointerOverGameObject())){
                desiredDistance -= Input.GetAxis ("Mouse ScrollWheel") * Time.deltaTime * zoomRate;

            }

            if (automove == true) {
                if (UIData.switchmode)
                    Molecule3DComp.ToParticle ();
                xDeg += Mathf.Lerp (0.0F, 100.0F, Time.deltaTime * 0.8f);
                yDeg = 0;
            }

            if (centerChanged) {
                //if we reach the position (for camera sliding) we stop!

                //otherwise we continue the translation.
                if (cameraTranslation) {

                    weight_cam += Time.deltaTime * 1;
                    target.localPosition = Vector3.Lerp (target.localPosition, newposition, weight_cam);

                    mainCamera.transform.localPosition = Vector3.Lerp (mainCamera.transform.localPosition, Vector3.zero, weight_cam);

                    //mainCamera.transform.eulerAngles = Vector3.Lerp (mainCamera.transform.eulerAngles, Vector3.zero, weight);

                    if (target.position == newposition && mainCamera.transform.localPosition== Vector3.zero) {

                        weight_cam = 0;
                        cameraTranslation = false;
                        centerChanged = false;
                    }
                }
            }
            if(xDeg != 0 || yDeg != 0 || zDeg != 0){
                //Camera rotation
                desiredRotation *= Quaternion.Euler (yDeg, xDeg, zDeg);
                currentRotation = transform.rotation;
                rotation = Quaternion.Lerp (currentRotation, desiredRotation, Time.deltaTime * zoomDampening);
            }
            if(!UIData.guided){ //|| reset_panoramic){
                transform.rotation = rotation;
            }

            //Camera movement
            currentDistance = Mathf.Lerp (currentDistance, desiredDistance, Time.deltaTime * zoomDampening);
            position = target.position - (rotation * Vector3.forward * currentDistance + targetOffset);


            if(!UIData.guided){ //|| reset_panoramic){
                transform.position = position;
                //reset_panoramic = false;
            }

            xDeg = 0;
            yDeg = 0;
            zDeg = 0;
            guiControl = false; 
        }
        //}

    }
    
    private static float ClampAngle (float angle, float min, float max)
    {
        if (angle < -360)
            angle += 360;
        if (angle > 360)
            angle -= 360;
        return Mathf.Clamp (angle, min, max);
    }
    
    public void ToCenter ()
    {
        LocCamera.transform.localPosition = Vector3.zero;
        target.transform.localPosition = Vector3.zero;
        transform.position = new Vector3 (0, 0, MoleculeModel.cameraLocation.z);
        LocCamera.transform.rotation = new Quaternion (0, 0, 0, 0);
        transform.rotation = Quaternion.identity;
        centerChanged = false;
        weight_cam = 0;
        Init ();
    }

// control of the joypad =============================================================================================      
//                       =============================================================================================      
    private void joypadOperate ()
    {
        target.rotation = transform.rotation;

        Vector3 v = LocCamera.transform.localPosition;

        /*
         * Left pad
         */
        v.x -= (Input.GetAxis ("Horizontal") * panSpeed * Time.deltaTime);
        v.y -= (Input.GetAxis ("Vertical") * panSpeed * Time.deltaTime);
        
        LocCamera.transform.localPosition = v;

        /*
         * Right pad
         */
        if (Input.GetAxis ("Axis3") > joypadDeadzone || (Input.GetAxis ("Axis3") < -joypadDeadzone))
        {
            xDeg = Input.GetAxis ("Axis3") * xSpeed * 0.08f;
        }

        if (Input.GetAxis ("Axis4") > joypadDeadzone || (Input.GetAxis ("Axis4") < -joypadDeadzone))
        {
            yDeg = Input.GetAxis ("Axis4") * ySpeed * 0.08f;
        }
        
        //Z rotation
        if (Input.GetButton("Rotate Z Right"))
        {
            zDeg = Time.deltaTime * xSpeed * 0.5f;
        }

        if (Input.GetButton("Rotate Z Left"))
        {
            zDeg = - Time.deltaTime * xSpeed * 0.5f;
        }

        //Zoom in
        if (Input.GetButton("Zoom In")) {
            desiredDistance -= Time.deltaTime * zoomRate * 0.08f; 
            if (UIData.switchmode)
                Molecule3DComp.ToParticle ();
        }
        //zoom out
        if (Input.GetButton("Zoom Out")) {
            desiredDistance += Time.deltaTime * zoomRate * 0.08f;
            if (UIData.switchmode)
                Molecule3DComp.ToParticle ();
        }
    }
    
    private void keyboardOperate ()
    {

        /*
         * X Rotation
         */

        if (Input.GetButton ("Rotate X Right")){
            if(!UIData.guided)
                upxDeg ();
        }
        
        if (Input.GetButton ("Rotate X Left")) {
            if (!UIData.guided)
                downxDeg ();
        }

        /*
         * Y Rotation
         */

        if (Input.GetButton ("Rotate Y Up")){
            if (!UIData.guided)
                upyDeg ();
        }

        if (Input.GetButton ("Rotate Y Down")){
            if(!UIData.guided)
                downyDeg ();
        }




    } // End of KeyboardOperate


    
}