protected void ConstructRawMesh(string id, BinaryReader br, int size, Vector3 bbMin, Vector3 bbMax)
{
// TODO: solve the issue that OpenCTM does NOT support multi-threading
lock (PCQueue.Current.LockerForUser)
if (_rawMeshCache.ContainsKey(id) == false)
{
OpenCTM.CtmFileReader reader = new OpenCTM.CtmFileReader(br.BaseStream);
OpenCTM.Mesh mesh = reader.decode();
RawMesh rawMesh = new RawMesh();
mesh.checkIntegrity();
{
List <Vector3> Vertices = new List <Vector3>();
for (int j = 0; j < mesh.getVertexCount(); j++)
{
Vertices.Add(new Vector3(mesh.vertices[(j * 3)], mesh.vertices[(j * 3) + 2], mesh.vertices[(j * 3) + 1]));
}
rawMesh.Vertices = Vertices.ToArray();
}
{
List <int> Triangles = new List <int>();
for (int j = 0; j < mesh.indices.Length / 3; j++)
{
Triangles.Add(mesh.indices[(j * 3)]);
Triangles.Add(mesh.indices[(j * 3) + 2]);
Triangles.Add(mesh.indices[(j * 3) + 1]);
}
rawMesh.Triangles = Triangles.ToArray();
}
if (mesh.getUVCount() > 0)
{
List <Vector2> UVList = new List <Vector2>();
for (int j = 0; j < mesh.texcoordinates[0].values.Length / 2; j++)
{
UVList.Add(new Vector2(mesh.texcoordinates[0].values[(j * 2)], 1 - mesh.texcoordinates[0].values[(j * 2) + 1]));
}
rawMesh.UVList = UVList.ToArray();
}
if (mesh.hasNormals())
{
List <Vector3> Normals = new List <Vector3>();
for (int j = 0; j < mesh.getVertexCount(); j++)
{
Normals.Add(new Vector3(mesh.normals[(j * 3)], mesh.normals[(j * 3) + 2], mesh.normals[(j * 3) + 1]));
}
rawMesh.Normals = Normals.ToArray();
}
rawMesh.BBMin = bbMin;
rawMesh.BBMax = bbMax;
_rawMeshCache.Add(id, rawMesh);
}
}
public override GameObject BuildScene(string name, bool saveToDisk = false)
{
try {
foreach (Eppy.Tuple <int, OpenCTM.Mesh> openctm in _openctm)
{
OpenCTM.Mesh ctmMesh = openctm.Item2;
if (ctmMesh == null || ctmMesh.getVertexCount() == 0 || ctmMesh.getTriangleCount() == 0)
{
state = SceneLoadingStatus.eCancelled;
return(gameObject);
}
Eppy.Tuple <int, int, GameObject, JSONNode> item = fragments.Single(x => x.Item1 == openctm.Item1);
GameObject meshObject = item.Item3;
Mesh mesh = new Mesh();
Vector3 [] vertices = MeshRequest2.getAsVector3(ctmMesh.vertices);
mesh.vertices = vertices;
mesh.triangles = ctmMesh.indices;
if (ctmMesh.hasNormals())
{
mesh.normals = MeshRequest2.getAsVector3(ctmMesh.normals);
}
for (int i = 0; i < ctmMesh.getUVCount(); i++)
{
mesh.SetUVs(i, MeshRequest2.getAsVector2List(ctmMesh.texcoordinates [i].values));
}
mesh.RecalculateNormals();
mesh.RecalculateBounds();
MeshFilter filter = meshObject.AddComponent <MeshFilter> ();
filter.sharedMesh = mesh;
MeshRenderer renderer = meshObject.AddComponent <MeshRenderer> ();
renderer.sharedMaterial = ForgeLoaderEngine.GetDefaultMaterial();
if (createCollider)
{
MeshCollider collider = meshObject.AddComponent <MeshCollider> ();
collider.sharedMesh = mesh;
}
#if UNITY_EDITOR
if (saveToDisk)
{
AssetDatabase.CreateAsset(mesh, ForgeConstants._resourcesPath + this.loader.PROJECTID + "/" + GetName(item.Item1) + ".asset");
//AssetDatabase.SaveAssets () ;
//AssetDatabase.Refresh () ;
//mesh =AssetDatabase.LoadAssetAtPath<Mesh> (ForgeConstants._resourcesPath + this.loader.PROJECTID + "/" + name + ".asset") ;
}
#endif
// Add our material to the queue
loader.GetMgr()._materials.Add(item.Item2);
//if ( loader.GetMgr ()._materials.Add (item.Item2) ) {
// MaterialRequest req = new MaterialRequest (loader, null, bearer, item.Item2, item.Item4);
// req.gameObject = meshObject;
// if ( fireRequestCallback != null )
// fireRequestCallback (this, req);
//}
}
base.BuildScene(name, saveToDisk);
state = SceneLoadingStatus.eWaitingMaterial;
} catch (Exception ex) {
Debug.Log(ForgeLoader.GetCurrentMethod() + " " + ex.Message);
state = SceneLoadingStatus.eError;
}
return(gameObject);
}
protected IEnumerator ConstructMesh(string id, BinaryReader br, int size, Vector3 bbMin, Vector3 bbMax)
{
// NOTE: OpenCTM does NOT support multi-threading
if (_MeshCache.ContainsKey(id) == false)
{
OpenCTM.CtmFileReader reader = new OpenCTM.CtmFileReader(br.BaseStream);
yield return(null);
OpenCTM.Mesh mesh = reader.decode();
yield return(null);
UnityEngine.Mesh um = new UnityEngine.Mesh();
{
Vector3[] Vertices = new Vector3[mesh.getVertexCount()];
for (int j = 0; j < mesh.getVertexCount(); j++)
{
Vertices[j].x = mesh.vertices[(j * 3)];
Vertices[j].y = mesh.vertices[(j * 3) + 2];
Vertices[j].z = mesh.vertices[(j * 3) + 1];
}
um.vertices = Vertices;
}
yield return(null);
{
int[] Triangles = new int[mesh.indices.Length];
for (int j = 0; j < mesh.indices.Length / 3; j++)
{
Triangles[(j * 3)] = mesh.indices[(j * 3)];
Triangles[(j * 3) + 1] = mesh.indices[(j * 3) + 2];
Triangles[(j * 3) + 2] = mesh.indices[(j * 3) + 1];
}
um.triangles = Triangles;
}
yield return(null);
if (mesh.getUVCount() > 0)
{
Vector2[] UVList = new Vector2[mesh.texcoordinates[0].values.Length / 2];
for (int j = 0; j < mesh.texcoordinates[0].values.Length / 2; j++)
{
UVList[j].x = mesh.texcoordinates[0].values[(j * 2)];
UVList[j].y = mesh.texcoordinates[0].values[(j * 2) + 1];
}
um.uv = UVList;
}
yield return(null);
if (mesh.hasNormals())
{
Vector3[] Normals = new Vector3[mesh.getVertexCount()];
for (int j = 0; j < mesh.getVertexCount(); j++)
{
Normals[j].x = mesh.normals[(j * 3)];
Normals[j].y = mesh.normals[(j * 3) + 2];
Normals[j].z = mesh.normals[(j * 3) + 1];
}
um.normals = Normals;
}
else
{
um.RecalculateNormals();
}
yield return(null);
um.bounds.SetMinMax(bbMin, bbMax);
_MeshCache.Add(id, um);
}
}