DisplayMolecule.cs

Go to the documentation of this file.

namespace Molecule.View {
    using UnityEngine;
    using System.Collections;
    using System.Collections.Generic;
    using Molecule.Model;
    using Molecule.Control;
    using Molecule.View.DisplayAtom;
    using Molecule.View.DisplayBond;
    using UI;


    public class DisplayMolecule {
        private static HBallManager hbManager;
        private static SphereManager spManager;
        private static CubeManager cubeManager;
        private static ShurikenParticleManager shManager;
        private static HBallMeshManager hbmeshManager;
        private static LineManager lineManager;
        private static CubeBondManager cubeBondManager;
        private static HStickManager hStickManager;
        private static HStickMeshManager hStickMeshManager;



        public static List<GenericManager> GetManagers() {
            UIData.AtomType aType = UIData.atomtype;
            List<GenericManager> managerList = new List<GenericManager>();
//          if(aType == UIData.AtomType.hyperball) {  //||  UIData.bondtype == UIData.BondType.hyperstick) {
                if(hbManager == null){
                    GameObject hbManagerObj = GameObject.FindGameObjectWithTag("HBallManager");
                    hbManager = hbManagerObj.GetComponent<HBallManager>();  
                }
                managerList.Add(hbManager);
//          }else if (aType == UIData.AtomType.sphere) {
                if(spManager == null){
                    GameObject spManagerObj = GameObject.FindGameObjectWithTag("SphereManager");
                    spManager = spManagerObj.GetComponent<SphereManager>();
                }
                managerList.Add(spManager);
//          } else if (aType == UIData.AtomType.cube) {
                if(cubeManager == null){
                    GameObject cubeManagerObj = GameObject.FindGameObjectWithTag("CubeManager");
                    cubeManager = cubeManagerObj.GetComponent<CubeManager>();
                }
                managerList.Add(cubeManager);
//          } else if (aType == UIData.AtomType.particleball) {
                if(shManager == null){
                    GameObject psObj = GameObject.FindGameObjectWithTag("ShurikenParticleManager");
                    shManager =  psObj.GetComponent<ShurikenParticleManager>();
                }
                managerList.Add(shManager);
//          } else if(aType == UIData.AtomType.optihb) {
                if(hbmeshManager == null){
                    GameObject hbmeshManagerObj = GameObject.FindGameObjectWithTag("HBallMeshManager");
                    hbmeshManager = hbmeshManagerObj.GetComponent<HBallMeshManager>();
                }
                managerList.Add(hbmeshManager);
//          }
//          if (UIData.bondtype == UIData.BondType.line) {
                if(lineManager == null){
                    GameObject lineManagerObj = GameObject.FindGameObjectWithTag("LineManager");
                    lineManager = lineManagerObj.GetComponent<LineManager>();
                }
                managerList.Add(lineManager);
//          } else if (UIData.bondtype == UIData.BondType.cube) {
                if(cubeBondManager == null){
                    GameObject cubeBondManagerObj = GameObject.FindGameObjectWithTag("CubeBondManager");
                    cubeBondManager = cubeBondManagerObj.GetComponent<CubeBondManager>();
                }
                managerList.Add(cubeBondManager);
//          } else if (UIData.bondtype == UIData.BondType.hyperstick) {
                if(hStickManager == null){
                    GameObject hStickManagerObj = GameObject.FindGameObjectWithTag("HStickManager");
                    hStickManager = hStickManagerObj.GetComponent<HStickManager>();
                }
                managerList.Add(hStickManager);
//          }
//          else if (UIData.bondtype == UIData.BondType.optihs) {
                if(hStickMeshManager == null){
                    GameObject hStickMeshManagerObj = GameObject.FindGameObjectWithTag("HStickMeshManager");
                    hStickMeshManager = hStickMeshManagerObj.GetComponent<HStickMeshManager>();
                }
                managerList.Add(hStickMeshManager);
//          }

            return managerList;
        }

