HBallManager.cs

Go to the documentation of this file.

using UnityEngine;
using UnityEngine.Rendering;

using System.Collections;
using System.Collections.Generic;
using UI;

// Foreach statements are bad, they should all be removed! Unfortunately, I discovered that a little late. --- Alexandre
using Molecule.Model;
using System.Linq;


public class HBallManager : GenericManager, GenericAtomManager {
    
    public static string[] allowedAtomsForPosition = {"CY", "C1", "U1", "G1", "G2", "A1", "A2"};
    

    public static BallUpdateHB[] hballs;
    private GameObject[] hballsGameObjects;
    
    public static bool xgmml = false;
    public static float depthFactor = 1.0f;
    public static float brightness = 1.0f;
    public static float shininess = 0.0f;
    public static bool resetBrightness = false;
    public static bool resetShininess = false;
    private static float oldDepthFactor = 1.0f;
    private static bool mouseOvers = false;
    private static bool wasInteractiveColored = false;
    
    static public bool ellipsoidView = false;
    static public bool ellipsoidsInitialized = false;
    public bool ellipsoidViewEnabled() {
        return ellipsoidView;
    }

    public override void Init () {
        hballs = GameObject.FindObjectsOfType(typeof(BallUpdateHB)) as BallUpdateHB[];
        if(UI.GUIDisplay.file_extension=="xgmml")
            xgmml = true;
        
        // Useful for second molecule
        BallUpdate.resetColors = true;
        BallUpdate.resetRadii = true;
        for (int i=0; i<hballs.Length; i++) {
            hballs[i].GetComponent<Renderer>().enabled = true;
            hballs[i].GetComponent<Renderer>().shadowCastingMode = ShadowCastingMode.Off;
            hballs[i].GetComponent<Renderer>().receiveShadows = false;
//          hballs[i].renderer.material.shader = Shader.Find("Diffuse");
        }
        hballsGameObjects = new GameObject[MoleculeModel.atoms.Count];
        MoleculeModel.atoms.CopyTo(hballsGameObjects);
        enabled = true;
        isInit = true;

    }
    
    public override void DestroyAll() {
        Debug.Log("Destroying Hyperboloids");
//      Debug.Log(hballs.Length.ToString());



        hballs = GameObject.FindObjectsOfType(typeof(BallUpdateHB)) as BallUpdateHB[];
        for (int i=0; i<hballs.Length; i++) {
//          hballs[i].renderer.enabled = false;
//          DestroyImmediate(hb);
            GameObject.Destroy(hballs[i].gameObject);
        }


        for (int i = 0; i < MoleculeModel.ellipsoids.Count; i++)
            GameObject.Destroy(MoleculeModel.ellipsoids[i]);

        MoleculeModel.ellipsoids.Clear();

        isInit = false;
    }
    
/*  private void InitSticks() {
        sticks = GameObject.FindObjectsOfType(typeof(StickUpdate)) as StickUpdate[];
        Debug.Log("HBallManager: Init sticks");
        foreach(StickUpdate stu in sticks) {
            stu.renderer.enabled = true;
            stu.renderer.shadowCastingMode = ShadowCastingMode. false;
            stu.renderer.receiveShadows = false;
//          stu.renderer.material.shader = Shader.Find("Diffuse");
        }
        initSticks = true;
    }
*/
    
/*  
    public void SetStickShader(){
        if(!GUIMoleculeController.toggle_NA_TEXATOM)
        {
            if(UIData.bondtype == UIData.BondType.hyperstick)
                foreach(StickUpdate stu in sticks)
                    stu.renderer.material.shader = Shader.Find("FvNano/Stick HyperBalls OpenGL");
        }
        else
        {
            if(UIData.bondtype == UIData.BondType.hyperstick)
                foreach(StickUpdate stu in sticks)
                    stu.renderer.material.shader = Shader.Find("FvNano/Stick HyperBalls 2 OpenGL");
        }
            
    }
*/
    
