HStickManager.cs

Go to the documentation of this file.

using UnityEngine;
using UnityEngine.Rendering;

using System.Collections;
using System.Collections.Generic;
using UI;
using Molecule.Model;

public class HStickManager : GenericManager {
    public static StickUpdate[] sticks;
    
    public static bool xgmml = false;
    public static float depthFactor = 1.0f;
    public static bool resetBrightness = false;
    public static bool adjustRadii = false;
    private static float oldDepthFactor = 1.0f;
    public static float shininess = 0.0f;
    public static bool resetShininess = false;
    private static bool wasInteractive = false;
    private static bool wasInteractiveColored = false;


    private Material[] stickMaterials;

    // Use this for initialization
    public override void Init () {
        if(UI.GUIDisplay.file_extension=="xgmml")
            xgmml = true;

        sticks = GameObject.FindObjectsOfType(typeof(StickUpdate)) as StickUpdate[];
        BallUpdate.bondsReadyToBeReset = true;
        enabled = true;

        stickMaterials = new Material[sticks.Length];

        for (int i=0; i< sticks.Length; i++){
            sticks[i].GetComponent<Renderer>().enabled = true;
            sticks[i].GetComponent<Renderer>().shadowCastingMode = ShadowCastingMode.Off;
            sticks[i].GetComponent<Renderer>().receiveShadows = false;
            stickMaterials[i] = sticks[i].GetComponent<Renderer>().material;
        }
        isInit = true;

    }
    
    public override void DestroyAll() {
        sticks = GameObject.FindObjectsOfType(typeof(StickUpdate)) as StickUpdate[];
        for(int i=0;i<sticks.Length;i++)
            GameObject.Destroy(sticks[i].gameObject);
        isInit = false;
    }
    
    public override void SetColor(Color col, List<string> atoms, string residue = "All", string chain = "All"){}
    public override void SetColor(Color col, int atomNum){}
    public override void SetRadii(List<string> atoms, string residue = "All", string chain = "All"){}
    public override void SetRadii(int atomNum){}
    
    public override GameObject GetBall(int id){
        return null;
    }
    
    public override void ToggleDistanceCueing(bool enabling) {
        if(UIData.bondtype != UIData.BondType.hyperstick)
            return;
        float attenuation;
        attenuation = enabling? 1f : 0f;
        
        //for (int i=0; i< sticks.Length; i++)
        for (int i=0; i< sticks.Length; i++)
            stickMaterials[i].SetFloat("_Attenuation", attenuation);
    }
    
    
    private void ResetColors() {
        if(UIData.bondtype == UIData.BondType.hyperstick){
            // sticks = GameObject.FindObjectsOfType(typeof(StickUpdate)) as StickUpdate[];

            for (int i=0; i< sticks.Length; i++) {
                Color atom1Color = MoleculeModel.atomsColorList[sticks[i].atomnumber1];
                Color atom2Color = MoleculeModel.atomsColorList[sticks[i].atomnumber2];

                stickMaterials[i].SetColor("_Color", atom1Color);
                stickMaterials[i].SetColor("_Color2",atom2Color);
            }
            
            BallUpdate.bondsReadyToBeReset = false;
        }
    }
    
    private void ResetTextures() {
        if(UIData.bondtype == UIData.BondType.hyperstick){
            sticks = GameObject.FindObjectsOfType(typeof(StickUpdate)) as StickUpdate[];
            if(UIData.atomtype == UIData.AtomType.hyperball){

                for (int i=0; i< sticks.Length; i++) {
                    stickMaterials[i].SetTexture("_MatCap", (MoleculeModel.atoms[sticks[i].atomnumber1] as GameObject).GetComponent<Renderer>().material.GetTexture("_MatCap"));
                    stickMaterials[i].SetTexture("_MatCap2", (MoleculeModel.atoms[sticks[i].atomnumber2] as GameObject).GetComponent<Renderer>().material.GetTexture("_MatCap"));
                }
            }
            else{
                for (int i=0; i< sticks.Length; i++) {
                    stickMaterials[i].SetTexture("_MatCap", (Texture)Resources.Load("lit_spheres/divers/daphz05"));
                    stickMaterials[i].SetTexture("_MatCap2", (Texture)Resources.Load("lit_spheres/divers/daphz05"));
                }   
            }
            BallUpdate.bondsReadyToBeReset = false;
        }
    }
    
