ModelAsset BuildGameObject(VrmLib.Model model, bool showMesh)
{
var assets = RuntimeUnityBuilder.ToUnityAsset(model, showMesh);
UniVRM10.ComponentBuilder.Build10(model, assets);
return(assets);
}
public void UpdateMeta(VrmLib.Model context)
{
var meta = context.Vrm.Meta;
m_textModelTitle.text = meta.Name;
m_textModelVersion.text = meta.Version;
m_textModelAuthor.text = meta.Author;
m_textModelContact.text = meta.ContactInformation;
m_textModelReference.text = meta.Reference;
// TODO: 1.0 仕様にする
m_textPermissionAllowed.text = meta.AvatarPermission.AvatarUsage.ToString();
m_textPermissionViolent.text = meta.AvatarPermission.IsAllowedViolentUsage.ToString();
m_textPermissionSexual.text = meta.AvatarPermission.IsAllowedSexualUsage.ToString();
m_textPermissionCommercial.text = meta.AvatarPermission.CommercialUsage.ToString();
m_textPermissionOther.text = meta.AvatarPermission.OtherPermissionUrl;
m_textDistributionLicense.text = meta.RedistributionLicense.ModificationLicense.ToString();
m_textDistributionOther.text = meta.RedistributionLicense.OtherLicenseUrl;
var thumbnail = new Texture2D(2, 2);
thumbnail.LoadImage(meta.Thumbnail.Bytes.ToArray());
m_thumbnail.texture = thumbnail;
}
public override void OnEnable()
{
base.OnEnable();
var importer = target as VrmScriptedImporter;
m_importer = importer;
using (Vrm10Data.ParseOrMigrate(m_importer.assetPath, importer.MigrateToVrm1, out m_result, out m_migration))
{
if (m_result == null)
{
// error
return;
}
m_model = ModelReader.Read(m_result.Data);
var tmp = m_importer.GetExternalObjectMap();
var generator = new Vrm10MaterialDescriptorGenerator();
var materialKeys = m_result.Data.GLTF.materials.Select((x, i) => generator.Get(m_result.Data, i).SubAssetKey);
var textureKeys = new Vrm10TextureDescriptorGenerator(m_result.Data).Get().GetEnumerable().Select(x => x.SubAssetKey);
m_materialEditor = new RemapEditorMaterial(materialKeys.Concat(textureKeys), GetEditorMap, SetEditorMap);
m_vrmEditor = new RemapEditorVrm(new[] { VRM10Object.SubAssetKey }.Concat(EnumerateExpressinKeys(m_result.VrmExtension.Expressions)), GetEditorMap, SetEditorMap);
}
}
byte[] ToVrm10(VrmLib.Model model)
{
// 右手系に変換
VrmLib.ModelExtensionsForCoordinates.ConvertCoordinate(model, VrmLib.Coordinates.Gltf);
var bytes = UniVRM10.ModelExtensions.ToGlb(model);
return(bytes);
}
private void CreateMaterialAssets(VrmLib.Model model, ModelAsset modelAsset)
{
foreach (var src in model.Materials)
{
// TODO: material has VertexColor
var material = RuntimeUnityMaterialBuilder.CreateMaterialAsset(src, hasVertexColor: false, Textures);
material.name = src.Name;
Materials.Add(src, material);
modelAsset.Materials.Add(material);
}
}
static public ModelAsset ToUnityAsset(VrmLib.Model model, string assetPath, IExternalUnityObject scriptedImporter)
{
var modelAsset = new ModelAsset();
CreateTextureAsset(model, modelAsset, scriptedImporter);
CreateMaterialAsset(model, modelAsset, scriptedImporter);
CreateMeshAsset(model, modelAsset);
// node
RuntimeUnityBuilder.CreateNodes(model.Root, null, modelAsset.Map.Nodes);
modelAsset.Root = modelAsset.Map.Nodes[model.Root];
// renderer
var map = modelAsset.Map;
foreach (var(node, go) in map.Nodes)
{
if (node.MeshGroup is null)
{
continue;
}
if (node.MeshGroup.Meshes.Count > 1)
{
throw new NotImplementedException("invalid isolated vertexbuffer");
}
var renderer = RuntimeUnityBuilder.CreateRenderer(node, go, map);
map.Renderers.Add(node, renderer);
modelAsset.Renderers.Add(renderer);
}
// humanoid
var boneMap = modelAsset.Map.Nodes
.Where(x => x.Key.HumanoidBone.GetValueOrDefault() != VrmLib.HumanoidBones.unknown)
.Select(x => (x.Value.transform, x.Key.HumanoidBone.Value))
.ToDictionary(x => x.transform, x => x.Item2);
if (boneMap.Any())
{
modelAsset.HumanoidAvatar = HumanoidLoader.LoadHumanoidAvatar(modelAsset.Root.transform, boneMap);
if (modelAsset.HumanoidAvatar != null)
{
modelAsset.HumanoidAvatar.name = "VRM";
}
}
var animator = modelAsset.Root.AddComponent <Animator>();
animator.avatar = modelAsset.HumanoidAvatar;
return(modelAsset);
}
public ModelAsset ToUnityAsset(VrmLib.Model model, string assetPath, IExternalUnityObject scriptedImporter)
{
var modelAsset = new ModelAsset();
CreateTextureAsset(model, modelAsset, scriptedImporter);
CreateMaterialAsset(model, modelAsset, scriptedImporter);
RuntimeUnityBuilder.CreateMeshAsset(model, modelAsset, Meshes);
// node
RuntimeUnityBuilder.CreateNodes(model.Root, null, Nodes);
modelAsset.Root = Nodes[model.Root];
Root = modelAsset.Root;
// renderer
foreach (var(mesh, renderer) in RuntimeUnityBuilder.CreateRendererAsset(Nodes, Meshes, Materials))
{
Renderers.Add(mesh, renderer);
}
// humanoid
var boneMap = Nodes
.Where(x => x.Key.HumanoidBone.GetValueOrDefault() != VrmLib.HumanoidBones.unknown)
.Select(x => (x.Value.transform, x.Key.HumanoidBone.Value))
.ToDictionary(x => x.transform, x => x.Item2);
if (boneMap.Any())
{
modelAsset.HumanoidAvatar = HumanoidLoader.LoadHumanoidAvatar(modelAsset.Root.transform, boneMap);
if (modelAsset.HumanoidAvatar != null)
{
modelAsset.HumanoidAvatar.name = "VRM";
}
}
var animator = modelAsset.Root.AddComponent <Animator>();
animator.avatar = modelAsset.HumanoidAvatar;
modelAsset.Map = new ModelMap
{
Nodes = Nodes,
Textures = Textures,
Materials = Materials,
Meshes = Meshes,
Renderers = Renderers,
};
return(modelAsset);
}
public override void OnEnable()
{
base.OnEnable();
m_importer = target as VrmScriptedImporter;
m_parser = VrmScriptedImporterImpl.Parse(m_importer.assetPath, m_importer.MigrateToVrm1);
if (m_parser == null)
{
return;
}
if (!UniGLTF.Extensions.VRMC_vrm.GltfDeserializer.TryGet(m_parser.GLTF.extensions, out m_vrm))
{
return;
}
m_model = VrmLoader.CreateVrmModel(m_parser);
}
public override void OnEnable()
{
base.OnEnable();
m_importer = target as VrmScriptedImporter;
m_message = VrmScriptedImporterImpl.TryParseOrMigrate(m_importer.assetPath, m_importer.MigrateToVrm1, out m_parser);
if (string.IsNullOrEmpty(m_message))
{
// ok
return;
}
if (!UniGLTF.Extensions.VRMC_vrm.GltfDeserializer.TryGet(m_parser.GLTF.extensions, out m_vrm))
{
return;
}
m_model = VrmLoader.CreateVrmModel(m_parser);
}
void OnLoaded(VrmLib.Model model)
{
// var root = context.Root;
// root.transform.SetParent(transform, false);
// //メッシュを表示します
// context.ShowMeshes();
// // add motion
// var humanPoseTransfer = root.AddComponent<UniHumanoid.HumanPoseTransfer>();
// if (m_target != null)
// {
// GameObject.Destroy(m_target.gameObject);
// }
// m_target = humanPoseTransfer;
// SetupTarget();
}
static public ModelAsset ToUnityAsset(VrmLib.Model model, string assetPath, IExternalUnityObject scriptedImporter)
{
var modelAsset = new ModelAsset();
CreateTextureAsset(model, modelAsset, scriptedImporter);
CreateMaterialAsset(model, modelAsset, scriptedImporter);
CreateMeshAsset(model, modelAsset);
// node
RuntimeUnityBuilder.CreateNodes(model.Root, null, modelAsset.Map.Nodes);
modelAsset.Root = modelAsset.Map.Nodes[model.Root];
// renderer
var map = modelAsset.Map;
foreach (var(node, go) in map.Nodes)
{
if (node.MeshGroup is null)
{
continue;
}
if (node.MeshGroup.Meshes.Count > 1)
{
throw new NotImplementedException("invalid isolated vertexbuffer");
}
var renderer = RuntimeUnityBuilder.CreateRenderer(node, go, map);
map.Renderers.Add(node, renderer);
modelAsset.Renderers.Add(renderer);
}
if (model.Vrm != null)
{
// humanoid
var humanoid = modelAsset.Root.AddComponent <Humanoid>();
humanoid.AssignBones(modelAsset.Map.Nodes.Select(x => (x.Key.HumanoidBone.GetValueOrDefault().ToUnity(), x.Value.transform)));
modelAsset.HumanoidAvatar = humanoid.CreateAvatar();
modelAsset.HumanoidAvatar.name = "VRM";
var animator = modelAsset.Root.AddComponent <Animator>();
animator.avatar = modelAsset.HumanoidAvatar;
}
return(modelAsset);
}
void OnData()
{
if (m_result == null)
{
// error
return;
}
m_model = ModelReader.Read(m_result.Data);
var tmp = m_importer.GetExternalObjectMap();
var generator = new Vrm10MaterialDescriptorGenerator();
var materialKeys = m_result.Data.GLTF.materials.Select((x, i) => generator.Get(m_result.Data, i).SubAssetKey);
var textureKeys = new Vrm10TextureDescriptorGenerator(m_result.Data).Get().GetEnumerable().Select(x => x.SubAssetKey);
m_materialEditor = new RemapEditorMaterial(materialKeys.Concat(textureKeys), GetEditorMap, SetEditorMap);
m_vrmEditor = new RemapEditorVrm(new[] { VRM10Object.SubAssetKey }.Concat(EnumerateExpressinKeys(m_result.VrmExtension.Expressions)), GetEditorMap, SetEditorMap);
}
public void LicenseUpdate(VrmLib.Model context)
{
#if false
var meta = context.VRM.extensions.VRM.meta;
m_textModelTitle.text = meta.title;
m_textModelVersion.text = meta.version;
m_textModelAuthor.text = meta.author;
m_textModelContact.text = meta.contactInformation;
m_textModelReference.text = meta.reference;
m_textPermissionAllowed.text = meta.allowedUser.ToString();
m_textPermissionViolent.text = meta.violentUssage.ToString();
m_textPermissionSexual.text = meta.sexualUssage.ToString();
m_textPermissionCommercial.text = meta.commercialUssage.ToString();
m_textPermissionOther.text = meta.otherPermissionUrl;
m_textDistributionLicense.text = meta.licenseType.ToString();
m_textDistributionOther.text = meta.otherLicenseUrl;
#else
var meta = context.Vrm.Meta;
_textModelTitle.text = meta.Name;
_textModelVersion.text = meta.Version;
_textModelAuthor.text = meta.Author;
_textModelContact.text = meta.ContactInformation;
_textModelReference.text = meta.Reference;
_textPermissionAllowed.text = meta.AvatarPermission.AvatarUsage.ToString();
_textPermissionViolent.text = meta.AvatarPermission.IsAllowedViolentUsage.ToString();
_textPermissionSexual.text = meta.AvatarPermission.IsAllowedSexualUsage.ToString();
_textPermissionCommercial.text = meta.AvatarPermission.CommercialUsage.ToString();
_textPermissionOther.text = meta.AvatarPermission.OtherPermissionUrl;
_textDistributionLicense.text = meta.RedistributionLicense.ModificationLicense.ToString();
_textDistributionOther.text = meta.RedistributionLicense.OtherLicenseUrl;
if (meta.Thumbnail != null)
{
var thumbnail = new Texture2D(2, 2);
thumbnail.LoadImage(meta.Thumbnail.Bytes.ToArray());
_thumbnail.texture = thumbnail;
}
#endif
}
static private void CreateMeshAsset(VrmLib.Model model, ModelAsset modelAsset)
{
for (int i = 0; i < model.MeshGroups.Count; ++i)
{
var src = model.MeshGroups[i];
if (src.Meshes.Count == 1)
{
// submesh 方式
var mesh = new Mesh();
mesh.name = src.Name;
mesh.LoadMesh(src.Meshes[0], src.Skin);
modelAsset.Map.Meshes.Add(src, mesh);
modelAsset.Meshes.Add(mesh);
}
else
{
// 頂点バッファの連結が必用
throw new NotImplementedException();
}
}
}
static private void CreateMaterialAsset(VrmLib.Model model, ModelAsset modelAsset, IExternalUnityObject scriptedImporter)
{
var externalObjects = scriptedImporter.GetExternalUnityObjects <Material>();
foreach (var src in model.Materials)
{
if (externalObjects.ContainsKey(src.Name))
{
modelAsset.Map.Materials.Add(src, externalObjects[src.Name]);
modelAsset.Materials.Add(externalObjects[src.Name]);
}
else
{
// TODO: material has VertexColor
var material = RuntimeUnityMaterialBuilder.CreateMaterialAsset(src, hasVertexColor: false, modelAsset.Map.Textures);
material.name = src.Name;
modelAsset.Map.Materials.Add(src, material);
modelAsset.Materials.Add(material);
}
}
}
private void CreateTextureAsset(VrmLib.Model model, ModelAsset modelAsset)
{
// textures
for (int i = 0; i < model.Textures.Count; ++i)
{
if (model.Textures[i] is VrmLib.ImageTexture imageTexture)
{
var name = !string.IsNullOrEmpty(imageTexture.Name)
? imageTexture.Name
: string.Format("{0}_img{1}", model.Root.Name, i);
var texture = CreateTexture(name, imageTexture);
Textures.Add(imageTexture, texture);
modelAsset.Textures.Add(texture);
}
else
{
Debug.LogWarning($"{i} not ImageTexture");
}
}
}
public static void CreateMeshAsset(VrmLib.Model model, ModelAsset modelAsset, Dictionary <VrmLib.MeshGroup, UnityEngine.Mesh> dstMeshes)
{
// mesh
for (int i = 0; i < model.MeshGroups.Count; ++i)
{
var src = model.MeshGroups[i];
if (src.Meshes.Count == 1)
{
// submesh 方式
var mesh = new Mesh();
mesh.name = src.Name;
mesh.LoadMesh(src.Meshes[0], src.Skin);
dstMeshes.Add(src, mesh);
modelAsset.Meshes.Add(mesh);
}
else
{
// 頂点バッファの連結が必用
throw new NotImplementedException();
}
}
}
static private void CreateTextureAsset(VrmLib.Model model, ModelAsset modelAsset, IExternalUnityObject scriptedImporter)
{
var externalObjects = scriptedImporter.GetExternalUnityObjects <Texture2D>();
// textures
for (int i = 0; i < model.Textures.Count; ++i)
{
if (model.Textures[i] is VrmLib.ImageTexture imageTexture)
{
if (string.IsNullOrEmpty(model.Textures[i].Name))
{
model.Textures[i].Name = string.Format("{0}_img{1}", model.Root.Name, i);
}
if (externalObjects.ContainsKey(model.Textures[i].Name))
{
modelAsset.Map.Textures.Add(imageTexture, externalObjects[model.Textures[i].Name]);
modelAsset.Textures.Add(externalObjects[model.Textures[i].Name]);
}
else
{
var name = !string.IsNullOrEmpty(imageTexture.Name)
? imageTexture.Name
: string.Format("{0}_img{1}", model.Root.Name, i);
var texture = RuntimeUnityBuilder.CreateTexture(imageTexture);
texture.name = name;
modelAsset.Map.Textures.Add(imageTexture, texture);
modelAsset.Textures.Add(texture);
}
}
else
{
Debug.LogWarning($"{i} not ImageTexture");
}
}
}
public static UniVRM10.MorphTargetBinding Build10(this MorphTargetBind bind, GameObject root, RuntimeUnityBuilder.ModelMap loader, VrmLib.Model model)
{
var libNode = model.Nodes[bind.Node.Value];
var node = loader.Nodes[libNode].transform;
var mesh = loader.Meshes[libNode.MeshGroup];
var relativePath = node.RelativePathFrom(root.transform);
// VRM-1.0 では値域は [0-1.0f]
return(new UniVRM10.MorphTargetBinding(relativePath, bind.Index.Value, bind.Weight.Value * 100.0f));
}
public void LicenseUpdatefunc(VrmLib.Model context)
{
_texts.LicenseUpdate(context);
}
public Vrm10Importer(
UniGLTF.GltfData data, UniGLTF.Extensions.VRMC_vrm.VRMC_vrm vrm,
IReadOnlyDictionary <SubAssetKey, UnityEngine.Object> externalObjectMap = null,
ITextureDeserializer textureDeserializer = null)
: base(data, externalObjectMap, textureDeserializer)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (vrm == null)
{
throw new ArgumentNullException("vrm");
}
m_vrm = vrm;
TextureDescriptorGenerator = new Vrm10TextureDescriptorGenerator(data);
MaterialDescriptorGenerator = new Vrm10MaterialDescriptorGenerator();
m_externalMap = externalObjectMap;
if (m_externalMap == null)
{
m_externalMap = new Dictionary <SubAssetKey, UnityEngine.Object>();
}
// bin に対して右手左手変換を破壊的に実行することに注意 !(bin が変換済みになる)
m_model = ModelReader.Read(data);
// assign humanoid bones
if (m_vrm.Humanoid != null)
{
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.Hips, VrmLib.HumanoidBones.hips);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftUpperLeg, VrmLib.HumanoidBones.leftUpperLeg);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightUpperLeg, VrmLib.HumanoidBones.rightUpperLeg);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftLowerLeg, VrmLib.HumanoidBones.leftLowerLeg);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightLowerLeg, VrmLib.HumanoidBones.rightLowerLeg);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftFoot, VrmLib.HumanoidBones.leftFoot);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightFoot, VrmLib.HumanoidBones.rightFoot);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.Spine, VrmLib.HumanoidBones.spine);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.Chest, VrmLib.HumanoidBones.chest);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.Neck, VrmLib.HumanoidBones.neck);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.Head, VrmLib.HumanoidBones.head);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftShoulder, VrmLib.HumanoidBones.leftShoulder);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightShoulder, VrmLib.HumanoidBones.rightShoulder);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftUpperArm, VrmLib.HumanoidBones.leftUpperArm);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightUpperArm, VrmLib.HumanoidBones.rightUpperArm);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftLowerArm, VrmLib.HumanoidBones.leftLowerArm);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightLowerArm, VrmLib.HumanoidBones.rightLowerArm);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftHand, VrmLib.HumanoidBones.leftHand);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightHand, VrmLib.HumanoidBones.rightHand);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftToes, VrmLib.HumanoidBones.leftToes);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightToes, VrmLib.HumanoidBones.rightToes);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftEye, VrmLib.HumanoidBones.leftEye);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightEye, VrmLib.HumanoidBones.rightEye);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.Jaw, VrmLib.HumanoidBones.jaw);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftThumbProximal, VrmLib.HumanoidBones.leftThumbProximal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftThumbIntermediate, VrmLib.HumanoidBones.leftThumbIntermediate);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftThumbDistal, VrmLib.HumanoidBones.leftThumbDistal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftIndexProximal, VrmLib.HumanoidBones.leftIndexProximal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftIndexIntermediate, VrmLib.HumanoidBones.leftIndexIntermediate);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftIndexDistal, VrmLib.HumanoidBones.leftIndexDistal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftMiddleProximal, VrmLib.HumanoidBones.leftMiddleProximal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftMiddleIntermediate, VrmLib.HumanoidBones.leftMiddleIntermediate);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftMiddleDistal, VrmLib.HumanoidBones.leftMiddleDistal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftRingProximal, VrmLib.HumanoidBones.leftRingProximal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftRingIntermediate, VrmLib.HumanoidBones.leftRingIntermediate);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftRingDistal, VrmLib.HumanoidBones.leftRingDistal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftLittleProximal, VrmLib.HumanoidBones.leftLittleProximal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftLittleIntermediate, VrmLib.HumanoidBones.leftLittleIntermediate);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.LeftLittleDistal, VrmLib.HumanoidBones.leftLittleDistal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightThumbProximal, VrmLib.HumanoidBones.rightThumbProximal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightThumbIntermediate, VrmLib.HumanoidBones.rightThumbIntermediate);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightThumbDistal, VrmLib.HumanoidBones.rightThumbDistal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightIndexProximal, VrmLib.HumanoidBones.rightIndexProximal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightIndexIntermediate, VrmLib.HumanoidBones.rightIndexIntermediate);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightIndexDistal, VrmLib.HumanoidBones.rightIndexDistal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightMiddleProximal, VrmLib.HumanoidBones.rightMiddleProximal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightMiddleIntermediate, VrmLib.HumanoidBones.rightMiddleIntermediate);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightMiddleDistal, VrmLib.HumanoidBones.rightMiddleDistal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightRingProximal, VrmLib.HumanoidBones.rightRingProximal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightRingIntermediate, VrmLib.HumanoidBones.rightRingIntermediate);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightRingDistal, VrmLib.HumanoidBones.rightRingDistal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightLittleProximal, VrmLib.HumanoidBones.rightLittleProximal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightLittleIntermediate, VrmLib.HumanoidBones.rightLittleIntermediate);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.RightLittleDistal, VrmLib.HumanoidBones.rightLittleDistal);
AssignHumanoid(m_model.Nodes, m_vrm.Humanoid.HumanBones.UpperChest, VrmLib.HumanoidBones.upperChest);
}
}
public VrmLib.Model ToGlbModel(GameObject root)
{
if (Model == null)
{
Model = new VrmLib.Model(VrmLib.Coordinates.Unity);
}
// node
{
Model.Root.Name = root.name;
CreateNodes(root.transform, Model.Root, Nodes);
Model.Nodes = Nodes
.Where(x => x.Value != Model.Root)
.Select(x => x.Value).ToList();
}
// material and textures
var rendererComponents = root.GetComponentsInChildren <Renderer>();
{
foreach (var renderer in rendererComponents)
{
var materials = renderer.sharedMaterials; // avoid copy
foreach (var material in materials)
{
if (Materials.ContainsKey(material))
{
continue;
}
var vrmMaterial = Export10(material, GetOrCreateTexture);
Model.Materials.Add(vrmMaterial);
Materials.Add(material, vrmMaterial);
}
}
}
// mesh
{
foreach (var renderer in rendererComponents)
{
if (renderer is SkinnedMeshRenderer skinnedMeshRenderer)
{
if (skinnedMeshRenderer.sharedMesh != null)
{
var mesh = CreateMesh(skinnedMeshRenderer.sharedMesh, skinnedMeshRenderer, Materials);
var skin = CreateSkin(skinnedMeshRenderer, Nodes, root);
if (skin != null)
{
// blendshape only で skinning が無いやつがある
mesh.Skin = skin;
Model.Skins.Add(mesh.Skin);
}
Model.MeshGroups.Add(mesh);
Nodes[renderer.gameObject].MeshGroup = mesh;
Meshes.Add(skinnedMeshRenderer.sharedMesh, mesh);
}
}
else if (renderer is MeshRenderer meshRenderer)
{
var filter = meshRenderer.gameObject.GetComponent <MeshFilter>();
if (filter != null && filter.sharedMesh != null)
{
var mesh = CreateMesh(filter.sharedMesh, meshRenderer, Materials);
Model.MeshGroups.Add(mesh);
Nodes[renderer.gameObject].MeshGroup = mesh;
Meshes.Add(filter.sharedMesh, mesh);
}
}
}
}
return(Model);
}
/// <summary>
/// metaObject が null のときは、root から取得する
/// </summary>
public VrmLib.Model ToModelFrom10(GameObject root, VRMMetaObject metaObject = null)
{
Model = new VrmLib.Model(VrmLib.Coordinates.Unity);
if (metaObject is null)
{
var vrmMeta = root.GetComponent <VRMMeta>();
if (vrmMeta is null || vrmMeta.Meta is null)
{
throw new NullReferenceException("metaObject is null");
}
metaObject = vrmMeta.Meta;
}
ToGlbModel(root);
// meta
var meta = new VrmLib.Meta();
meta.Name = metaObject.Name;
meta.Version = metaObject.Version;
meta.Copyrights = metaObject.Copyrights;
meta.Authors.AddRange(metaObject.Authors);
meta.ContactInformation = metaObject.ContactInformation;
meta.Reference = metaObject.Reference;
meta.Thumbnail = metaObject.Thumbnail.ToPngImage(VrmLib.ImageUsage.None);
meta.AvatarPermission = new VrmLib.AvatarPermission
{
AvatarUsage = metaObject.AllowedUser,
IsAllowedViolentUsage = metaObject.ViolentUsage,
IsAllowedSexualUsage = metaObject.SexualUsage,
CommercialUsage = metaObject.CommercialUsage,
IsAllowedGameUsage = metaObject.GameUsage,
IsAllowedPoliticalOrReligiousUsage = metaObject.PoliticalOrReligiousUsage,
OtherPermissionUrl = metaObject.OtherPermissionUrl,
};
meta.RedistributionLicense = new VrmLib.RedistributionLicense
{
CreditNotation = metaObject.CreditNotation,
IsAllowRedistribution = metaObject.Redistribution,
ModificationLicense = metaObject.ModificationLicense,
OtherLicenseUrl = metaObject.OtherLicenseUrl,
};
Model.Vrm = new VrmLib.Vrm(meta, UniVRM10.VRMVersion.VERSION, UniVRM10.VRMSpecVersion.Version);
// humanoid
{
var humanoid = root.GetComponent <Humanoid>();
if (humanoid is null)
{
humanoid = root.AddComponent <Humanoid>();
humanoid.AssignBonesFromAnimator();
}
foreach (HumanBodyBones humanBoneType in Enum.GetValues(typeof(HumanBodyBones)))
{
var transform = humanoid.GetBoneTransform(humanBoneType);
if (transform != null && Nodes.TryGetValue(transform.gameObject, out VrmLib.Node node))
{
node.HumanoidBone = (VrmLib.HumanoidBones)Enum.Parse(typeof(VrmLib.HumanoidBones), humanBoneType.ToString(), true);
}
}
}
// blendShape
{
Model.Vrm.BlendShape = new VrmLib.BlendShapeManager();
var blendShapeProxy = root.GetComponent <UniVRM10.VRMController>();
if (blendShapeProxy != null)
{
foreach (var clip in blendShapeProxy.BlendShapeAvatar.Clips)
{
var blendShape = ToVrmLib(clip, root);
if (blendShape != null)
{
Model.Vrm.BlendShape.BlendShapeList.Add(blendShape);
}
}
}
}
// firstPerson
{
var firstPerson = new VrmLib.FirstPerson();
var firstPersonComponent = root.GetComponent <UniVRM10.VRMFirstPerson>();
if (firstPersonComponent != null)
{
foreach (var annotation in firstPersonComponent.Renderers)
{
firstPerson.Annotations.Add(
new VrmLib.FirstPersonMeshAnnotation(Nodes[annotation.Renderer.gameObject],
annotation.FirstPersonFlag)
);
}
Model.Vrm.FirstPerson = firstPerson;
}
}
// lookAt
{
var blendShapeProxy = root.GetComponent <UniVRM10.VRMController>();
var lookAt = new VrmLib.LookAt();
var lookAtBlendShape = blendShapeProxy;
var lookAtBone = blendShapeProxy;
if (lookAtBlendShape != null)
{
if (lookAtBlendShape.LookAtType == VRMController.LookAtTypes.BlendShape)
{
lookAt.HorizontalInner = new VrmLib.LookAtRangeMap();
lookAt.HorizontalOuter = new VrmLib.LookAtRangeMap()
{
InputMaxValue = lookAtBlendShape.HorizontalOuter.CurveXRangeDegree,
OutputScaling = lookAtBlendShape.HorizontalOuter.CurveYRangeDegree
};
lookAt.VerticalUp = new VrmLib.LookAtRangeMap()
{
InputMaxValue = lookAtBlendShape.VerticalUp.CurveXRangeDegree,
OutputScaling = lookAtBlendShape.VerticalUp.CurveYRangeDegree,
};
lookAt.VerticalDown = new VrmLib.LookAtRangeMap()
{
InputMaxValue = lookAtBlendShape.VerticalDown.CurveXRangeDegree,
OutputScaling = lookAtBlendShape.VerticalDown.CurveYRangeDegree,
};
}
else if (lookAtBlendShape.LookAtType == VRMController.LookAtTypes.Bone)
{
lookAt.HorizontalInner = new VrmLib.LookAtRangeMap()
{
InputMaxValue = lookAtBone.HorizontalInner.CurveXRangeDegree,
OutputScaling = lookAtBone.HorizontalInner.CurveYRangeDegree
};
lookAt.HorizontalOuter = new VrmLib.LookAtRangeMap()
{
InputMaxValue = lookAtBone.HorizontalOuter.CurveXRangeDegree,
OutputScaling = lookAtBone.HorizontalOuter.CurveYRangeDegree
};
lookAt.VerticalUp = new VrmLib.LookAtRangeMap()
{
InputMaxValue = lookAtBone.VerticalUp.CurveXRangeDegree,
OutputScaling = lookAtBone.VerticalUp.CurveYRangeDegree,
};
lookAt.VerticalDown = new VrmLib.LookAtRangeMap()
{
InputMaxValue = lookAtBone.VerticalDown.CurveXRangeDegree,
OutputScaling = lookAtBone.VerticalDown.CurveYRangeDegree,
};
}
lookAt.OffsetFromHeadBone = blendShapeProxy.OffsetFromHead.ToNumericsVector3();
}
Model.Vrm.LookAt = lookAt;
}
// springBone
{
var springBoneColliderGroups = root.GetComponentsInChildren <UniVRM10.VRMSpringBoneColliderGroup>();
if (springBoneColliderGroups != null)
{
Model.Vrm.SpringBone = new VrmLib.SpringBoneManager();
var colliders = new Dictionary <UniVRM10.VRMSpringBoneColliderGroup, VrmLib.SpringBoneColliderGroup>();
foreach (var colliderGroup in springBoneColliderGroups)
{
var colliderGroups = colliderGroup.Colliders.Select(x =>
{
switch (x.ColliderType)
{
case SpringBoneColliderTypes.Sphere:
return(VrmLib.VrmSpringBoneCollider.CreateSphere(x.Offset.ToNumericsVector3(), x.Radius));
case SpringBoneColliderTypes.Capsule:
return(VrmLib.VrmSpringBoneCollider.CreateCapsule(x.Offset.ToNumericsVector3(), x.Radius, x.Tail.ToNumericsVector3()));
default:
throw new NotImplementedException();
}
});
var vrmColliderGroup = new VrmLib.SpringBoneColliderGroup(Nodes[colliderGroup.gameObject], colliderGroups);
Model.Vrm.SpringBone.Colliders.Add(vrmColliderGroup);
colliders.Add(colliderGroup, vrmColliderGroup);
}
var springBones = root.GetComponentsInChildren <UniVRM10.VRMSpringBone>();
foreach (var springBone in springBones)
{
var vrmSpringBone = new VrmLib.SpringBone()
{
Comment = springBone.m_comment,
Stiffness = springBone.m_stiffnessForce,
GravityPower = springBone.m_gravityPower,
GravityDir = springBone.m_gravityDir.ToNumericsVector3(),
DragForce = springBone.m_dragForce,
Origin = (springBone.m_center != null) ? Nodes[springBone.m_center.gameObject] : null,
HitRadius = springBone.m_hitRadius,
};
foreach (var rootBone in springBone.RootBones)
{
vrmSpringBone.Bones.Add(Nodes[rootBone.gameObject]);
}
foreach (var collider in springBone.ColliderGroups)
{
vrmSpringBone.Colliders.Add(colliders[collider]);
}
Model.Vrm.SpringBone.Springs.Add(vrmSpringBone);
}
}
}
return(Model);
}
/// <summary>
/// data を model で更新する
/// </summary>
/// <param name="data">更新前のオリジナル</param>
/// <param name="model">座標系の変換などの操作済み</param>
/// <returns></returns>
public static (glTF, ArraySegment <byte>) Execute(GltfData data, VrmLib.Model model)
{
return(new MeshUpdater(data).Update(model));
}
public override void OnImportAsset(AssetImportContext ctx)
{
Debug.Log("OnImportAsset to " + ctx.assetPath);
try
{
// Create Vrm Model
VrmLib.Model model = VrmLoader.CreateVrmModel(ctx.assetPath);
if (model == null)
{
// maybe VRM-0.X
return;
}
Debug.Log($"VrmLoader.CreateVrmModel: {model}");
// Build Unity Model
var assets = EditorUnityBuilder.ToUnityAsset(model, assetPath, this);
ComponentBuilder.Build10(model, assets);
// Texture
var externalTextures = this.GetExternalUnityObjects <UnityEngine.Texture2D>();
foreach (var texture in assets.Textures)
{
if (texture == null)
{
continue;
}
if (externalTextures.ContainsValue(texture))
{
}
else
{
ctx.AddObjectToAsset(texture.name, texture);
}
}
// Material
var externalMaterials = this.GetExternalUnityObjects <UnityEngine.Material>();
foreach (var material in assets.Materials)
{
if (material == null)
{
continue;
}
if (externalMaterials.ContainsValue(material))
{
}
else
{
ctx.AddObjectToAsset(material.name, material);
}
}
// Mesh
foreach (var mesh in assets.Meshes)
{
ctx.AddObjectToAsset(mesh.name, mesh);
}
//// ScriptableObject
// avatar
ctx.AddObjectToAsset("avatar", assets.HumanoidAvatar);
// meta
{
var external = this.GetExternalUnityObjects <UniVRM10.VRM10MetaObject>().FirstOrDefault();
if (external.Value != null)
{
var controller = assets.Root.GetComponent <VRM10Controller>();
if (controller != null)
{
controller.Meta = external.Value;
}
}
else
{
var meta = assets.ScriptableObjects
.FirstOrDefault(x => x.GetType() == typeof(UniVRM10.VRM10MetaObject)) as UniVRM10.VRM10MetaObject;
if (meta != null)
{
meta.name = "meta";
ctx.AddObjectToAsset(meta.name, meta);
}
}
}
// expression
{
var external = this.GetExternalUnityObjects <UniVRM10.VRM10Expression>();
if (external.Any())
{
}
else
{
var expression = assets.ScriptableObjects
.Where(x => x.GetType() == typeof(UniVRM10.VRM10Expression))
.Select(x => x as UniVRM10.VRM10Expression);
foreach (var clip in expression)
{
clip.name = clip.ExpressionName;
ctx.AddObjectToAsset(clip.ExpressionName, clip);
}
}
}
{
var external = this.GetExternalUnityObjects <UniVRM10.VRM10ExpressionAvatar>().FirstOrDefault();
if (external.Value != null)
{
var controller = assets.Root.GetComponent <VRM10Controller>();
if (controller != null)
{
controller.Expression.ExpressionAvatar = external.Value;
}
}
else
{
var expressionAvatar = assets.ScriptableObjects
.FirstOrDefault(x => x.GetType() == typeof(UniVRM10.VRM10ExpressionAvatar)) as UniVRM10.VRM10ExpressionAvatar;
if (expressionAvatar != null)
{
expressionAvatar.name = "expressionAvatar";
ctx.AddObjectToAsset(expressionAvatar.name, expressionAvatar);
}
}
}
// Root
ctx.AddObjectToAsset(assets.Root.name, assets.Root);
ctx.SetMainObject(assets.Root);
}
catch (System.Exception ex)
{
Debug.LogError(ex);
}
}
public static UniVRM10.MorphTargetBinding Build10(this MorphTargetBind bind, GameObject root, Vrm10Importer.ModelMap loader, VrmLib.Model model)
{
var libNode = model.Nodes[bind.Node.Value];
var node = loader.Nodes[libNode].transform;
var mesh = loader.Meshes[libNode.MeshGroup];
var relativePath = node.RelativePathFrom(root.transform);
return(new UniVRM10.MorphTargetBinding(relativePath, bind.Index.Value, bind.Weight.Value));
}
public static IEnumerator ToUnityAssetAsync(VrmLib.Model model, ModelAsset asset)
{
// texture
for (int i = 0; i < model.Textures.Count; ++i)
{
var src = model.Textures[i];
var name = !string.IsNullOrEmpty(src.Name)
? src.Name
: string.Format("{0}_img{1}", model.Root.Name, i);
if (src is VrmLib.ImageTexture imageTexture)
{
var texture = RuntimeUnityBuilder.CreateTexture(imageTexture);
texture.name = name;
asset.Map.Textures.Add(src, texture);
asset.Textures.Add(texture);
}
else
{
Debug.LogWarning($"{name} not ImageTexture");
}
// next frame
yield return(null);
}
// material
foreach (var src in model.Materials)
{
// TODO: material has VertexColor
var material = RuntimeUnityMaterialBuilder.CreateMaterialAsset(src, hasVertexColor: false, asset.Map.Textures);
material.name = src.Name;
asset.Map.Materials.Add(src, material);
asset.Materials.Add(material);
// next frame
yield return(null);
}
// mesh
for (int i = 0; i < model.MeshGroups.Count; ++i)
{
var src = model.MeshGroups[i];
if (src.Meshes.Count == 1)
{
// submesh 方式
var mesh = new Mesh();
mesh.name = src.Name;
mesh.LoadMesh(src.Meshes[0], src.Skin);
asset.Map.Meshes.Add(src, mesh);
asset.Meshes.Add(mesh);
}
else
{
// 頂点バッファの連結が必用
throw new NotImplementedException();
}
// next frame
yield return(null);
}
// node: recursive
yield return(CreateNodesAsync(model.Root, null, asset.Map.Nodes));
asset.Root = asset.Map.Nodes[model.Root];
// next frame
yield return(null);
// renderer
var map = asset.Map;
foreach (var(node, go) in map.Nodes)
{
if (node.MeshGroup is null)
{
continue;
}
if (node.MeshGroup.Meshes.Count > 1)
{
throw new NotImplementedException("invalid isolated vertexbuffer");
}
var renderer = RuntimeUnityBuilder.CreateRenderer(node, go, map);
renderer.enabled = false;
map.Renderers.Add(node, renderer);
asset.Renderers.Add(renderer);
// next frame
yield return(null);
}
// humanoid
var boneMap = map.Nodes
.Where(x => x.Key.HumanoidBone.GetValueOrDefault() != VrmLib.HumanoidBones.unknown)
.Select(x => (x.Value.transform, x.Key.HumanoidBone.Value)).AsEnumerable();
// next frame
yield return(null);
asset.HumanoidAvatar = HumanoidLoader.LoadHumanoidAvatar(asset.Root.transform, boneMap);
asset.HumanoidAvatar.name = "VRM";
// next frame
yield return(null);
var animator = asset.Root.AddComponent <Animator>();
animator.avatar = asset.HumanoidAvatar;
}
/// <summary>
/// metaObject が null のときは、root から取得する
/// </summary>
public VrmLib.Model ToModelFrom10(GameObject root, VRMMetaObject metaObject = null)
{
Model = new VrmLib.Model(VrmLib.Coordinates.Unity);
if (metaObject is null)
{
var vrmMeta = root.GetComponent <VRMMeta>();
if (vrmMeta is null || vrmMeta.Meta is null)
{
throw new NullReferenceException("metaObject is null");
}
metaObject = vrmMeta.Meta;
}
var meta = new VrmLib.Meta();
meta.Name = metaObject.Name;
meta.Version = metaObject.Version;
meta.Copyrights = metaObject.Copyrights;
meta.Authors.AddRange(metaObject.Authors);
meta.ContactInformation = metaObject.ContactInformation;
meta.Reference = metaObject.Reference;
meta.Thumbnail = metaObject.Thumbnail.ToPngImage(VrmLib.ImageUsage.None);
meta.AvatarPermission = new VrmLib.AvatarPermission
{
AvatarUsage = metaObject.AllowedUser,
IsAllowedViolentUsage = metaObject.ViolentUsage,
IsAllowedSexualUsage = metaObject.SexualUsage,
CommercialUsage = metaObject.CommercialUsage,
IsAllowedGameUsage = metaObject.GameUsage,
IsAllowedPoliticalOrReligiousUsage = metaObject.PoliticalOrReligiousUsage,
OtherPermissionUrl = metaObject.OtherPermissionUrl,
};
meta.RedistributionLicense = new VrmLib.RedistributionLicense
{
CreditNotation = metaObject.CreditNotation,
IsAllowRedistribution = metaObject.Redistribution,
ModificationLicense = metaObject.ModificationLicense,
OtherLicenseUrl = metaObject.OtherLicenseUrl,
};
Model.Vrm = new VrmLib.Vrm(meta, UniVRM10.VRMVersion.VERSION, UniVRM10.VRMSpecVersion.Version);
// node
{
Model.Root = new VrmLib.Node(root.name);
CreateNodes(root.transform, Model.Root, Nodes);
Model.Nodes = Nodes
.Where(x => x.Value != Model.Root)
.Select(x => x.Value).ToList();
}
// humanoid
{
var animator = root.GetComponent <Animator>();
if (animator != null && animator.avatar != null)
{
foreach (HumanBodyBones humanBoneType in Enum.GetValues(typeof(HumanBodyBones)))
{
if (humanBoneType == HumanBodyBones.LastBone)
{
continue;
}
var transform = animator.GetBoneTransform(humanBoneType);
if (transform != null && Nodes.TryGetValue(transform.gameObject, out VrmLib.Node node))
{
node.HumanoidBone = (VrmLib.HumanoidBones)Enum.Parse(typeof(VrmLib.HumanoidBones), humanBoneType.ToString(), true);
}
}
}
}
// material and textures
var rendererComponents = root.GetComponentsInChildren <Renderer>();
{
foreach (var renderer in rendererComponents)
{
var materials = renderer.sharedMaterials; // avoid copy
foreach (var material in materials)
{
if (Materials.ContainsKey(material))
{
continue;
}
var vrmMaterial = Export10(material, GetOrCreateTexture);
Model.Materials.Add(vrmMaterial);
Materials.Add(material, vrmMaterial);
}
}
}
// mesh
{
foreach (var renderer in rendererComponents)
{
if (renderer is SkinnedMeshRenderer skinnedMeshRenderer)
{
if (skinnedMeshRenderer.sharedMesh != null)
{
var mesh = CreateMesh(skinnedMeshRenderer.sharedMesh, skinnedMeshRenderer, Materials);
var skin = CreateSkin(skinnedMeshRenderer, Nodes, root);
if (skin != null)
{
// blendshape only で skinning が無いやつがある
mesh.Skin = skin;
Model.Skins.Add(mesh.Skin);
}
Model.MeshGroups.Add(mesh);
Nodes[renderer.gameObject].MeshGroup = mesh;
Meshes.Add(skinnedMeshRenderer.sharedMesh, mesh);
}
}
else if (renderer is MeshRenderer meshRenderer)
{
var filter = meshRenderer.gameObject.GetComponent <MeshFilter>();
if (filter != null && filter.sharedMesh != null)
{
var mesh = CreateMesh(filter.sharedMesh, meshRenderer, Materials);
Model.MeshGroups.Add(mesh);
Nodes[renderer.gameObject].MeshGroup = mesh;
Meshes.Add(filter.sharedMesh, mesh);
}
}
}
}
// blendShape
{
Model.Vrm.BlendShape = new VrmLib.BlendShapeManager();
var blendShapeProxy = root.GetComponent <UniVRM10.VRMBlendShapeProxy>();
if (blendShapeProxy != null)
{
foreach (var clip in blendShapeProxy.BlendShapeAvatar.Clips)
{
var blendShape = new VrmLib.BlendShape(clip.Preset, clip.BlendShapeName, clip.IsBinary);
blendShape.IgnoreBlink = clip.IgnoreBlink;
blendShape.IgnoreLookAt = clip.IgnoreLookAt;
blendShape.IgnoreMouth = clip.IgnoreMouth;
foreach (var value in clip.Values)
{
var transform = GetTransformFromRelativePath(root.transform, value.RelativePath);
if (transform == null)
{
continue;
}
var renderer = transform.gameObject.GetComponent <SkinnedMeshRenderer>();
if (renderer == null)
{
continue;
}
var mesh = renderer.sharedMesh;
if (mesh == null)
{
continue;
}
var names = new List <string>();
for (int i = 0; i < mesh.blendShapeCount; ++i)
{
names.Add(mesh.GetBlendShapeName(i));
}
var blendShapeValue = new VrmLib.BlendShapeBindValue(
Meshes[mesh],
names[value.Index],
value.Weight
);
blendShape.BlendShapeValues.Add(blendShapeValue);
}
foreach (var value in clip.MaterialValues)
{
var materialPair = Materials.FirstOrDefault(x => x.Key.name == value.MaterialName);
if (materialPair.Equals(default(KeyValuePair <Material, VrmLib.Material>)))
{
continue;
}
var bind = new VrmLib.MaterialBindValue(
materialPair.Value,
value.ValueName,
value.TargetValue.ToNumericsVector4()
);
blendShape.MaterialValues.Add(bind);
}
Model.Vrm.BlendShape.BlendShapeList.Add(blendShape);
}
}
}
// firstPerson
{
var firstPerson = new VrmLib.FirstPerson();
var firstPersonComponent = root.GetComponent <UniVRM10.VRMFirstPerson>();
if (firstPersonComponent != null)
{
firstPerson.m_fp = Nodes[firstPersonComponent.FirstPersonBone.gameObject];
foreach (var renderer in firstPersonComponent.Renderers)
{
firstPerson.Annotations.Add(
new VrmLib.FirstPersonMeshAnnotation(Meshes[renderer.SharedMesh],
renderer.FirstPersonFlag)
);
}
Model.Vrm.FirstPerson = firstPerson;
}
}
// lookAt
{
var lookAt = new VrmLib.LookAt();
var lookAtBlendShape = root.GetComponent <UniVRM10.VRMLookAtBlendShapeApplier>();
var lookAtBone = root.GetComponent <UniVRM10.VRMLookAtBoneApplier>();
if (lookAtBlendShape != null)
{
lookAt.HorizontalInner = new VrmLib.LookAtRangeMap();
lookAt.HorizontalOuter = new VrmLib.LookAtRangeMap()
{
InputMaxValue = lookAtBlendShape.HorizontalOuter.CurveXRangeDegree,
OutputScaling = lookAtBlendShape.HorizontalOuter.CurveYRangeDegree
};
lookAt.VerticalUp = new VrmLib.LookAtRangeMap()
{
InputMaxValue = lookAtBlendShape.VerticalUp.CurveXRangeDegree,
OutputScaling = lookAtBlendShape.VerticalUp.CurveYRangeDegree,
};
lookAt.VerticalDown = new VrmLib.LookAtRangeMap()
{
InputMaxValue = lookAtBlendShape.VerticalDown.CurveXRangeDegree,
OutputScaling = lookAtBlendShape.VerticalDown.CurveYRangeDegree,
};
}
else if (lookAtBone != null)
{
lookAt.HorizontalInner = new VrmLib.LookAtRangeMap()
{
InputMaxValue = lookAtBone.HorizontalInner.CurveXRangeDegree,
OutputScaling = lookAtBone.HorizontalInner.CurveYRangeDegree
};
lookAt.HorizontalOuter = new VrmLib.LookAtRangeMap()
{
InputMaxValue = lookAtBone.HorizontalOuter.CurveXRangeDegree,
OutputScaling = lookAtBone.HorizontalOuter.CurveYRangeDegree
};
lookAt.VerticalUp = new VrmLib.LookAtRangeMap()
{
InputMaxValue = lookAtBone.VerticalUp.CurveXRangeDegree,
OutputScaling = lookAtBone.VerticalUp.CurveYRangeDegree,
};
lookAt.VerticalDown = new VrmLib.LookAtRangeMap()
{
InputMaxValue = lookAtBone.VerticalDown.CurveXRangeDegree,
OutputScaling = lookAtBone.VerticalDown.CurveYRangeDegree,
};
}
var firstPersonComponent = root.GetComponent <UniVRM10.VRMFirstPerson>();
if (firstPersonComponent != null)
{
lookAt.OffsetFromHeadBone = firstPersonComponent.FirstPersonOffset.ToNumericsVector3();
}
Model.Vrm.LookAt = lookAt;
}
// springBone
{
var springBoneColliderGroups = root.GetComponentsInChildren <UniVRM10.VRMSpringBoneColliderGroup>();
if (springBoneColliderGroups != null)
{
Model.Vrm.SpringBone = new VrmLib.SpringBoneManager();
var colliders = new Dictionary <UniVRM10.VRMSpringBoneColliderGroup, VrmLib.SpringBoneColliderGroup>();
foreach (var colliderGroup in springBoneColliderGroups)
{
var colliderGroups = colliderGroup.Colliders.Select(x =>
new VrmLib.VrmSpringBoneColliderSphere(x.Offset.ToNumericsVector3(), x.Radius));
var vrmColliderGroup = new VrmLib.SpringBoneColliderGroup(Nodes[colliderGroup.gameObject], colliderGroups);
Model.Vrm.SpringBone.Colliders.Add(vrmColliderGroup);
colliders.Add(colliderGroup, vrmColliderGroup);
}
var springBones = root.GetComponentsInChildren <UniVRM10.VRMSpringBone>();
foreach (var springBone in springBones)
{
var vrmSpringBone = new VrmLib.SpringBone()
{
Comment = springBone.m_comment,
Stiffness = springBone.m_stiffnessForce,
GravityPower = springBone.m_gravityPower,
GravityDir = springBone.m_gravityDir.ToNumericsVector3(),
DragForce = springBone.m_dragForce,
Origin = (springBone.m_center != null) ? Nodes[springBone.m_center.gameObject] : null,
HitRadius = springBone.m_hitRadius,
};
foreach (var rootBone in springBone.RootBones)
{
vrmSpringBone.Bones.Add(Nodes[rootBone.gameObject]);
}
foreach (var collider in springBone.ColliderGroups)
{
vrmSpringBone.Colliders.Add(colliders[collider]);
}
Model.Vrm.SpringBone.Springs.Add(vrmSpringBone);
}
}
}
return(Model);
}
public override async Task <RuntimeGltfInstance> LoadAsync(IAwaitCaller awaitCaller, Func <string, IDisposable> MeasureTime = null)
{
if (awaitCaller == null)
{
throw new ArgumentNullException();
}
// NOTE: VRM データに対して、Load 前に必要なヘビーな変換処理を行う.
// ヘビーなため、別スレッドで Run する.
await awaitCaller.Run(() =>
{
// bin に対して右手左手変換を破壊的に実行することに注意 !(bin が変換済みになる)
m_model = ModelReader.Read(Data);
if (m_doNormalize)
{
var result = m_model.SkinningBake(Data.NativeArrayManager);
Debug.Log($"SkinningBake: {result}");
}
// assign humanoid bones
if (m_vrm.VrmExtension.Humanoid is UniGLTF.Extensions.VRMC_vrm.Humanoid humanoid)
{
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.Hips, VrmLib.HumanoidBones.hips);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftUpperLeg, VrmLib.HumanoidBones.leftUpperLeg);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightUpperLeg, VrmLib.HumanoidBones.rightUpperLeg);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftLowerLeg, VrmLib.HumanoidBones.leftLowerLeg);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightLowerLeg, VrmLib.HumanoidBones.rightLowerLeg);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftFoot, VrmLib.HumanoidBones.leftFoot);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightFoot, VrmLib.HumanoidBones.rightFoot);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.Spine, VrmLib.HumanoidBones.spine);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.Chest, VrmLib.HumanoidBones.chest);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.Neck, VrmLib.HumanoidBones.neck);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.Head, VrmLib.HumanoidBones.head);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftShoulder, VrmLib.HumanoidBones.leftShoulder);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightShoulder, VrmLib.HumanoidBones.rightShoulder);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftUpperArm, VrmLib.HumanoidBones.leftUpperArm);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightUpperArm, VrmLib.HumanoidBones.rightUpperArm);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftLowerArm, VrmLib.HumanoidBones.leftLowerArm);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightLowerArm, VrmLib.HumanoidBones.rightLowerArm);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftHand, VrmLib.HumanoidBones.leftHand);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightHand, VrmLib.HumanoidBones.rightHand);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftToes, VrmLib.HumanoidBones.leftToes);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightToes, VrmLib.HumanoidBones.rightToes);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftEye, VrmLib.HumanoidBones.leftEye);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightEye, VrmLib.HumanoidBones.rightEye);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.Jaw, VrmLib.HumanoidBones.jaw);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftThumbProximal, VrmLib.HumanoidBones.leftThumbProximal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftThumbIntermediate, VrmLib.HumanoidBones.leftThumbIntermediate);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftThumbDistal, VrmLib.HumanoidBones.leftThumbDistal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftIndexProximal, VrmLib.HumanoidBones.leftIndexProximal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftIndexIntermediate, VrmLib.HumanoidBones.leftIndexIntermediate);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftIndexDistal, VrmLib.HumanoidBones.leftIndexDistal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftMiddleProximal, VrmLib.HumanoidBones.leftMiddleProximal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftMiddleIntermediate, VrmLib.HumanoidBones.leftMiddleIntermediate);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftMiddleDistal, VrmLib.HumanoidBones.leftMiddleDistal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftRingProximal, VrmLib.HumanoidBones.leftRingProximal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftRingIntermediate, VrmLib.HumanoidBones.leftRingIntermediate);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftRingDistal, VrmLib.HumanoidBones.leftRingDistal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftLittleProximal, VrmLib.HumanoidBones.leftLittleProximal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftLittleIntermediate, VrmLib.HumanoidBones.leftLittleIntermediate);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.LeftLittleDistal, VrmLib.HumanoidBones.leftLittleDistal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightThumbProximal, VrmLib.HumanoidBones.rightThumbProximal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightThumbIntermediate, VrmLib.HumanoidBones.rightThumbIntermediate);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightThumbDistal, VrmLib.HumanoidBones.rightThumbDistal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightIndexProximal, VrmLib.HumanoidBones.rightIndexProximal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightIndexIntermediate, VrmLib.HumanoidBones.rightIndexIntermediate);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightIndexDistal, VrmLib.HumanoidBones.rightIndexDistal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightMiddleProximal, VrmLib.HumanoidBones.rightMiddleProximal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightMiddleIntermediate, VrmLib.HumanoidBones.rightMiddleIntermediate);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightMiddleDistal, VrmLib.HumanoidBones.rightMiddleDistal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightRingProximal, VrmLib.HumanoidBones.rightRingProximal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightRingIntermediate, VrmLib.HumanoidBones.rightRingIntermediate);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightRingDistal, VrmLib.HumanoidBones.rightRingDistal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightLittleProximal, VrmLib.HumanoidBones.rightLittleProximal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightLittleIntermediate, VrmLib.HumanoidBones.rightLittleIntermediate);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.RightLittleDistal, VrmLib.HumanoidBones.rightLittleDistal);
AssignHumanoid(m_model.Nodes, humanoid.HumanBones.UpperChest, VrmLib.HumanoidBones.upperChest);
}
});
return(await base.LoadAsync(awaitCaller, MeasureTime));
}
/// <summary>
/// モデル(Transform + Renderer)を構築する。
/// <summary>
public static ModelAsset ToUnityAsset(VrmLib.Model model, bool showMesh = true)
{
var modelAsset = new ModelAsset();
// texture
for (int i = 0; i < model.Textures.Count; ++i)
{
var src = model.Textures[i];
var name = !string.IsNullOrEmpty(src.Name)
? src.Name
: string.Format("{0}_img{1}", model.Root.Name, i);
if (src is VrmLib.ImageTexture imageTexture)
{
var texture = CreateTexture(imageTexture);
texture.name = name;
modelAsset.Map.Textures.Add(src, texture);
modelAsset.Textures.Add(texture);
}
else
{
Debug.LogWarning($"{name} not ImageTexture");
}
}
// material
foreach (var src in model.Materials)
{
// TODO: material has VertexColor
var material = RuntimeUnityMaterialBuilder.CreateMaterialAsset(src, hasVertexColor: false, modelAsset.Map.Textures);
material.name = src.Name;
modelAsset.Map.Materials.Add(src, material);
modelAsset.Materials.Add(material);
}
// mesh
for (int i = 0; i < model.MeshGroups.Count; ++i)
{
var src = model.MeshGroups[i];
if (src.Meshes.Count == 1)
{
// submesh 方式
var mesh = new Mesh();
mesh.name = src.Name;
mesh.LoadMesh(src.Meshes[0], src.Skin);
modelAsset.Map.Meshes.Add(src, mesh);
modelAsset.Meshes.Add(mesh);
}
else
{
// 頂点バッファの連結が必用
throw new NotImplementedException();
}
}
// node: recursive
CreateNodes(model.Root, null, modelAsset.Map.Nodes);
modelAsset.Root = modelAsset.Map.Nodes[model.Root];
// renderer
var map = modelAsset.Map;
foreach (var(node, go) in map.Nodes)
{
if (node.MeshGroup is null)
{
continue;
}
if (node.MeshGroup.Meshes.Count > 1)
{
throw new NotImplementedException("invalid isolated vertexbuffer");
}
var renderer = CreateRenderer(node, go, map);
if (!showMesh)
{
renderer.enabled = false;
}
map.Renderers.Add(node, renderer);
modelAsset.Renderers.Add(renderer);
}
var humanoid = modelAsset.Root.AddComponent <Humanoid>();
humanoid.AssignBones(map.Nodes.Select(x => (x.Key.HumanoidBone.GetValueOrDefault().ToUnity(), x.Value.transform)));
modelAsset.HumanoidAvatar = humanoid.CreateAvatar();
modelAsset.HumanoidAvatar.name = "VRM";
var animator = modelAsset.Root.AddComponent <Animator>();
animator.avatar = modelAsset.HumanoidAvatar;
return(modelAsset);
}
