AtomMeshStyle.cs

Go to the documentation of this file.

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

Explanations : Merge Meshes into one or several big meshes. The shader is modified to not only draw 1 sphere but multiple spheres.
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.DisplayAtom {
    using System;
    using UnityEngine;
    using System.Collections;
    using System.Collections.Generic;
    using Molecule.Model;
    using UI;
    using UnityEngine.Rendering;


    public class AtomMeshStyle : IAtomStyle {
        public static GameObject AtomMeshParent = new GameObject("AtomMeshParent");
        public List<GameObject> meshesGO;
        public List<GameObject> collidersGO;
        private Dictionary<int,KeyValuePair<int,int> > coordAtomTexture;
        private GameObject collidersParent;

        public AtomMeshStyle() {
        }

        public void DisplayAtoms(UIData.AtomType type_atom, bool force_display = false){
            UIData.shadow = false;

            if(type_atom != UIData.AtomType.particleball || !UIData.isParticlesInitialized ||force_display){

                HBallMeshManager hbmeshManager = GameObject.FindGameObjectWithTag("HBallMeshManager").GetComponent<HBallMeshManager>();
                hbmeshManager.enabled = true;
                if(AtomMeshParent == null)
                    AtomMeshParent = new GameObject("AtomMeshParent");


                if(AtomMeshParent.GetComponentsInChildren<Renderer>().Length > 0){
                    hbmeshManager.EnableRenderers();
                    return;
                }

                // if(MoleculeModel.atoms != null)  {
                    // MoleculeModel.atoms.Clear();
                    // MoleculeModel.atoms=null;
                // }
                    
                // MoleculeModel.atoms=new ArrayList();

                meshesGO = new List<GameObject>();
                collidersGO = new List<GameObject>();
                Debug.Log("DisplayAtoms :: ***clear MolecularModel**** " );

                DisplayAtomMethodByMesh(MoleculeModel.atomsLocationlist, MoleculeModel.atomsTypelist);

                // GameObject HBcubesParent = GameObject.FindGameObjectWithTag("HBCubes");

                // foreach(Transform t in HBcubesParent.transform)
                    // MoleculeModel.atoms.Add(t.gameObject);

                // MoleculeModel.atomsnumber = MoleculeModel.atoms.Count;

                hbmeshManager.hball_meshes = (GameObject[]) meshesGO.ToArray();
                hbmeshManager.collidersGO = (GameObject[]) collidersGO.ToArray();
                hbmeshManager.collidersParent = collidersParent;
                hbmeshManager.coordAtomTexture = coordAtomTexture;
                hbmeshManager.Init();
                hbmeshManager.enabled = true;

            }
        }

        private void DisplayAtomMethodByMesh(IList alist, IList typelist){
            Vector3 posAtom = new Vector3();
            coordAtomTexture = new Dictionary<int,KeyValuePair<int,int> >();
            
            int idmesh = 0;
            int cptAtoms = 0;
            int currentVertex = 0;
            int NBPARAM = 13; //Number of parameters in the texture

            collidersParent = new GameObject("Colliders");
            collidersParent.transform.parent = AtomMeshParent.transform;

            GameObject currentGO = GameObject.CreatePrimitive(PrimitiveType.Cube);
            currentGO.transform.name = "AtomMesh0";
            currentGO.transform.parent = AtomMeshParent.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 = alist.Count*VERTICES_IN_CUBE;
            int maxAtomsinMesh = (int)LIMIT_VERTICES_IN_MESH/VERTICES_IN_CUBE;
            int currentAtomsinMesh = (int)Mathf.Min(maxAtomsinMesh,alist.Count - (idmesh*maxAtomsinMesh));

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

            // MoleculeModel.atomsnumber=nb_meshes_needed;//alist.Count;

            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>();

            //Create a texture to store parameters of spheres (13 parameters to store)
            //It is used to fetch parameters for each atom in the shader
            Texture2D[] newTextures = new Texture2D[nb_meshes_needed];
            newTextures[idmesh] =  new Texture2D(NBPARAM,currentAtomsinMesh,TextureFormat.ARGB32, false);
            float brightness=1.0f,attenuation=0.0f;

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


            for(int i=0;i<alist.Count;i++){

                //If the current mesh can't store the current atoms create a new mesh
                if(currentVertex + tmpMesh.vertices.Length >= LIMIT_VERTICES_IN_MESH){
                    // atoms_by_mesh[idmesh] = cptAtoms;
                    //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];
                    // MoleculeModel.atoms.Add(currentGO);
                    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/Ball HyperBalls Merged");
                    //Set fixed parameters for the shader
                    curMat.SetTexture("_MainTex",newTextures[idmesh]);
                    curMat.SetTexture("_MatCap",(Texture)Resources.Load("lit_spheres/divers/daphz05"));
                    curMat.SetFloat("_Brightness",brightness);
                    curMat.SetFloat("_Attenuation",attenuation);
                    curMat.SetFloat("_NBParam",(float)NBPARAM);
                    curMat.SetFloat("_NBAtoms",(float)currentAtomsinMesh);
                    currentGO.GetComponent<Renderer>().shadowCastingMode = ShadowCastingMode.Off;
                    currentGO.GetComponent<Renderer>().receiveShadows = false;

                    currentGO = GameObject.CreatePrimitive(PrimitiveType.Cube);
                    currentGO.transform.name = "AtomMesh"+(idmesh+1).ToString();
                    currentGO.transform.parent = AtomMeshParent.transform;
                    GameObject.Destroy(currentGO.GetComponent<Collider>());
                    
                    newVertices.Clear();
                    newUV.Clear();
                    newTriangles.Clear();
                    idmesh++;
                    currentAtomsinMesh = (int)Mathf.Min(maxAtomsinMesh,alist.Count - (idmesh*maxAtomsinMesh));
                    newTextures[idmesh] =  new Texture2D(NBPARAM,currentAtomsinMesh,TextureFormat.ARGB32, false);
                    combinedMeshes[idmesh] = new Mesh();
                    currentVertex = 0;
                    cptAtoms = 0;
                }

                float [] a=alist[i] as float[];
                AtomModel aModel = (AtomModel)typelist[i];

                posAtom.x = a[0];
                posAtom.y = a[1];
                posAtom.z = a[2];

                //Store the vertices
                foreach(Vector3 v in tmpMesh.vertices){
                    newVertices.Add(Vector3.Scale(v,new Vector3(aModel.scale/100,aModel.scale/100,aModel.scale/100))+posAtom);
                    //IMPORTANT : Add the id of the atom in each vertex (used to fetch data in the texture)
                    newUV.Add(new Vector2(cptAtoms,0f));
                }

                //Store the triangles
                foreach(int tri in tmpMesh.triangles)
                    newTriangles.Add(tri+currentVertex);


                newTextures[idmesh].SetPixel(0,cptAtoms,EncodeFloatToColor.EncodeFloatRGBA(aModel.radius/3.0f));//Encoded Radius

                newTextures[idmesh].SetPixel(1,cptAtoms,aModel.baseColor);//Color
                newTextures[idmesh].SetPixel(2,cptAtoms,EncodeFloatToColor.EncodeFloatRGBA(posAtom.x));//Sphere position x (can be changed)
                newTextures[idmesh].SetPixel(3,cptAtoms,EncodeFloatToColor.EncodeFloatRGBA(posAtom.y));//Sphere position y (can be changed)
                newTextures[idmesh].SetPixel(4,cptAtoms,EncodeFloatToColor.EncodeFloatRGBA(posAtom.z));//Sphere position z (can be changed)

                newTextures[idmesh].SetPixel(5,cptAtoms,new Vector4(1.0f,0f,0f,0f));//Visibility
                
                newTextures[idmesh].SetPixel(6,cptAtoms,EncodeFloatToColor.EncodeFloatRGBA(posAtom.x));//Base sphere position (doesn't change)
                newTextures[idmesh].SetPixel(7,cptAtoms,EncodeFloatToColor.EncodeFloatRGBA(posAtom.y));//Base sphere position (doesn't change)
                newTextures[idmesh].SetPixel(8,cptAtoms,EncodeFloatToColor.EncodeFloatRGBA(posAtom.z));//Base sphere position (doesn't change)

                newTextures[idmesh].SetPixel(9,cptAtoms,EncodeFloatToColor.EncodeFloatRGBA(equation.x));//Equation parameters
                newTextures[idmesh].SetPixel(10,cptAtoms,EncodeFloatToColor.EncodeFloatRGBA(equation.y));//Equation parameters
                newTextures[idmesh].SetPixel(11,cptAtoms,EncodeFloatToColor.EncodeFloatRGBA(equation.z));//Equation parameters
                newTextures[idmesh].SetPixel(12,cptAtoms,EncodeFloatToColor.EncodeFloatRGBA(equation.w));//Equation parameters


                coordAtomTexture.Add(i,new KeyValuePair<int,int>(idmesh,cptAtoms));
                //Create Collider for each atom
                GameObject colGO = new GameObject("Collider_Atom_"+i);
                SphereCollider sc = colGO.AddComponent<SphereCollider>();
                sc.radius = aModel.radius/3.0f;
                colGO.transform.parent = collidersParent.transform;
                collidersGO.Add(colGO);
                colGO.transform.position = posAtom;


                // MoleculeModel.atoms.Add(colGO);

                // o.tag=aModel.type;
                // MoleculeModel.atoms.Add(o);

                // GameObject dummy = new GameObject("Dummy");
                // dummy.transform.parent = AtomMeshParent.transform;
                // dummy.transform.position = posAtom;
                // MoleculeModel.atoms.Add(dummy);

                currentVertex+=tmpMesh.vertices.Length;

                cptAtoms++;


            }
            //Fill the mesh with the arrays
            // atoms_by_mesh[idmesh] = cptAtoms;
            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];
            // MoleculeModel.atoms.Add(currentGO);
            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/Ball HyperBalls Merged");
            //Set fixed parameters for the shader
            lastMat.SetTexture("_MainTex",newTextures[idmesh]);
            lastMat.SetTexture("_MatCap",(Texture)Resources.Load("lit_spheres/divers/daphz05"));
            lastMat.SetFloat("_Brightness",brightness);
            lastMat.SetFloat("_Attenuation",attenuation);
            lastMat.SetFloat("_NBParam",(float)NBPARAM);
            lastMat.SetFloat("_NBAtoms",(float)currentAtomsinMesh);
            currentGO.GetComponent<Renderer>().shadowCastingMode = ShadowCastingMode.Off;
            currentGO.GetComponent<Renderer>().receiveShadows = false;
            GameObject.Destroy(tmp);
        }
    }

}