SurfaceManager.cs

Go to the documentation of this file.

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

public class SurfaceManager {
    /**********************
     *  Static variables  *
     **********************/
    public static float brightness = 1f;
    public static float colorWeight = 0.5f;

    public static bool pdbGen = false;// bool of density grid. true when density was calculated
    public static GameObject pdb2den;
    //
    // Cut parameters
    //
    public static float cutX = 1f;
    public static float cutY = 0f;
    public static float cutZ = 0f;
    public static float depthCut = 40f;
    public static float depthCutMin = 0;
    public static float depthCutMax = 0;

    // If true, a strictly correct algorithm will be used instead of the AtomTree
    // heuristics. I don't think there's much point in doing that, since AtomTree
    // seems to produce the same results in most cases.
    private static bool slowColoring = false;
    private static List<Vector3> atomLocations;
    private static List<Color> atomColors;

    private List<GameObject> surfaceList = new List<GameObject>();
    private List<GameObject> surfacePos = new List<GameObject>();
    private List<GameObject> surfaceNeg = new List<GameObject>();

    private static GameObject VolumetricDensityObj = null;
    private static VolumetricDensity volumetricDensityscript = null;

    private AtomTree atomTree;
    private float bTime;

    private float valmin = 0;
    private float valmax = 0;
    private string bftype = "";

    public static bool surfaceInitialized = false;

    public static ColorObject SurfaceColor = new ColorObject(Color.white); // color of surface
    public static ColorObject SurfaceInsideColor = new ColorObject(Color.gray); // color of the inside of the surface   

    public static float surfaceThreshold = 0.5f;
    public static int cutMode = 0;//0 = no cut | 1 = static cut | 2 = mobile cut

    public static bool externalSurfaceTexture = false;
    public static string surfaceTextureName = null;

    public static string m_last_extSurf_Path = null;
    public static Texture2D extSurf = null;
    public static bool volumetricDensityActivated = false;



    public static bool useHetatmForSurface = false;

    public static bool useSugarForSurface = false;

    private void InitTree() {
        
        bTime = Time.realtimeSinceStartup;
        atomTree = AtomTree.Build();
    }
    public void ResetColorVertices(){
        GameObject[] surfaceObjs = getSurfaces();
        foreach(GameObject surfaceObj in surfaceObjs) {
            ResetColorVertices(surfaceObj.GetComponent<MeshFilter>().mesh);
        }
    }
    public void ResetColorVertices(Mesh mesh){
        int nbVertices = mesh.vertices.Length;
        Color32[] meshColors = new Color32[nbVertices];
        for(int i=0; i<nbVertices; i++) {
            meshColors[i] = Color.white;
        }
        mesh.colors32 = meshColors;
    }
    private void ColorVertices(Mesh mesh) {
        int nbVertices = mesh.vertices.Length;
        float valtype;
        List<float> BFactorList = MoleculeModel.BFactorList;
        Vector3[] vertices = mesh.vertices;
        Color32[] meshColors = new Color32[nbVertices];
        
        resetSurfaceColors();
        if(SurfaceManager.slowColoring) {
            List<float[]> atomLocs = MoleculeModel.atomsLocationlist;
            SurfaceManager.atomLocations = new List<Vector3>();
            for(int i=0; i<atomLocs.Count; i++) {
                SurfaceManager.atomLocations.Add(new Vector3(atomLocs[i][0], atomLocs[i][1], atomLocs[i][2]));
            }
            SurfaceManager.atomColors = MoleculeModel.atomsColorList;
        }
        
        string type;
        for(int i=0; i<nbVertices; i++) {
                type = atomTree.GetClosestAtomType(vertices[i]);
                if(UI.UIData.surfColChain){
                    Ribbons.InitCol();
                    meshColors[i] = Ribbons.GetColorChain(type);
                }
                else if(UI.UIData.surfColHydroKD){
                    HydrophobicScales.InitKyteDoo();
                    meshColors[i] = HydrophobicScales.GetColorHydro(type);
                }
                else if(UI.UIData.surfColHydroEng){
                    HydrophobicScales.InitEngleman();
                    meshColors[i] = HydrophobicScales.GetColorHydro(type);
                }

                else if(UI.UIData.surfColHydroEis){
                    HydrophobicScales.InitEisenberg();
                    meshColors[i] = HydrophobicScales.GetColorHydro(type);
                }
                else if(UI.UIData.surfColPChim){
                    HydrophobicScales.InitPhysChim();
                    meshColors[i] = HydrophobicScales.GetColorHydro(type);
                }
                else if(UI.UIData.surfColHydroWO){
                    HydrophobicScales.InitWhiteOct();
                    meshColors[i] = HydrophobicScales.GetColorHydro(type);
                }
                else if(UI.UIData.surfColBF){
                    valtype = float.Parse (type);
                    if(valmax == 0){
                        valmin = BFactorRep.GetMin(BFactorList);
                        valmax = BFactorRep.GetMax(BFactorList);
                    }
                    valtype = (valtype - valmin) / (valmax -valmin);
                    bftype = BFactorRep.GetBFStyle(valtype);
                    meshColors[i] = AtomModel.GetModel (bftype).baseColor;
                }
                else
                    meshColors[i] = MoleculeModel.GetAtomColor(type);
        }
        mesh.colors32 = meshColors;
    }
    
