public override void ExportExtensions(GetBytesWithMimeFromTexture2D getTextureBytes)
{
// avatar
var animator = Copy.GetComponent <Animator>();
if (animator != null)
{
var humanoid = Copy.GetComponent <VRMHumanoidDescription>();
UniHumanoid.AvatarDescription description = null;
var nodes = Copy.transform.Traverse().Skip(1).ToList();
{
var isCreated = false;
if (humanoid != null)
{
description = humanoid.GetDescription(out isCreated);
}
if (description != null)
{
// use description
VRM.humanoid.Apply(description, nodes);
}
if (isCreated)
{
GameObject.DestroyImmediate(description);
}
}
{
// set humanoid bone mapping
var avatar = animator.avatar;
foreach (HumanBodyBones key in Enum.GetValues(typeof(HumanBodyBones)))
{
if (key == HumanBodyBones.LastBone)
{
break;
}
var transform = animator.GetBoneTransform(key);
if (transform != null)
{
VRM.humanoid.SetNodeIndex(key, nodes.IndexOf(transform));
}
}
}
}
// morph
var master = Copy.GetComponent <VRMBlendShapeProxy>();
if (master != null)
{
var avatar = master.BlendShapeAvatar;
if (avatar != null)
{
foreach (var x in avatar.Clips)
{
VRM.blendShapeMaster.Add(x, this);
}
}
}
// secondary
VRMSpringUtility.ExportSecondary(Copy.transform, Nodes,
x => VRM.secondaryAnimation.colliderGroups.Add(x),
x => VRM.secondaryAnimation.boneGroups.Add(x)
);
#pragma warning disable 0618
// meta(obsolete)
{
var meta = Copy.GetComponent <VRMMetaInformation>();
if (meta != null)
{
VRM.meta.author = meta.Author;
VRM.meta.contactInformation = meta.ContactInformation;
VRM.meta.title = meta.Title;
if (meta.Thumbnail != null)
{
VRM.meta.texture = glTF.PushGltfTexture(glTF.buffers.Count - 1, meta.Thumbnail, ColorSpace.sRGB, getTextureBytes);
}
VRM.meta.licenseType = meta.LicenseType;
VRM.meta.otherLicenseUrl = meta.OtherLicenseUrl;
VRM.meta.reference = meta.Reference;
}
}
#pragma warning restore 0618
// meta
{
var _meta = Copy.GetComponent <VRMMeta>();
if (_meta != null && _meta.Meta != null)
{
var meta = _meta.Meta;
// info
VRM.meta.version = meta.Version;
VRM.meta.author = meta.Author;
VRM.meta.contactInformation = meta.ContactInformation;
VRM.meta.reference = meta.Reference;
VRM.meta.title = meta.Title;
if (meta.Thumbnail != null)
{
VRM.meta.texture = TextureManager.ExportSRGB(meta.Thumbnail);
}
// ussage permission
VRM.meta.allowedUser = meta.AllowedUser;
VRM.meta.violentUssage = meta.ViolentUssage;
VRM.meta.sexualUssage = meta.SexualUssage;
VRM.meta.commercialUssage = meta.CommercialUssage;
VRM.meta.otherPermissionUrl = meta.OtherPermissionUrl;
// distribution license
VRM.meta.licenseType = meta.LicenseType;
if (meta.LicenseType == LicenseType.Other)
{
VRM.meta.otherLicenseUrl = meta.OtherLicenseUrl;
}
}
}
// firstPerson
var firstPerson = Copy.GetComponent <VRMFirstPerson>();
if (firstPerson != null)
{
if (firstPerson.FirstPersonBone != null)
{
VRM.firstPerson.firstPersonBone = Nodes.IndexOf(firstPerson.FirstPersonBone);
VRM.firstPerson.firstPersonBoneOffset = firstPerson.FirstPersonOffset;
VRM.firstPerson.meshAnnotations = firstPerson.Renderers.Select(x => new glTF_VRM_MeshAnnotation
{
mesh = Meshes.IndexOf(x.SharedMesh),
firstPersonFlag = x.FirstPersonFlag.ToString(),
}).ToList();
}
// lookAt
{
var lookAtHead = Copy.GetComponent <VRMLookAtHead>();
if (lookAtHead != null)
{
var boneApplyer = Copy.GetComponent <VRMLookAtBoneApplyer>();
var blendShapeApplyer = Copy.GetComponent <VRMLookAtBlendShapeApplyer>();
if (boneApplyer != null)
{
VRM.firstPerson.lookAtType = LookAtType.Bone;
VRM.firstPerson.lookAtHorizontalInner.Apply(boneApplyer.HorizontalInner);
VRM.firstPerson.lookAtHorizontalOuter.Apply(boneApplyer.HorizontalOuter);
VRM.firstPerson.lookAtVerticalDown.Apply(boneApplyer.VerticalDown);
VRM.firstPerson.lookAtVerticalUp.Apply(boneApplyer.VerticalUp);
}
else if (blendShapeApplyer != null)
{
VRM.firstPerson.lookAtType = LookAtType.BlendShape;
VRM.firstPerson.lookAtHorizontalOuter.Apply(blendShapeApplyer.Horizontal);
VRM.firstPerson.lookAtVerticalDown.Apply(blendShapeApplyer.VerticalDown);
VRM.firstPerson.lookAtVerticalUp.Apply(blendShapeApplyer.VerticalUp);
}
}
}
}
// materials
foreach (var m in Materials)
{
VRM.materialProperties.Add(VRMMaterialExporter.CreateFromMaterial(m, TextureManager));
}
// Serialize VRM
var f = new JsonFormatter();
VRMSerializer.Serialize(f, VRM);
var bytes = f.GetStoreBytes();
glTFExtensionExport.GetOrCreate(ref glTF.extensions).Add("VRM", bytes);
}
public virtual void Export(MeshExportSettings meshExportSettings, Func <Texture, bool> useAsset, GetBytesWithMimeFromTexture2D getTextureBytes)
{
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();
TextureManager = new TextureExporter(useAsset);
var materialExporter = CreateMaterialExporter();
glTF.materials = Materials.Select(x => materialExporter.ExportMaterial(x, TextureManager)).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(getTextureBytes);
// Extension で Texture が増える場合があるので最後に呼ぶ
for (int i = 0; i < TextureManager.Exported.Count; ++i)
{
var(unityTexture, colorSpace) = TextureManager.Exported[i];
glTF.PushGltfTexture(bufferIndex, unityTexture, colorSpace, getTextureBytes);
}
}
public static glTF Export(MeshExportSettings configuration, GameObject go, Func <Texture, bool> useAsset, GetBytesWithMimeFromTexture2D getTextureBytes)
{
var gltf = new glTF();
using (var exporter = new VRMExporter(gltf))
{
exporter.Prepare(go);
exporter.Export(configuration, useAsset, getTextureBytes);
}
return(gltf);
}
public virtual void ExportExtensions(GetBytesWithMimeFromTexture2D getTextureBytes)
{
// do nothing
}