public gltfMorphTarget ToGltf(glTF gltf, int bufferIndex, bool useNormal)
{
var positionAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, m_positions.ToArray(), glBufferTarget.ARRAY_BUFFER);
var normalAccessorIndex = -1;
if (useNormal)
{
normalAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, m_normals.ToArray(), glBufferTarget.ARRAY_BUFFER);
}
return(new gltfMorphTarget
{
POSITION = positionAccessorIndex,
NORMAL = normalAccessorIndex,
});
}
public gltfMorphTarget ToGltf(glTF gltf, int bufferIndex, bool useNormal)
{
var positionAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, m_positions.ToArray(), glBufferTarget.ARRAY_BUFFER);
gltf.accessors[positionAccessorIndex].min = m_positions.Aggregate(m_positions[0], (a, b) => new Vector3(Mathf.Min(a.x, b.x), Math.Min(a.y, b.y), Mathf.Min(a.z, b.z))).ToArray();
gltf.accessors[positionAccessorIndex].max = m_positions.Aggregate(m_positions[0], (a, b) => new Vector3(Mathf.Max(a.x, b.x), Math.Max(a.y, b.y), Mathf.Max(a.z, b.z))).ToArray();
var normalAccessorIndex = -1;
if (useNormal)
{
normalAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, m_normals.ToArray(), glBufferTarget.ARRAY_BUFFER);
}
return(new gltfMorphTarget
{
POSITION = positionAccessorIndex,
NORMAL = normalAccessorIndex,
});
}
public glTFPrimitives ToGltfPrimitive(glTF gltf, int bufferIndex, int materialIndex, IEnumerable <int> indices)
{
var indicesAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, indices.Select(x => (uint)m_vertexIndexMap[x]).ToArray(), glBufferTarget.ELEMENT_ARRAY_BUFFER);
var positions = m_positions.ToArray();
var positionAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, positions, glBufferTarget.ARRAY_BUFFER);
var normals = m_normals.ToArray();
var normalAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, normals, glBufferTarget.ARRAY_BUFFER);
var uvAccessorIndex0 = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, m_uv.ToArray(), glBufferTarget.ARRAY_BUFFER);
int?jointsAccessorIndex = default;
if (m_joints != null)
{
jointsAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, m_joints.ToArray(), glBufferTarget.ARRAY_BUFFER);
}
int?weightAccessorIndex = default;
if (m_weights != null)
{
weightAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, m_weights.ToArray(), glBufferTarget.ARRAY_BUFFER);
}
var primitive = new glTFPrimitives
{
indices = indicesAccessorIndex,
attributes = new glTFAttributes
{
POSITION = positionAccessorIndex,
NORMAL = normalAccessorIndex,
TEXCOORD_0 = uvAccessorIndex0,
JOINTS_0 = jointsAccessorIndex.GetValueOrDefault(-1),
WEIGHTS_0 = weightAccessorIndex.GetValueOrDefault(-1),
},
material = materialIndex,
mode = 4,
};
return(primitive);
}
public void FromGameObject(glTF gltf, GameObject go, bool useSparseAccessorForMorphTarget = false)
{
var bytesBuffer = new ArrayByteBuffer(new byte[50 * 1024 * 1024]);
var bufferIndex = gltf.AddBuffer(bytesBuffer);
GameObject tmpParent = null;
if (go.transform.childCount == 0)
{
tmpParent = new GameObject("tmpParent");
go.transform.SetParent(tmpParent.transform, true);
go = tmpParent;
}
try
{
Nodes = go.transform.Traverse()
.Skip(1) // exclude root object for the symmetry with the importer
.ToList();
#region Materials and Textures
Materials = Nodes.SelectMany(x => x.GetSharedMaterials()).Where(x => x != null).Distinct().ToList();
var unityTextures = Materials.SelectMany(x => TextureIO.GetTextures(x)).Where(x => x.Texture != null).Distinct().ToList();
List <Texture> exportTextures = null;
Textures = unityTextures.Select(y => y.Texture).ToList();
var materialExporter = CreateMaterialExporter();
gltf.materials = Materials.Select(x => materialExporter.ExportMaterial(x, Textures, out exportTextures)).ToList();
for (int i = 0; i < unityTextures.Count; ++i)
{
var unityTexture = unityTextures[i];
TextureIO.ExportTexture(gltf, bufferIndex, exportTextures[i], unityTexture.TextureType);
}
#endregion
#region Meshes
var unityMeshes = Nodes
.Select(x => new MeshWithRenderer
{
Mesh = x.GetSharedMesh(),
Rendererer = x.GetComponent <Renderer>(),
})
.Where(x =>
{
if (x.Mesh == null)
{
return(false);
}
if (x.Rendererer.sharedMaterials == null ||
x.Rendererer.sharedMaterials.Length == 0)
{
return(false);
}
return(true);
})
.ToList();
ExportMeshes(gltf, bufferIndex, unityMeshes, Materials, useSparseAccessorForMorphTarget);
Meshes = unityMeshes.Select(x => x.Mesh).ToList();
#endregion
#region Skins
var unitySkins = Nodes
.Select(x => x.GetComponent <SkinnedMeshRenderer>()).Where(x =>
x != null &&
x.bones != null &&
x.bones.Length > 0)
.ToList();
gltf.nodes = Nodes.Select(x => ExportNode(x, Nodes, unityMeshes.Select(y => y.Mesh).ToList(), unitySkins)).ToList();
gltf.scenes = new List <gltfScene>
{
new gltfScene
{
nodes = go.transform.GetChildren().Select(x => Nodes.IndexOf(x)).ToArray(),
}
};
foreach (var x in unitySkins)
{
var matrices = x.sharedMesh.bindposes.Select(y => y.ReverseZ()).ToArray();
var accessor = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, matrices, glBufferTarget.NONE);
var skin = new glTFSkin
{
inverseBindMatrices = accessor,
joints = x.bones.Select(y => Nodes.IndexOf(y)).ToArray(),
skeleton = Nodes.IndexOf(x.rootBone),
};
var skinIndex = gltf.skins.Count;
gltf.skins.Add(skin);
foreach (var z in Nodes.Where(y => y.Has(x)))
{
var nodeIndex = Nodes.IndexOf(z);
var node = gltf.nodes[nodeIndex];
node.skin = skinIndex;
}
}
#endregion
#if UNITY_EDITOR
#region Animations
var clips = new List <AnimationClip>();
var animator = go.GetComponent <Animator>();
var animation = go.GetComponent <Animation>();
if (animator != null)
{
clips = AnimationExporter.GetAnimationClips(animator);
}
else if (animation != null)
{
clips = AnimationExporter.GetAnimationClips(animation);
}
if (clips.Any())
{
foreach (AnimationClip clip in clips)
{
var animationWithCurve = AnimationExporter.Export(clip, go.transform, Nodes);
foreach (var kv in animationWithCurve.SamplerMap)
{
var sampler = animationWithCurve.Animation.samplers[kv.Key];
var inputAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, kv.Value.Input);
sampler.input = inputAccessorIndex;
var outputAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, kv.Value.Output);
sampler.output = outputAccessorIndex;
// modify accessors
var outputAccessor = gltf.accessors[outputAccessorIndex];
var channel = animationWithCurve.Animation.channels.First(x => x.sampler == kv.Key);
switch (glTFAnimationTarget.GetElementCount(channel.target.path))
{
case 1:
outputAccessor.type = "SCALAR";
outputAccessor.count = 1;
break;
case 3:
outputAccessor.type = "VEC3";
outputAccessor.count /= 3;
break;
case 4:
outputAccessor.type = "VEC4";
outputAccessor.count /= 4;
break;
default:
throw new NotImplementedException();
}
}
gltf.animations.Add(animationWithCurve.Animation);
}
}
#endregion
#endif
}
finally
{
if (tmpParent != null)
{
tmpParent.transform.GetChild(0).SetParent(null);
if (Application.isPlaying)
{
GameObject.Destroy(tmpParent);
}
else
{
GameObject.DestroyImmediate(tmpParent);
}
}
}
}
static gltfMorphTarget ExportMorphTarget(glTF gltf, int bufferIndex,
Mesh mesh, int j,
bool useSparseAccessorForMorphTarget)
{
var blendShapeVertices = mesh.vertices;
var usePosition = blendShapeVertices != null && blendShapeVertices.Length > 0;
var blendShapeNormals = mesh.normals;
var useNormal = usePosition && blendShapeNormals != null && blendShapeNormals.Length == blendShapeVertices.Length;
var blendShapeTangents = mesh.tangents.Select(y => (Vector3)y).ToArray();
//var useTangent = usePosition && blendShapeTangents != null && blendShapeTangents.Length == blendShapeVertices.Length;
var useTangent = false;
var frameCount = mesh.GetBlendShapeFrameCount(j);
mesh.GetBlendShapeFrameVertices(j, frameCount - 1, blendShapeVertices, blendShapeNormals, null);
var blendShapePositionAccessorIndex = -1;
var blendShapeNormalAccessorIndex = -1;
var blendShapeTangentAccessorIndex = -1;
if (useSparseAccessorForMorphTarget)
{
var accessorCount = blendShapeVertices.Length;
var sparseIndices = Enumerable.Range(0, blendShapeVertices.Length)
.Where(x => UseSparse(
usePosition, blendShapeVertices[x],
useNormal, blendShapeNormals[x],
useTangent, blendShapeTangents[x]))
.ToArray()
;
if (sparseIndices.Length == 0)
{
usePosition = false;
useNormal = false;
useTangent = false;
}
else
{
Debug.LogFormat("Sparse {0}/{1}", sparseIndices.Length, mesh.vertexCount);
}
/*
* var vertexSize = 12;
* if (useNormal) vertexSize += 12;
* if (useTangent) vertexSize += 24;
* var sparseBytes = (4 + vertexSize) * sparseIndices.Length;
* var fullBytes = (vertexSize) * blendShapeVertices.Length;
* Debug.LogFormat("Export sparse: {0}/{1}bytes({2}%)",
* sparseBytes, fullBytes, (int)((float)sparseBytes / fullBytes)
* );
*/
var sparseIndicesViewIndex = -1;
if (usePosition)
{
sparseIndicesViewIndex = gltf.ExtendBufferAndGetViewIndex(bufferIndex, sparseIndices);
blendShapeVertices = sparseIndices.Select(x => blendShapeVertices[x].ReverseZ()).ToArray();
blendShapePositionAccessorIndex = gltf.ExtendSparseBufferAndGetAccessorIndex(bufferIndex, accessorCount,
blendShapeVertices,
sparseIndices, sparseIndicesViewIndex,
glBufferTarget.ARRAY_BUFFER);
}
if (useNormal)
{
blendShapeNormals = sparseIndices.Select(x => blendShapeNormals[x].ReverseZ()).ToArray();
blendShapeNormalAccessorIndex = gltf.ExtendSparseBufferAndGetAccessorIndex(bufferIndex, accessorCount,
blendShapeNormals,
sparseIndices, sparseIndicesViewIndex,
glBufferTarget.ARRAY_BUFFER);
}
if (useTangent)
{
blendShapeTangents = sparseIndices.Select(x => blendShapeTangents[x].ReverseZ()).ToArray();
blendShapeTangentAccessorIndex = gltf.ExtendSparseBufferAndGetAccessorIndex(bufferIndex, accessorCount,
blendShapeTangents, sparseIndices, sparseIndicesViewIndex,
glBufferTarget.ARRAY_BUFFER);
}
}
else
{
for (int i = 0; i < blendShapeVertices.Length; ++i)
{
blendShapeVertices[i] = blendShapeVertices[i].ReverseZ();
}
if (usePosition)
{
blendShapePositionAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex,
blendShapeVertices,
glBufferTarget.ARRAY_BUFFER);
}
if (useNormal)
{
for (int i = 0; i < blendShapeNormals.Length; ++i)
{
blendShapeNormals[i] = blendShapeNormals[i].ReverseZ();
}
blendShapeNormalAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex,
blendShapeNormals,
glBufferTarget.ARRAY_BUFFER);
}
if (useTangent)
{
for (int i = 0; i < blendShapeTangents.Length; ++i)
{
blendShapeTangents[i] = blendShapeTangents[i].ReverseZ();
}
blendShapeTangentAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex,
blendShapeTangents,
glBufferTarget.ARRAY_BUFFER);
}
}
if (blendShapePositionAccessorIndex != -1)
{
gltf.accessors[blendShapePositionAccessorIndex].min = blendShapeVertices.Aggregate(blendShapeVertices[0], (a, b) => new Vector3(Mathf.Min(a.x, b.x), Math.Min(a.y, b.y), Mathf.Min(a.z, b.z))).ToArray();
gltf.accessors[blendShapePositionAccessorIndex].max = blendShapeVertices.Aggregate(blendShapeVertices[0], (a, b) => new Vector3(Mathf.Max(a.x, b.x), Math.Max(a.y, b.y), Mathf.Max(a.z, b.z))).ToArray();
}
return(new gltfMorphTarget
{
POSITION = blendShapePositionAccessorIndex,
NORMAL = blendShapeNormalAccessorIndex,
TANGENT = blendShapeTangentAccessorIndex,
});
}
static glTFMesh ExportPrimitives(glTF gltf, int bufferIndex,
string rendererName,
Mesh mesh, Material[] materials,
List <Material> unityMaterials)
{
var positions = mesh.vertices.Select(y => y.ReverseZ()).ToArray();
var positionAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, positions, glBufferTarget.ARRAY_BUFFER);
gltf.accessors[positionAccessorIndex].min = positions.Aggregate(positions[0], (a, b) => new Vector3(Mathf.Min(a.x, b.x), Math.Min(a.y, b.y), Mathf.Min(a.z, b.z))).ToArray();
gltf.accessors[positionAccessorIndex].max = positions.Aggregate(positions[0], (a, b) => new Vector3(Mathf.Max(a.x, b.x), Math.Max(a.y, b.y), Mathf.Max(a.z, b.z))).ToArray();
var normalAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.normals.Select(y => y.ReverseZ()).ToArray(), glBufferTarget.ARRAY_BUFFER);
#if GLTF_EXPORT_TANGENTS
var tangentAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.tangents.Select(y => y.ReverseZ()).ToArray(), glBufferTarget.ARRAY_BUFFER);
#endif
var uvAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.uv.Select(y => y.ReverseUV()).ToArray(), glBufferTarget.ARRAY_BUFFER);
var colorAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.colors, glBufferTarget.ARRAY_BUFFER);
var boneweights = mesh.boneWeights;
var weightAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, boneweights.Select(y => new Vector4(y.weight0, y.weight1, y.weight2, y.weight3)).ToArray(), glBufferTarget.ARRAY_BUFFER);
var jointsAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, boneweights.Select(y => new UShort4((ushort)y.boneIndex0, (ushort)y.boneIndex1, (ushort)y.boneIndex2, (ushort)y.boneIndex3)).ToArray(), glBufferTarget.ARRAY_BUFFER);
var attributes = new glTFAttributes
{
POSITION = positionAccessorIndex,
};
if (normalAccessorIndex != -1)
{
attributes.NORMAL = normalAccessorIndex;
}
#if GLTF_EXPORT_TANGENTS
if (tangentAccessorIndex != -1)
{
attributes.TANGENT = tangentAccessorIndex;
}
#endif
if (uvAccessorIndex != -1)
{
attributes.TEXCOORD_0 = uvAccessorIndex;
}
if (colorAccessorIndex != -1)
{
attributes.COLOR_0 = colorAccessorIndex;
}
if (weightAccessorIndex != -1)
{
attributes.WEIGHTS_0 = weightAccessorIndex;
}
if (jointsAccessorIndex != -1)
{
attributes.JOINTS_0 = jointsAccessorIndex;
}
var gltfMesh = new glTFMesh(mesh.name);
for (int j = 0; j < mesh.subMeshCount; ++j)
{
var indices = TriangleUtil.FlipTriangle(mesh.GetIndices(j)).Select(y => (uint)y).ToArray();
var indicesAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, indices, glBufferTarget.ELEMENT_ARRAY_BUFFER);
if (j >= materials.Length)
{
Debug.LogWarningFormat("{0}.materials is not enough", rendererName);
break;
}
gltfMesh.primitives.Add(new glTFPrimitives
{
attributes = attributes,
indices = indicesAccessorIndex,
mode = 4, // triangels ?
material = unityMaterials.IndexOf(materials[j])
});
}
return(gltfMesh);
}
public static int ExtendBufferAndGetAccessorIndex <T>(this glTF gltf, int bufferIndex, T[] array,
glBufferTarget target = glBufferTarget.NONE) where T : struct
{
return(gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, new ArraySegment <T>(array), target));
}
public static gltfMorphTarget Export(glTF gltf, int gltfBuffer, Vector3[] positions, Vector3[] normals, bool useSparse)
{
var accessorCount = positions.Length;
if (normals != null && positions.Length != normals.Length)
{
throw new Exception();
}
int[] sparseIndices = default;
if (useSparse)
{
sparseIndices = Enumerable.Range(0, positions.Length).Where(x => positions[x] != Vector3.zero).ToArray();
if (sparseIndices.Length == 0)
{
// sparse 対象がすべて [0, 0, 0] の場合
// new glTFSparse
// {
// count = 0,
// }
// のようになる。
// たぶん、仕様的にはあり。
// 解釈できない場合あり。
useSparse = false;
}
}
if (useSparse)
{
if (sparseIndices == null)
{
throw new Exception();
}
// positions
var positionAccessorIndex = -1;
if (sparseIndices.Length > 0)
{
var sparseIndicesViewIndex = gltf.ExtendBufferAndGetViewIndex(gltfBuffer, sparseIndices);
positionAccessorIndex = gltf.ExtendSparseBufferAndGetAccessorIndex(gltfBuffer, accessorCount,
sparseIndices.Select(x => positions[x]).ToArray(), sparseIndices, sparseIndicesViewIndex,
glBufferTarget.NONE);
}
// normals
var normalAccessorIndex = -1;
if (normals != null)
{
var sparseNormalIndices = Enumerable.Range(0, positions.Length).Where(x => normals[x] != Vector3.zero).ToArray();
if (sparseNormalIndices.Length > 0)
{
var sparseNormalIndicesViewIndex = gltf.ExtendBufferAndGetViewIndex(gltfBuffer, sparseNormalIndices);
normalAccessorIndex = gltf.ExtendSparseBufferAndGetAccessorIndex(gltfBuffer, accessorCount,
sparseNormalIndices.Select(x => normals[x]).ToArray(), sparseNormalIndices, sparseNormalIndicesViewIndex,
glBufferTarget.NONE);
}
}
return(new gltfMorphTarget
{
POSITION = positionAccessorIndex,
NORMAL = normalAccessorIndex,
});
}
else
{
// position
var positionAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(gltfBuffer, positions, glBufferTarget.ARRAY_BUFFER);
gltf.accessors[positionAccessorIndex].min = positions.Aggregate(positions[0], (a, b) => new Vector3(Mathf.Min(a.x, b.x), Math.Min(a.y, b.y), Mathf.Min(a.z, b.z))).ToArray();
gltf.accessors[positionAccessorIndex].max = positions.Aggregate(positions[0], (a, b) => new Vector3(Mathf.Max(a.x, b.x), Math.Max(a.y, b.y), Mathf.Max(a.z, b.z))).ToArray();
// normal
var normalAccessorIndex = -1;
if (normals != null)
{
normalAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(gltfBuffer, normals, glBufferTarget.ARRAY_BUFFER);
}
return(new gltfMorphTarget
{
POSITION = positionAccessorIndex,
NORMAL = normalAccessorIndex,
});
}
}
public static Exported FromGameObject(glTF gltf, GameObject go, bool useSparseAccessorForMorphTarget = false)
{
var bytesBuffer = new ArrayByteBuffer(new byte[50 * 1024 * 1024]);
var bufferIndex = gltf.AddBuffer(bytesBuffer);
if (go.transform.childCount == 0)
{
throw new UniGLTFException("root node required");
}
var unityNodes = go.transform.Traverse()
.Skip(1) // exclude root object for the symmetry with the importer
.ToList();
#region Material
var unityMaterials = unityNodes.SelectMany(x => x.GetSharedMaterials()).Where(x => x != null).Distinct().ToList();
var unityTextures = unityMaterials.SelectMany(x => x.GetTextures()).Where(x => x != null).Distinct().ToList();
for (int i = 0; i < unityTextures.Count; ++i)
{
var texture = unityTextures[i];
ExportTexture(gltf, bufferIndex, texture);
}
gltf.materials = unityMaterials.Select(x => ExportMaterial(x, unityTextures)).ToList();
#endregion
#region Meshes
var unityMeshes = unityNodes
.Select(x => new MeshWithRenderer
{
Mesh = x.GetSharedMesh(),
Rendererer = x.GetComponent <Renderer>(),
})
.Where(x => x.Mesh != null)
.ToList();
ExportMeshes(gltf, bufferIndex, unityMeshes, unityMaterials, useSparseAccessorForMorphTarget);
#endregion
#region Skins
var unitySkins = unityNodes
.Select(x => x.GetComponent <SkinnedMeshRenderer>()).Where(x => x != null)
.ToList();
gltf.nodes = unityNodes.Select(x => ExportNode(x, unityNodes, unityMeshes.Select(y => y.Mesh).ToList(), unitySkins)).ToList();
gltf.scenes = new List <gltfScene>
{
new gltfScene
{
nodes = go.transform.GetChildren().Select(x => unityNodes.IndexOf(x)).ToArray(),
}
};
foreach (var x in unitySkins)
{
var matrices = x.sharedMesh.bindposes.Select(y => y.ReverseZ()).ToArray();
var accessor = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, matrices, glBufferTarget.NONE);
var skin = new glTFSkin
{
inverseBindMatrices = accessor,
joints = x.bones.Select(y => unityNodes.IndexOf(y)).ToArray(),
skeleton = unityNodes.IndexOf(x.rootBone),
};
var skinIndex = gltf.skins.Count;
gltf.skins.Add(skin);
foreach (var z in unityNodes.Where(y => y.Has(x)))
{
var nodeIndex = unityNodes.IndexOf(z);
var node = gltf.nodes[nodeIndex];
node.skin = skinIndex;
node.extras.skinRootBone = unityNodes.IndexOf(x.rootBone);
}
}
#endregion
#if UNITY_EDITOR
#region Animations
var animation = go.GetComponent <Animation>();
if (animation != null)
{
foreach (AnimationState state in animation)
{
var animationWithCurve = ExportAnimation(state.clip, go.transform, unityNodes);
foreach (var kv in animationWithCurve.SamplerMap)
{
var sampler = animationWithCurve.Animation.samplers[kv.Key];
var inputAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, kv.Value.Input);
sampler.input = inputAccessorIndex;
var outputAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, kv.Value.Output);
sampler.output = outputAccessorIndex;
// modify accessors
var outputAccessor = gltf.accessors[outputAccessorIndex];
var channel = animationWithCurve.Animation.channels.First(x => x.sampler == kv.Key);
switch (glTFAnimationTarget.GetElementCount(channel.target.path))
{
case 3:
outputAccessor.type = "VEC3";
outputAccessor.count /= 3;
break;
case 4:
outputAccessor.type = "VEC4";
outputAccessor.count /= 4;
break;
default:
throw new NotImplementedException();
}
}
gltf.animations.Add(animationWithCurve.Animation);
}
}
#endregion
#endif
return(new Exported
{
Meshes = unityMeshes,
Nodes = unityNodes.Select(x => x.transform).ToList(),
Materials = unityMaterials,
Textures = unityTextures,
});
}
static glTFMesh ExportPrimitives(glTF gltf, int bufferIndex,
MeshWithRenderer unityMesh, List <Material> unityMaterials)
{
var mesh = unityMesh.Mesh;
var materials = unityMesh.Renderer.sharedMaterials;
var positions = mesh.vertices.Select(y => y.ReverseZ()).ToArray();
var positionAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, positions, glBufferTarget.ARRAY_BUFFER);
gltf.accessors[positionAccessorIndex].min = positions.Aggregate(positions[0], (a, b) => new Vector3(Mathf.Min(a.x, b.x), Math.Min(a.y, b.y), Mathf.Min(a.z, b.z))).ToArray();
gltf.accessors[positionAccessorIndex].max = positions.Aggregate(positions[0], (a, b) => new Vector3(Mathf.Max(a.x, b.x), Math.Max(a.y, b.y), Mathf.Max(a.z, b.z))).ToArray();
var normalAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.normals.Select(y => y.normalized.ReverseZ()).ToArray(), glBufferTarget.ARRAY_BUFFER);
#if GLTF_EXPORT_TANGENTS
var tangentAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.tangents.Select(y => y.ReverseZ()).ToArray(), glBufferTarget.ARRAY_BUFFER);
#endif
var uvAccessorIndex0 = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.uv.Select(y => y.ReverseUV()).ToArray(), glBufferTarget.ARRAY_BUFFER);
var uvAccessorIndex1 = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.uv2.Select(y => y.ReverseUV()).ToArray(), glBufferTarget.ARRAY_BUFFER);
var colorAccessorIndex = -1;
var vColorState = MeshExportInfo.DetectVertexColor(mesh, materials);
if (vColorState == MeshExportInfo.VertexColorState.ExistsAndIsUsed || // VColor使っている
vColorState == MeshExportInfo.VertexColorState.ExistsAndMixed // VColorを使っているところと使っていないところが混在(とりあえずExportする)
)
{
// UniUnlit で Multiply 設定になっている
colorAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.colors, glBufferTarget.ARRAY_BUFFER);
}
var boneweights = mesh.boneWeights;
var weightAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, boneweights.Select(y => new Vector4(y.weight0, y.weight1, y.weight2, y.weight3)).ToArray(), glBufferTarget.ARRAY_BUFFER);
var jointsAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, boneweights.Select(y =>
new UShort4(
(ushort)unityMesh.GetJointIndex(y.boneIndex0),
(ushort)unityMesh.GetJointIndex(y.boneIndex1),
(ushort)unityMesh.GetJointIndex(y.boneIndex2),
(ushort)unityMesh.GetJointIndex(y.boneIndex3))
).ToArray(), glBufferTarget.ARRAY_BUFFER);
var attributes = new glTFAttributes
{
POSITION = positionAccessorIndex,
};
if (normalAccessorIndex != -1)
{
attributes.NORMAL = normalAccessorIndex;
}
#if GLTF_EXPORT_TANGENTS
if (tangentAccessorIndex != -1)
{
attributes.TANGENT = tangentAccessorIndex;
}
#endif
if (uvAccessorIndex0 != -1)
{
attributes.TEXCOORD_0 = uvAccessorIndex0;
}
if (uvAccessorIndex1 != -1)
{
attributes.TEXCOORD_1 = uvAccessorIndex1;
}
if (colorAccessorIndex != -1)
{
attributes.COLOR_0 = colorAccessorIndex;
}
if (weightAccessorIndex != -1)
{
attributes.WEIGHTS_0 = weightAccessorIndex;
}
if (jointsAccessorIndex != -1)
{
attributes.JOINTS_0 = jointsAccessorIndex;
}
var gltfMesh = new glTFMesh(mesh.name);
var indices = new List <uint>();
for (int j = 0; j < mesh.subMeshCount; ++j)
{
indices.Clear();
var triangles = mesh.GetIndices(j);
if (triangles.Length == 0)
{
// https://github.com/vrm-c/UniVRM/issues/664
continue;
}
for (int i = 0; i < triangles.Length; i += 3)
{
var i0 = triangles[i];
var i1 = triangles[i + 1];
var i2 = triangles[i + 2];
// flip triangle
indices.Add((uint)i2);
indices.Add((uint)i1);
indices.Add((uint)i0);
}
var indicesAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, indices.ToArray(), glBufferTarget.ELEMENT_ARRAY_BUFFER);
if (indicesAccessorIndex < 0)
{
// https://github.com/vrm-c/UniVRM/issues/664
throw new Exception();
}
if (j >= materials.Length)
{
Debug.LogWarningFormat("{0}.materials is not enough", unityMesh.Renderer.name);
break;
}
gltfMesh.primitives.Add(new glTFPrimitives
{
attributes = attributes,
indices = indicesAccessorIndex,
mode = 4, // triangles ?
material = unityMaterials.IndexOf(materials[j])
});
}
return(gltfMesh);
}
public static Exported FromGameObject(glTF gltf, GameObject go)
{
var bytesBuffer = new ArrayByteBuffer();
var bufferIndex = gltf.AddBuffer(bytesBuffer);
var unityNodes = go.transform.Traverse()
.Skip(1) // exclude root object for the symmetry with the importer
.ToList();
#region Material
var unityMaterials = unityNodes.SelectMany(x => x.GetSharedMaterials()).Where(x => x != null).Distinct().ToList();
var unityTextures = unityMaterials.SelectMany(x => x.GetTextures()).Where(x => x != null).Distinct().ToList();
for (int i = 0; i < unityTextures.Count; ++i)
{
var texture = unityTextures[i];
var bytesWithPath = new BytesWithPath(texture);;
// add view
var view = gltf.buffers[bufferIndex].Storage.Extend(bytesWithPath.Bytes, glBufferTarget.NONE);
var viewIndex = gltf.AddBufferView(view);
// add image
var imageIndex = gltf.images.Count;
gltf.images.Add(new glTFImage
{
bufferView = viewIndex,
mimeType = bytesWithPath.Mime,
});
// add sampler
var filter = default(glFilter);
switch (texture.filterMode)
{
case FilterMode.Point:
filter = glFilter.NEAREST;
break;
default:
filter = glFilter.LINEAR;
break;
}
var wrap = default(glWrap);
switch (texture.wrapMode)
{
case TextureWrapMode.Clamp:
wrap = glWrap.CLAMP_TO_EDGE;
break;
case TextureWrapMode.Repeat:
wrap = glWrap.REPEAT;
break;
#if UNITY_2017_OR_NEWER
case TextureWrapMode.Mirror:
wrap = glWrap.MIRRORED_REPEAT;
break;
#endif
default:
throw new NotImplementedException();
}
var samplerIndex = gltf.samplers.Count;
gltf.samplers.Add(new glTFTextureSampler
{
magFilter = filter,
minFilter = filter,
wrapS = wrap,
wrapT = wrap,
});
// add texture
gltf.textures.Add(new glTFTexture
{
sampler = samplerIndex,
source = imageIndex,
});
}
gltf.materials = unityMaterials.Select(x => ExportMaterial(x, unityTextures)).ToList();
#endregion
#region Meshes
var unityMeshes = unityNodes
.Select(x => new MeshWithRenderer
{
Mesh = x.GetSharedMesh(),
Rendererer = x.GetComponent <Renderer>(),
})
.Where(x => x.Mesh != null)
.ToList();
for (int i = 0; i < unityMeshes.Count; ++i)
{
var x = unityMeshes[i];
var mesh = x.Mesh;
var materials = x.Rendererer.sharedMaterials;
var positions = mesh.vertices.Select(y => y.ReverseZ()).ToArray();
var positionAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, positions, glBufferTarget.ARRAY_BUFFER);
gltf.accessors[positionAccessorIndex].min = positions.Aggregate(positions[0], (a, b) => new Vector3(Mathf.Min(a.x, b.x), Math.Min(a.y, b.y), Mathf.Min(a.z, b.z))).ToArray();
gltf.accessors[positionAccessorIndex].max = positions.Aggregate(positions[0], (a, b) => new Vector3(Mathf.Max(a.x, b.x), Math.Max(a.y, b.y), Mathf.Max(a.z, b.z))).ToArray();
var normalAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.normals.Select(y => y.ReverseZ()).ToArray(), glBufferTarget.ARRAY_BUFFER);
var tangentAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.tangents.Select(y => y.ReverseZ()).ToArray(), glBufferTarget.ARRAY_BUFFER);
var colorAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.colors.Select(y => (Vector4)y).ToArray(), glBufferTarget.ARRAY_BUFFER);
var uvAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.uv.Select(y => y.ReverseY()).ToArray(), glBufferTarget.ARRAY_BUFFER);
var boneweights = mesh.boneWeights;
var weightAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, boneweights.Select(y => new Vector4(y.weight0, y.weight1, y.weight2, y.weight3)).ToArray(), glBufferTarget.ARRAY_BUFFER);
var jointsAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, boneweights.Select(y => new UShort4((ushort)y.boneIndex0, (ushort)y.boneIndex1, (ushort)y.boneIndex2, (ushort)y.boneIndex3)).ToArray(), glBufferTarget.ARRAY_BUFFER);
var attributes = new glTFAttributes
{
POSITION = positionAccessorIndex,
};
if (normalAccessorIndex != -1)
{
attributes.NORMAL = normalAccessorIndex;
}
if (tangentAccessorIndex != -1)
{
attributes.TANGENT = tangentAccessorIndex;
}
if (colorAccessorIndex != -1)
{
attributes.COLOR_0 = colorAccessorIndex;
}
if (uvAccessorIndex != -1)
{
attributes.TEXCOORD_0 = uvAccessorIndex;
}
if (weightAccessorIndex != -1)
{
attributes.WEIGHTS_0 = weightAccessorIndex;
}
if (jointsAccessorIndex != -1)
{
attributes.JOINTS_0 = jointsAccessorIndex;
}
gltf.meshes.Add(new glTFMesh(mesh.name));
for (int j = 0; j < mesh.subMeshCount; ++j)
{
var indices = TriangleUtil.FlipTriangle(mesh.GetIndices(j)).Select(y => (uint)y).ToArray();
var indicesAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, indices, glBufferTarget.ELEMENT_ARRAY_BUFFER);
gltf.meshes.Last().primitives.Add(new glTFPrimitives
{
attributes = attributes,
indices = indicesAccessorIndex,
mode = 4, // triangels ?
//material = unityMaterials.IndexOf(materials[j])
material = unityMaterials.IndexOf(materials[0]) // JIA change for Maquette image entity
});
}
if (mesh.blendShapeCount > 0)
{
for (int j = 0; j < mesh.blendShapeCount; ++j)
{
var blendShapeVertices = mesh.vertices;
var blendShpaeNormals = mesh.normals;
var blendShapeTangents = mesh.tangents.Select(y => (Vector3)y).ToArray();
var blendShapeColors = mesh.colors.Select(y => (Vector4)y).ToArray();
var k = mesh.GetBlendShapeFrameCount(j);
mesh.GetBlendShapeFrameVertices(j, k - 1, blendShapeVertices, blendShpaeNormals, null);
var blendShapePositionAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex,
blendShapeVertices.Select(y => y.ReverseZ()).ToArray(), glBufferTarget.ARRAY_BUFFER);
var blendShapeNormalAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex,
blendShpaeNormals.Select(y => y.ReverseZ()).ToArray(), glBufferTarget.ARRAY_BUFFER);
var blendShapeTangentAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex,
blendShapeTangents.Select(y => y.ReverseZ()).ToArray(), glBufferTarget.ARRAY_BUFFER);
var blendShapeColorAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex,
blendShapeColors.ToArray(), glBufferTarget.ARRAY_BUFFER);
//
// first primitive has whole blendShape
//
gltf.meshes.Last().primitives[0].targets.Add(new glTFAttributes
{
POSITION = blendShapePositionAccessorIndex,
NORMAL = blendShapeNormalAccessorIndex,
TANGENT = blendShapeTangentAccessorIndex,
COLOR_0 = blendShapeColorAccessorIndex,
});
}
}
}
#endregion
#region Skins
var unitySkins = unityNodes
.Select(x => x.GetComponent <SkinnedMeshRenderer>()).Where(x => x != null)
.ToList();
gltf.nodes = unityNodes.Select(x => ExportNode(x, unityNodes, unityMeshes.Select(y => y.Mesh).ToList(), unitySkins)).ToList();
gltf.scenes = new List <gltfScene>
{
new gltfScene
{
nodes = go.transform.GetChildren().Select(x => unityNodes.IndexOf(x)).ToArray(),
}
};
foreach (var x in unitySkins)
{
var matrices = x.sharedMesh.bindposes.Select(y => y.ReverseZ()).ToArray();
var accessor = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, matrices, glBufferTarget.NONE);
var skin = new glTFSkin
{
inverseBindMatrices = accessor,
joints = x.bones.Select(y => unityNodes.IndexOf(y)).ToArray(),
skeleton = unityNodes.IndexOf(x.rootBone),
};
var skinIndex = gltf.skins.Count;
gltf.skins.Add(skin);
foreach (var z in unityNodes.Where(y => y.Has(x)))
{
var nodeIndex = unityNodes.IndexOf(z);
gltf.nodes[nodeIndex].skin = skinIndex;
}
}
#endregion
#if UNITY_EDITOR
#region Animations
var animation = go.GetComponent <Animation>();
if (animation != null)
{
foreach (AnimationState state in animation)
{
var animationWithCurve = ExportAnimation(state.clip, go.transform, unityNodes);
foreach (var kv in animationWithCurve.SamplerMap)
{
var sampler = animationWithCurve.Animation.samplers[kv.Key];
var inputAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, kv.Value.Input);
sampler.input = inputAccessorIndex;
var outputAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, kv.Value.Output);
sampler.output = outputAccessorIndex;
// modify accessors
var outputAccessor = gltf.accessors[outputAccessorIndex];
var channel = animationWithCurve.Animation.channels.First(x => x.sampler == kv.Key);
switch (glTFAnimationTarget.GetElementCount(channel.target.path))
{
case 3:
outputAccessor.type = "VEC3";
outputAccessor.count /= 3;
break;
case 4:
outputAccessor.type = "VEC4";
outputAccessor.count /= 4;
break;
default:
throw new NotImplementedException();
}
}
gltf.animations.Add(animationWithCurve.Animation);
}
}
#endregion
#endif
// glb buffer
gltf.buffers[bufferIndex].UpdateByteLength();
return(new Exported
{
Meshes = unityMeshes,
Nodes = unityNodes.Select(x => x.transform).ToList(),
Materials = unityMaterials,
Textures = unityTextures,
});
}
public virtual void Export(MeshExportSettings meshExportSettings, ITextureSerializer textureSerializer)
{
var bytesBuffer = new ArrayByteBuffer(new byte[50 * 1024 * 1024]);
var bufferIndex = glTF.AddBuffer(bytesBuffer);
Nodes = Copy.transform.Traverse()
.Skip(1) // exclude root object for the symmetry with the importer
.ToList();
var unityMeshes = MeshWithRenderer.FromNodes(Nodes).Where(x => x.Mesh.vertices.Any()).ToList();
var uniqueUnityMeshes = new List <MeshWithRenderer>();
foreach (var um in unityMeshes)
{
if (!uniqueUnityMeshes.Any(x => x.IsSameMeshAndMaterials(um)))
{
uniqueUnityMeshes.Add(um);
}
}
#region Materials and Textures
Materials = uniqueUnityMeshes.SelectMany(x => x.Renderer.sharedMaterials).Where(x => x != null).Distinct().ToList();
TextureExporter = new TextureExporter(textureSerializer);
var materialExporter = CreateMaterialExporter();
glTF.materials = Materials.Select(x => materialExporter.ExportMaterial(x, TextureExporter)).ToList();
#endregion
#region Meshes
MeshBlendShapeIndexMap = new Dictionary <Mesh, Dictionary <int, int> >();
foreach (var unityMesh in uniqueUnityMeshes)
{
var(gltfMesh, blendShapeIndexMap) = MeshExporter.ExportMesh(glTF, bufferIndex, unityMesh, Materials, meshExportSettings, m_axisInverter);
glTF.meshes.Add(gltfMesh);
Meshes.Add(unityMesh.Mesh);
if (!MeshBlendShapeIndexMap.ContainsKey(unityMesh.Mesh))
{
// 同じmeshが複数回現れた
MeshBlendShapeIndexMap.Add(unityMesh.Mesh, blendShapeIndexMap);
}
}
#endregion
#region Nodes and Skins
var unitySkins = uniqueUnityMeshes
.Where(x => x.UniqueBones != null)
.ToList();
glTF.nodes = Nodes.Select(x => ExportNode(x, Nodes, uniqueUnityMeshes, unitySkins.Select(y => y.Renderer as SkinnedMeshRenderer).ToList())).ToList();
glTF.scenes = new List <gltfScene>
{
new gltfScene
{
nodes = Copy.transform.GetChildren().Select(x => Nodes.IndexOf(x)).ToArray(),
}
};
foreach (var x in unitySkins)
{
var matrices = x.GetBindPoses().Select(m_axisInverter.InvertMat4).ToArray();
var accessor = glTF.ExtendBufferAndGetAccessorIndex(bufferIndex, matrices, glBufferTarget.NONE);
var renderer = x.Renderer as SkinnedMeshRenderer;
var skin = new glTFSkin
{
inverseBindMatrices = accessor,
joints = x.UniqueBones.Select(y => Nodes.IndexOf(y)).ToArray(),
skeleton = Nodes.IndexOf(renderer.rootBone),
};
var skinIndex = glTF.skins.Count;
glTF.skins.Add(skin);
foreach (var z in Nodes.Where(y => y.Has(x.Renderer)))
{
var nodeIndex = Nodes.IndexOf(z);
var node = glTF.nodes[nodeIndex];
node.skin = skinIndex;
}
}
#endregion
#if UNITY_EDITOR
#region Animations
var clips = new List <AnimationClip>();
var animator = Copy.GetComponent <Animator>();
var animation = Copy.GetComponent <Animation>();
if (animator != null)
{
clips = AnimationExporter.GetAnimationClips(animator);
}
else if (animation != null)
{
clips = AnimationExporter.GetAnimationClips(animation);
}
if (clips.Any())
{
foreach (AnimationClip clip in clips)
{
var animationWithCurve = AnimationExporter.Export(clip, Copy.transform, Nodes);
foreach (var kv in animationWithCurve.SamplerMap)
{
var sampler = animationWithCurve.Animation.samplers[kv.Key];
var inputAccessorIndex = glTF.ExtendBufferAndGetAccessorIndex(bufferIndex, kv.Value.Input);
sampler.input = inputAccessorIndex;
var outputAccessorIndex = glTF.ExtendBufferAndGetAccessorIndex(bufferIndex, kv.Value.Output);
sampler.output = outputAccessorIndex;
// modify accessors
var outputAccessor = glTF.accessors[outputAccessorIndex];
var channel = animationWithCurve.Animation.channels.First(x => x.sampler == kv.Key);
switch (glTFAnimationTarget.GetElementCount(channel.target.path))
{
case 1:
outputAccessor.type = "SCALAR";
//outputAccessor.count = ;
break;
case 3:
outputAccessor.type = "VEC3";
outputAccessor.count /= 3;
break;
case 4:
outputAccessor.type = "VEC4";
outputAccessor.count /= 4;
break;
default:
throw new NotImplementedException();
}
}
animationWithCurve.Animation.name = clip.name;
glTF.animations.Add(animationWithCurve.Animation);
}
}
#endregion
#endif
ExportExtensions(textureSerializer);
// Extension で Texture が増える場合があるので最後に呼ぶ
for (int i = 0; i < TextureExporter.Exported.Count; ++i)
{
var(unityTexture, colorSpace) = TextureExporter.Exported[i];
glTF.PushGltfTexture(bufferIndex, unityTexture, colorSpace, textureSerializer);
}
}
/// <summary>
/// primitive 間で vertex を共有する形で Export する。
/// UniVRM-0.71.0 以降は、MeshExporterDivided.Export もある。
///
/// * GLB/GLTF は shared(default) と divided を選択可能
/// * VRM0 は shared 仕様
/// * VRM1 は divided 仕様
///
/// /// </summary>
/// <param name="gltf"></param>
/// <param name="bufferIndex"></param>
/// <param name="unityMesh"></param>
/// <param name="unityMaterials"></param>
/// <param name="axisInverter"></param>
/// <param name="settings"></param>
/// <returns></returns>
public static (glTFMesh, Dictionary <int, int> blendShapeIndexMap) Export(glTF gltf, int bufferIndex,
MeshExportInfo unityMesh, List <Material> unityMaterials,
IAxisInverter axisInverter, GltfExportSettings settings)
{
var mesh = unityMesh.Mesh;
var materials = unityMesh.Materials;
var positions = mesh.vertices.Select(axisInverter.InvertVector3).ToArray();
var positionAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, positions, glBufferTarget.ARRAY_BUFFER);
gltf.accessors[positionAccessorIndex].min = positions.Aggregate(positions[0], (a, b) => new Vector3(Mathf.Min(a.x, b.x), Math.Min(a.y, b.y), Mathf.Min(a.z, b.z))).ToArray();
gltf.accessors[positionAccessorIndex].max = positions.Aggregate(positions[0], (a, b) => new Vector3(Mathf.Max(a.x, b.x), Math.Max(a.y, b.y), Mathf.Max(a.z, b.z))).ToArray();
var normalAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.normals.Select(y => axisInverter.InvertVector3(y.normalized)).ToArray(), glBufferTarget.ARRAY_BUFFER);
int?tangentAccessorIndex = default;
if (settings.ExportTangents)
{
tangentAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.tangents.Select(axisInverter.InvertVector4).ToArray(), glBufferTarget.ARRAY_BUFFER);
}
var uvAccessorIndex0 = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.uv.Select(y => y.ReverseUV()).ToArray(), glBufferTarget.ARRAY_BUFFER);
var uvAccessorIndex1 = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.uv2.Select(y => y.ReverseUV()).ToArray(), glBufferTarget.ARRAY_BUFFER);
var colorAccessorIndex = -1;
var vColorState = VertexColorUtility.DetectVertexColor(mesh, materials);
if (vColorState == VertexColorState.ExistsAndIsUsed || // VColor使っている
vColorState == VertexColorState.ExistsAndMixed // VColorを使っているところと使っていないところが混在(とりあえずExportする)
)
{
// UniUnlit で Multiply 設定になっている
colorAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, mesh.colors, glBufferTarget.ARRAY_BUFFER);
}
var boneweights = mesh.boneWeights;
var weightAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, boneweights.Select(y => new Vector4(y.weight0, y.weight1, y.weight2, y.weight3)).ToArray(), glBufferTarget.ARRAY_BUFFER);
var jointsAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, boneweights.Select(y =>
new UShort4(
(ushort)unityMesh.GetJointIndex(y.boneIndex0),
(ushort)unityMesh.GetJointIndex(y.boneIndex1),
(ushort)unityMesh.GetJointIndex(y.boneIndex2),
(ushort)unityMesh.GetJointIndex(y.boneIndex3))
).ToArray(), glBufferTarget.ARRAY_BUFFER);
var attributes = new glTFAttributes
{
POSITION = positionAccessorIndex,
};
if (normalAccessorIndex != -1)
{
attributes.NORMAL = normalAccessorIndex;
}
if (tangentAccessorIndex.HasValue)
{
attributes.TANGENT = tangentAccessorIndex.Value;
}
if (uvAccessorIndex0 != -1)
{
attributes.TEXCOORD_0 = uvAccessorIndex0;
}
if (uvAccessorIndex1 != -1)
{
attributes.TEXCOORD_1 = uvAccessorIndex1;
}
if (colorAccessorIndex != -1)
{
attributes.COLOR_0 = colorAccessorIndex;
}
if (weightAccessorIndex != -1)
{
attributes.WEIGHTS_0 = weightAccessorIndex;
}
if (jointsAccessorIndex != -1)
{
attributes.JOINTS_0 = jointsAccessorIndex;
}
var gltfMesh = new glTFMesh(mesh.name);
var indices = new List <uint>();
for (int j = 0; j < mesh.subMeshCount; ++j)
{
indices.Clear();
var triangles = mesh.GetIndices(j);
if (triangles.Length == 0)
{
// https://github.com/vrm-c/UniVRM/issues/664
continue;
}
for (int i = 0; i < triangles.Length; i += 3)
{
var i0 = triangles[i];
var i1 = triangles[i + 1];
var i2 = triangles[i + 2];
// flip triangle
indices.Add((uint)i2);
indices.Add((uint)i1);
indices.Add((uint)i0);
}
var indicesAccessorIndex = gltf.ExtendBufferAndGetAccessorIndex(bufferIndex, indices.ToArray(), glBufferTarget.ELEMENT_ARRAY_BUFFER);
if (indicesAccessorIndex < 0)
{
// https://github.com/vrm-c/UniVRM/issues/664
throw new Exception();
}
if (j >= materials.Length)
{
Debug.LogWarningFormat("{0}.materials is not enough", unityMesh.Mesh.name);
break;
}
gltfMesh.primitives.Add(new glTFPrimitives
{
attributes = attributes,
indices = indicesAccessorIndex,
mode = 4, // triangles ?
material = unityMaterials.IndexOf(materials[j])
});
}
var blendShapeIndexMap = new Dictionary <int, int>();
{
var targetNames = new List <string>();
int exportBlendShapes = 0;
for (int j = 0; j < unityMesh.Mesh.blendShapeCount; ++j)
{
var morphTarget = ExportMorphTarget(gltf, bufferIndex,
unityMesh.Mesh, j,
settings.UseSparseAccessorForMorphTarget,
settings.ExportOnlyBlendShapePosition, axisInverter);
if (morphTarget.POSITION < 0)
{
// Skip empty blendShape.
// Shift blendShape's index.
continue;
}
var blendShapeName = unityMesh.Mesh.GetBlendShapeName(j);
blendShapeIndexMap.Add(j, exportBlendShapes++);
targetNames.Add(blendShapeName);
//
// all primitive has same blendShape
//
for (int k = 0; k < gltfMesh.primitives.Count; ++k)
{
gltfMesh.primitives[k].targets.Add(morphTarget);
}
}
gltf_mesh_extras_targetNames.Serialize(gltfMesh, targetNames);
}
return(gltfMesh, blendShapeIndexMap);
}
public virtual void Export(MeshExportSettings meshExportSettings)
{
var bytesBuffer = new ArrayByteBuffer(new byte[50 * 1024 * 1024]);
var bufferIndex = glTF.AddBuffer(bytesBuffer);
GameObject tmpParent = null;
if (Copy.transform.childCount == 0)
{
tmpParent = new GameObject("tmpParent");
Copy.transform.SetParent(tmpParent.transform, true);
Copy = tmpParent;
}
try
{
Nodes = Copy.transform.Traverse()
.Skip(1) // exclude root object for the symmetry with the importer
.ToList();
#region Materials and Textures
Materials = Nodes.SelectMany(x => x.GetSharedMaterials()).Where(x => x != null).Distinct().ToList();
var unityTextures = Materials.SelectMany(x => TextureIO.GetTextures(x)).Where(x => x.Texture != null).Distinct().ToList();
TextureManager = new TextureExportManager(unityTextures.Select(x => x.Texture));
var materialExporter = CreateMaterialExporter();
glTF.materials = Materials.Select(x => materialExporter.ExportMaterial(x, TextureManager)).ToList();
for (int i = 0; i < unityTextures.Count; ++i)
{
var unityTexture = unityTextures[i];
TextureIO.ExportTexture(glTF, bufferIndex, TextureManager.GetExportTexture(i), unityTexture.TextureType);
}
#endregion
#region Meshes
var unityMeshes = MeshWithRenderer.FromNodes(Nodes).ToList();
MeshBlendShapeIndexMap = new Dictionary <Mesh, Dictionary <int, int> >();
foreach (var(mesh, gltfMesh, blendShapeIndexMap) in MeshExporter.ExportMeshes(
glTF, bufferIndex, unityMeshes, Materials, meshExportSettings))
{
glTF.meshes.Add(gltfMesh);
if (!MeshBlendShapeIndexMap.ContainsKey(mesh))
{
// 同じmeshが複数回現れた
MeshBlendShapeIndexMap.Add(mesh, blendShapeIndexMap);
}
}
Meshes = unityMeshes.Select(x => x.Mesh).ToList();
#endregion
#region Nodes and Skins
var unitySkins = unityMeshes
.Where(x => x.UniqueBones != null)
.ToList();
glTF.nodes = Nodes.Select(x => ExportNode(x, Nodes, unityMeshes.Select(y => y.Renderer).ToList(), unitySkins.Select(y => y.Renderer as SkinnedMeshRenderer).ToList())).ToList();
glTF.scenes = new List <gltfScene>
{
new gltfScene
{
nodes = Copy.transform.GetChildren().Select(x => Nodes.IndexOf(x)).ToArray(),
}
};
foreach (var x in unitySkins)
{
var matrices = x.GetBindPoses().Select(y => y.ReverseZ()).ToArray();
var accessor = glTF.ExtendBufferAndGetAccessorIndex(bufferIndex, matrices, glBufferTarget.NONE);
var renderer = x.Renderer as SkinnedMeshRenderer;
var skin = new glTFSkin
{
inverseBindMatrices = accessor,
joints = x.UniqueBones.Select(y => Nodes.IndexOf(y)).ToArray(),
skeleton = Nodes.IndexOf(renderer.rootBone),
};
var skinIndex = glTF.skins.Count;
glTF.skins.Add(skin);
foreach (var z in Nodes.Where(y => y.Has(x.Renderer)))
{
var nodeIndex = Nodes.IndexOf(z);
var node = glTF.nodes[nodeIndex];
node.skin = skinIndex;
}
}
#endregion
#if UNITY_EDITOR
#region Animations
var clips = new List <AnimationClip>();
var animator = Copy.GetComponent <Animator>();
var animation = Copy.GetComponent <Animation>();
if (animator != null)
{
clips = AnimationExporter.GetAnimationClips(animator);
}
else if (animation != null)
{
clips = AnimationExporter.GetAnimationClips(animation);
}
if (clips.Any())
{
foreach (AnimationClip clip in clips)
{
var animationWithCurve = AnimationExporter.Export(clip, Copy.transform, Nodes);
foreach (var kv in animationWithCurve.SamplerMap)
{
var sampler = animationWithCurve.Animation.samplers[kv.Key];
var inputAccessorIndex = glTF.ExtendBufferAndGetAccessorIndex(bufferIndex, kv.Value.Input);
sampler.input = inputAccessorIndex;
var outputAccessorIndex = glTF.ExtendBufferAndGetAccessorIndex(bufferIndex, kv.Value.Output);
sampler.output = outputAccessorIndex;
// modify accessors
var outputAccessor = glTF.accessors[outputAccessorIndex];
var channel = animationWithCurve.Animation.channels.First(x => x.sampler == kv.Key);
switch (glTFAnimationTarget.GetElementCount(channel.target.path))
{
case 1:
outputAccessor.type = "SCALAR";
//outputAccessor.count = ;
break;
case 3:
outputAccessor.type = "VEC3";
outputAccessor.count /= 3;
break;
case 4:
outputAccessor.type = "VEC4";
outputAccessor.count /= 4;
break;
default:
throw new NotImplementedException();
}
}
animationWithCurve.Animation.name = clip.name;
glTF.animations.Add(animationWithCurve.Animation);
}
}
#endregion
#endif
}
finally
{
if (tmpParent != null)
{
tmpParent.transform.GetChild(0).SetParent(null);
if (Application.isPlaying)
{
GameObject.Destroy(tmpParent);
}
else
{
GameObject.DestroyImmediate(tmpParent);
}
}
}
}