    private Color GetClosestAtomColor(Vector3 pos) {
        float minDist = float.MaxValue;
        Color minColor = Color.magenta;
        float dist;
        for(int i=0; i<SurfaceManager.atomLocations.Count; i++) {
            dist = Vector3.SqrMagnitude(pos - SurfaceManager.atomLocations[i]);
            Debug.Log ("dist " + dist);
            if(dist < minDist) {
                minDist = dist;
                minColor = SurfaceManager.atomColors[i];
            }
        }
        return minColor;
    }

    /*
     *  Surface Manager API
     */

    public GameObject getParentGameObject ()
    {
        return GameObject.Find("SurfaceManager");
    }

    public void ColorVertices() {
        GameObject[] surfaceObjs = getSurfaces();
        foreach(GameObject surfaceObj in surfaceObjs) {
            ColorVertices(surfaceObj.GetComponent<MeshFilter>().mesh);
        }
        float elapsed = 100f * (Time.realtimeSinceStartup - bTime);
        Debug.Log("SurfaceManager::Update Atom Color total processing time: " + elapsed.ToString());
    }
    
    public void ResetBrightness() {
        GameObject[] surfaceObjs = getSurfaces();
        for(int i=0; i<surfaceObjs.Length; i++)
            surfaceObjs[i].GetComponent<Renderer>().material.SetFloat("_Brightness", SurfaceManager.brightness);
    }
    
    public void ResetColorWeight() {
        GameObject[] surfaceObjs = getSurfaces();
        for(int i=0; i<surfaceObjs.Length; i++)
            surfaceObjs[i].GetComponent<Renderer>().material.SetFloat("_ColorWeight", SurfaceManager.colorWeight);
    }

    public static void InitCutParameters()
    {
        SurfaceManager.depthCutMin = -5 + Mathf.Min(new float[]{MoleculeModel.MinValue.x,
            MoleculeModel.MinValue.y,
            MoleculeModel.MinValue.z});
        SurfaceManager.depthCutMax = 5 + Mathf.Max(new float[]{MoleculeModel.MaxValue.x,
            MoleculeModel.MaxValue.y,
            MoleculeModel.MaxValue.z});
        SurfaceManager.depthCut = SurfaceManager.depthCutMax;
    }

    public void addSurface(GameObject surface)
    {
        surfaceList.Add(surface);
    }
    public void addSurfacePos(GameObject surface){
        surfacePos.Add(surface);
    }
    public void addSurfaceNeg(GameObject surface){
        surfaceNeg.Add(surface);
    }
    public GameObject[] getSurfaces() 
    {
        return surfaceList.ToArray();
    }
    public GameObject[] getSurfacesNeg(){
        return surfaceNeg.ToArray();
    }
    public GameObject[] getSurfacesPos(){
        return surfacePos.ToArray();
    }


