Molecule3D.cs

Go to the documentation of this file.

using UnityEngine;
using System.Collections;
using System.Xml;
using System.Text;
using System;
using ParseData.ParsePDB;
using UI;
using Molecule.View;
using System.Net;

using SocketConnect.UnitySocket;
using Cmd;
using Molecule.Model;
using Molecule.Control;
using System.IO;

public class Molecule3D:MonoBehaviour {

    private bool fontInitialized = false;

    private static GameObject LocCamera;
    private Skybox camSky;
    public GUIDisplay gUIDisplay;
    private RequestPDB requestPDB;
    private Boolean isControl=false;
    public  IPEndPoint _ipep;
    public ArrayList clubLocationalist=new ArrayList();
    public float sensitivityX = 1.5F;
    public float sensitivityY = 1.5F;
    public float minimumX = -360F;
    public float maximumX = 360F;
    public float minimumY = -60F;
    public float maximumY = 60F;
    private float rotationXX = 0F;
    private float rotationYY = 0F;
    public string location;
    public Vector2 directoryScroll= new Vector2();
    public Vector2 fileScroll= new Vector2();
    private GameObject toggleNewUI;

    public GUISkin mySkin;
    
    // video with Benoit
    public int polop = 0;
    public int masque = 0;
    
    private GameObject scenecontroller;
    
    //T.T DEBUG
    public bool fileLoadingFinished=false;

    // Stores the default FOV angle.
    private float default_fov_angle;
    private float default_fov_angle_rad;

    // Stores the default near plane distance.
    public float default_near_clip_plane;

    public float default_near_plane_length;

    // User configurable field of view angle in radians.
    private float angle_rad;

    private Camera camera;

//      private string FPS="";

    //To keep track of the normal type when hiding atoms or in LOD mode
    private UIData.AtomType previous_AtomType = UIData.AtomType.noatom;
    public UIData.AtomType PreviousAtomType {
        get {
            return previous_AtomType;
        }
    }
    
    private UIData.BondType previous_BondType = UIData.BondType.nobond;
    public UIData.BondType PreviousBondType {
        get {
            return previous_BondType;
        }
    }

    public void OnDisable()
    {
        clearScene();
    }

