public static SMesh Serialize(this Mesh _mesh)
{
if (_mesh == null)
{
return(null);
}
SMesh returnVal = new SMesh
{
bindposes = _mesh.bindposes,
boneWeights = _mesh.boneWeights,
bounds = _mesh.bounds,
colors = _mesh.colors.Serialize(),
indexFormat = _mesh.indexFormat,
name = _mesh.name,
normals = _mesh.normals.Serialize(),
tangents = _mesh.tangents.Serialize(),
uv = _mesh.uv.Serialize(),
uv2 = _mesh.uv2.Serialize(),
uv3 = _mesh.uv3.Serialize(),
uv4 = _mesh.uv4.Serialize(),
uv5 = _mesh.uv5.Serialize(),
uv6 = _mesh.uv6.Serialize(),
uv7 = _mesh.uv7.Serialize(),
uv8 = _mesh.uv8.Serialize(),
vertices = _mesh.vertices.Serialize()
};
//Do triangles still aka mesh
return(returnVal);
}
private void CreateCMPData(FBXNode n)
{
Vector3 vOffset = Vector3.Zero;
CmpndData cmpnd = new CmpndData();
cmpnd.index = 0;
cmpnd.object_name = n.GetName();
if (cmpnd.object_name == "Root")
{
cmpnd.name = "Root";
}
else
{
cmpnd.name = "Part_" + cmpnd.object_name;
if (Relocate)
{
vOffset = T(n.EvaluateLocalTranslation(FBXTime.Infinite(), ArcManagedFBX.Types.EPivotSet.eSourcePivot, false, false));
}
}
cmpnd.object_data = new ThreeDBData();
cmpnd.object_data.data = new LodData[8];
cmpnd.object_data.wireframe_lod = 0;
int lods = 0;
for (int i = 0; i < n.GetChildCount(); i++)
{
var cur_lodnode = n.GetChild(i);
var match = Regex.Match(cur_lodnode.GetName(), @"^.+_lod(?<lod>[0-9])(?<wireframe>_vwd)?");
if (match.Success)
{
uint lod = uint.Parse(match.Groups["lod"].Value);
if (match.Groups["wireframe"].Success)
{
cmpnd.object_data.wireframe_lod = lod;
}
cmpnd.object_data.data[lod].meshes = new List <SMesh>();
lods++;
int numVerts = 0;
int numFaces = 0;
Vector3 bbmin = new Vector3(float.MaxValue);
Vector3 bbmax = new Vector3(float.MinValue);
for (int j = 0; j < cur_lodnode.GetChildCount(); j++)
{
var cur_node = cur_lodnode.GetChild(j);
var attr = cur_node.GetNodeAttribute();
if (attr == null)
{
continue;
}
if (attr.GetAttributeType() != ArcManagedFBX.Types.EAttributeType.eMesh)
{
continue;
}
var pmesh = attr as FBXMesh;
var cur_node_trans = T(cur_node.EvaluateGlobalTransform(FBXTime.Infinite(), ArcManagedFBX.Types.EPivotSet.eSourcePivot, false, false));
var cur_node_geo = T(cur_node.GetGeometricMatrix(ArcManagedFBX.Types.EPivotSet.eSourcePivot));
cur_node_trans = cur_node_geo * cur_node_trans;
SMesh mesh = new SMesh();
int nTris = pmesh.GetPolygonCount();
if (nTris <= 0)
{
continue;
}
if (cur_node.GetMaterialCount() <= 0)
{
mesh.material_name = "default";
}
else
{
var material = cur_node.GetMaterial(0);
mesh.material_name = material.GetName();
}
mesh.name = cur_node.GetName();
mesh.t = new VMSTri[nTris];
int nVerts = nTris * 3;
mesh.v = new VMSVert[nVerts];
var vertices = pmesh.GetControlPoints();
int tangentLayerCount = pmesh.GetElementTangentCount();
var tangentLayer = tangentLayerCount > 0 ? pmesh.GetElementTangent().GetDirectArray() : null;
int binormalLayerCount = pmesh.GetElementBinormalCount();
var binormalLayer = binormalLayerCount > 0 ? pmesh.GetElementBinormal().GetDirectArray() : null;
for (int nTri = 0; nTri < nTris; nTri++)
{
mesh.t[nTri].vertices = new ushort[3];
for (int k = 0; k < 3; k++)
{
int nVert = (nTri * 3 + k);
Vector3 vertice, normal;
Vector2 uv;
bool unmapped = false;
FBXVector fbxuv = new FBXVector();
FBXVector fbxnormal = new FBXVector();
vertice = Vector3.TransformCoordinate(T(vertices[pmesh.GetPolygonVertex(nTri, k)]), cur_node_trans);
// offset vertice
vertice -= vOffset;
pmesh.GetPolygonVertexUV(nTri, k, "map1", ref fbxuv, ref unmapped);
uv = T2(fbxuv);
pmesh.GetPolygonVertexNormal(nTri, k, ref fbxnormal);
normal = Vector3.TransformNormal(T(fbxnormal), cur_node_trans);
mesh.t[nTri].vertices[k] = (ushort)nVert;
mesh.v[nVert].vert = vertice;
mesh.v[nVert].normal = normal;
mesh.v[nVert].uv = uv;
mesh.v[nVert].tangent = tangentLayer != null?T(tangentLayer.GetAt(nVert)) : Vector3.Zero;
mesh.v[nVert].binormal = binormalLayer != null?T(binormalLayer.GetAt(nVert)) : Vector3.Zero;
/*
*
* float alpha = 1.0f;
* int iVCindex = mesh->pMesh->GetFaceVertex(pTriangle->meshFaceIndex, i);
* if (iVCindex != -1)
* {
* alpha = mesh->pMesh->GetAlphaVertex(pTriangle->alpha[i]);
* color = mesh->pMesh->GetColorVertex(pTriangle->color[i]);
* mesh->v[nVert].diffuse = (DWORD)(alpha * 255) << 24 | (DWORD)(color.x * 255) << 16 | (DWORD)(color.y * 255) << 8 | (DWORD)(color.z * 255);
* mesh->v[nVert].uv = uv;
* }
* else
* {
* mesh->v[nVert].tangent = Point3(0, 0, 0);
* mesh->v[nVert].binormal = Point3(0, 0, 0);
* }*/
bbmin = Vector3.Min(bbmin, vertice);
bbmax = Vector3.Max(bbmin, vertice);
}
}
mesh.nVerts = nVerts;
numVerts += mesh.nVerts;
mesh.nTris = nTris;
numFaces += mesh.nTris;
cmpnd.object_data.data[lod].meshes.Add(mesh);
}
cmpnd.object_data.data[lod].vmeshref = new VMeshRef();
cmpnd.object_data.data[lod].vmeshref.BoundingBoxMaxX = bbmax.X;
cmpnd.object_data.data[lod].vmeshref.BoundingBoxMaxY = bbmax.Y;
cmpnd.object_data.data[lod].vmeshref.BoundingBoxMaxZ = bbmax.Z;
cmpnd.object_data.data[lod].vmeshref.BoundingBoxMinX = bbmin.X;
cmpnd.object_data.data[lod].vmeshref.BoundingBoxMinY = bbmin.Y;
cmpnd.object_data.data[lod].vmeshref.BoundingBoxMinZ = bbmin.Z;
var vCenter = (bbmax + bbmin) / 2;
cmpnd.object_data.data[lod].vmeshref.CenterX = vCenter.X;
cmpnd.object_data.data[lod].vmeshref.CenterY = vCenter.Y;
cmpnd.object_data.data[lod].vmeshref.CenterZ = vCenter.Z;
cmpnd.object_data.data[lod].vmeshref.Radius = (bbmax - vCenter).Length() * 1.25f;
cmpnd.object_data.data[lod].vmeshref.HeaderSize = 60;
cmpnd.object_data.data[lod].vmeshref.NumMeshes = (ushort)cmpnd.object_data.data[lod].meshes.Count;
cmpnd.object_data.data[lod].vmeshref.NumVert = (ushort)numVerts;
cmpnd.object_data.data[lod].vmeshref.NumIndex = (ushort)(numFaces * 3);
if (numFaces * 3 > 0xFFFF)
{
throw new ArgumentException($"{cmpnd.object_name} references more than 65535 vertices. Split the group into smaller groups!");
}
}
}
cmpnd.object_data.lods = (uint)lods;
cmpnd.index = cmpndData.Count;
cmpndData.Add(cmpnd);
if (cmpnd.object_name != "Root")
{
if (cmpnd.object_name.EndsWith("_rev"))
{
CmpRevData.Part revdata = new CmpRevData.Part();
revdata.ParentName = "Root";
revdata.ChildName = cmpnd.object_name;
revdata.OriginX = vOffset.X;
revdata.OriginY = vOffset.Y;
revdata.OriginZ = vOffset.Z;
var mat = n.EvaluateLocalTransform(FBXTime.Infinite(), ArcManagedFBX.Types.EPivotSet.eSourcePivot, false, false);
revdata.RotMatXX = (float)mat.mData[0].x;
revdata.RotMatXY = (float)mat.mData[1].x;
revdata.RotMatXZ = (float)mat.mData[2].x;
revdata.RotMatYX = (float)mat.mData[0].y;
revdata.RotMatYY = (float)mat.mData[1].y;
revdata.RotMatYZ = (float)mat.mData[2].y;
revdata.RotMatZX = (float)mat.mData[0].z;
revdata.RotMatZY = (float)mat.mData[1].z;
revdata.RotMatZZ = (float)mat.mData[2].z;
revdata.AxisRotX = (float)mat.mData[0].x;
revdata.AxisRotY = (float)mat.mData[1].x;
revdata.AxisRotZ = (float)mat.mData[2].x;
revdata.Max = 1;
rev.Parts.Add(revdata);
}
else if (cmpnd.object_name.EndsWith("_pris"))
{
CmpRevData.Part revdata = new CmpRevData.Part();
revdata.ParentName = "Root";
revdata.ChildName = cmpnd.object_name;
revdata.OriginX = vOffset.X;
revdata.OriginY = vOffset.Y;
revdata.OriginZ = vOffset.Z;
revdata.RotMatXX = revdata.RotMatYY = revdata.RotMatZZ = 1;
revdata.AxisRotZ = 1;
revdata.Max = 360;
pris.Parts.Add(revdata);
}
else
{
CmpFixData.Part fixdata = new CmpFixData.Part();
fixdata.ParentName = "Root";
fixdata.ChildName = cmpnd.object_name;
fixdata.OriginX = vOffset.X;
fixdata.OriginY = vOffset.Y;
fixdata.OriginZ = vOffset.Z;
fixdata.RotMatXX = fixdata.RotMatYY = fixdata.RotMatZZ = 1;
fix.Parts.Add(fixdata);
}
}
}
public void ReadObj(string File)
{
List <Syroot.Maths.Vector4F> verts = new List <Syroot.Maths.Vector4F>();
List <Syroot.Maths.Vector4F> norms = new List <Syroot.Maths.Vector4F>();
List <Syroot.Maths.Vector4F> uvs = new List <Syroot.Maths.Vector4F>();
SMesh CMesh = new SMesh();
string[] text = System.IO.File.ReadAllLines(File);
//Import the obj
foreach (string l in text)
{
if (l.Contains("o "))
{
CMesh = new SMesh();
meshes.Add(CMesh);
CMesh.Name = l.Remove(0, 2);
}
if (l.Contains("v "))
{
string[] vertArry = l.Remove(0, 2).Split(' ');
verts.Add(new Syroot.Maths.Vector4F(float.Parse(vertArry[0]), float.Parse(vertArry[1]), float.Parse(vertArry[2]), 1.0f));
}
if (l.Contains("vn "))
{
string[] vertArry = l.Remove(0, 3).Split(' ');
norms.Add(new Syroot.Maths.Vector4F(float.Parse(vertArry[0]), float.Parse(vertArry[1]), float.Parse(vertArry[2]), 0.0f));
}
if (l.Contains("vt "))
{
string[] vertArry = l.Remove(0, 3).Split(' ');
uvs.Add(new Syroot.Maths.Vector4F(float.Parse(vertArry[0]), float.Parse(vertArry[1]) * -1, 0f, 0f));
}
if (l.Contains("f "))
{
string[] vertArry = l.Remove(0, 2).Split(' ');
if (vertArry.Length > 3)
{
Console.WriteLine("Non-Traingulated Mesh\tPlease Re-Export with triangulated Mesh");
}
List <string> faceArray = new List <string>();
CMesh.rawFace.Add(new List <string>(vertArry.OfType <string>().ToList()));
}
}
//Time To Clean Our OBJ
foreach (SMesh sm in meshes)
{
List <Syroot.Maths.Vector3> points = new List <Syroot.Maths.Vector3>();
Dictionary <string, uint> lookup = new Dictionary <string, uint>();
uint fi = 0;
foreach (List <string> faceRaw in sm.rawFace)
{
foreach (string f in faceRaw)
{
if (!lookup.ContainsKey(f))
{
lookup.Add(f, fi);
sm.faces.Add(fi++);
string[] sr = f.Split('/');
sm.verts.Add(verts[int.Parse(sr[0]) - 1]);
sm.uvs.Add(uvs[int.Parse(sr[1]) - 1]);
sm.norms.Add(norms[int.Parse(sr[2]) - 1]);
}
else
{
sm.faces.Add(lookup[f]);
}
}
}
}
}
public static GameObject getGameObject(PreparedMesh prepMesh, String fn)
{
GameObject parentObject = new GameObject(prepMesh.meshName);
foreach (string obj in prepMesh.objectNames)
{
GameObject subObject = new GameObject(obj);
subObject.transform.parent = parentObject.transform;
//Create mesh
Mesh m = new Mesh();
m.name = obj;
Debug.Log("mesh " + m.name);
SMesh pm2 = prepMesh.pMesh2.subMeshes[obj];
var meshMaterialNames = pm2.materialNames;
//apply stuff
m.vertices = pm2.pV;
m.normals = pm2.pN;
m.uv = pm2.pUV;
//Debug.Log("vertices:" + m.vertices.Count());
m.subMeshCount = pm2.pI.Count;
for (int i = 0; i < pm2.pI.Count; i++)
{
m.SetTriangles(pm2.pI[i], i);
}
if (!prepMesh.hasNormals)
{
m.RecalculateNormals();
}
m.RecalculateBounds();
MeshFilter mf = subObject.AddComponent <MeshFilter>();
MeshRenderer mr = subObject.AddComponent <MeshRenderer>();
//MeshCollider mc = subObject.AddComponent<MeshCollider>();
string PNG_DIR = Assets.ProgramSettings.get("PNG_TEXTURE_DIR");
Shader basicBasic = Shader.Find("BasicShader");
Shader basicTransparent = Shader.Find("TransparentBasicShader");
Shader basicWaterTransparent = Shader.Find("WaterShader");
Shader basicTerrain = Shader.Find("BasicTerrainShader");
Shader basic = basicBasic;
if (fn.Contains("terrain"))
{
basic = basicTerrain;
}
Material[] processedMaterials = new Material[meshMaterialNames.Count];
for (int i = 0; i < meshMaterialNames.Count; i++)
{
string matName = meshMaterialNames[i];
string matNameL = meshMaterialNames[i].ToLower();
string[] transNames = { "leave", "leaf", "fern", "hedge", "foliage", "shrub", "ocean_chunk", "bush", "plants_combine" };
foreach (string tb in transNames)
{
if (matNameL.Contains(tb))
{
basic = basicTransparent;
break;
}
}
if (matNameL.Contains("ocean_chunk"))
{
basic = basicWaterTransparent;
}
if (prepMesh.materialCache == null)
{
processedMaterials[i] = new Material(basic);
processedMaterials[i].mainTexture = LoadTexture(PNG_DIR + matName);
}
else
{
Material mfn = Array.Find(prepMesh.materialCache, x => x.name == matName);
if (mfn == null)
{
processedMaterials[i] = new Material(basic);
}
else
{
processedMaterials[i] = mfn;
}
}
processedMaterials[i].mainTextureScale = new Vector2(1, -1);
processedMaterials[i].name = matName;
}
mr.materials = processedMaterials;
mf.mesh = m;
//mc.sharedMesh = m;
}
originals[fn] = parentObject;
return(parentObject);
}
public static PrepMesh2 prepMesh2(PreparedMesh prepMesh, String fn)
{
PrepMesh2 pMesh2 = new PrepMesh2();
Debug.Log(prepMesh.objectNames.Count);
foreach (string obj in prepMesh.objectNames)
{
SMesh sMesh = new SMesh();
List <Vector3> processedVertices = new List <Vector3>();
List <Vector3> processedNormals = new List <Vector3>();
List <Vector2> processedUVs = new List <Vector2>();
List <int[]> processedIndexes = new List <int[]>();
Dictionary <int, int> remapTable = new Dictionary <int, int>();
//POPULATE MESH
List <string> meshMaterialNames = new List <string>();
#region dosubmesh
OBJFace[] ofaces = prepMesh.faceList.Where(x => x.meshName == obj).ToArray();
Debug.Log(ofaces.Length);
foreach (string mn in prepMesh.materialNames)
{
OBJFace[] faces = ofaces.Where(x => x.materialName == mn).ToArray();
Debug.Log("[" + mn + "] faces: " + faces.Length);
if (faces.Length > 0)
{
int iSize = 0;
foreach (OBJFace f in faces)
{
iSize += f.indexes.Length;
}
List <int> indexes = new List <int>(iSize);
foreach (OBJFace f in faces)
{
indexes.AddRange(f.indexes);
}
processedVertices.Capacity += indexes.Count;
processedNormals.Capacity += indexes.Count;
processedUVs.Capacity += indexes.Count;
meshMaterialNames.Add(mn);
for (int i = 0; i < indexes.Count; i++)
{
int idx = indexes[i];
//build remap table
if (remapTable.ContainsKey(idx))
{
//ezpz
indexes[i] = remapTable[idx];
}
else
{
processedVertices.Add(prepMesh.uvertices[idx]);
processedNormals.Add(prepMesh.unormals[idx]);
processedUVs.Add(prepMesh.uuvs[idx]);
remapTable[idx] = processedVertices.Count - 1;
indexes[i] = remapTable[idx];
}
}
processedIndexes.Add(indexes.ToArray());
}
else
{
}
}
#endregion
sMesh.pV = processedVertices.ToArray();
sMesh.pN = processedNormals.ToArray();
sMesh.pUV = processedUVs.ToArray();
sMesh.pI = processedIndexes;
sMesh.materialNames = meshMaterialNames;
pMesh2.subMeshes[obj] = sMesh;
}
return(pMesh2);
}