    public void DestroySurfaces() {
        GameObject [] SurfaceManager = getSurfaces();
        foreach (GameObject Surface in SurfaceManager)
        {
            surfaceList.Remove(Surface);
            Object.Destroy(Surface);
        }
        surfaceInitialized = false;
    }
    public void DestroyPos(){
        for(int i=0;i<surfacePos.Count;i++){
            Object.Destroy(surfacePos[i]);
            surfacePos.Remove(surfacePos[i]);
        }

    }
    public void DestroyNeg(){
        for(int i=0;i<surfaceNeg.Count;i++){
            Object.Destroy(surfaceNeg[i]);
            surfaceNeg.Remove(surfaceNeg[i]);
        }

    }

    public static void GenerateSurface() {
        if (UIData.toggleBfac || surfaceInitialized) {
            UIData.toggleBfac = false;
            pdbGen = false;
            UnityMolMain.getSurfaceManager().DestroySurfaces();
            
        }
        
        if (!pdbGen) {  
            MoleculeModel.surfaceFileExists = true;
            if(pdb2den == null){
                pdb2den = new GameObject ("pdb2den OBJ");
                pdb2den.AddComponent<PDBtoDEN> ();
            }

            PDBtoDEN generatedensity = pdb2den.GetComponent<PDBtoDEN> ();
            
            generatedensity.TranPDBtoDEN ();
            pdbGen = true;
        }
        
        if (!surfaceInitialized) {
            PDBtoDEN.ProSurface (surfaceThreshold);
            surfaceInitialized = true;
        }
    }

    public static void GenerateSurfaceBfact(){
        if(surfaceInitialized){
            pdbGen = false;
            UnityMolMain.getSurfaceManager().DestroySurfaces();
        }
        
        if (!pdbGen) {  
            MoleculeModel.surfaceFileExists = true;
            UIData.toggleBfac = true;

            if(pdb2den == null){
                pdb2den = new GameObject ("pdb2den OBJ");
                pdb2den.AddComponent<PDBtoDEN>();
            }


            PDBtoDEN generatedensity = pdb2den.GetComponent<PDBtoDEN>();
            generatedensity.TranPDBtoDEN ();
            pdbGen = true;
        }
        if(!surfaceInitialized) {
            PDBtoDEN.ProSurface (surfaceThreshold);
            surfaceInitialized = true;
        }
    }
    public static void ShowHideVolumetricDensity(){
        volumetricDensityActivated = !volumetricDensityActivated;
        
        if(VolumetricDensityObj == null){
            VolumetricDensityObj = new GameObject("VolumetricDensity");
            volumetricDensityscript = VolumetricDensityObj.AddComponent<VolumetricDensity>();
        }
        
        if (volumetricDensityActivated)
            volumetricDensityscript.Init ();
        else
            volumetricDensityscript.Clear ();
    
    }

    public static void ShowHideSurfaces(){
        GameObject[] SurfaceManager = UnityMolMain.getSurfaceManager().getSurfaces();
        foreach (GameObject Surface in SurfaceManager) {
            Surface.GetComponent<Renderer>().enabled = !Surface.GetComponent<Renderer>().enabled;
        }

    }


    public void ShowHideSurfaceNeg(){
        GameObject[] SurfacesNeg = UnityMolMain.getSurfaceManager().getSurfacesNeg();
        foreach (GameObject Surface in SurfacesNeg) 
            Surface.GetComponent<Renderer>().enabled = !Surface.GetComponent<Renderer>().enabled;
    }

    public void ShowHideSurfacePos(){
        GameObject[] getSurfacesPos = UnityMolMain.getSurfaceManager().getSurfacesPos();
        foreach (GameObject Surface in getSurfacesPos) 
            Surface.GetComponent<Renderer>().enabled = !Surface.GetComponent<Renderer>().enabled;
    }