    public static void clearScene()
    {
        GUIDisplay.id="";

        UnityMolMain.getArtemisManager().disconnect();

        UnityMolMain.getVRPNManager().clearTools();
        
        // ----- Clearing all variables -----
        UIData.isCubeLoaded = false;
        UIData.isSphereLoaded = false;
        UIData.isHBallLoaded = false;

        SugarOldGUI.toggle_RING_BLENDING = false;
        SugarOldGUI.toggle_TWISTER= false;
        SugarOldGUI.toggle_OXYGEN = false;

        LoadTypeGUI.toggle_NA_HIDE = false;
        LoadTypeGUI.toggle_HIDE_HYDROGEN = false;
        LoadTypeGUI.toggle_NA_MEASURE = false;

        UIData.loadHireRNA = false;

        // FOLLOWING COMMENTS FOR HISTORIC REFERENCE. CAN BE CLEANED IN THE FUTURE (MVB)
        // ON STOPPING WE PRVIOUSLY GOT THE FOLLOWING ERROR:
        // go.IsActive() && go.GetTag() != 0
        // UnityEngine.Camera:get_main()
        // Molecule3D:clearScene() (at Assets/Scripts/Molecule3D.cs:161)
        // Molecule3D:OnDisable() (at Assets/Scripts/Molecule3D.cs:136)
        //
        // it can be avoided as follows (but is not severe):
        // It occurs because the method checks for Camera.main, but after stopping 
        // the scene, Camera.main no longer exits and even checking to see if exists 
        // causes an error.
        // If you really, really want to get rid of it, you can do this:
        // 1) Add a variable like this: private Camera myCamera;
        // 2) In Start(), initialize the variable, like this: myCamera = Camera.main;
        // 3) In this function replace any use of "Camera.main" with "myCamera". Make sure 
        // the first part of the method is something like this:
        // if (myCamera == null)
        // return;
        // We actually have such a variable already: LocCamera. So replace the following
        // code Camera.main by LocCamera
        //      if (Camera.main) {
        //          MeasureDistance mds = Camera.main.GetComponent<MeasureDistance> ();
        //          if (mds && mds.enabled) {
        //              mds.enabled = false;
        //          }
        //      }
        if (LocCamera) {
            MeasureDistance mds = LocCamera.GetComponent<MeasureDistance> ();
            if (mds && mds.enabled) {
                mds.enabled = false;
            }
        }

        SugarManager.ColorationModeBond=0;
        SugarManager.ColorationModeRing=0;
        UIData.isParticlesInitialized=false;
        RepresentationOldGUI.globalRadius = 0.35f;
        UIData.secondarystruct = false;

        // UIData.atomtype = UIData.AtomType.noatom;
        // UIData.bondtype = UIData.BondType.nobond;
        MoleculeModel.existingName.Clear();
        MoleculeModel.existingRes.Clear();
        MoleculeModel.existingChain.Clear();

        MoleculeModel.residueIds.Clear();
        MoleculeModel.residues.Clear();

        Molecule.Model.MoleculeModel.atomsLocalScaleList.Clear();
        RequestPDB.isDone=false;
        

        SurfaceManager.pdbGen = false;
        UIData.hasMoleculeDisplay = false;
        GUIMoleculeController.toggle_NA_INTERACTIVE = false; // causes all sorts of headaches otherwise
        LocCamera.GetComponent<ClickAtom>().ClearSelection(); // so the halos don't stay after clearing
        
        UnityMolMain.getGuidedNavigationManager().Clear();

        DisplayMolecule.ClearMemory();


        UIData.isMoleculeDisplayed = false;
        UIData.isFileLoaded = false;
        
        // Delete all the Parents to start again on a clear ground
        // GameObject.Destroy(Molecule.View.DisplayAtom.AtomCubeStyle.AtomCubeParent);
        // GameObject.Destroy(Molecule.View.DisplayAtom.AtomSphereStyle.AtomSphereParent);
        // GameObject.Destroy(Molecule.View.DisplayAtom.AtomMeshStyle.AtomMeshParent);


        DepthCueing.reset = true;
        AmbientOcclusion.reset = true;
        
        UIData.loadHireRNA = false;
    }

    void Awake() {
        System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US");   

        LocCamera=Camera.main.gameObject;

        camera = LocCamera.GetComponent<Camera>();

        default_fov_angle = camera.fieldOfView;
        default_near_clip_plane = camera.nearClipPlane;

        default_fov_angle_rad = default_fov_angle * Mathf.Deg2Rad;
        default_near_plane_length = default_near_clip_plane * Mathf.Tan(default_fov_angle_rad / 2f);
    }

    void Start() {      
        requestPDB = gameObject.AddComponent<RequestPDB>();
        DisplayMolecule.GetManagers();
        GameObject hbmeshManagerObj = GameObject.FindGameObjectWithTag("HBallMeshManager");
        UnityMolMain.setCurrentAtomManager(hbmeshManagerObj.GetComponent<HBallMeshManager>());
        GameObject hStickMeshManagerObj = GameObject.FindGameObjectWithTag("HStickMeshManager");
        UnityMolMain.setCurrentBondManager(hStickMeshManagerObj.GetComponent<HStickMeshManager>());

        LocCamera=Camera.main.gameObject;
        gUIDisplay = new GUIDisplay();
        camSky = LocCamera.GetComponent<Skybox>();

        toggleNewUI = GameObject.Find("New UI Toggle Canvas");

        scenecontroller = GameObject.Find("LoadBox");
        
        gUIDisplay=new GUIDisplay();

        AtomModel.InitAtomic();
        UnityMolMain.getElectrostaticManager().Init();
    }

    public void Display() {

        Debug.Log("Displaying atoms !!! "+UIData.atomtype+" / "+UIData.bondtype);
        DisplayMolecule.ChangeRepresentation(UIData.atomtype,UIData.bondtype);
    }

