public override object parser(GameObject _object, Component component, UnityScene unityScene)
{
UnityVertexData skeletonData = null;
SkinnedMeshRenderer renderer = component as SkinnedMeshRenderer;
skeletonData = parserSkeleton(renderer, unityScene);
UnityMeshData meshData = base.parser(_object, component, unityScene) as UnityMeshData;
meshData.skeleton = skeletonData;
return(meshData);
}
static async Task SetFromSystemMeshDataAsync(this Mesh mesh, Func <SystemMeshData> getMeshData)
{
var meshData = await UnityMeshData.FromSystemDataAsync(getMeshData);
mesh.Clear();
mesh.vertices = meshData.Vertices;
if (mesh.vertices.Length > ushort.MaxValue)
{
mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
}
mesh.SetIndices(meshData.Indices, meshData.Topology, 0);
mesh.normals = meshData.Normals;
mesh.RecalculateBounds();
}
private async void LoadMesh(string meshPath)
{
_gameObject.transform.localScale = new Vector3(-1, 1, 1);
var meshFilter = _gameObject.AddComponent <MeshFilter>();
Mesh mesh;
while (_loadingInProgress && !_meshCache.ContainsKey(meshPath))
{
await new WaitForSecondsRealtime(0.1f).WaitAsync();
}
if (_loadingInProgress && !_meshCache.ContainsKey(meshPath))
{
throw new Exception("WaitWhile failed");
}
if (!_meshCache.ContainsKey(meshPath))
{
Debug.Log($"LoadMesh({meshPath})");
_loadingInProgress = true;
var startTime = DateTime.Now;
var objDef = await Resources.LoadText(meshPath);
var objMesh = await ObjMesh.Load(objDef);
var unityMeshData = await UnityMeshData.Load(objMesh);
mesh = unityMeshData.ToUnityMesh();
var time = (DateTime.Now - startTime).TotalSeconds;
_meshCache[meshPath] = mesh;
_loadingInProgress = false;
Debug.Log($"LoadMesh({meshPath}): finished after {time}s ({objDef.Length} bytes, " +
$"{unityMeshData.TriangleCount / 3} tris, {unityMeshData.VertexCount} verts)");
}
else
{
mesh = _meshCache[meshPath];
}
meshFilter.sharedMesh = mesh;
}
public override object parser(GameObject _object, Component component, UnityScene unityScene)
{
Renderer renderer = component as Renderer;
Mesh mesh = getMesh(renderer);
if (null == mesh)
{
return(null);
}
UnityMeshData meshData = new UnityMeshData();
UnityVertexData vertexData = new UnityVertexData();
meshData.vertex = vertexData;
/*pos*/
Vector3[] vectors = mesh.vertices;
/*normal*/
Vector3[] normals = mesh.normals;
/*uv*/
Vector2[] uvs = mesh.uv;
Vector4[] tangnets = null;//mesh.tangents;
Color[] colors = mesh.colors;
int numVertices = vectors.Length;
meshData.numVertices = numVertices;
int offset = 0;
Dictionary <string, Variable> variables = new Dictionary <string, Variable>();
if (null != vectors && numVertices == vectors.Length)
{
variables.Add("pos", new Variable(3, offset));
offset += 3;
}
if (null != normals && numVertices == normals.Length)
{
variables.Add("normal", new Variable(3, offset));
offset += 3;
}
if (null != tangnets && 0 != tangnets.Length)
{
variables.Add("tangnet", new Variable(4, offset));
offset += 4;
}
if (null != uvs && numVertices == uvs.Length)
{
variables.Add("uv", new Variable(2, offset));
offset += 2;
}
if (null != colors && numVertices == colors.Length)
{
variables.Add("color", new Variable(4, offset));
offset += 4;
}
variables.Add("data32PerVertex", new Variable(offset, offset));
vertexData.vertex = Export.vector3toByte(vectors, normals, uvs, tangnets, colors);
vertexData.data32PerVertex = offset;
vertexData.variables = variables;
meshData.index = Export.ToUnit16(mesh.triangles);
meshData.numTriangles = mesh.triangles.Length / 3;
meshData.bounds = Export.toUntiyBounds(mesh.bounds, new Matrix4x4());
// meshData.skeleton = skeletonData;
meshData.material = Export.ExportMaterial(renderer.material);
meshData.node = renderer.gameObject.name;
if ("" == meshData.node)
{
Debug.LogError("error node name");
}
return(meshData);
}
private IEnumerator GetUnityMeshData(List <Vector3> vertices, List <Vector2> uvs, List <Vector3> normals, List <MeshFaceData> faceData)
{
int meshCount = 1;
if (triangleIndiciesCount > MAX_VERTICES_PER_MESH)
{
meshCount = triangleIndiciesCount / MAX_VERTICES_PER_MESH;
if (triangleIndiciesCount % MAX_VERTICES_PER_MESH > 0)
{
meshCount++;
}
}
unityMeshData = new UnityMeshData[meshCount];
for (int meshIndex = 0; meshIndex < meshCount; meshIndex++)
{
int meshFaceDataIndexOffset = 0;
for (int i = 0; i < meshIndex; i++)
{
meshFaceDataIndexOffset += MAX_VERTICES_PER_MESH;
}
int meshFaceDataCount = 0;
if (meshIndex == meshCount - 1)
{
meshFaceDataCount = triangleIndiciesCount % MAX_VERTICES_PER_MESH;
}
else
{
meshFaceDataCount = MAX_VERTICES_PER_MESH;
}
Vector3[] newVerts = new Vector3[meshFaceDataCount];
Vector2[] newUVs = new Vector2[meshFaceDataCount];
Vector3[] newNormals = new Vector3[meshFaceDataCount];
Color32[] colors = new Color32[meshFaceDataCount];
int[] newTriangles = new int[meshFaceDataCount];
for (int i = 0; i < meshFaceDataCount; i++)
{
newVerts[i] = vertices[faceData[i + meshFaceDataIndexOffset].verticeIndexX - 1];
newUVs[i] = uvs[faceData[i + meshFaceDataIndexOffset].verticeIndexZ - 1];
newNormals[i] = normals[faceData[i + meshFaceDataIndexOffset].verticeIndexZ - 1];
if (matDic.ContainsKey(faceData[i + meshFaceDataIndexOffset].materialName))
{
colors[i] = matDic[faceData[i + meshFaceDataIndexOffset].materialName].color;
}
else
{
colors[i] = Color.gray;
}
newTriangles[i] = i;
}
unityMeshData[meshIndex] = new UnityMeshData(newVerts, newUVs, newNormals, newTriangles, colors);
}
yield return(null);
}
protected UnityMeshData toMeshData(Renderer renderer, UnityScene unityScene)
{
Mesh mesh = null;
UnityVertexData skeletonData = null;
if (renderer is MeshRenderer)
{
mesh = renderer.GetComponent <MeshFilter>().mesh;
}
else if (renderer is SkinnedMeshRenderer)
{
mesh = (renderer as SkinnedMeshRenderer).sharedMesh;
skeletonData = parserSkeleton(renderer as SkinnedMeshRenderer, unityScene);
}
if (null == mesh)
{
return(null);
}
UnityMeshData meshData = new UnityMeshData();
UnityVertexData vertexData = new UnityVertexData();
meshData.vertex = vertexData;
/*pos*/
Vector3[] vectors = mesh.vertices;
/*normal*/
Vector3[] normals = mesh.normals;
/*uv*/
Vector2[] uvs = mesh.uv;
Vector4[] tangnets = null;//mesh.tangents;
Color[] colors = mesh.colors;
int numVertices = vectors.Length;
meshData.numVertices = numVertices;
int offset = 0;
Dictionary <string, Variable> variables = new Dictionary <string, Variable>();
if (null != vectors && numVertices == vectors.Length)
{
variables.Add("pos", new Variable(3, offset));
offset += 3;
}
if (null != normals && numVertices == normals.Length)
{
variables.Add("normal", new Variable(3, offset));
offset += 3;
}
if (null != tangnets && 0 != tangnets.Length)
{
variables.Add("tangnet", new Variable(4, offset));
offset += 4;
}
if (null != uvs && numVertices == uvs.Length)
{
variables.Add("uv", new Variable(2, offset));
offset += 2;
}
if (null != colors && numVertices == colors.Length)
{
variables.Add("color", new Variable(4, offset));
offset += 4;
}
variables.Add("data32PerVertex", new Variable(offset, offset));
vertexData.vertex = Export.vector3toByte(vectors, normals, uvs, tangnets, colors);
vertexData.data32PerVertex = offset;
vertexData.variables = variables;
meshData.index = Export.ToUnit16(mesh.triangles);
meshData.numTriangles = mesh.triangles.Length / 3;
meshData.bounds = Export.toUntiyBounds(mesh.bounds, Export.newMatrix4x4());
meshData.skeleton = skeletonData;
meshData.material = Export.ExportMaterial(renderer.material, unityScene);
meshData.node = renderer.gameObject.name;
if ("" == meshData.node)
{
Debug.LogError("error node name");
}
return(meshData);
}