    public override void ResetPositions()   {

        sticks = GameObject.FindObjectsOfType(typeof(StickUpdate)) as StickUpdate[];
        for (int i=0; i< sticks.Length; i++) {
            float[] fposAtom1 = MoleculeModel.atomsLocationlist[sticks[i].atomnumber1];
            float[] fposAtom2 = MoleculeModel.atomsLocationlist[sticks[i].atomnumber2];

            Vector3 posAtom1 = new Vector3(fposAtom1[0],fposAtom1[1],fposAtom1[2]);
            Vector3 posAtom2 = new Vector3(fposAtom2[0],fposAtom2[1],fposAtom2[2]);

            stickMaterials[i].SetVector("_TexPos1", posAtom1);
            sticks[i].transform.position = posAtom1;
            stickMaterials[i].SetVector("_TexPos2", posAtom2);
        }
    }

    public void ResetPositionsInteractive(){

        // sticks = GameObject.FindObjectsOfType(typeof(StickUpdate)) as StickUpdate[];
        for (int i=0; i< sticks.Length; i++) {

            Vector3 posAtom1 = ((GameObject)MoleculeModel.atoms[sticks[i].atomnumber1]).transform.position;
            Vector3 posAtom2 = ((GameObject)MoleculeModel.atoms[sticks[i].atomnumber2]).transform.position;

            stickMaterials[i].SetVector("_TexPos1", posAtom1);
            sticks[i].transform.position = posAtom1;
            stickMaterials[i].SetVector("_TexPos2", posAtom2);
        }
    }
    