    void OnGUI() {  
        GUI.skin = mySkin;
        
        if(!fontInitialized) {
            Rectangles.SetFontSize();
            fontInitialized = true;
        }
    
        if(GUIMoleculeController.m_fileBrowser != null)
            GUIMoleculeController.m_fileBrowser.OnGUI();

        if (gUIDisplay == null)
        {
            gUIDisplay = new GUIDisplay();
        }
            
        if(gUIDisplay.m_fileBrowser != null) {
            GUIMoleculeController.FileBrowser_show=true;
            gUIDisplay.m_fileBrowser.OnGUI();
        } else
            GUIMoleculeController.FileBrowser_show=false;
        
        UIData.EnableUpdate=false;
        if((!UIData.hiddenUI)&&(!UIData.hiddenUIbutFPS)){
            gUIDisplay.Display();
        }
        
        if((!UIData.hiddenUI)&&(UIData.hiddenUIbutFPS)){
            GUIMoleculeController.toggle_INFOS = true;
        }
        
        if(!UIData.hiddenUI)
            if(GUIMoleculeController.showPanelsMenu)
                GUIMoleculeController.SetPanels();
        
        if(!UIData.hiddenUI)
            if (GUIMoleculeController.showResiduesMenu)
                GUIMoleculeController.SetResidues();
        
        if(!UIData.hiddenUI)
            if (GUIMoleculeController.showAtomsExtendedMenu)
                GUIMoleculeController.SetAtomsExtended();
        
        if(!UIData.hiddenUI)
            if (GUIMoleculeController.showChainsMenu)
                GUIMoleculeController.SetChains();

        if(UIData.changeStructure) {

            DisplayMolecule.ChangeRepresentation(UIData.atomtype,UIData.bondtype);

            UIData.changeStructure = false;
            UIData.isParticlesInitialized = false;
        }

        if(!UIData.isMoleculeDisplayed && UIData.isFileLoaded ){

            ControlMolecule.BuildMoleculeComponents();
            ControlMolecule.CreateResidues();
            /*
            ControlMolecule.CreateSplines();
            ControlMolecule.CreateResiduesSugar2();*/
            
            if(UIData.loadHireRNA)
            {
                ControlMolecule.BuildHireRnaHydrogenBondsStructures();
            }

            if(GUIDisplay.pdbID == "3EI0")
                UIData.isGLIC = true;
            
            UIData.isParticlesInitialized = false ; // new file, new particle system needed
            MoleculeModel.networkLoaded = false ; // protein loaded, network removed if present

            Display();
            UIData.isMoleculeDisplayed = true;
            UnityMolMain.getElectrostaticManager().DisplayFieldLines();
    //      Deta=MoleculeModel.target;
            isControl=true;

            SurfaceManager.InitCutParameters();
            SetCenter(0);
            UnityMolMain.getSurfaceManager().RecenterSurfaces(Vector3.zero);
            UIData.isMoleculeDisplayed = true;
        }

        if(UIData.isOpenFile) {
            loadFile();
        }



        camSky.enabled=UIData.backGroundIs;

        UIData.EnableUpdate=true;
        
        if(UIData.interactive&&UIData.resetInteractive) {
            DisplayMolecule.AddPhysics();
            UIData.resetInteractive=false;          
        }
        else if(!UIData.interactive && UIData.resetInteractive) {
            DisplayMolecule.DeletePhysics();
            UIData.resetInteractive = false;
        }
        
        
        if(GUI.tooltip != "")GUI.Box ( new Rect(180,Screen.height-55,450,25), GUI.tooltip);
        if(MoleculeModel.newtooltip != "")GUI.Box ( new Rect(180,Screen.height-55,450,25), MoleculeModel.newtooltip);
    }

    
    // loading the file in all possibilities
    public void loadFile() {

        UIData.isMoleculeDisplayed = false;
        UIData.isOpenFile = false;
        UIData.isFileLoaded = false;

        #if !UNITY_WEBPLAYER
        // check all format reading by unitymol PDB, XGMML and OBJ
        if(UIData.fetchPDBFile) {
            Debug.Log("pdbServer/pdbID :: "+GUIDisplay.pdbServer + GUIDisplay.pdbID);
            Debug.Log("proxyServer+proxyPort :: "+GUIDisplay.proxyServer + GUIDisplay.proxyPort);
            int proxyport = 0;
            if(GUIDisplay.proxyPort != "")
                proxyport = int.Parse(GUIDisplay.proxyPort);
            else
                proxyport = 0;
            
            // Debug.Log("RequestPDB = null ??????????????????????? "+(requestPDB==null));
            // requestPDB.FetchPDB(GUIDisplay.pdbServer, GUIDisplay.pdbID, GUIDisplay.proxyServer, proxyport);
            ParsePDB.FetchPDB2(GUIDisplay.pdbServer, GUIDisplay.pdbID,GUIDisplay.proxyServer, proxyport);
        }
        // if we laod a pdb file launch the reading of file
        else if(GUIDisplay.file_extension=="pdb")
        {
            // requestPDB.LoadPDBRequest(GUIDisplay.file_base_name);
            ParsePDB.LoadPDBRequest2(GUIDisplay.file_base_name);
        }
        
        //Aurélien : reading a reaction file
        else if(GUIDisplay.file_extension=="reaction")
        {   
            requestPDB.LoadPDBReaction(GUIDisplay.file_base_name);
        }
        
        //Aurélien : reading a top animation file
        else if(GUIDisplay.file_extension=="animtop")
        {   
            requestPDB.LoadAnimTop(GUIDisplay.file_base_name);
        }
        
        //Aurélien : reading a top animation file
        else if(GUIDisplay.file_extension=="animcrd")
        {   
            requestPDB.LoadAnimCrd(GUIDisplay.file_base_name);
        }
        
        // check the format of xgmml    
        else if(UI.GUIDisplay.file_extension=="xgmml") {
            requestPDB.LoadXGMML("file://"+GUIDisplay.file_base_name+"."+GUIDisplay.file_extension);
            // while(!RequestPDB.isDone) {
                // Debug.Log(requestPDB.progress);
                // yield return new WaitForEndOfFrame();
            // }
            UIData.atomtype=UIData.AtomType.hyperball;
            UIData.bondtype=UIData.BondType.hyperstick;
            RepresentationOldGUI.globalRadius = 0.22f;
            RepresentationOldGUI.shrink = 0.0001f;
            RepresentationOldGUI.linkScale = 0.70f;
            SendMessage("Display",SendMessageOptions.DontRequireReceiver);
        }
        else if(UI.GUIDisplay.file_extension=="obj") {
            ParsePDB.LoadOBJRequest(GUIDisplay.file_base_name+"."+GUIDisplay.file_extension);
            MoleculeModel.surfaceFileExists=true;
        }   
        //              requestPDB.GetTypelist();
        
        //if the application is an wep player or a mobile application
        #else
        
        
        //          socketPDB=new SocketPDB(id);
        //          socketPDB.getAtoms();
        // //               socketPDB.getTypes();
        //          clubLocationalist=socketPDB.getClubLocation();
        //          clubRotationList=socketPDB.getClubRotation();

        if(UIData.init_molecule != "")
            ParsePDB.LoadPDBResource2(UIData.init_molecule);
        
        #endif
        //Debug.Log("SDGFSDGSDGDSG");
        GUIMoleculeController.showAtomMenu = true;
        UIData.hasMoleculeDisplay = true;
        Debug.Log("T.T ==> END OF LOADING");
    }