        public static void AddPhysics() {
            UIData.resetInteractive=false;
            if(MoleculeModel.atomsByChar!=null) {
                foreach(string key in MoleculeModel.atomsByChar.Keys){
                    foreach(GameObject box in MoleculeModel.atomsByChar[key]) {
                        if(box&&box.GetComponent <Rigidbody>()==null) {
                            box.AddComponent<Rigidbody>();
                            box.GetComponent<Rigidbody>().useGravity = false;
                            box.GetComponent<Rigidbody>().interpolation = RigidbodyInterpolation.Interpolate;
                            box.GetComponent<Rigidbody>().drag = 0.6f;
                        }
                        if(box&&box.GetComponent <SpringJoint>()==null) {
                            box.AddComponent<SpringJoint>();
                            box.GetComponent<SpringJoint>().spring = 5;
                        }
                    }
                }
            }
        }
        public static void DeletePhysics() {
            UIData.resetInteractive=false;
            if(MoleculeModel.atomsByChar!=null) {
                foreach(string key in MoleculeModel.atomsByChar.Keys){
                    foreach(GameObject box in MoleculeModel.atomsByChar[key]) {
                        if(box&&box.GetComponent <SpringJoint>())
                            Object.Destroy (box.GetComponent <SpringJoint>());
                        if(box&&box.GetComponent <Rigidbody>())
                            Object.Destroy (box.GetComponent <Rigidbody>());
                    }
                }
            }
        }

        public static void ToggleDistanceCueing(bool enabling) {
            List<GenericManager> managers = GetManagers();
            foreach(GenericManager manager in managers)
                manager.ToggleDistanceCueing(enabling);
        }
        
        public static void DestroyAtomsAndBonds() {
            List<GenericManager> managers = GetManagers();
            foreach(GenericManager manager in managers)
                manager.DestroyAll();
        }
        public static void DestroyBonds(){

            GenericManager bondManager = UnityMolMain.getCurrentBondManager();
            if(bondManager != null){
                bondManager.DestroyAll();
            }
        }
        public static void DestroyAllAtomsAndBonds(){
            if(hbManager != null){
                hbManager.DestroyAll();
            }
            if(spManager != null){
                spManager.DestroyAll();
            }
            if(cubeManager != null){
                cubeManager.DestroyAll();
            }
            if(shManager != null){
                shManager.DestroyAll();
            }
            if(hbmeshManager != null){
                hbmeshManager.DestroyAll();
            }
            if(lineManager != null){
                lineManager.DestroyAll();
            }
            if(cubeBondManager != null){
                cubeBondManager.DestroyAll();
            }
            if(hStickManager != null){
                hStickManager.DestroyAll();
            }
            if(hStickMeshManager != null){
                hStickMeshManager.DestroyAll();
            }


        }
        public static void InitManagers() {
            List<GenericManager> managers = GetManagers();
            foreach(GenericManager manager in managers)
                manager.Init();
        }

        public static void HideMolecule(){
            HideAtoms();
            HideBonds();
        }

        public static void ShowMolecule(){
            ShowAtoms();
            ShowBonds();
        }
        public static void HideAtoms() {
            GenericManager atomManager = UnityMolMain.getCurrentAtomManager();
            atomManager.DisableRenderers();
        }


        public static void ShowAtoms() {
            GenericManager atomManager = UnityMolMain.getCurrentAtomManager();
            atomManager.EnableRenderers();
        }
        public static void ShowBonds(){

            GenericManager bondManager = UnityMolMain.getCurrentBondManager();
            if(bondManager != null){
                bondManager.EnableRenderers();
            }
        }
        public static void HideBonds(){

            GenericManager bondManager = UnityMolMain.getCurrentBondManager();

            if(bondManager != null)
                bondManager.DisableRenderers();
        }
        public static void showHydrogens(bool hide){
            
            GenericManager atomManager = UnityMolMain.getCurrentAtomManager();
            GenericManager bondManager = UnityMolMain.getCurrentBondManager();


            atomManager.showHydrogens(hide);
            
            if(bondManager != null )
                bondManager.showHydrogens(hide);
            
            LoadTypeGUI.toggle_HIDE_HYDROGEN = hide;
        }