    public static void SurfaceRenderUp (){
        SurfaceManager surfaceManager = UnityMolMain.getSurfaceManager();
        GameObject[] surfaceObjs = surfaceManager.getSurfaces();
        Shader vertexcolored = Shader.Find ("Vertex Colored");
        Shader matcapcut = Shader.Find ("Mat Cap Cut");
        foreach (GameObject surfaceObj in surfaceObjs) {
            if (surfaceObj.GetComponent<Renderer>().material.shader == vertexcolored) {
                surfaceObj.GetComponent<Renderer>().material.shader = matcapcut;
                surfaceObj.GetComponent<Renderer>().material.SetTexture ("_MatCap", (Texture)Resources.Load ("lit_spheres/divers/daphz1"));
            } else {
                surfaceManager.InitTree ();
                surfaceManager.ColorVertices ();
                // Init and ColorVertice already change the shader of all the SurfaceOBJ. So if you continue the foreach
                // you'll find "VertexColored" for the next shaders and it will replace them by MatCapCut
                break; // So you must break...
            }
        }
    }

    public void resetSurfaceColors(){
        GameObject[] Surfaces = UnityMolMain.getSurfaceManager().getSurfaces();
        foreach (GameObject Surface in Surfaces) {
            Surface.GetComponent<Renderer>().material.SetColor("_Color", Color.white);
        }
    }
    public void updateColors(){
        ResetColorVertices();
        GameObject[] Surfaces = UnityMolMain.getSurfaceManager().getSurfaces();
        foreach (GameObject Surface in Surfaces) {
            Surface.GetComponent<Renderer>().material.SetColor("_Color", SurfaceColor.color);
            Surface.GetComponent<Renderer>().material.SetColor("_ColorIN", SurfaceInsideColor.color);   
        }
    }
    public void updateCut(){
        GameObject[] Surfaces = UnityMolMain.getSurfaceManager().getSurfaces();
        foreach (GameObject Surface in Surfaces) {
            Surface.GetComponent<Renderer>().material.SetVector("_SurfacePos", Surface.transform.position);
            Surface.GetComponent<Renderer>().material.SetFloat("_depthcut", SurfaceManager.depthCut);
            Surface.GetComponent<Renderer>().material.SetFloat("_cutX", SurfaceManager.cutX);
            Surface.GetComponent<Renderer>().material.SetFloat("_cutY", SurfaceManager.cutY);
            Surface.GetComponent<Renderer>().material.SetFloat("_cutZ", SurfaceManager.cutZ);
            Surface.GetComponent<Renderer>().material.SetFloat("_cut", (float)cutMode);
        }
    }
    public void updateTexture(){
        GameObject[] Surfaces = UnityMolMain.getSurfaceManager().getSurfaces();
        foreach (GameObject Surface in Surfaces) {
            if(extSurf!=null || surfaceTextureName!=null){
                if(externalSurfaceTexture){
                    if(!UIData.grayscalemode)
                        Surface.GetComponent<Renderer>().material.SetTexture("_MatCap",extSurf);
                    else{
                        Surface.GetComponent<Renderer>().material.SetTexture("_MatCap",ToGray(extSurf));
                    }
                }
                else{
                    if(!UIData.grayscalemode)
                        Surface.GetComponent<Renderer>().material.SetTexture("_MatCap",(Texture)Resources.Load(surfaceTextureName)); // do not do that every frame!
                    else{
                        Surface.GetComponent<Renderer>().material.SetTexture("_MatCap",ToGray((Texture)Resources.Load(surfaceTextureName)));
                    }
                }
            }
            else 
                Surface.GetComponent<Renderer>().material.SetTexture("_MatCap",(Texture)Resources.Load("lit_spheres/divers/daphz1"));
        }

    }

    public static void usePropertiesColor() {
        UIData.surfColPChim = !UIData.surfColPChim;
        // SurfaceManager.SurfaceRenderUp();
        UnityMolMain.getSurfaceManager().InitTree();
        UnityMolMain.getSurfaceManager().ColorVertices();
        UIData.surfColPChim = false;
    }