    // Update is called once per frame
    void Update() {

        RepresentationOldGUI.showHyperballsMenu = (UIData.bondtype == UIData.BondType.hyperstick || UIData.bondtype == UIData.BondType.optihs) 
                                                    && (!RepresentationOldGUI.showBondType && !RepresentationOldGUI.showAtomType)
                                                    && GUIMoleculeController.showAtomMenu;



        //Aurélien : update of every atom's coordinate to the next animation step, rendering mode is set to hyperball-hyperstick with 0.2 radius
        if(Reaction.isReaction && (Reaction.current < Reaction.count) && Reaction.isReady && Reaction.animation){
            if(!Reaction.affichage)
            {

                DisplayMolecule.ChangeRepresentation(UIData.AtomType.hyperball,UIData.BondType.hyperstick);
                
                //Setting radius at 0.2
                RepresentationOldGUI.globalRadius = 0.2f;
                
                //Destroying previous particle effects (particlein 1 in particle manager)
                GameObject.Find("ParticleManager").SendMessage("killCurrentEffects",SendMessageOptions.DontRequireReceiver);
                
                Reaction.affichage = true;
            }
            int j;
            if(Reaction.forward){
                ArrayList xyz = (ArrayList)Reaction.coord[Reaction.current];
                for(int i=0;i<Reaction.acount;i++){
                    j = ((MoleculeModel.atoms[i] as GameObject).GetComponent("AtomIndex") as AtomIndex).index;
                    (MoleculeModel.atoms[i] as GameObject).transform.position = new Vector3((xyz[j] as float[])[0], (xyz[j] as float[])[1], (xyz[j] as float[])[2]);
                }
            }
            else{
                ArrayList xyz = (ArrayList)Reaction.coord[Reaction.count - Reaction.current - 1];
                for(int i=0;i<Reaction.acount;i++){
                    j = ((MoleculeModel.atoms[i] as GameObject).GetComponent("AtomIndex") as AtomIndex).index;
                    (MoleculeModel.atoms[i] as GameObject).transform.position = new Vector3((xyz[j] as float[])[0], (xyz[j] as float[])[1], (xyz[j] as float[])[2]);
                }
            }

            // Copied from DisplayMolecule.GetManagers.
            // Does not work otherwise. Why?
            if (UIData.bondtype == UIData.BondType.line) {
                GameObject lineManagerObj = GameObject.FindGameObjectWithTag("LineManager");
                LineManager lineManager = lineManagerObj.GetComponent<LineManager>();
                lineManager.ResetPositions();
            } else if (UIData.bondtype == UIData.BondType.cube) {
                GameObject cubeBondManagerObj = GameObject.FindGameObjectWithTag("CubeBondManager");
                CubeBondManager cubeBondManager = cubeBondManagerObj.GetComponent<CubeBondManager>();
                cubeBondManager.ResetPositions();
            } else if (UIData.bondtype == UIData.BondType.hyperstick) {
                GameObject hStickManagerObj = GameObject.FindGameObjectWithTag("HStickManager");
                HStickManager hStickManager = hStickManagerObj.GetComponent<HStickManager>();
                hStickManager.ResetPositions();
            } else if (UIData.bondtype == UIData.BondType.optihs) {
                GameObject hStickMeshManagerObj = GameObject.FindGameObjectWithTag("HStickMeshManager");
                HStickMeshManager hStickMeshManager = hStickMeshManagerObj.GetComponent<HStickMeshManager>();
                hStickMeshManager.ResetPositions();
            }
            
            //Next step
            Reaction.current++;
        }
        
        //Aurélien : update of every atom's coordinate to the next reaction step, rendering mode is set to hyperball-hyperstick with 0.2 radius
        if(Reaction.isReaction && (Reaction.current < Reaction.count) && Reaction.isReady && !Reaction.animation){
            if(!Reaction.affichage)
            {
                DisplayMolecule.ChangeRepresentation(UIData.AtomType.hyperball,UIData.BondType.hyperstick);

                
                //Setting radius at 0.2
                RepresentationOldGUI.globalRadius = 0.2f;
                
                //Destroying previous particle effects (particlein 1 in particle manager)
                GameObject.Find("ParticleManager").SendMessage("killCurrentEffects",SendMessageOptions.DontRequireReceiver);
                
                Reaction.affichage = true;
            }
            int j;
            if(Reaction.forward){
                ArrayList xyz = (ArrayList)Reaction.coord[Reaction.current];
                for(int i=0;i<Reaction.acount;i++){
                    j = ((MoleculeModel.atoms[i] as GameObject).GetComponent("AtomIndex") as AtomIndex).index - 1;
                    (MoleculeModel.atoms[i] as GameObject).transform.position = new Vector3((xyz[j] as float[])[0], (xyz[j] as float[])[1], (xyz[j] as float[])[2]);
                }
            }
            else{
                ArrayList xyz = (ArrayList)Reaction.coord[Reaction.count - Reaction.current - 1];
                for(int i=0;i<Reaction.acount;i++){
                    j = ((MoleculeModel.atoms[i] as GameObject).GetComponent("AtomIndex") as AtomIndex).index - 1;
                    (MoleculeModel.atoms[i] as GameObject).transform.position = new Vector3((xyz[j] as float[])[0], (xyz[j] as float[])[1], (xyz[j] as float[])[2]);
                }
            }   
            //Updating the bonds
            Molecule.Control.ControlMolecule.UpdateBondsFromGameObject(MoleculeModel.atoms);
            
            //Next step
            Reaction.current++;
        }
        
        if(isControl&&(!UIData.cameraStop2)) { // Seems to be true as long as the mouse is in the game window and not on the gui
            MouseOperate();
            KeyOperate();
            
            //SetCenterbySpace();
            HiddenOperate();
            OpenMenuOperate();
        }
        
        // Always false ?
        /*if (GUIMoleculeController.toggle_HB_SANIM) {
            GUIMoleculeController.shrink +=  Time.deltaTime * GUIMoleculeController.hb_sanim * GUIMoleculeController.hb_ssign;
            if (GUIMoleculeController.shrink > 0.95f )
                GUIMoleculeController.hb_ssign = -1.0f;
            if (GUIMoleculeController.shrink < 0.05f )
                GUIMoleculeController.hb_ssign = 1.0f;
        }*/
        
        // Always false ?
        /*if (GUIMoleculeController.toggle_HB_RANIM) {
            GUIMoleculeController.globalRadius +=  Time.deltaTime * GUIMoleculeController.hb_ranim * GUIMoleculeController.hb_rsign;
            if (GUIMoleculeController.globalRadius > 0.95f )
                GUIMoleculeController.hb_rsign = -1.0f;
            if (GUIMoleculeController.globalRadius < 0.05f )
                GUIMoleculeController.hb_rsign = 1.0f;
        }*/
    
        if(GUIMoleculeController.toggle_HB_TRANS) // Always true ?
            RepresentationOldGUI.transDelta = 25.0f;
        else
            RepresentationOldGUI.transDelta = 1.0f;
    
        if (RepresentationOldGUI.transMETAPHOR) {
            RepresentationOldGUI.globalRadius = transition(RepresentationOldGUI.globalRadius, RepresentationOldGUI.newGlobalRadius, RepresentationOldGUI.deltaRadius);
            RepresentationOldGUI.linkScale = transition(RepresentationOldGUI.linkScale, RepresentationOldGUI.newScale, RepresentationOldGUI.deltaScale);
            RepresentationOldGUI.shrink = transition(RepresentationOldGUI.shrink, RepresentationOldGUI.newShrink, RepresentationOldGUI.deltaShrink);

            HBallMeshManager.resetRadii = true;
            HStickMeshManager.resetScale = true;
            HStickMeshManager.resetShrink = true;

            if(RepresentationOldGUI.globalRadius == RepresentationOldGUI.newGlobalRadius && RepresentationOldGUI.linkScale == RepresentationOldGUI.newScale && RepresentationOldGUI.shrink == RepresentationOldGUI.newShrink)           
                RepresentationOldGUI.transMETAPHOR = false;
        }
        
        LineUpdate.scale=RepresentationOldGUI.linkScale;
        
        StickUpdate.radiusFactor = RepresentationOldGUI.globalRadius;
        StickUpdate.shrink      = RepresentationOldGUI.shrink;
        StickUpdate.scale       = RepresentationOldGUI.linkScale;
        BallUpdateHB.radiusFactor = RepresentationOldGUI.globalRadius;

//      BallUpdateHB.depthfactor = GUIMoleculeController.depthfactor;
        HBallManager.depthFactor = GUIMoleculeController.depthfactor;
        HStickManager.depthFactor = GUIMoleculeController.depthfactor;
        BallUpdateSphere.radiusFactor = RepresentationOldGUI.globalRadius;
        BallUpdateCube.radiusFactor = RepresentationOldGUI.globalRadius;
        BallUpdateRC.radiusFactor = RepresentationOldGUI.globalRadius;
        
        BallUpdateHB.drag = GUIMoleculeController.drag;
        BallUpdateHB.spring = GUIMoleculeController.spring;
        
        BallUpdateHB.EnergyGrayColor = ElectrostaticManager.EnergyGrayColor.color;      
        
        UnityMolMain.getElectrostaticManager().update();

        //SetVolumetricDensity();
        // gUIDisplay.gUIMoleculeController.GetPanelPixel();
    }
        
