BondMeshStyle.cs

Go to the documentation of this file.

/* TODO :   -Add copyright
            -Use Quads instead of cubes to reduce the number of vertices = Impostors
            -Use a texture to map in the shader (-> texture atlas)
            -Don't use already created sticks but directly create one mesh

Explanations : Merge Meshes into one or several big meshes. The shader is modified to not only draw 1 stick but multiple sticks.
To do so we need to pass each sphere parameter to the shader using a texture2D. The data have to be encoded from a 32 bits float
to a 32 bits Color4. Two methods can be used. The chosen one is faster but with lower precision and data have to be ranged between -500 and 500.

*/


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

    using UI;
    using Molecule.View.DisplayAtom;


    public class BondMeshStyle:IBondStyle {
        public List<int[]> bondList;
        public List<int[]> bondEPList;
        
        public static GameObject BondMeshParent = new GameObject("BondMeshParent");
        public List<GameObject> meshesGO;
        private Dictionary<int,KeyValuePair<int,int> > coordStickTexture;
        
        public BondMeshStyle() {
        }

        public void DisplayBonds(){
            UIData.shadow = false;

            GameObject hsmeshManagerObj = GameObject.FindGameObjectWithTag("HStickMeshManager");
            HStickMeshManager hsmeshManager = hsmeshManagerObj.GetComponent<HStickMeshManager>();
            hsmeshManager.enabled = true;

            if(BondMeshParent.transform.Find("BondMesh0")){
                hsmeshManager.EnableRenderers();
                return;

            }
            if(UIData.secondarystruct)
                bondEPList=MoleculeModel.bondCAList;
            else
                bondEPList=MoleculeModel.bondEPList;
                
            MoleculeModel.bondsnumber=bondEPList.Count;
            meshesGO = new List<GameObject>();
            DisplayBondsMethodByMesh(bondEPList.Count);
            

            hsmeshManager.hstick_meshes = meshesGO.ToArray();
            hsmeshManager.coordStickTexture = coordStickTexture;
            hsmeshManager.Init();
            hsmeshManager.enabled = true;

            
        }

        private void DisplayBondsMethodByMesh(int nb_sticks){
            
            if(nb_sticks==0)
                return;

            int idmesh = 0;
            int cptSticks = 0;
            int currentVertex = 0;
            int NBPARAM = 20; //Number of parameters in the texture

            GameObject currentGO = GameObject.CreatePrimitive(PrimitiveType.Cube);
            currentGO.transform.name = "BondMesh0";
            currentGO.transform.parent = BondMeshParent.transform;
            GameObject.Destroy(currentGO.GetComponent<Collider>());

            GameObject tmp = GameObject.CreatePrimitive(PrimitiveType.Cube);
            Mesh tmpMesh = tmp.GetComponent<MeshFilter>().mesh;
            GameObject.Destroy(tmp.GetComponent<Collider>());


            int VERTICES_IN_CUBE = tmpMesh.vertices.Length;//24 vertices by cube
            int LIMIT_VERTICES_IN_MESH = 65536;//Unity limit : number of vertices in a mesh
            int totalVertices = nb_sticks*VERTICES_IN_CUBE;
            int maxSticksinMesh = (int)LIMIT_VERTICES_IN_MESH/VERTICES_IN_CUBE;
            int currentSticksinMesh = (int)Mathf.Min(maxSticksinMesh,nb_sticks - (idmesh*maxSticksinMesh));

            //Compute the number of meshes needed to store all the sticks
            int nb_meshes_needed = (int)Mathf.Ceil(totalVertices/(float)LIMIT_VERTICES_IN_MESH);

            Mesh[] combinedMeshes = new Mesh[nb_meshes_needed];
            combinedMeshes[idmesh] = new Mesh();
            // int[] atoms_by_mesh = new int[nb_meshes_needed];
            List<Vector3> newVertices = new List<Vector3>();
            List<Vector2> newUV = new List<Vector2>();
            List<int> newTriangles = new List<int>();

            coordStickTexture = new Dictionary<int,KeyValuePair<int,int> >();

            //Create a texture to store parameters of sticks (20 parameters to store)
            //It is used to fetch parameters for each stick in the shader
            Texture2D[] newTextures = new Texture2D[nb_meshes_needed];
            newTextures[idmesh] =  new Texture2D(NBPARAM,currentSticksinMesh,TextureFormat.ARGB32, false);
            float brightness=1.0f,attenuation=0.0f,shrink=0.4f,visibility=1.0f,scale=1.0f,ellipse=1.0f;

            // Vector4 equation = new Vector4(1.0f,1.0f,1.0f,1.0f);



            for(int i=0;i<nb_sticks;i++){

                //If the current mesh is full, create a new texture
                if(currentVertex + tmpMesh.vertices.Length >= LIMIT_VERTICES_IN_MESH){
                    //Fill the mesh with the arrays
                    combinedMeshes[idmesh].vertices = newVertices.ToArray();
                    combinedMeshes[idmesh].uv = newUV.ToArray();
                    combinedMeshes[idmesh].triangles = newTriangles.ToArray();
                    combinedMeshes[idmesh].Optimize();
                    currentGO.GetComponent<MeshFilter>().mesh.Clear();
                    currentGO.GetComponent<MeshFilter>().mesh = combinedMeshes[idmesh];
                    meshesGO.Add(currentGO);

                    //Upload the texture to the GPU 
                    newTextures[idmesh].Apply(false,false);//DO NOT REMOVE !!!!!!!!!!!!!!!!!!
                    newTextures[idmesh].wrapMode = TextureWrapMode.Clamp;//Mandatory to access the data in the shader
                    newTextures[idmesh].filterMode = FilterMode.Point;//Texture will be used reading pixels

                    Material curMat = currentGO.GetComponent<Renderer>().material;
                    curMat.shader = Shader.Find("FvNano/Sticks HyperBalls Merged");
                    //Set fixed parameters for the shader
                    curMat.SetTexture("_MainTex",newTextures[idmesh]);
                    curMat.SetTexture("_MatCap",(Texture)Resources.Load("lit_spheres/divers/daphz05"));
                    curMat.SetTexture("_MatCap2",(Texture)Resources.Load("lit_spheres/divers/daphz05"));
                    curMat.SetFloat("_Brightness",brightness);
                    curMat.SetFloat("_Attenuation",attenuation);
                    curMat.SetFloat("_NBParam",(float)NBPARAM);
                    curMat.SetFloat("_NBSticks",(float)currentSticksinMesh);
                    curMat.SetFloat("_Shrink",shrink);
                    curMat.SetFloat("_Visibility",visibility);
                    curMat.SetFloat("_Scale",scale);
                    curMat.SetFloat("_EllipseFactor",ellipse);
                    currentGO.GetComponent<Renderer>().shadowCastingMode = ShadowCastingMode.Off;
                    currentGO.GetComponent<Renderer>().receiveShadows = false;

                    currentGO = GameObject.CreatePrimitive(PrimitiveType.Cube);
                    currentGO.transform.name = "BondMesh"+(idmesh+1).ToString();
                    currentGO.transform.parent = BondMeshParent.transform;
                    GameObject.Destroy(currentGO.GetComponent<Collider>());
                    
                    newVertices.Clear();
                    newUV.Clear();
                    newTriangles.Clear();
                    idmesh++;
                    currentSticksinMesh = (int)Mathf.Min(maxSticksinMesh,nb_sticks - (idmesh*maxSticksinMesh));
                    newTextures[idmesh] =  new Texture2D(NBPARAM,currentSticksinMesh,TextureFormat.ARGB32, false);
                    combinedMeshes[idmesh] = new Mesh();
                    currentVertex = 0;
                    cptSticks = 0;
                }



                int[] atomsIds = bondEPList[i] as int[];

                /*
                //Temporary Fix the problem when showing optimized hyperballs
                if(atomsIds[0]<0 || atomsIds[0]>=MoleculeModel.atoms.Count){
                    Debug.LogError("Probleme avec "+atomsIds[0]);
                    GameObject.Destroy(tmp);
                    GameObject.Destroy(currentGO);
                    return;
                }
                if(atomsIds[1]<0 || atomsIds[1]>=MoleculeModel.atoms.Count){
                    Debug.LogError("Probleme (2) avec "+atomsIds[1]);
                    GameObject.Destroy(tmp);
                    GameObject.Destroy(currentGO);
                    return;
                }*/


                // GameObject atom1 = (GameObject)MoleculeModel.atoms[atomsIds[0]];
                // GameObject atom2 = (GameObject)MoleculeModel.atoms[atomsIds[1]];
                AtomModel a1Model = (AtomModel)MoleculeModel.atomsTypelist[atomsIds[0]];
                AtomModel a2Model = (AtomModel)MoleculeModel.atomsTypelist[atomsIds[1]];


                float [] a1=MoleculeModel.atomsLocationlist[atomsIds[0]] as float[];
                float [] a2=MoleculeModel.atomsLocationlist[atomsIds[1]] as float[];
                Vector3 posAtom1 = new Vector3();
                Vector3 posAtom2 = new Vector3();
                posAtom1.x = a1[0];
                posAtom1.y = a1[1];
                posAtom1.z = a1[2];
                posAtom2.x = a2[0];
                posAtom2.y = a2[1];
                posAtom2.z = a2[2];



                //Store the vertices
                foreach(Vector3 v in tmpMesh.vertices){
                    newVertices.Add(Vector3.Scale(v,new Vector3(a1Model.scale/100,a1Model.scale/100,a1Model.scale/100))+posAtom1);
                    //IMPORTANT : Add the id of the stick in each vertex (used to fetch data in the texture)
                    newUV.Add(new Vector2(cptSticks,0f));
                }
                //Store the triangles
                foreach(int tri in tmpMesh.triangles)
                    newTriangles.Add(tri+currentVertex);


                coordStickTexture.Add(i,new KeyValuePair<int,int>(idmesh,cptSticks));

                //Encoded Radii
                newTextures[idmesh].SetPixel(0,cptSticks ,EncodeFloatToColor.EncodeFloatRGBA(a1Model.radius/3.0f));//Radius sphere 1
                newTextures[idmesh].SetPixel(1,cptSticks ,EncodeFloatToColor.EncodeFloatRGBA(a2Model.radius/3.0f));//Radius sphere 2

                newTextures[idmesh].SetPixel(2,cptSticks ,a1Model.baseColor);//Color sphere 1
                newTextures[idmesh].SetPixel(3,cptSticks ,a2Model.baseColor);//Color sphere 2


                newTextures[idmesh].SetPixel(4,cptSticks ,EncodeFloatToColor.EncodeFloatRGBA(posAtom1.x));//Sphere 1 position x
                newTextures[idmesh].SetPixel(5,cptSticks ,EncodeFloatToColor.EncodeFloatRGBA(posAtom1.y));//Sphere 1 position y
                newTextures[idmesh].SetPixel(6,cptSticks ,EncodeFloatToColor.EncodeFloatRGBA(posAtom1.z));//Sphere 1 position z

                newTextures[idmesh].SetPixel(7,cptSticks ,EncodeFloatToColor.EncodeFloatRGBA(posAtom2.x));//Sphere 2 position x
                newTextures[idmesh].SetPixel(8,cptSticks ,EncodeFloatToColor.EncodeFloatRGBA(posAtom2.y));//Sphere 2 position y
                newTextures[idmesh].SetPixel(9,cptSticks ,EncodeFloatToColor.EncodeFloatRGBA(posAtom2.z));//Sphere 2 position z

                newTextures[idmesh].SetPixel(10,cptSticks ,new Vector4(visibility,0f,0f,0f));

                Vector3 light = Vector3.zero;
                //Light
                newTextures[idmesh].SetPixel(11,cptSticks,EncodeFloatToColor.EncodeFloatRGBA(light.x));
                newTextures[idmesh].SetPixel(12,cptSticks,EncodeFloatToColor.EncodeFloatRGBA(light.y));
                newTextures[idmesh].SetPixel(13,cptSticks,EncodeFloatToColor.EncodeFloatRGBA(light.z));

                newTextures[idmesh].SetPixel(14,cptSticks,EncodeFloatToColor.EncodeFloatRGBA(posAtom1.x));//Base Sphere 1 position x
                newTextures[idmesh].SetPixel(15,cptSticks,EncodeFloatToColor.EncodeFloatRGBA(posAtom1.y));//Base Sphere 1 position y
                newTextures[idmesh].SetPixel(16,cptSticks,EncodeFloatToColor.EncodeFloatRGBA(posAtom1.z));//Base Sphere 1 position z

                newTextures[idmesh].SetPixel(17,cptSticks,EncodeFloatToColor.EncodeFloatRGBA(posAtom2.x));//Base Sphere 2 position x
                newTextures[idmesh].SetPixel(18,cptSticks,EncodeFloatToColor.EncodeFloatRGBA(posAtom2.y));//Base Sphere 2 position y
                newTextures[idmesh].SetPixel(19,cptSticks,EncodeFloatToColor.EncodeFloatRGBA(posAtom2.z));//Base Sphere 2 position z


                cptSticks++;
                currentVertex+=tmpMesh.vertices.Length;

            }
            //Fill the mesh with the arrays
            combinedMeshes[idmesh].vertices = newVertices.ToArray();
            combinedMeshes[idmesh].uv = newUV.ToArray();
            combinedMeshes[idmesh].triangles = newTriangles.ToArray();
            combinedMeshes[idmesh].Optimize();
            currentGO.GetComponent<MeshFilter>().mesh.Clear();
            currentGO.GetComponent<MeshFilter>().mesh = combinedMeshes[idmesh];
            meshesGO.Add(currentGO);

            //Upload the texture to the GPU 
            newTextures[idmesh].Apply(false,false);//DO NOT REMOVE !!!!!!!!!!!!!!!!!!
            newTextures[idmesh].wrapMode = TextureWrapMode.Clamp;//Mandatory to access the data in the shader
            newTextures[idmesh].filterMode = FilterMode.Point;//Texture will be used reading pixels

            Material lastMat = currentGO.GetComponent<Renderer>().material;
            lastMat.shader = Shader.Find("FvNano/Sticks HyperBalls Merged");
            //Set fixed parameters for the shader
            lastMat.SetTexture("_MainTex",newTextures[idmesh]);
            lastMat.SetTexture("_MatCap",(Texture)Resources.Load("lit_spheres/divers/daphz05"));
            lastMat.SetTexture("_MatCap2",(Texture)Resources.Load("lit_spheres/divers/daphz05"));
            lastMat.SetFloat("_Brightness",brightness);
            lastMat.SetFloat("_Attenuation",attenuation);
            lastMat.SetFloat("_NBParam",(float)NBPARAM);
            lastMat.SetFloat("_NBSticks",(float)currentSticksinMesh);
            lastMat.SetFloat("_Shrink",shrink);
            lastMat.SetFloat("_Visibility",visibility);
            lastMat.SetFloat("_Scale",scale);
            lastMat.SetFloat("_EllipseFactor",ellipse);
            currentGO.GetComponent<Renderer>().receiveShadows = false;
            currentGO.GetComponent<Renderer>().shadowCastingMode = ShadowCastingMode.Off;
            GameObject.Destroy(tmp);

        }
    }
}