GeometryBuffer.cs

Go to the documentation of this file.

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

public class GeometryBuffer {
    
    int vertextot= 0;
    private List<ObjectData> objects;
    public List<Vector3> vertices;
    public List<Vector2> uvs;
    public List<Vector3> normals;
    
    private ObjectData current;
    private class ObjectData {
        public string name;
        public List<GroupData> groups;
        public List<FaceIndices> allFaces;
        public ObjectData() {
            groups = new List<GroupData>();
            allFaces = new List<FaceIndices>();
        }
    }
    

    
    
    private GroupData curgr;
    private class GroupData {
        public string name;
        public string materialName;
        public List<FaceIndices> faces;
        public GroupData() {
            faces = new List<FaceIndices>();
        }
        public bool isEmpty { get { return faces.Count == 0; } }
    }
    
    public GeometryBuffer() {
        objects = new List<ObjectData>();
        ObjectData d = new ObjectData();
        d.name = "default";
        objects.Add(d);
        current = d;
        
        GroupData g = new GroupData();
        g.name = "default";
        g.materialName = "default";
        d.groups.Add(g);
        curgr = g;
        
        vertices = new List<Vector3>();
        uvs = new List<Vector2>();
        normals = new List<Vector3>();
    }
    
    public void PushObject(string name) {
        //Debug.Log("Adding new object " + name + ". Current is empty: " + isEmpty);
        if(isEmpty) objects.Remove(current);
        
        ObjectData n = new ObjectData();
        n.name = name;
        objects.Add(n);
        
        GroupData g = new GroupData();
        g.name = "default";
        g.materialName = "default";
        n.groups.Add(g);
        
        curgr = g;
        current = n;
    }
    
    public void PushGroup(string name) {
        if(curgr.isEmpty) current.groups.Remove(curgr);
        GroupData g = new GroupData();
        g.name = name;
        g.materialName = "default";
        current.groups.Add(g);
        curgr = g;
    }
    
    public void PushMaterialName(string name) {
        Debug.Log("Pushing new material " + name + " with curgr.empty=" + curgr.isEmpty);
        if(!curgr.isEmpty) PushGroup(name);
        if(curgr.name == "default") curgr.name = name;
        curgr.materialName = name;
    }
    
    public void PushVertex(Vector3 v) {
        vertices.Add(v);
        vertextot++;
    }
    
    public void PushUV(Vector2 v) {
        uvs.Add(v);
    }
    
    public void PushNormal(Vector3 v) {
        normals.Add(v);
    }
    
    public void PushFace(FaceIndices f) {
        curgr.faces.Add(f);
        current.allFaces.Add(f);

    }
    
    public void Trace() {
        Debug.Log("OBJ has " + objects.Count + " object(s)");
        Debug.Log("OBJ has " + vertices.Count + " vertice(s)");
        Debug.Log("OBJ has " + uvs.Count + " uv(s)");
        Debug.Log("OBJ has " + normals.Count + " normal(s)");
        foreach(ObjectData od in objects) {
            Debug.Log(od.name + " has " + od.groups.Count + " group(s)");
            foreach(GroupData gd in od.groups) {
                Debug.Log(od.name + "/" + gd.name + " has " + gd.faces.Count + " faces(s)");
            }
        }
        
    }
    
    public int numObjects { get { return objects.Count; } } 
    public bool isEmpty { get { return vertices.Count == 0; } }
//  public bool hasUVs { get { return uvs.Count == 0; } }
    public bool hasUVs = true;
    public bool hasNormals { get { return normals.Count > 0; } }
    