    float transition(float val, float newVal, float deltaVal) {
        if(val <= newVal && deltaVal < 0.0f) return newVal;
        if(val >= newVal && deltaVal > 0.0f) return newVal;
        return val + deltaVal;  
    }
    
    private void OpenMenuOperate() {
        if(Input.GetKeyDown(KeyCode.Delete)) {
                UIData.openAllMenu=!UIData.openAllMenu; // ???
                DisplayMolecule.ChangeRepresentation(UIData.AtomType.particleball,UIData.BondType.nobond);

        }
    }

    public void SetFOV(float angle)
    {
        // Set field of view angle.
        camera.fieldOfView = angle;

        // Compute frustum ratio.
        angle_rad = angle * Mathf.Deg2Rad / 2f;

        float new_near_plane = default_near_plane_length / Mathf.Tan(angle_rad);

        // Reset projection matrix.
        camera.ResetProjectionMatrix();

        // Adjust camera position.
        camera.transform.localPosition = new Vector3(0f, 0f, -(new_near_plane - default_near_clip_plane) * 800f);
    }

    private void HiddenOperate() {
        if(Input.GetButtonDown("Hide GUI")) {
            if(!UIData.hiddenUI) { //&& !UIData.hiddenUIbutFPS && !UIData.hiddenCamera) {
                    UIData.hiddenUI=true;
                    toggleNewUI.SetActive(false);
                    Debug.Log("Hide all the UI.");
            } 
            // I really don't know why we'd want to disable the camera.
/*          else if(UIData.hiddenUI && !UIData.hiddenUIbutFPS && !UIData.hiddenCamera) {
                    UIData.hiddenCamera=true;
                    LocCamera.GetComponent<Camera>().enabled=false;
                    Debug.Log("Hide all the UI and Camera.");
            }
*/
            // Doesn't seem to work
/*          else if(UIData.hiddenUI && !UIData.hiddenUIbutFPS) { //&& UIData.hiddenCamera) {
                    //UIData.hiddenCamera=false;
                    //LocCamera.GetComponent<Camera>().enabled=true;
                    UIData.hiddenUI=false;
                    UIData.hiddenUIbutFPS=true;
                    Debug.Log("Hide all the UI except FPS."); 
            }
*/
            else if(UIData.hiddenUI) { 
                    UIData.hiddenUI=false;
                    toggleNewUI.SetActive(true);
                    //UIData.hiddenUIbutFPS=false;      
                    Debug.Log("Show all the UI and Camera.");
            }   
        }
    }