    public void ResetColorsInteractive() {
        for (int i=0; i< sticks.Length; i++) {

            Color colAtom1 = ((GameObject)MoleculeModel.atoms[sticks[i].atomnumber1]).GetComponent<Renderer>().sharedMaterial.color;
            Color colAtom2 = ((GameObject)MoleculeModel.atoms[sticks[i].atomnumber2]).GetComponent<Renderer>().sharedMaterial.color;

            stickMaterials[i].SetColor("_Color", colAtom1);
            stickMaterials[i].SetColor("_Color2",colAtom2);
        }
    }
    public override void ResetIMDSimulationPositions() {
        Vector3 atomOne = Vector3.zero;
        Vector3 atomTwo = Vector3.zero;

        for(int i=0;i<Molecule.Model.MoleculeModel.bondEPList.Count;i++){
            Vector3 posAtom1 = MoleculeModel.atomsIMDSimulationLocationlist[sticks[i].atomnumber1];
            Vector3 posAtom2 = MoleculeModel.atomsIMDSimulationLocationlist[sticks[i].atomnumber2];

            stickMaterials[i].SetVector("_TexPos1", posAtom1);
            sticks[i].transform.position = posAtom1;
            stickMaterials[i].SetVector("_TexPos2", posAtom2);
        }       
    }
    public override void ResetRadii() {
        adjustRadii = false;
        // sticks = GameObject.FindObjectsOfType(typeof(StickUpdate)) as StickUpdate[];
        // if(UIData.atomtype == UIData.AtomType.hyperball) {
            for(int i=0;i<sticks.Length;i++){


                int idAtom1 = sticks[i].atomnumber1;
                int idAtom2 = sticks[i].atomnumber2;
                float oriRadius1 = Molecule.Model.MoleculeModel.atomsTypelist[idAtom1].radius;
                float oriRadius2 = Molecule.Model.MoleculeModel.atomsTypelist[idAtom2].radius;
            
                float radiusAtom1 = oriRadius1 * RepresentationOldGUI.globalRadius * Molecule.Model.MoleculeModel.atomsLocalScaleList[idAtom1]/100;
                float radiusAtom2 = oriRadius2 * RepresentationOldGUI.globalRadius * Molecule.Model.MoleculeModel.atomsLocalScaleList[idAtom2]/100;


                //if it's not a network
                if(!xgmml){


                    stickMaterials[i].SetFloat("_Rayon1", radiusAtom1);
                    stickMaterials[i].SetFloat("_Rayon2", radiusAtom2);
                //if it's a network, we had to reduce de size of stick (otherwise it looks like a licornice representation)
                }else{
                //  Debug.Log(sticks[i].atompointer1.renderer.material.GetFloat("_Rayon")/2);
                    stickMaterials[i].SetFloat("_Rayon1", radiusAtom1/2);
                    stickMaterials[i].SetFloat("_Rayon2", radiusAtom2/2);
                }
                // Might not be necessary anymore.
                sticks[i].oldrayon1 = radiusAtom1;
                sticks[i].oldrayon2 = radiusAtom2;
            }
        // }
        // else if(UIData.atomtype == UIData.AtomType.optihb){

        //  for(int i=0;i<Molecule.Model.MoleculeModel.bondEPList.Count;i++){
        //      int idAtom1 = Molecule.Model.MoleculeModel.bondEPList[i][0];
        //      int idAtom2 = Molecule.Model.MoleculeModel.bondEPList[i][1];
        //      float oriRadius1 = Molecule.Model.MoleculeModel.atomsTypelist[idAtom1].radius;
        //      float oriRadius2 = Molecule.Model.MoleculeModel.atomsTypelist[idAtom2].radius;

        //      if(!xgmml){
        //          sticks[i].GetComponent<Renderer>().material.SetFloat("_Rayon1",oriRadius1
        //                                                              * RepresentationOldGUI.globalRadius
        //                                                              * Molecule.Model.MoleculeModel.atomsLocalScaleList[idAtom1]/100);

        //          sticks[i].GetComponent<Renderer>().material.SetFloat("_Rayon2",oriRadius2
        //                                                              * RepresentationOldGUI.globalRadius
        //                                                              * Molecule.Model.MoleculeModel.atomsLocalScaleList[idAtom2]/100);
        //      }
        //      else{
        //          sticks[i].GetComponent<Renderer>().material.SetFloat("_Rayon1",(oriRadius1
        //                                                              * RepresentationOldGUI.globalRadius
        //                                                              * Molecule.Model.MoleculeModel.atomsLocalScaleList[idAtom1]/100)/2);

        //          sticks[i].GetComponent<Renderer>().material.SetFloat("_Rayon2",(oriRadius2
        //                                                              * RepresentationOldGUI.globalRadius
        //                                                              * Molecule.Model.MoleculeModel.atomsLocalScaleList[idAtom2]/100)/2);
        //      }
        //  }

        // }
        // else {
        //  for (int i=0; i< sticks.Length; i++) {
        //      sticks[i].GetComponent<Renderer>().material.SetFloat("_Rayon1", sticks[i].atompointer1.transform.lossyScale.x/2);
        //      sticks[i].GetComponent<Renderer>().material.SetFloat("_Rayon2", sticks[i].atompointer2.transform.lossyScale.x/2);
                
        //      sticks[i].oldrayon1 = sticks[i].atompointer1.transform.lossyScale.x/2;
        //      sticks[i].oldrayon2 = sticks[i].atompointer2.transform.lossyScale.x/2;
        //  }           
        // }
    }
    
    public override void EnableRenderers() {
        UnityMolMain.setCurrentBondManager(this);
        for (int i=0; i< sticks.Length; i++)
            sticks[i].GetComponent<Renderer>().enabled = true;
        enabled = true;
    }
    
    public override void DisableRenderers() {
        sticks = GameObject.FindObjectsOfType(typeof(StickUpdate)) as StickUpdate[];
        Debug.Log("StickManager: DisableRenderers()" + sticks.Length);
        for (int i=0; i< sticks.Length; i++)
            sticks[i].GetComponent<Renderer>().enabled = false;
        enabled = false;
    }
    