    public void PopulateMeshes(GameObject[] gs, Dictionary<string, Material> mats) {
        if(gs.Length != numObjects) return; // Should not happen unless obj file is corrupt...
        
        for(int i = 0; i < gs.Length; i++) {

            ObjectData od = objects[i];
            
            if(od.name != "default") gs[i].name = od.name;
            
//          Debug.Log("triangle tot:"+ triangletot);
            Vector3[] tvertices = new Vector3[vertextot];
            Vector2[] tuvs = new Vector2[vertextot];
            Vector3[] tnormals = new Vector3[vertextot];
            
            int[] triangles = new int[od.allFaces.Count];
            
            //Calcul of baricenter of the surface
            float barix=0;
            float bariy=0;
            float bariz=0;
//
            for (int bari =0; bari< vertextot;bari++){
                barix = barix + vertices[bari].x;
//              Debug.Log("t " + vertices[bari]);
                bariy = bariy + vertices[bari].y;
                bariz = bariz + vertices[bari].z;
            }
//          Debug.Log(" baricentre: "+ barix +" "+ bariy+ " "+ bariz);
//
            barix = barix/vertextot;
            bariy = bariy/vertextot;
            bariz = bariz/vertextot;
            Debug.Log("Surface baricentre coords :: "+ barix +" "+ bariy+ " "+ bariz);
            
            int k=0;
//          float pas = 1f/214f;
//          float temp1=pas;
//          float temp2=pas;
//          int compteur=1;
            for (int l=0; l<vertextot;l++){
                tvertices[l] = vertices[l];
                tvertices[l].x = vertices[l].x;//-barix;
                tvertices[l].y = vertices[l].y;//-bariy;
                tvertices[l].z = vertices[l].z;//-bariz;
                tnormals[l]= normals[l];
                
                //Calcul de l'uv map non fonctionnel
                
//              tuvs[k]=new Vector2(temp1,temp2);
//              Debug.Log("Vector : "+tuvs[k] +" pas : " +pas + "compteur :" +compteur);
//              compteur++;
//              temp1 += pas;
//              if (temp1 >0.99){
//                  temp2 += pas;
//                  temp1= pas;
//              }
                
            }
            foreach(FaceIndices fi in od.allFaces) {
                triangles[k] = fi.vi;
//              tvertices[k] = vertices[fi.vi];
//              if(hasUVs) tuvs[k] = uvs[fi.vu];
//              if(hasNormals) tnormals[k] = normals[fi.vn];
                k++;
            }
        
            Vector3 baricenter = new Vector3(barix,bariy,bariz);
            Debug.Log("Obj center = " + baricenter);
            gs[i].transform.localPosition = gs[i].transform.localPosition + MoleculeModel.Offset;
            gs[i].transform.localPosition = gs[i].transform.localPosition + MoleculeModel.Center;
//          gs[i].transform.localPosition = gs[i].transform.localPosition + MoleculeModel.Offset;
//          Debug.Log(" baricentre: "+ barix +" "+ bariy+ " "+ bariz);
            Mesh m = (gs[i].GetComponent(typeof(MeshFilter)) as MeshFilter).mesh;
            m.vertices = tvertices;
            MoleculeModel.vertices = tvertices;
            if(hasUVs) m.uv = tuvs;
            if(hasNormals) m.normals = tnormals;
        
            //Unity has a left-handed coordinates system while Molecular obj are right-handed
            //So we have to change the winding order
            for(int tri=0; tri<triangles.Length; tri=tri+3)
            {
                int tmp = triangles[tri];
                triangles[tri] = triangles[tri+2];
                triangles[tri+2] = tmp;
            }

            if(od.groups.Count == 1) {
                GroupData gd = od.groups[0];
                Debug.Log("Mesh material used :: "+gd.materialName);
                gs[i].GetComponent<Renderer>().material = mats[gd.materialName];
                
//              int[] triangles = new int[gd.faces.Count];
//              for(int j = 0; j < triangles.Length; j++) triangles[j] = j;
                
                m.triangles = triangles;
                
            } //else {
//              int gl = od.groups.Count;
//              Material[] sml = new Material[gl];
//              m.subMeshCount = gl;
//              int c = 0;
//              
//              for(int j = 0; j < gl; j++) {
//                  sml[j] = mats[od.groups[j].materialName]; 
//                  int[] triangles = new int[od.groups[j].faces.Count];
//                  int l = od.groups[j].faces.Count + c;
//                  int s = 0;
//                  for(; c < l; c++, s++) triangles[s] = c;
//                  m.SetTriangles(triangles, j);
//              }
//              
//              gs[i].renderer.materials = sml;
//          }
        }
    }
}