    private void KeyOperate() { 
        /*
         * This shit might be completely useless
         */
        if(Input.GetKeyUp(KeyCode.D))
            if(UIData.switchmode)
                ToNotParticle();

        if(Input.GetKeyUp(KeyCode.W))
            if(UIData.switchmode)
                ToNotParticle();

        if(Input.GetKeyUp(KeyCode.S))
            if(UIData.switchmode)
                ToNotParticle();
        
        if(Input.GetKeyUp(KeyCode.A))
            if(UIData.switchmode)
                ToNotParticle();
        
        if(Input.GetButtonUp("Zoom In"))
            if(UIData.switchmode)
                ToNotParticle();

        if(Input.GetButtonUp("Zoom Out"))
            if(UIData.switchmode)
                ToNotParticle();

        if(Input.GetButtonUp("Rotate X Right"))
            if(UIData.switchmode)
                ToNotParticle();
        
        if(Input.GetButtonUp("Rotate X Left"))
            if(UIData.switchmode)
                ToNotParticle();

        if(Input.GetButtonUp("Render Cubes")) {
            DisplayMolecule.ChangeRepresentation(UIData.AtomType.cube,UIData.bondtype);

        }
        
        if(Input.GetButtonUp("Render Spheres")) {
            DisplayMolecule.ChangeRepresentation(UIData.AtomType.sphere,UIData.bondtype);

        }
        
        if(Input.GetButtonUp("Render Hyperballs")) {
            DisplayMolecule.ChangeRepresentation(UIData.AtomType.hyperball,UIData.bondtype);


        }
        if(Input.GetButtonUp("Render Optimized Hyperballs")) {
            DisplayMolecule.ChangeRepresentation(UIData.AtomType.optihb,UIData.BondType.optihs);


        }
        if(Input.GetButtonDown("Hide Molecule")) {
            DisplayMolecule.ChangeRepresentation(UIData.AtomType.particleball,UIData.BondType.nobond);

        }
        
        // Takes a screenshot of the scene
        if(Input.GetButtonDown("Take Screenshot")) {
            ScreenShot comp = LocCamera.GetComponent<ScreenShot> ();
            comp.open = true;
        }
        
        Vector3 vv=new Vector3();
        vv=LocCamera.transform.localPosition;       
        
        if(!GUIMoleculeController.toggle_NA_MAXCAM)
            vv.z+=Input.GetAxis("Mouse ScrollWheel")*5;

        LocCamera.transform.localPosition=vv;       
    }
    