    public static void useBFactorColor() {
        UIData.surfColBF = !UIData.surfColBF;
        // SurfaceManager.SurfaceRenderUp();
        UnityMolMain.getSurfaceManager().InitTree();
        UnityMolMain.getSurfaceManager().ColorVertices();
        UIData.surfColBF = false;
    }

    public static void useChainColor() {
        UIData.surfColChain = !UIData.surfColChain;
        // SurfaceManager.SurfaceRenderUp();
        UnityMolMain.getSurfaceManager().InitTree();
        UnityMolMain.getSurfaceManager().ColorVertices();
        UIData.surfColChain = false;
    }

    public static void useKyteAndDoolittleColor() {
        UIData.surfColHydroKD = !UIData.surfColHydroKD;
        // SurfaceManager.SurfaceRenderUp();
        UnityMolMain.getSurfaceManager().InitTree();
        UnityMolMain.getSurfaceManager().ColorVertices();
        UIData.surfColHydroKD = false;
    }

    public static void useEnglemanColor() {
        UIData.surfColHydroEng = !UIData.surfColHydroEng;
        // SurfaceManager.SurfaceRenderUp();
        UnityMolMain.getSurfaceManager().InitTree();
        UnityMolMain.getSurfaceManager().ColorVertices();
        UIData.surfColHydroEng = false;
    }

    public static void useEinsenbergColor() {
        UIData.surfColHydroEis = !UIData.surfColHydroEis;
        // SurfaceManager.SurfaceRenderUp();
        UnityMolMain.getSurfaceManager().InitTree();
        UnityMolMain.getSurfaceManager().ColorVertices();
        UIData.surfColHydroEis = false;
    }

    public static void useWhiteOctanolColor() {
        UIData.surfColHydroWO = !UIData.surfColHydroWO;
        // SurfaceManager.SurfaceRenderUp();
        UnityMolMain.getSurfaceManager().InitTree();
        UnityMolMain.getSurfaceManager().ColorVertices();
        UIData.surfColHydroWO = false;
    }

    public static void setBrightness(float value) {
        SurfaceManager.brightness = value;
        UnityMolMain.getSurfaceManager().ResetBrightness();
    }

    public static void setColorWeight(float value) {
        SurfaceManager.colorWeight = value;
        UnityMolMain.getSurfaceManager().ResetColorWeight();
    }

    public void RecenterSurfaces(Vector3 pos){
        for(int i=0;i<surfaceList.Count;i++)
            surfaceList[i].transform.position += pos+MoleculeModel.Offset;
        UnityMolMain.getElectrostaticManager().RecenterFieldLines(pos);
    }

    //From HBallManager
    public Texture2D ToGray(Texture texture){ // Should be moved out of HBallManager since it's also used for Surface Textures
        Texture2D tex2D = (Texture2D)texture;
        Texture2D grayTex = new Texture2D(tex2D.width, tex2D.height);
        float grayScale;
        float alpha;
        for (int y  = 0; y < tex2D.height; ++y) {
            for (int x  = 0; x < tex2D.width; ++x) {
                grayScale = tex2D.GetPixel(x, y).r * 0.21f + tex2D.GetPixel(x, y).g * 0.71f + tex2D.GetPixel(x, y).b * 0.07f;
                alpha =  tex2D.GetPixel(x, y).a;
                grayTex.SetPixel (x, y, new Color(grayScale, grayScale, grayScale, alpha));
            }
        }
        grayTex.Apply();
        return grayTex;
    }

    public void SetTransparentSurface(bool transparent){
        for(int i=0;i<surfaceList.Count;i++){
            if(transparent)
                surfaceList[i].GetComponent<MeshRenderer>().material = (Material) Resources.Load("Materials/transSurface");
            else
                surfaceList[i].GetComponent<MeshRenderer>().material = (Material) Resources.Load("Materials/matcapSurface");
        }
    }

    public void SetTransparentSurfaceColor(Color newcolor){
        for(int i=0;i<surfaceList.Count;i++){
            surfaceList[i].GetComponent<MeshRenderer>().material.color = newcolor;
        }
    }

}