    public override void EnableShadows(){
        for(int i=0; i<sticks.Length; i++){
            sticks[i].GetComponent<Renderer>().shadowCastingMode = ShadowCastingMode.On;
            sticks[i].GetComponent<Renderer>().receiveShadows = true;
            sticks[i].GetComponent<Renderer>().material.shader = Shader.Find("FvNano/HyperSticks Shadow GL_D3D");
        }
    }

    public override void DisableShadows(){
        for(int i=0; i<sticks.Length; i++){
            sticks[i].GetComponent<Renderer>().shadowCastingMode = ShadowCastingMode.Off;
            sticks[i].GetComponent<Renderer>().receiveShadows = false;
            sticks[i].GetComponent<Renderer>().material.shader = Shader.Find("FvNano/HyperSticks GL_D3D");

        }
    }
    public override void showHydrogens(bool hide){
        for(int i=0; i<sticks.Length; i++){
            int idAtom1 = sticks[i].atomnumber1;
            int idAtom2 = sticks[i].atomnumber2;
            if( Molecule.Model.MoleculeModel.atomsTypelist[idAtom1].type  == "H" ||
                      Molecule.Model.MoleculeModel.atomsTypelist[idAtom2].type == "H")
                sticks[i].GetComponent<Renderer>().enabled = ! hide;
        }
    }

    private void ResetBrightness() {
        for(int i=0; i<sticks.Length; i++)
            sticks[i].GetComponent<Renderer>().material.SetFloat("_Brightness", HBallManager.brightness);
        
        resetBrightness = false;
    }
    public void ResetShininess(){
        for(int i=0; i<sticks.Length; i++)
            sticks[i].GetComponent<Renderer>().material.SetFloat("_Shininess", shininess);
    }

    // Update is called once per frame
    void Update () {
        if(UIData.bondtype != UIData.BondType.hyperstick) {
            enabled = false;
            return;
        }
        
        if(BallUpdate.bondsReadyToBeReset){
            ResetColors();
            ResetTextures();
        }
        
        if(resetBrightness)
            ResetBrightness();
        
        if(wasInteractive && !GUIMoleculeController.toggle_NA_INTERACTIVE){
            ResetPositions();
            ResetColors();
        }
        if(GUIMoleculeController.toggle_NA_INTERACTIVE){
            if(UIData.toggleGray){
                ResetColorsInteractive();
                wasInteractiveColored = true;
            }
            else if(wasInteractiveColored){
                ResetColors();
                wasInteractiveColored = false;
            }
            ResetPositionsInteractive();
            wasInteractive = true;
        }
        
        if (xgmml && (oldDepthFactor!=depthFactor)) {
//          ResetBondVectors();
            ResetPositions();
            oldDepthFactor=depthFactor;
        }
        
        
        if(BallUpdate.resetRadii || (StickUpdate.shrink != StickUpdate.oldshrink)) {
            // for (int i=0; i< sticks.Length; i++)
                // sticks[i].GetComponent<Renderer>().material.SetFloat("_Shrink", StickUpdate.shrink);
            for(int i=0;i<sticks.Length;i++)
                stickMaterials[i].SetFloat("_Shrink",StickUpdate.shrink);
            StickUpdate.oldshrink = StickUpdate.shrink;
        }
        if(BallUpdate.resetRadii || (StickUpdate.scale != StickUpdate.oldscale)) {
            // for (int i=0; i< sticks.Length; i++)
                // sticks[i].GetComponent<Renderer>().material.SetFloat("_Scale",StickUpdate.scale);
            for(int i=0;i<sticks.Length;i++)
                stickMaterials[i].SetFloat("_Scale",StickUpdate.scale);
            StickUpdate.oldscale = StickUpdate.scale;
        }

        if(adjustRadii)
            ResetRadii();

        if(resetShininess)
            ResetShininess();
        
    }
    
}