static void BuildBlendShape(Mesh mesh, MeshContext meshContext, BlendShape blendShape, Vector3[] emptyVertices)
{
if (blendShape.Positions.Count > 0)
{
if (blendShape.Positions.Count == mesh.vertexCount)
{
mesh.AddBlendShapeFrame(blendShape.Name, FRAME_WEIGHT,
blendShape.Positions.ToArray(),
(meshContext.Normals.Count == mesh.vertexCount && blendShape.Normals.Count == blendShape.Positions.Count()) ? blendShape.Normals.ToArray() : null,
null
);
}
else
{
Debug.LogWarningFormat("May be partial primitive has blendShape. Require separate mesh or extend blend shape, but not implemented: {0}", blendShape.Name);
}
}
else
{
// Debug.LogFormat("empty blendshape: {0}.{1}", mesh.name, blendShape.Name);
// add empty blend shape for keep blend shape index
mesh.AddBlendShapeFrame(blendShape.Name, FRAME_WEIGHT,
emptyVertices,
null,
null
);
}
}
internal static async Task <MeshWithMaterials> BuildMeshAsync(
IAwaitCaller awaitCaller,
Func <int, Material> ctx,
MeshContext meshContext)
{
Profiler.BeginSample("MeshImporter.BuildMesh");
var(mesh, recalculateTangents) = BuildMesh(meshContext);
Profiler.EndSample();
if (recalculateTangents)
{
await awaitCaller.NextFrame();
mesh.RecalculateTangents();
await awaitCaller.NextFrame();
}
// 先にすべてのマテリアルを作成済みなのでテクスチャーは生成済み。Resultを使ってよい
var result = new MeshWithMaterials
{
Mesh = mesh,
Materials = meshContext.MaterialIndices.Select(ctx).ToArray()
};
await awaitCaller.NextFrame();
if (meshContext.BlendShapes.Count > 0)
{
var emptyVertices = new Vector3[mesh.vertexCount];
foreach (var blendShape in meshContext.BlendShapes)
{
await BuildBlendShapeAsync(awaitCaller, mesh, blendShape, emptyVertices);
}
}
Profiler.BeginSample("Mesh.UploadMeshData");
mesh.UploadMeshData(false);
Profiler.EndSample();
return(result);
}
public MeshContext ReadMesh(ImporterContext ctx, int meshIndex)
{
var gltfMesh = ctx.GLTF.meshes[meshIndex];
var meshContext = new MeshContext(gltfMesh.name, meshIndex);
if (HasSharedVertexBuffer(gltfMesh))
{
meshContext.ImportMeshSharingVertexBuffer(ctx, gltfMesh);
}
else
{
meshContext.ImportMeshIndependentVertexBuffer(ctx, gltfMesh);
}
meshContext.RenameBlendShape(gltfMesh);
meshContext.DropUnusedVertices();
return(meshContext);
}
private static (Mesh, bool) BuildMesh(MeshContext meshContext)
{
meshContext.AddDefaultMaterial();
//Debug.Log(prims.ToJson());
var mesh = new Mesh
{
name = meshContext.Name
};
meshContext.UploadMeshVertices(mesh);
meshContext.UploadMeshIndices(mesh);
// NOTE: mesh.vertices では自動的に行われていたが、SetVertexBuffer では行われないため、明示的に呼び出す.
mesh.RecalculateBounds();
if (!meshContext.HasNormal)
{
mesh.RecalculateNormals();
}
return(mesh, true);
}
internal MeshContext ReadMesh(GltfData data, int meshIndex, IAxisInverter inverter)
{
Profiler.BeginSample("ReadMesh");
var gltfMesh = data.GLTF.meshes[meshIndex];
var meshContext = new MeshContext(gltfMesh.name, meshIndex);
if (HasSharedVertexBuffer(gltfMesh))
{
meshContext.ImportMeshSharingVertexBuffer(data, gltfMesh, inverter);
}
else
{
meshContext.ImportMeshIndependentVertexBuffer(data, gltfMesh, inverter);
}
meshContext.RenameBlendShape(gltfMesh);
meshContext.DropUnusedVertices();
Profiler.EndSample();
return(meshContext);
}
// multiple submesh sharing same VertexBuffer
private static MeshContext _ImportMeshSharingVertexBuffer(ImporterContext ctx, glTFMesh gltfMesh)
{
var context = new MeshContext();
{
var prim = gltfMesh.primitives.First();
context.positions = ctx.GLTF.GetArrayFromAccessor <Vector3>(prim.attributes.POSITION).SelectInplace(x => x.ReverseZ());
// normal
if (prim.attributes.NORMAL != -1)
{
context.normals = ctx.GLTF.GetArrayFromAccessor <Vector3>(prim.attributes.NORMAL).SelectInplace(x => x.ReverseZ());
}
// tangent
if (prim.attributes.TANGENT != -1)
{
context.tangents = ctx.GLTF.GetArrayFromAccessor <Vector4>(prim.attributes.TANGENT).SelectInplace(x => x.ReverseZ());
}
// uv
if (prim.attributes.TEXCOORD_0 != -1)
{
context.uv = ctx.GLTF.GetArrayFromAccessor <Vector2>(prim.attributes.TEXCOORD_0).SelectInplace(x => x.ReverseY());
}
else
{
// for inconsistent attributes in primitives
context.uv = new Vector2[context.positions.Length];
}
// color
if (prim.attributes.COLOR_0 != -1)
{
context.colors = ctx.GLTF.GetArrayFromAccessor <Color>(prim.attributes.COLOR_0);
}
// skin
if (prim.attributes.JOINTS_0 != -1 && prim.attributes.WEIGHTS_0 != -1)
{
var joints0 = ctx.GLTF.GetArrayFromAccessor <UShort4>(prim.attributes.JOINTS_0); // uint4
var weights0 = ctx.GLTF.GetArrayFromAccessor <Float4>(prim.attributes.WEIGHTS_0);
for (int i = 0; i < weights0.Length; ++i)
{
weights0[i] = weights0[i].One();
}
for (int j = 0; j < joints0.Length; ++j)
{
var bw = new BoneWeight();
bw.boneIndex0 = joints0[j].x;
bw.weight0 = weights0[j].x;
bw.boneIndex1 = joints0[j].y;
bw.weight1 = weights0[j].y;
bw.boneIndex2 = joints0[j].z;
bw.weight2 = weights0[j].z;
bw.boneIndex3 = joints0[j].w;
bw.weight3 = weights0[j].w;
context.boneWeights.Add(bw);
}
}
// blendshape
if (prim.targets != null && prim.targets.Count > 0)
{
context.blendShapes.AddRange(prim.targets.Select((x, i) => new BlendShape(
i < prim.extras.targetNames.Count && !string.IsNullOrEmpty(prim.extras.targetNames[i])
? prim.extras.targetNames[i]
: i.ToString())));
for (int i = 0; i < prim.targets.Count; ++i)
{
//var name = string.Format("target{0}", i++);
var primTarget = prim.targets[i];
var blendShape = context.blendShapes[i];
if (primTarget.POSITION != -1)
{
blendShape.Positions.Assign(
ctx.GLTF.GetArrayFromAccessor <Vector3>(primTarget.POSITION), x => x.ReverseZ());
}
if (primTarget.NORMAL != -1)
{
blendShape.Normals.Assign(
ctx.GLTF.GetArrayFromAccessor <Vector3>(primTarget.NORMAL), x => x.ReverseZ());
}
if (primTarget.TANGENT != -1)
{
blendShape.Tangents.Assign(
ctx.GLTF.GetArrayFromAccessor <Vector3>(primTarget.TANGENT), x => x.ReverseZ());
}
}
}
}
foreach (var prim in gltfMesh.primitives)
{
if (prim.indices == -1)
{
context.subMeshes.Add(TriangleUtil.FlipTriangle(Enumerable.Range(0, context.positions.Length)).ToArray());
}
else
{
var indices = ctx.GLTF.GetIndices(prim.indices);
context.subMeshes.Add(indices);
}
// material
context.materialIndices.Add(prim.material);
}
return(context);
}
// multiple submMesh is not sharing a VertexBuffer.
// each subMesh use a independent VertexBuffer.
private static MeshContext _ImportMeshIndependentVertexBuffer(ImporterContext ctx, glTFMesh gltfMesh)
{
//Debug.LogWarning("_ImportMeshIndependentVertexBuffer");
var targets = gltfMesh.primitives[0].targets;
for (int i = 1; i < gltfMesh.primitives.Count; ++i)
{
if (!gltfMesh.primitives[i].targets.SequenceEqual(targets))
{
throw new NotImplementedException(string.Format("diffirent targets: {0} with {1}",
gltfMesh.primitives[i],
targets));
}
}
var positions = new List <Vector3>();
var normals = new List <Vector3>();
var tangents = new List <Vector4>();
var uv = new List <Vector2>();
var colors = new List <Color>();
var meshContext = new MeshContext();
foreach (var prim in gltfMesh.primitives)
{
var indexOffset = positions.Count;
var indexBuffer = prim.indices;
var positionCount = positions.Count;
positions.AddRange(ctx.GLTF.GetArrayFromAccessor <Vector3>(prim.attributes.POSITION).Select(x => x.ReverseZ()));
positionCount = positions.Count - positionCount;
// normal
if (prim.attributes.NORMAL != -1)
{
normals.AddRange(ctx.GLTF.GetArrayFromAccessor <Vector3>(prim.attributes.NORMAL).Select(x => x.ReverseZ()));
}
if (prim.attributes.TANGENT != -1)
{
tangents.AddRange(ctx.GLTF.GetArrayFromAccessor <Vector4>(prim.attributes.TANGENT).Select(x => x.ReverseZ()));
}
// uv
if (prim.attributes.TEXCOORD_0 != -1)
{
uv.AddRange(ctx.GLTF.GetArrayFromAccessor <Vector2>(prim.attributes.TEXCOORD_0).Select(x => x.ReverseY()));
}
else
{
// for inconsistent attributes in primitives
uv.AddRange(new Vector2[positionCount]);
}
// color
if (prim.attributes.COLOR_0 != -1)
{
colors.AddRange(ctx.GLTF.GetArrayFromAccessor <Color>(prim.attributes.COLOR_0));
}
// skin
if (prim.attributes.JOINTS_0 != -1 && prim.attributes.WEIGHTS_0 != -1)
{
var joints0 = ctx.GLTF.GetArrayFromAccessor <UShort4>(prim.attributes.JOINTS_0); // uint4
var weights0 = ctx.GLTF.GetArrayFromAccessor <Float4>(prim.attributes.WEIGHTS_0).Select(x => x.One()).ToArray();
for (int j = 0; j < joints0.Length; ++j)
{
var bw = new BoneWeight();
bw.boneIndex0 = joints0[j].x;
bw.weight0 = weights0[j].x;
bw.boneIndex1 = joints0[j].y;
bw.weight1 = weights0[j].y;
bw.boneIndex2 = joints0[j].z;
bw.weight2 = weights0[j].z;
bw.boneIndex3 = joints0[j].w;
bw.weight3 = weights0[j].w;
meshContext.boneWeights.Add(bw);
}
}
// blendshape
if (prim.targets != null && prim.targets.Count > 0)
{
for (int i = 0; i < prim.targets.Count; ++i)
{
//var name = string.Format("target{0}", i++);
var primTarget = prim.targets[i];
var blendShape = new BlendShape(!string.IsNullOrEmpty(prim.extras.targetNames[i])
? prim.extras.targetNames[i]
: i.ToString())
;
if (primTarget.POSITION != -1)
{
blendShape.Positions.AddRange(
ctx.GLTF.GetArrayFromAccessor <Vector3>(primTarget.POSITION).Select(x => x.ReverseZ()).ToArray());
}
if (primTarget.NORMAL != -1)
{
blendShape.Normals.AddRange(
ctx.GLTF.GetArrayFromAccessor <Vector3>(primTarget.NORMAL).Select(x => x.ReverseZ()).ToArray());
}
if (primTarget.TANGENT != -1)
{
blendShape.Tangents.AddRange(
ctx.GLTF.GetArrayFromAccessor <Vector3>(primTarget.TANGENT).Select(x => x.ReverseZ()).ToArray());
}
meshContext.blendShapes.Add(blendShape);
}
}
var indices =
(indexBuffer >= 0)
? ctx.GLTF.GetIndices(indexBuffer)
: TriangleUtil.FlipTriangle(Enumerable.Range(0, meshContext.positions.Length)).ToArray() // without index array
;
for (int i = 0; i < indices.Length; ++i)
{
indices[i] += indexOffset;
}
meshContext.subMeshes.Add(indices);
// material
meshContext.materialIndices.Add(prim.material);
}
meshContext.positions = positions.ToArray();
meshContext.normals = normals.ToArray();
meshContext.tangents = tangents.ToArray();
meshContext.uv = uv.ToArray();
return(meshContext);
}
public static MeshWithMaterials BuildMesh(ImporterContext ctx, MeshContext meshContext)
{
if (!meshContext.materialIndices.Any())
{
meshContext.materialIndices.Add(0);
}
//Debug.Log(prims.ToJson());
var mesh = new Mesh();
mesh.name = meshContext.name;
if (meshContext.positions.Length > UInt16.MaxValue)
{
#if UNITY_2017_3_OR_NEWER
mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
#else
Debug.LogWarningFormat("vertices {0} exceed 65535. not implemented. Unity2017.3 supports large mesh",
meshContext.positions.Length);
#endif
}
mesh.vertices = meshContext.positions;
if (meshContext.normals != null && meshContext.normals.Length > 0)
{
mesh.normals = meshContext.normals;
}
else
{
mesh.RecalculateNormals();
}
if (meshContext.tangents != null && meshContext.tangents.Length > 0)
{
mesh.tangents = meshContext.tangents;
}
else
{
#if UNITY_5_6_OR_NEWER
mesh.RecalculateTangents();
#endif
}
if (meshContext.uv != null && meshContext.uv.Length > 0)
{
mesh.uv = meshContext.uv;
}
if (meshContext.colors != null && meshContext.colors.Length > 0)
{
mesh.colors = meshContext.colors;
}
if (meshContext.boneWeights != null && meshContext.boneWeights.Count > 0)
{
mesh.boneWeights = meshContext.boneWeights.ToArray();
}
mesh.subMeshCount = meshContext.subMeshes.Count;
for (int i = 0; i < meshContext.subMeshes.Count; ++i)
{
mesh.SetTriangles(meshContext.subMeshes[i], i);
}
var result = new MeshWithMaterials
{
Mesh = mesh,
Materials = meshContext.materialIndices.Select(x => ctx.Materials[x]).ToArray()
};
if (meshContext.blendShapes != null)
{
foreach (var blendShape in meshContext.blendShapes)
{
if (blendShape.Positions.Count > 0)
{
if (blendShape.Positions.Count == mesh.vertexCount)
{
mesh.AddBlendShapeFrame(blendShape.Name, FRAME_WEIGHT,
blendShape.Positions.ToArray(),
(meshContext.normals != null && meshContext.normals.Length == mesh.vertexCount) ? blendShape.Normals.ToArray() : null,
null
);
}
else
{
Debug.LogWarningFormat("May be partial primitive has blendShape. Rquire separete mesh or extend blend shape, but not implemented: {0}", blendShape.Name);
}
}
else
{
Debug.LogFormat("empty blendshape: {0}.{1}", mesh.name, blendShape.Name);
// add empty blend shape for keep blend shape index
mesh.AddBlendShapeFrame(blendShape.Name, FRAME_WEIGHT,
//Enumerable.Range(0, mesh.vertexCount).Select(x => Vector3.zero).ToArray(),
null,
null,
null
);
}
}
}
return(result);
}
// mesh is sharing morph targets.
private static MeshContext _ImportMeshSharingMorphTarget(ImporterContext ctx, glTFMesh gltfMesh)
{
var positions = new List <Vector3>();
var normals = new List <Vector3>();
var tangents = new List <Vector4>();
var uv = new List <Vector2>();
var colors = new List <Color>();
var blendShapes = new List <BlendShape>();
var meshContext = new MeshContext();
// blendshapes
var targetNames = gltfMesh.extras.targetNames;
for (int i = 1; i < gltfMesh.primitives.Count; ++i)
{
if (gltfMesh.primitives[i].targets.Count != targetNames.Count)
{
throw new FormatException(string.Format("different targets length: {0} with targetNames length.",
gltfMesh.primitives[i]));
}
}
for (var i = 0; i < targetNames.Count; i++)
{
var blendShape = new BlendShape(!string.IsNullOrEmpty(targetNames[i]) ? targetNames[i] : i.ToString());
blendShapes.Add(blendShape);
}
foreach (var prim in gltfMesh.primitives)
{
var indexOffset = positions.Count;
var indexBuffer = prim.indices;
var positionCount = positions.Count;
positions.AddRange(ctx.GLTF.GetArrayFromAccessor <Vector3>(prim.attributes.POSITION).Select(x => x.ReverseZ()));
positionCount = positions.Count - positionCount;
// normal
if (prim.attributes.NORMAL != -1)
{
normals.AddRange(ctx.GLTF.GetArrayFromAccessor <Vector3>(prim.attributes.NORMAL).Select(x => x.ReverseZ()));
}
if (prim.attributes.TANGENT != -1)
{
tangents.AddRange(ctx.GLTF.GetArrayFromAccessor <Vector4>(prim.attributes.TANGENT).Select(x => x.ReverseZ()));
}
// uv
if (prim.attributes.TEXCOORD_0 != -1)
{
if (ctx.IsGeneratedUniGLTFAndOlder(1, 16))
{
#pragma warning disable 0612
// backward compatibility
uv.AddRange(ctx.GLTF.GetArrayFromAccessor <Vector2>(prim.attributes.TEXCOORD_0).Select(x => x.ReverseY()));
#pragma warning restore 0612
}
else
{
uv.AddRange(ctx.GLTF.GetArrayFromAccessor <Vector2>(prim.attributes.TEXCOORD_0).Select(x => x.ReverseUV()));
}
}
else
{
// for inconsistent attributes in primitives
uv.AddRange(new Vector2[positionCount]);
}
// color
if (prim.attributes.COLOR_0 != -1)
{
colors.AddRange(ctx.GLTF.GetArrayFromAccessor <Color>(prim.attributes.COLOR_0));
}
// skin
if (prim.attributes.JOINTS_0 != -1 && prim.attributes.WEIGHTS_0 != -1)
{
var joints0 = ctx.GLTF.GetArrayFromAccessor <UShort4>(prim.attributes.JOINTS_0); // uint4
var weights0 = ctx.GLTF.GetArrayFromAccessor <Float4>(prim.attributes.WEIGHTS_0).Select(x => x.One()).ToArray();
for (int j = 0; j < joints0.Length; ++j)
{
var bw = new BoneWeight();
bw.boneIndex0 = joints0[j].x;
bw.weight0 = weights0[j].x;
bw.boneIndex1 = joints0[j].y;
bw.weight1 = weights0[j].y;
bw.boneIndex2 = joints0[j].z;
bw.weight2 = weights0[j].z;
bw.boneIndex3 = joints0[j].w;
bw.weight3 = weights0[j].w;
meshContext.boneWeights.Add(bw);
}
}
// blendshape
if (prim.targets != null && prim.targets.Count > 0)
{
for (int i = 0; i < prim.targets.Count; ++i)
{
var primTarget = prim.targets[i];
if (primTarget.POSITION != -1)
{
blendShapes[i].Positions.AddRange(
ctx.GLTF.GetArrayFromAccessor <Vector3>(primTarget.POSITION).Select(x => x.ReverseZ()).ToArray());
}
if (primTarget.NORMAL != -1)
{
blendShapes[i].Normals.AddRange(
ctx.GLTF.GetArrayFromAccessor <Vector3>(primTarget.NORMAL).Select(x => x.ReverseZ()).ToArray());
}
if (primTarget.TANGENT != -1)
{
blendShapes[i].Tangents.AddRange(
ctx.GLTF.GetArrayFromAccessor <Vector3>(primTarget.TANGENT).Select(x => x.ReverseZ()).ToArray());
}
}
}
var indices =
(indexBuffer >= 0)
? ctx.GLTF.GetIndices(indexBuffer)
: TriangleUtil.FlipTriangle(Enumerable.Range(0, meshContext.positions.Length)).ToArray() // without index array
;
for (int i = 0; i < indices.Length; ++i)
{
indices[i] += indexOffset;
}
meshContext.subMeshes.Add(indices);
// material
meshContext.materialIndices.Add(prim.material);
}
meshContext.positions = positions.ToArray();
meshContext.normals = normals.ToArray();
meshContext.tangents = tangents.ToArray();
meshContext.uv = uv.ToArray();
meshContext.blendShapes = blendShapes;
return(meshContext);
}
async Task <MeshWithMaterials> BuildMeshAsync(IAwaitCaller awaitCaller, Func <string, IDisposable> MeasureTime, MeshContext x, int i)
{
using (MeasureTime("BuildMesh"))
{
var meshWithMaterials = await MeshImporter.BuildMeshAsync(awaitCaller, MaterialFactory.GetMaterial, x);
var mesh = meshWithMaterials.Mesh;
// mesh name
if (string.IsNullOrEmpty(mesh.name))
{
mesh.name = string.Format("UniGLTF import#{0}", i);
}
var originalName = mesh.name;
for (int j = 1; Meshes.Any(y => y.Mesh.name == mesh.name); ++j)
{
mesh.name = string.Format("{0}({1})", originalName, j);
}
return(meshWithMaterials);
}
}