    /* replaced by R and C in maxCamera.
    private void SetCenterbySpace() {
        if(Input.GetKeyUp(KeyCode.R)) {
            Debug.Log("Press the R key");
            SetCenter(0);
        }
        replace by touch C in maxCamera
      if(Input.GetKeyUp(KeyCode.T)) {
            Debug.Log("Press the T key");
            SetCenter(1);
        }
    }*/

// controlled when maxcam is desactivate with the mouse =============================================================================================       
    private void MouseOperate() {
        Vector3 v=new Vector3();
        if (LocCamera == null)
            LocCamera = Camera.main.gameObject;
        v=LocCamera.transform.localPosition;
    
        if(!GUIMoleculeController.toggle_NA_MAXCAM) {
//          if (Input.GetMouseButton(1) )
//              v=LocCamera.transform.localPosition;

            if (Input.GetMouseButton(0)) {
                if(UIData.switchmode)ToParticle();
                rotationXX += Input.GetAxis("Mouse X") * sensitivityX;
                rotationYY += Input.GetAxis("Mouse Y") * sensitivityY;
                print("Mouse X"+Input.GetAxis("Mouse X"));
                print("Mouse Y"+Input.GetAxis("Mouse Y"));
                print("rotationXX"+rotationXX);
                print("rotationYY"+rotationYY);
        
                Quaternion xQuaternion = Quaternion.AngleAxis (rotationXX, Vector3.up);
                Quaternion yQuaternion = Quaternion.AngleAxis (rotationYY, Vector3.left);
                transform.localRotation =  xQuaternion * yQuaternion;
//              transform.localRotation = originalRotation * xQuaternion * yQuaternion;
                if(UIData.switchmode)ToNotParticle();
            }
            
            if(Input.GetMouseButtonUp(1))
                if(UIData.switchmode)ToNotParticle();
            
            v.z+=Input.GetAxis("Mouse ScrollWheel")*5;
            LocCamera.transform.localPosition=v;
            Debug.Log ("get mouse: " +v.z);             
        }
    }