        public static void ChangeRepresentation(UIData.AtomType newAtomType,UIData.BondType newBondType = UIData.BondType.nobond){

//          HideAtoms();
//          if(UIData.bondtype != newBondType)
//              HideBonds();



            GenericManager atomManager = null;
            GenericManager bondManager = null;
            
            atomManager = UnityMolMain.getCurrentAtomManager();
            bondManager = UnityMolMain.getCurrentBondManager();

            atomManager.DisableRenderers();
            bondManager.DisableRenderers();

            UIData.atomtype = newAtomType;
            UIData.bondtype = newBondType;

            // Select the renderer corresponding to the selected representation.
            //
            if (UIData.atomtype == UIData.AtomType.cube) {
                UnityMolMain.setCurrentAtomManager(cubeManager);
            }
            else if (UIData.atomtype == UIData.AtomType.hyperball) {
                UnityMolMain.setCurrentAtomManager(hbManager);
            }
            else if(UIData.atomtype == UIData.AtomType.optihb){
                UnityMolMain.setCurrentAtomManager(hbmeshManager);
            }
            else if(UIData.atomtype == UIData.AtomType.sphere){
                UnityMolMain.setCurrentAtomManager(spManager);
            }
            else if(UIData.atomtype == UIData.AtomType.particleball){
                UnityMolMain.setCurrentAtomManager(shManager);
            }

            if (UIData.bondtype==UIData.BondType.cube) {
                UnityMolMain.setCurrentBondManager(cubeBondManager);
            }
            else if (UIData.bondtype==UIData.BondType.hyperstick) {
                UnityMolMain.setCurrentBondManager(hStickManager);
            }
            else if(UIData.bondtype==UIData.BondType.line) {
                UnityMolMain.setCurrentBondManager(lineManager);
            }
            else if(UIData.bondtype==UIData.BondType.optihs){
                UnityMolMain.setCurrentBondManager(hStickMeshManager);
            }

            atomManager = UnityMolMain.getCurrentAtomManager();
            bondManager = UnityMolMain.getCurrentBondManager();

            //
            // Instantiate atoms if not already done.
            //

            if (atomManager.isInit && UIData.atomtype != UIData.AtomType.noatom) {
                atomManager.EnableRenderers();
            } else {
                if(UIData.atomtype == UIData.AtomType.cube || UIData.atomtype == UIData.AtomType.hyperball){
                    IAtomStyle displayAtom=new AtomCubeStyle();
                    displayAtom.DisplayAtoms(UIData.atomtype);
                }

                else if(UIData.atomtype == UIData.AtomType.optihb){
                    IAtomStyle displayAtom=new AtomMeshStyle();
                    displayAtom.DisplayAtoms(UIData.atomtype);
                    hbmeshManager.EnableRenderers();
                    UnityMolMain.setCurrentAtomManager(hbmeshManager);
                }
                else if(UIData.atomtype == UIData.AtomType.sphere){
                    IAtomStyle displayAtom=new AtomSphereStyle();
                    displayAtom.DisplayAtoms(UIData.atomtype);
                    spManager.EnableRenderers();
                    UnityMolMain.setCurrentAtomManager(spManager);
                }
                else if(UIData.atomtype == UIData.AtomType.particleball){
                    IAtomStyle displayAtom=new AtomParticleStyle();
                    displayAtom.DisplayAtoms(UIData.atomtype);
                }
            }

            //
            // Instantiate bonds if not already done.
            //
            if (bondManager.isInit && UIData.bondtype != UIData.BondType.nobond) {
                bondManager.EnableRenderers();
            }
            else {
                if(UIData.bondtype==UIData.BondType.cube||UIData.bondtype==UIData.BondType.hyperstick||UIData.bondtype==UIData.BondType.bbhyperstick) {
                    IBondStyle displayBond=new BondCubeStyle();
                    displayBond.DisplayBonds();
                }
                else if(UIData.bondtype==UIData.BondType.line) {
                    IBondStyle displayBond=new BondLineStyle();
                    displayBond.DisplayBonds();
                }
                else if(UIData.bondtype==UIData.BondType.optihs){
                    IBondStyle displayBond=new BondMeshStyle();
                    displayBond.DisplayBonds();
                }
            }

            atomManager.ResetRadii();
            bondManager.ResetRadii();

            if(UIData.bondtype != UIData.BondType.nobond)
                showHydrogens(LoadTypeGUI.toggle_HIDE_HYDROGEN);

        }



        public static void ClearMemory(){


                // DestroyAtomsAndBonds();
                DestroyAllAtomsAndBonds();


                UnityMolMain.getSurfaceManager().DestroySurfaces();
                UnityMolMain.getElectrostaticManager().DestroyElectIso();
                UnityMolMain.getElectrostaticManager().DestroyFieldLines();

                SugarManager.DestroyRingBlending();
                SugarManager.DestroySugarRibs();
                SugarManager.DestroyOxySphere();

        }
    }


}