    public override void ToggleDistanceCueing(bool enabling) {
        if(UIData.bondtype != UIData.BondType.hyperstick)
            return;
        float attenuation;
        attenuation = enabling? 1f : 0f;
        
        for (int i=0; i<hballs.Length; i++)
            hballs[i].GetComponent<Renderer>().material.SetFloat("_Attenuation", attenuation);
    }
    
    

    
    
/*  /// <summary>
    public void SetTexture(Texture texture) {
        Debug.Log("HBallManager object: SetTexture(Texture)");
        
        for (int i=0; i<hballs.Length; i++)
            if(hb!=null)
                hballs[i].renderer.material.SetTexture("_MatCap", texture);
        BallUpdate.bondsReadyToBeReset = true;
    }
*/
    
/*  /// <summary>
    public void SetTexture(string resource_name) {
        Debug.Log("HBallManager object: SetTexture(String) : " + resource_name);
        
        Texture text2D = (Texture)Resources.Load(resource_name);
        SetTexture(text2D);
    }
*/  
    
    
    public void SetTexture(Texture texture, List<string> atom, string residue = "All", string chain = "All") {
        if(hballs == null)
            findAtoms();
        Debug.Log("SetTexture HBall");
        for (int i = 0; i < MoleculeModel.ellipsoids.Count; i++)
        {
            MoleculeModel.ellipsoids[i].GetComponent<Renderer>().material.SetTexture("_MatCap", texture);
        }
        if(!atom.Contains ("All")){
            if(residue == "All"){
                if(chain == "All"){
    // ---------- ATOM
//                  Debug.Log("ATOM");
                    if(GUIDisplay.quickSelection){
                        for (int i=0; i<hballs.Length; i++)
                            if(atom.Contains(hballs[i].tag))
                                hballs[i].GetComponent<Renderer>().material.SetTexture("_MatCap", texture);
                    }else{
                        for (int i=0; i<hballs.Length; i++)
                            if(atom.Contains(Molecule.Model.MoleculeModel.atomsNamelist[(int)hballs[i].number]))
                                hballs[i].GetComponent<Renderer>().material.SetTexture("_MatCap", texture);
                    }
                }
                else{
        // ---------- ATOM + CHAIN
//                  Debug.Log("ATOM+CHAIN");
                    if(GUIDisplay.quickSelection){
                        for (int i=0; i<hballs.Length; i++){
                            if(atom.Contains(hballs[i].tag)
                                && Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                                    hballs[i].GetComponent<Renderer>().material.SetTexture("_MatCap", texture);     
                        }
                    }else{
                        for (int i=0; i<hballs.Length; i++){
                            if(atom.Contains(Molecule.Model.MoleculeModel.atomsNamelist[(int)hballs[i].number])
                                && Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                                    hballs[i].GetComponent<Renderer>().material.SetTexture("_MatCap", texture);     
                        }
                    }
                }
            }
            else{
                if(chain == "All"){
        // ---------- ATOM + RESIDUE
//                  Debug.Log("ATOM+RESIDUE");
                    if(GUIDisplay.quickSelection){
                        for (int i=0; i<hballs.Length; i++){
                            if(atom.Contains(hballs[i].tag)
                                && Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue)
                                    hballs[i].GetComponent<Renderer>().material.SetTexture("_MatCap", texture);
                        }
                    }else{
                        for (int i=0; i<hballs.Length; i++){
                        if(atom.Contains(Molecule.Model.MoleculeModel.atomsNamelist[(int)hballs[i].number])
                            && Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue)
                                hballs[i].GetComponent<Renderer>().material.SetTexture("_MatCap", texture);
                    }
                    }
                }
                else{
        // ---------- ATOM + RESIDUE + CHAIN
//                  Debug.Log("ATOM+RESIDUE+CHAIN");
                    if(GUIDisplay.quickSelection){
                        for (int i=0; i<hballs.Length; i++){
                            if(atom.Contains(hballs[i].tag)
                                && Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue
                                && Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                                    hballs[i].GetComponent<Renderer>().material.SetTexture("_MatCap", texture);     
                        }
                    }else{
                        for (int i=0; i<hballs.Length; i++){
                        if(atom.Contains(hballs[i].tag)
                            && Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue
                            && Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                                hballs[i].GetComponent<Renderer>().material.SetTexture("_MatCap", texture);     
                    }
                    }
                }
            }
        }
        else{
            if(residue == "All"){
                if(chain == "All"){
        // ---------- ALL
//                  Debug.Log("ALL");
                    for (int i=0; i<hballs.Length; i++)
                        hballs[i].GetComponent<Renderer>().material.SetTexture("_MatCap", texture);
                }
                else{
        // ---------- CHAIN
//                  Debug.Log("CHAIN");
                    for (int i=0; i<hballs.Length; i++){
                        if(Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                            hballs[i].GetComponent<Renderer>().material.SetTexture("_MatCap", texture);     
                    }
                }
            }
            else{
                if(chain == "All"){
        // ---------- RESIDUE
//                  Debug.Log("RESIDUE");
                    for (int i=0; i<hballs.Length; i++){
                        if(Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue)
                            hballs[i].GetComponent<Renderer>().material.SetTexture("_MatCap", texture);
                    }
                }
                else{
        // ---------- RESIDUE + CHAIN
//                  Debug.Log("RESIDUE.CHAIN");
                    for (int i=0; i<hballs.Length; i++){
                        if(Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue
                            && Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                                hballs[i].GetComponent<Renderer>().material.SetTexture("_MatCap", texture);     
                    }
                }
            }
        }
        
        BallUpdate.bondsReadyToBeReset = true;
    }
    
    public void SetTexture(string resource_name, List<string> atom, string residue = "All", string chain = "All") {
        Texture text2D = (Texture)Resources.Load(resource_name);
        SetTexture(text2D, atom, residue, chain);
    }
    
    public void SetTexture(Texture texture, int atomNum) {
        Debug.Log("HBallManager object: SetTexture(Texture, int) : " + texture.name + " - " + atomNum);
        
        for (int i=0; i<hballs.Length; i++)
            if(hballs[i].GetComponent<BallUpdate>().number == atomNum)
                hballs[i].GetComponent<Renderer>().material.SetTexture("_MatCap", texture);
        BallUpdate.bondsReadyToBeReset = true;
    }
    
    public void SetTexture(string resource_name, int atomNum) {
        Texture text2D = (Texture)Resources.Load(resource_name);
        SetTexture(text2D, atomNum);
    }
    
    
    private void ResetColors() {
//      Debug.Log("Resetting HBall colors");
        if(UIData.atomtype == UIData.AtomType.hyperball) {

            for (int i=0; i<hballs.Length; i++)
                //C.R
                if(UIData.secondarystruct){
                    hballs[i].GetComponent<Renderer>().material.SetColor("_Color", hballs[i].atomcolor);}
                else
                {   
                    hballs[i].GetComponent<Renderer>().material.SetColor("_Color", Molecule.Model.MoleculeModel.atomsColorList[(int)hballs[i].number]);
                }
            BallUpdate.resetColors = false;
            BallUpdate.bondsReadyToBeReset = true;
        }
    }
    
    
    public override void SetColor(Color col, List<string> atom, string residue = "All", string chain = "All") {
//      Debug.Log("SetColor HBall");
        if(!atom.Contains ("All")){
            if(residue == "All"){
                if(chain == "All"){
        // ---------- ATOM
//                  Debug.Log("ATOM");
                    if(GUIDisplay.quickSelection){
                        for (int i=0; i<hballs.Length; i++){
                            if(atom.Contains(hballs[i].tag))
                                Molecule.Model.MoleculeModel.atomsColorList[(int)hballs[i].number] = col;
                        }
                    }else{
                        for (int i=0; i<hballs.Length; i++){
                            if(atom.Contains(Molecule.Model.MoleculeModel.atomsNamelist[(int)hballs[i].number]))
                                Molecule.Model.MoleculeModel.atomsColorList[(int)hballs[i].number] = col;
                        }
                    }
                }
                else{
        // ---------- ATOM + CHAIN
//                  Debug.Log("ATOM+CHAIN");
                    if(GUIDisplay.quickSelection){
                        for (int i=0; i<hballs.Length; i++){
                            if(atom.Contains(hballs[i].tag)
                                && Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                                    Molecule.Model.MoleculeModel.atomsColorList[(int)hballs[i].number] = col;   
                        }
                    }else{
                        for (int i=0; i<hballs.Length; i++){
                            if(atom.Contains(Molecule.Model.MoleculeModel.atomsNamelist[(int)hballs[i].number])
                                && Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                                    Molecule.Model.MoleculeModel.atomsColorList[(int)hballs[i].number] = col;   
                            }
                    }
                }
            }
            else{
                if(chain == "All"){
        // ---------- ATOM + RESIDUE
//                  Debug.Log("ATOM+RESIDUE");
                    if(GUIDisplay.quickSelection){
                        for (int i=0; i<hballs.Length; i++){
                            if(atom.Contains(hballs[i].tag)
                                && Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue)
                                    Molecule.Model.MoleculeModel.atomsColorList[(int)hballs[i].number] = col;
                        }
                    }else{
                        for (int i=0; i<hballs.Length; i++){
                            if(atom.Contains(Molecule.Model.MoleculeModel.atomsNamelist[(int)hballs[i].number])
                                && Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue)
                                    Molecule.Model.MoleculeModel.atomsColorList[(int)hballs[i].number] = col;
                        }
                    }
                }
                else{
        // ---------- ATOM + RESIDUE + CHAIN
//                  Debug.Log("ATOM+RESIDUE+CHAIN");
                    if(GUIDisplay.quickSelection){
                        for (int i=0; i<hballs.Length; i++){
                            if(atom.Contains(hballs[i].tag)
                                && Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue
                                && Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                                    Molecule.Model.MoleculeModel.atomsColorList[(int)hballs[i].number] = col;   
                        }
                    }else{
                        for (int i=0; i<hballs.Length; i++){
                            if(atom.Contains(Molecule.Model.MoleculeModel.atomsNamelist[(int)hballs[i].number])
                                && Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue
                                && Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                                    Molecule.Model.MoleculeModel.atomsColorList[(int)hballs[i].number] = col;   
                        }
                    }
                }
            }
        }
        else{
            if(residue == "All"){
                if(chain == "All"){
        // ---------- EVERYTHING
//                  Debug.Log("EVERYTHING");
                    for (int i=0; i<hballs.Length; i++)
                        Molecule.Model.MoleculeModel.atomsColorList[(int)hballs[i].number] = col;
                }
                else{
        // ---------- CHAIN
//                  Debug.Log("CHAIN");
                    for (int i=0; i<hballs.Length; i++){
                        if(Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                            Molecule.Model.MoleculeModel.atomsColorList[(int)hballs[i].number] = col;   
                    }
                }
            }
            else{
                if(chain == "All"){
        // ---------- RESIDUE
//                  Debug.Log("RESIDUE");
                    for (int i=0; i<hballs.Length; i++){
                        if(Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue){
                            Molecule.Model.MoleculeModel.atomsColorList[(int)hballs[i].number] = col;       
                        }
                    }
                }
                else{
        // ---------- CHAIN + RESIDUE
//                  Debug.Log("RESIDUE+CHAIN");
                    for (int i=0; i<hballs.Length; i++){
                        if(Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue
                            && Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                                Molecule.Model.MoleculeModel.atomsColorList[(int)hballs[i].number] = col;
                    }
                }
            }
        }
        
        BallUpdate.resetColors = true;
//      BallUpdate.bondsReadyToBeReset = true;
    }
    
    public override void SetColor(Color col, int atomNum) { 
        for (int i=0; i<hballs.Length; i++){
            if(hballs[i].GetComponent<BallUpdate>().number == atomNum)
                Molecule.Model.MoleculeModel.atomsColorList[(int)hballs[i].number] = col;
        }
        BallUpdate.resetColors = true;
    }
    
        public override void SetRadii(List<string> atom, string residue = "All", string chain = "All") {
            if(!atom.Contains ("All")){
                if(residue == "All"){
                    if(chain == "All"){
            // ---------- ATOM
                        if(GUIDisplay.quickSelection){
                            for (int i=0; i<hballs.Length; i++) {
                                if(atom.Contains(hballs[i].tag))
                                    Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number] = (GUIDisplay.newScale);
                            }
                        }else{
                            for (int i=0; i<hballs.Length; i++) {
                                if(atom.Contains(Molecule.Model.MoleculeModel.atomsNamelist[(int)hballs[i].number]))
                                    Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number] = (GUIDisplay.newScale);
                                }
                        }
                    }
                    else{
            // ---------- ATOM + CHAIN
                        if(GUIDisplay.quickSelection){
                            for (int i=0; i<hballs.Length; i++) {
                                if(atom.Contains(hballs[i].tag)
                                    && Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                                        Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number] = (GUIDisplay.newScale);        
                            }
                        }else{
                            for (int i=0; i<hballs.Length; i++) {
                                if(atom.Contains(Molecule.Model.MoleculeModel.atomsNamelist[(int)hballs[i].number])
                                    && Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                                        Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number] = (GUIDisplay.newScale);        
                            }
                        }
                    }
                }
                else{
                    if(chain == "All"){
            // ---------- ATOM + RESIDUE
                        if(GUIDisplay.quickSelection){
                            for (int i=0; i<hballs.Length; i++) {
                                if(atom.Contains(hballs[i].tag)
                                    && Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue)
                                        Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number] = (GUIDisplay.newScale);
                            }
                        }else{
                            for (int i=0; i<hballs.Length; i++) {
                                if(atom.Contains(Molecule.Model.MoleculeModel.atomsNamelist[(int)hballs[i].number])
                                    && Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue)
                                        Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number] = (GUIDisplay.newScale);
                            }
                        }
                    }
                    else{
            // ---------- ATOM + CHAIN + RESIDUE
                        if(GUIDisplay.quickSelection){
                            for (int i=0; i<hballs.Length; i++) {
                                if(atom.Contains(hballs[i].tag) 
                                    && Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue
                                    && Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                                        Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number] = (GUIDisplay.newScale);        
                            }
                        }else{
                            for (int i=0; i<hballs.Length; i++) {
                                if(atom.Contains(Molecule.Model.MoleculeModel.atomsNamelist[(int)hballs[i].number])
                                    && Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue
                                    && Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                                        Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number] = (GUIDisplay.newScale);        
                            }
                        }
                    }
                }
            }
            else{
                if(residue == "All"){
                    if(chain == "All"){
            // ---------- EVERYTHING
                        for (int i=0; i<hballs.Length; i++) {
                            Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number] = (GUIDisplay.newScale);
                        }
                    }
                    else{
            // ---------- CHAIN
                        for (int i=0; i<hballs.Length; i++) {
                            if(Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                                Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number] = (GUIDisplay.newScale);        
                        }
                    }
                }
                else{
                    if(chain == "All"){
            // ---------- RESIDUE
                        for (int i=0; i<hballs.Length; i++) {
                            if(Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue)
                                Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number] = (GUIDisplay.newScale);
                        }
                    }
                    else{
            // ---------- CHAIN + RESIDUE
                        for (int i=0; i<hballs.Length; i++) {
                            if(Molecule.Model.MoleculeModel.atomsResnamelist[(int)hballs[i].number] == residue
                                && Molecule.Model.MoleculeModel.atomsChainList[(int)hballs[i].number] == chain)
                                    Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number] = (GUIDisplay.newScale);    
                        }
                    }
                }
            }
            BallUpdate.resetRadii = true;
            BallUpdate.bondsReadyToBeReset = true;
        }
        
        public override void SetRadii(int id) {
            for (int i=0; i<hballs.Length; i++) {
                if((int)hballs[i].number == id)
                    Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number] = (GUIDisplay.newScale);
            }
            BallUpdate.resetRadii = true;
            BallUpdate.bondsReadyToBeReset = true;
        }
    
    public Color GetColor(Vector3 pos){
        for (int i=0; i<hballs.Length; i++)
            if(hballs[i].transform.position == pos)
                return hballs[i].GetComponent<Renderer>().material.GetColor("_Color");
        return Color.white;
    }
    
    public override GameObject GetBall(int id){
        return hballs[id].gameObject;
    }
    
    
    private void MoveNetworkNodes() {
        for (int i=0; i<hballs.Length; i++)
            hballs[i].transform.localPosition = new Vector3(hballs[i].transform.localPosition.x,hballs[i].transform.localPosition.y, hballs[i].z * depthFactor);
    }
    
    public override void ResetPositions(){
        if(hballs == null){
            Init();
        }
        for (int j=0; j<hballs.Length; j++){
            int i = (int)hballs[j].number;
            hballs[j].transform.localPosition = new Vector3(MoleculeModel.atomsLocationlist[i][0], 
                                                            MoleculeModel.atomsLocationlist[i][1],
                                                            MoleculeModel.atomsLocationlist[i][2]);
        }
        BallUpdate.bondsReadyToBeReset = true;
        Molecule.View.DisplayMolecule.ChangeRepresentation(UIData.atomtype,UIData.bondtype);
    }
    
    public override void ResetIMDSimulationPositions(){
        for (int j=0; j<hballs.Length; j++){
            int i = (int)hballs[j].number;
            hballs[j].transform.localPosition = MoleculeModel.atomsIMDSimulationLocationlist[i];
        }
    }
    
    public override void ResetRadii() {
        if(UIData.atomtype == UIData.AtomType.hyperball){
            hballs = GameObject.FindObjectsOfType(typeof(BallUpdateHB)) as BallUpdateHB[];
            //T.T sometimes this list is not initialized. So we initialise it here.
            
            if (Molecule.Model.MoleculeModel.atomsLocalScaleList.Count==0){
                for (int i=0; i<(Molecule.Model.MoleculeModel.atomsTypelist.Count); i++){
                    Molecule.Model.MoleculeModel.atomsLocalScaleList.Add(GUIDisplay.newScale);
                }
            }

            //C.R 
            if (Molecule.Model.MoleculeModel.atomsLocalScaleList.Count < hballs[0].number+1){
                for(int i=(Molecule.Model.MoleculeModel.atomsLocalScaleList.Count)+1; i<=hballs[0].number+1; i++){
                    Molecule.Model.MoleculeModel.atomsLocalScaleList.Add(GUIDisplay.newScale);
                }
            }           
             
            for (int i=0; i<hballs.Length; i++) {
                if (UIData.secondarystruct){
                    if(SecondaryStructureOldGUI.structType == "B Factor"){
                        if (hballs[i].rayon == 3.7f){
                            hballs[i].GetComponent<Renderer>().material.SetFloat("_Rayon", hballs[i].rayon 
                                * (SecondaryStructureOldGUI.highBFradius)
                                                          * (RepresentationOldGUI.globalRadius)
                                                          * (Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number]/100));}
                        else{
                            hballs[i].GetComponent<Renderer>().material.SetFloat("_Rayon", hballs[i].rayon 
                                                          * (RepresentationOldGUI.globalRadius)
                                                          * (Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number]/100));
                        }
                    }
                    else
                    hballs[i].GetComponent<Renderer>().material.SetFloat("_Rayon", hballs[i].rayon 
                                                  * (RepresentationOldGUI.globalRadius)
                                                  * (Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number]/100));
                }
                else{
                    hballs[i].GetComponent<Renderer>().material.SetFloat("_Rayon", Molecule.Model.MoleculeModel.atomsTypelist[(int)hballs[i].number].radius 
                                                  * (RepresentationOldGUI.globalRadius)
                                                  * (Molecule.Model.MoleculeModel.atomsLocalScaleList[(int)hballs[i].number]/100));
                }
            }
            BallUpdate.oldRadiusFactor = BallUpdate.radiusFactor;
        }
    }
    
    private void CreateMouseOvers() {
        
        for (int i=0; i<hballs.Length; i++) {
            hballs[i].gameObject.AddComponent<MouseOverMolecule>();
        }
        mouseOvers = true;
    }
    
    private void DestroyMouseOvers() {
        hballs = GameObject.FindObjectsOfType(typeof(BallUpdateHB)) as BallUpdateHB[];
        for (int i=0; i<hballs.Length; i++) {
            Destroy(hballs[i].GetComponent<MouseOverMolecule>());
        }
        mouseOvers = false;
    }
    private void ExitInteractive(){
        for (int i=0; i<hballs.Length; i++) {
            Destroy(hballs[i].GetComponent<SpringJoint>());
            Destroy(hballs[i].GetComponent<Rigidbody>());
        }
        ResetPositions();
        ResetColors();
    }
    
    public void CreateMouseOversIMDSimulation() {
        for (int i=0; i<hballsGameObjects.Length; i++) {
            MouseOverMoleculeIMDSimulation mover = (MouseOverMoleculeIMDSimulation) hballsGameObjects[i].AddComponent<MouseOverMoleculeIMDSimulation>();
            mover.setAtomId(i);
        }
        mouseOvers = true;
    }

    public void DestroyMouseOversIMDSimulation() {
        hballs = GameObject.FindObjectsOfType(typeof(BallUpdateHB)) as BallUpdateHB[];
        for (int i=0; i<hballsGameObjects.Length; i++) {
            Destroy(hballsGameObjects[i].GetComponent<MouseOverMoleculeIMDSimulation>());
        }
        mouseOvers = false;
    }
    
    private void StartPhysicsManagement(){
        for (int i=0; i<hballs.Length; i++) {
            if(!hballs[i].GetComponent<Rigidbody>())
                hballs[i].gameObject.AddComponent<Rigidbody>();
            if(!hballs[i].GetComponent<SpringJoint>())
                hballs[i].gameObject.AddComponent<SpringJoint>();
        }
    }
    private void ManagePhysics() {

        if(UIData.toggleGray) {
            for (int i=0; i<hballs.Length; i++) {
                float v = hballs[i].GetComponent<Rigidbody>().velocity.magnitude;
            
                Color c = Color.Lerp(Color.white, Color.black, v);
                hballs[i].GetComponent<Renderer>().material.SetColor("_Color", c); // ugly

            }
            wasInteractiveColored = true;
        }
        else if(wasInteractiveColored){
            for (int i=0; i<hballs.Length; i++) {
                hballs[i].GetComponent<Renderer>().material.SetColor("_Color", Molecule.Model.MoleculeModel.atomsColorList[(int)hballs[i].number]);
            }
            wasInteractiveColored = false;
        }
    }
    
    
    public override void DisableRenderers() {
        Debug.Log("HBallManager: Disabling renderers");
        if (GUIMoleculeController.toggle_IMD)
        {
            DestroyMouseOversIMDSimulation();
        }
        hballs = GameObject.FindObjectsOfType(typeof(BallUpdateHB)) as BallUpdateHB[];
        for (int i=0; i<hballs.Length; i++){
            //if(hb)
            hballs[i].GetComponent<Renderer>().enabled = false;
            if(UIData.atomtype != UIData.AtomType.particleball) // Particles don't have their own collider so we must keep it
                hballs[i].GetComponent<Collider>().enabled = false; // Disable the collider at the same time to avoid ghost-clicking with atom selection
        }
//      DeactivateBases();
        DeactivateEllipsoids();
        
        enabled = false;
    }

    
    public override void EnableRenderers(){
        if (GUIMoleculeController.toggle_IMD)
        {
            CreateMouseOversIMDSimulation();
        }
        UnityMolMain.setCurrentAtomManager(this);
        hballs = GameObject.FindObjectsOfType(typeof(BallUpdateHB)) as BallUpdateHB[];
        //if(UIData.atomtype != UIData.AtomType.hyperball)
        //  return;
        
        for (int i=0; i<hballs.Length; i++){
            //if(hb)
            hballs[i].GetComponent<Renderer>().enabled = true;
            hballs[i].GetComponent<Collider>().enabled = true;
        }
        
        Debug.Log("HBallManager: Enabling renderer");
        enabled = true;
    }

    public override void EnableShadows(){
        hballs = GameObject.FindObjectsOfType(typeof(BallUpdateHB)) as BallUpdateHB[];
        for(int i=0; i<hballs.Length; i++){
            hballs[i].GetComponent<Renderer>().shadowCastingMode = ShadowCastingMode.On;
            hballs[i].GetComponent<Renderer>().receiveShadows = true;
            hballs[i].GetComponent<Renderer>().material.shader = Shader.Find("FvNano/HyperBalls Shadow GL_D3D");
        }
    }

    public override void DisableShadows(){
        hballs = GameObject.FindObjectsOfType(typeof(BallUpdateHB)) as BallUpdateHB[];
        for(int i=0; i<hballs.Length; i++){
            hballs[i].GetComponent<Renderer>().shadowCastingMode = ShadowCastingMode.Off;
            hballs[i].GetComponent<Renderer>().receiveShadows = false;
            hballs[i].GetComponent<Renderer>().material.shader = Shader.Find("FvNano/HyperBalls GL_D3D");

        }
    }


    
    private void ResetBrightness() {
        for(int i=0; i<hballs.Length; i++)
            hballs[i].GetComponent<Renderer>().material.SetFloat("_Brightness", brightness);
        
        HStickManager.resetBrightness = true;
        HStickMeshManager.resetBrightness = true;
        resetBrightness = false;
    }
    

    void Update () {
        if (UIData.isHBallLoaded == true && ellipsoidsInitialized == false && UIData.ffType == UIData.FFType.HiRERNA)
        {
            GenerateEllipsoids();
        }
        
        //if(UIData.atomtype != UIData.AtomType.hyperball) {
        //  DisableRenderers();
        //}
            
        if(BallUpdate.resetColors && !Molecule.Model.MoleculeModel.networkLoaded){
//          Debug.Log("HBALL RESETCOLOR CALL" + UIData.atomtype);
            ResetColors();
        }
        
        if(resetBrightness)
            ResetBrightness();
        
        if (xgmml && (oldDepthFactor!=depthFactor)) {
            MoveNetworkNodes();
            oldDepthFactor=depthFactor;
        }

        if(mouseOvers && !GUIMoleculeController.toggle_NA_INTERACTIVE ){
            DestroyMouseOvers();
            ExitInteractive();
        }

        if(GUIMoleculeController.toggle_NA_INTERACTIVE) {
            if(!mouseOvers) {
                CreateMouseOvers();
                StartPhysicsManagement();
            }

            ManagePhysics();
        }



        if( UIData.isFileLoaded && ( (BallUpdate.oldRadiusFactor != BallUpdate.radiusFactor) || BallUpdate.resetRadii ||
            (UIData.bondtype == UIData.BondType.hyperstick && (StickUpdate.shrink != StickUpdate.oldshrink)
                                                || (StickUpdate.scale != StickUpdate.oldscale)) ) ) {
            if(UIData.atomtype == UIData.AtomType.hyperball) {
                ResetRadii();
                BallUpdate.resetRadii = false;
            }
            if(UIData.bondtype == UIData.BondType.hyperstick)
                HStickManager.adjustRadii = true;
        }
        
        if (GUIMoleculeController.toggle_IMD && ellipsoidView)
        {
//          Debug.Log(">>>>>>>>>>>>>>>Update Ellipsoids");
            UpdateEllipsoids();
        }
        if(resetShininess)
            ResetShininess();
/*      if(UIData.EnableUpdate){ // not sure what that's for
            
        }
*/
    }
    
    //
    // HiRERNA
    //
    
    public Vector3 computeEllipsoidPosition(int residueId)
    {
        int[] atoms = MoleculeModel.atomsForEllipsoidsPerResidue[residueId];
        
        Vector3 sum = new Vector3(0.0f, 0.0f, 0.0f);
        int currentAtomId = 0;
        int nbOfAtoms = 0;
        for (int i = 0; i < 3; i++) {
            currentAtomId = atoms[i];
            if (allowedAtomsForPosition.Contains(MoleculeModel.atomsNamelist[currentAtomId])) {
                GameObject go = hballsGameObjects[currentAtomId] as GameObject;
                sum += go.transform.position;
                nbOfAtoms += 1;
            }
        }
        
        return sum / nbOfAtoms;
    }
    
    public Vector3 computeEllipsoidNormal(int residueId)
    {
        int[] atoms = MoleculeModel.atomsForEllipsoidsPerResidue[residueId];
        
        GameObject go = hballsGameObjects[atoms[0]] as GameObject;
        Vector3 point1 = go.transform.position;
        
        go = hballsGameObjects[atoms[1]] as GameObject;
        Vector3 point2 = go.transform.position;
        
        go = hballsGameObjects[atoms[2]] as GameObject;
        Vector3 point3 = go.transform.position;
        
        //      Vector3 planeNormal = 
        
        //      float angleXY = 180 * Mathf.Acos(Vector3.Dot (planeNormal, new Vector3(0.0f, 0.0f, 1.0f)) / planeNormal.magnitude) / Mathf.PI;
        //      float angleXZ = 180 * Mathf.Acos(Vector3.Dot (planeNormal, new Vector3(0.0f, 1.0f, 0.0f)) / planeNormal.magnitude) / Mathf.PI;
        //      float angleYZ = 180 * Mathf.Acos(Vector3.Dot (planeNormal, new Vector3(1.0f, 0.0f, 0.0f)) / planeNormal.magnitude) / Mathf.PI;
        
        //      Debug.Log (angleXY);
        //      Debug.Log (angleXZ);
        //      Debug.Log (angleYZ);
        
        return Vector3.Cross(point2 - point1, point3 - point1).normalized;
    }
    
    public Vector3 computeEllipsoidOrientation(int residueId)
    {
        return (hballsGameObjects[MoleculeModel.atomsForEllipsoidsOrientationPerResidue[residueId]].transform.position - MoleculeModel.ellipsoidsPerResidue[residueId].transform.position).normalized;
    }
    
    public void findAtoms()
    {
        // Traverse "residues" (in fact, these are nucleotides)
        Debug.Log("Finding atoms");
        foreach (KeyValuePair<int, ArrayList> entry in MoleculeModel.residues)
        {
            int nbOfAtoms = entry.Value.Count;
            
            int currentAtomId = 0;
            string currentAtomName;
            string currentResidueName;
            
            int i = 0;
            List<int> triplet = new List<int>();
            while (i != nbOfAtoms)
            {
                currentAtomId = (int)entry.Value[i];
                currentAtomName = MoleculeModel.atomsNamelist[currentAtomId];
                currentResidueName = MoleculeModel.atomsResnamelist[currentAtomId]; // Could potentially be out of this loop
                
                // For bases G and A, ellipsoid is computed from the triplet CY-G1-G2 or CY-A1-A2
                // For U and C, we use CA-CY-C1 or CA-CY-U1
                if (currentResidueName == "G" || currentResidueName == "A") {
                    if (currentAtomName == "CY" || currentAtomName == "G1" || currentAtomName == "G2" || currentAtomName == "A1" || currentAtomName == "A2") {
                        triplet.Add (currentAtomId);
                    }
                }
                else
                {
                    if (currentAtomName == "CY" || currentAtomName == "CA" || currentAtomName == "C1" || currentAtomName == "U1") {
                        triplet.Add (currentAtomId);
                    }
                }
                
                if (triplet.Count == 3)
                {
                    i = nbOfAtoms;
                }
                else
                {
                    i++;
                }
            }
            MoleculeModel.atomsForEllipsoidsPerResidue[entry.Key] = triplet.ToArray();
            
            i = 0;
            while (i != nbOfAtoms)
            {
                currentAtomId = (int)entry.Value[i];
                currentAtomName = MoleculeModel.atomsNamelist[currentAtomId];
                if (currentAtomName == "CA")
                {
//                  Debug.Log ("Residue: " + entry.Key);
//                  Debug.Log ("Found CA atom");
                    MoleculeModel.atomsForEllipsoidsOrientationPerResidue[entry.Key] = currentAtomId;
                    i = nbOfAtoms;
                }
                else
                {
                    i++;
                }
            }
        }
    }
    
    public void findBonds()
    {
        // Find bonds associated with base atoms
        StickUpdate[] sticks = GameObject.FindObjectsOfType(typeof(StickUpdate)) as StickUpdate[];
        MoleculeModel.bondsForReplacedAtoms.Clear();
        int nbOfSticks = sticks.Length;
        for (int i = 0; i < nbOfSticks; i++)
        {   
            int atomNumber1 = sticks[i].atomnumber1;
            int atomNumber2 = sticks[i].atomnumber2;
            
            if (   MoleculeModel.atomsTypelist[atomNumber1].type == "X"
                || MoleculeModel.atomsTypelist[atomNumber2].type == "X"
                || MoleculeModel.atomsNamelist[atomNumber1] == "CY"
                || MoleculeModel.atomsNamelist[atomNumber2] == "CY")
            {
                MoleculeModel.bondsForReplacedAtoms.Add(sticks[i].gameObject);
            }
        }
    }
    
    public void UpdateEllipsoids()
    {
        foreach (KeyValuePair<int, GameObject> entry in MoleculeModel.ellipsoidsPerResidue)
        {
            GameObject Atom = entry.Value;
            
            Vector3 pos = computeEllipsoidPosition(entry.Key);
            Atom.transform.position = pos;
            
            Vector3 normal = computeEllipsoidNormal(entry.Key);
            Atom.transform.forward = normal;

            Atom.transform.LookAt(hballsGameObjects[MoleculeModel.atomsForEllipsoidsOrientationPerResidue[entry.Key]].transform.position, normal);
        }
    }
    
    public void GenerateEllipsoids()
    {
        findAtoms();
        
        findBonds();
        
        string currentResidueName;
                
        GameObject Atom;
        
        // Create ellipsoid game objects and bonds
        foreach (KeyValuePair<int, ArrayList> entry in MoleculeModel.residues)
        {
            Atom = GameObject.CreatePrimitive(PrimitiveType.Cube);

            Atom.GetComponent<Renderer>().material.shader = Shader.Find("FvNano/HyperBalls GL_D3D");

            Atom.AddComponent<BallUpdate>();
            BallUpdate comp = Atom.GetComponent<BallUpdate>();
            
            currentResidueName = MoleculeModel.atomsResnamelist[(int)entry.Value[0]];
            
            if (currentResidueName == "C") {
                Atom.GetComponent<Renderer>().material.SetColor("_Color", Color.yellow);
            }
            else if (currentResidueName == "G") {
                Atom.GetComponent<Renderer>().material.SetColor("_Color", Color.green);
            }
            else if (currentResidueName == "A") {
                Atom.GetComponent<Renderer>().material.SetColor("_Color", Color.red);
            }
            else if (currentResidueName == "U") {
                Atom.GetComponent<Renderer>().material.SetColor("_Color", new Color(0.7f, 0.7f, 0.98f));
            }
            
            comp.rayon = 1.0f;
            comp.SetRayonFactor(1.0f);
            Atom.GetComponent<Renderer>().material.SetFloat("_Rayon", 1.0f);
            Atom.GetComponent<Renderer>().material.SetVector("_Equation", new Vector4(1.0f, 1.0f, 1.0f, 1.0f));
            
            Atom.GetComponent<Renderer>().transform.localScale = new Vector3(3.0f, 1.5f, 4.0f);
            
//          Atom.AddComponent<Projector>();
            comp.enabled = true;
            
            MoleculeModel.ellipsoidsPerResidue[entry.Key] = Atom;
            MoleculeModel.ellipsoids.Add(Atom);
        }
        
        UpdateEllipsoids();

        ellipsoidsInitialized = true;
        DeactivateEllipsoids();
    }
    
    public void ActivateBases()
    {
        // Enable base atoms and bonds, then disable ellipsoids
//      GameObject[] baseAtoms = MoleculeModel.atomsByChar["X"];
//      for (int i = 0; i < baseAtoms.Length; i++)
//      {
//              baseAtoms[i].SetActive(true);
//          baseAtoms[i].renderer.enabled = true;
//      }
        foreach (KeyValuePair<int, int[]> entry in MoleculeModel.atomsForEllipsoidsPerResidue)
        {
            for(int i = 0; i < entry.Value.Length; i++)
            {
                if (allowedAtomsForPosition.Contains(MoleculeModel.atomsNamelist[entry.Value[i]])) {
                    GameObject go = hballsGameObjects[entry.Value[i]] as GameObject;
                    go.GetComponent<Renderer>().enabled = true;
                }
            }
        }
        
        for (int i = 0; i < MoleculeModel.bondsForReplacedAtoms.Count; i++)
        {
            //              MoleculeModel.bondsForReplacedAtoms[i].SetActive(true);
            MoleculeModel.bondsForReplacedAtoms[i].GetComponent<Renderer>().enabled = true;
        }
    }
    
    public void DeactivateBases()
    {
        // Disable base atoms and bonds, then enable ellipsoids
//      GameObject[] baseAtoms = MoleculeModel.atomsByChar["X"];
//      for (int i = 0; i < baseAtoms.Length; i++)
//      {
            //              baseAtoms[i].SetActive(false);
//          baseAtoms[i].renderer.enabled = false;
//      }
        foreach (KeyValuePair<int, int[]> entry in MoleculeModel.atomsForEllipsoidsPerResidue)
        {
            for(int i = 0; i < entry.Value.Length; i++)
            {
                if (allowedAtomsForPosition.Contains(MoleculeModel.atomsNamelist[entry.Value[i]])) {
                    GameObject go = hballsGameObjects[entry.Value[i]] as GameObject;
                    go.GetComponent<Renderer>().enabled = false;
                }
            }
        }
        
        for (int i = 0; i < MoleculeModel.bondsForReplacedAtoms.Count; i++)
        {
//          MoleculeModel.bondsForReplacedAtoms[i].SetActive(false);
            if (MoleculeModel.bondsForReplacedAtoms[i])
            {
                MoleculeModel.bondsForReplacedAtoms[i].GetComponent<Renderer>().enabled = false;
            }
        }
    }
    
    public void ActivateEllipsoids()
    {
        if (ellipsoidsInitialized == false)
            return;
        for (int i = 0; i < MoleculeModel.ellipsoids.Count(); i++)
        {
            MoleculeModel.ellipsoids[i].GetComponent<Renderer>().enabled = true;
        }
    }
    
    public void DeactivateEllipsoids()
    {
        if (ellipsoidsInitialized == false)
            return;
        for (int i = 0; i < MoleculeModel.ellipsoids.Count(); i++)
        {
            MoleculeModel.ellipsoids[i].GetComponent<Renderer>().enabled = false;
        }
    }
    
    public void RenderEllipsoids()
    {
        DeactivateBases();
        
        ActivateEllipsoids();
    }
    
    public void RenderAtoms()
    {
        DeactivateEllipsoids();
        
        ActivateBases();
    }
    
    public void SwitchRendering()
    {
        ellipsoidView = !ellipsoidView;
        if (ellipsoidView == true)
        {
            RenderEllipsoids();
        }
        else
        {
            RenderAtoms();
        }
    }

    public void ResetShininess(){
        for(int i=0; i<hballs.Length; i++)
            hballs[i].GetComponent<Renderer>().material.SetFloat("_Shininess", shininess);
        
        resetShininess = false;
        HStickMeshManager.shininess = shininess;
        HStickManager.shininess = shininess;
        HStickMeshManager.resetShininess = true;
        HStickManager.resetShininess = true;
    }

    // Returns the closest atom game object in space from a given position during an IMD simulation.
    public SingleAtomSelection getClosestAtomGameObject(Vector3 position) {
        BallUpdateHB closestAtom = hballs[0];
        BallUpdateHB tempAtom;

        SingleAtomSelection selection = new SingleAtomSelection();

        float minDist = Vector3.Distance(closestAtom.gameObject.transform.position, position);
        float tempDist;

        for (int i = 1; i < hballs.Length; i++) {
            tempAtom = hballs[i];
            tempDist = Vector3.Distance(tempAtom.gameObject.transform.position, position);
            if (tempDist < minDist) {
                minDist = tempDist;
                closestAtom = tempAtom;
            }
        }

        selection.go = closestAtom.gameObject;
        selection.pdbIndex = (int) closestAtom.number;

        return selection;
    }

    public override void showHydrogens(bool hide) {
        for (int j=0; j<hballs.Length; j++){
            if (hballs[j].tag=="H")
                hballs[j].GetComponent<Renderer>().enabled = !hide;
        }
    }

}