    private void SetCenter( int mode) {
        GameObject CamTarget = GameObject.Find("Cam Target");
    
        // choose the main function 0 to restart position or 1 to center around an atom
        if (mode == 0) {
            //Debug.Log("Entering :: SetCenter for cam target to" + MoleculeModel.cameraLocation.z);
            if(scenecontroller.GetComponent<maxCamera>().enabled) {
                maxCamera comp = scenecontroller.GetComponent<maxCamera>();
                comp.ToCenter();
            }
            if(UIData.atomtype == UIData.AtomType.hyperball){
                GameObject hbManagerObj = GameObject.FindGameObjectWithTag("HBallManager");
                HBallManager hbManager = hbManagerObj.GetComponent<HBallManager>();
                hbManager.ResetPositions();
            }
        } else if (mode ==1) {
            Debug.Log("target : " +MoleculeModel.target);
            CamTarget.transform.rotation = transform.rotation;
            CamTarget.transform.position = MoleculeModel.target;
        }
    }
    
    
    
    public void ToNotParticle() {
        if(UIData.atomtype != UIData.AtomType.particleball && UIData.atomtype != previous_AtomType) {
            previous_AtomType = UIData.atomtype;
            previous_BondType = UIData.bondtype;
        }
        DisplayMolecule.ChangeRepresentation(previous_AtomType,previous_BondType);
    }
    
    public void ToParticle() {
        if(UIData.atomtype != UIData.AtomType.particleball) {
            previous_AtomType = UIData.atomtype;
            previous_BondType = UIData.bondtype;
        }
        DisplayMolecule.ChangeRepresentation(UIData.AtomType.particleball,UIData.BondType.nobond);
    }
}