protected override async Task OnLoadHierarchy(IAwaitCaller awaitCaller, Func <string, IDisposable> MeasureTime)
{
Root.name = "VRM";
using (MeasureTime("VRM LoadMeta"))
{
await LoadMetaAsync();
}
await awaitCaller.NextFrame();
using (MeasureTime("VRM LoadHumanoid"))
{
LoadHumanoid();
}
await awaitCaller.NextFrame();
using (MeasureTime("VRM LoadBlendShapeMaster"))
{
LoadBlendShapeMaster();
}
await awaitCaller.NextFrame();
using (MeasureTime("VRM LoadSecondary"))
{
VRMSpringUtility.LoadSecondary(Root.transform, Nodes,
VRM.secondaryAnimation);
}
await awaitCaller.NextFrame();
using (MeasureTime("VRM LoadFirstPerson"))
{
LoadFirstPerson();
}
}
protected override async Task OnLoadHierarchy(IAwaitCaller awaitCaller, Func <string, IDisposable> MeasureTime)
{
Root.name = "VRM1";
// humanoid
var humanoid = Root.AddComponent <UniHumanoid.Humanoid>();
humanoid.AssignBones(m_map.Nodes.Select(x => (ToUnity(x.Key.HumanoidBone.GetValueOrDefault()), x.Value.transform)));
m_humanoid = humanoid.CreateAvatar();
m_humanoid.name = "humanoid";
var animator = Root.AddComponent <Animator>();
animator.avatar = m_humanoid;
// VrmController
var controller = Root.AddComponent <VRM10Controller>();
// vrm
controller.Vrm = await LoadVrmAsync(awaitCaller, m_vrm);
// springBone
if (UniGLTF.Extensions.VRMC_springBone.GltfDeserializer.TryGet(Data.GLTF.extensions, out UniGLTF.Extensions.VRMC_springBone.VRMC_springBone springBone))
{
await LoadSpringBoneAsync(awaitCaller, controller, springBone);
}
// constraint
await LoadConstraintAsync(awaitCaller, controller);
}
public async Task <VRMMetaObject> ReadMetaAsync(IAwaitCaller awaitCaller = null, bool createThumbnail = false)
{
awaitCaller = awaitCaller ?? new ImmediateCaller();
var meta = ScriptableObject.CreateInstance <VRMMetaObject>();
meta.name = "Meta";
meta.ExporterVersion = VRM.exporterVersion;
var gltfMeta = VRM.meta;
meta.Version = gltfMeta.version; // model version
meta.Author = gltfMeta.author;
meta.ContactInformation = gltfMeta.contactInformation;
meta.Reference = gltfMeta.reference;
meta.Title = gltfMeta.title;
if (gltfMeta.texture >= 0)
{
var(key, param) = GltfTextureImporter.CreateSRGB(Data, gltfMeta.texture, Vector2.zero, Vector2.one);
meta.Thumbnail = await TextureFactory.GetTextureAsync(param, awaitCaller) as Texture2D;
}
meta.AllowedUser = gltfMeta.allowedUser;
meta.ViolentUssage = gltfMeta.violentUssage;
meta.SexualUssage = gltfMeta.sexualUssage;
meta.CommercialUssage = gltfMeta.commercialUssage;
meta.OtherPermissionUrl = gltfMeta.otherPermissionUrl;
meta.LicenseType = gltfMeta.licenseType;
meta.OtherLicenseUrl = gltfMeta.otherLicenseUrl;
return(meta);
}
public async Task <VRMMetaObject> ReadMetaAsync(IAwaitCaller awaitCaller = null, bool createThumbnail = false)
{
if (awaitCaller == null)
{
awaitCaller = default(ImmediateCaller);
}
var meta = ScriptableObject.CreateInstance <VRMMetaObject>();
meta.name = "Meta";
meta.ExporterVersion = VRM.exporterVersion;
var gltfMeta = VRM.meta;
meta.Version = gltfMeta.version; // model version
meta.Author = gltfMeta.author;
meta.ContactInformation = gltfMeta.contactInformation;
meta.Reference = gltfMeta.reference;
meta.Title = gltfMeta.title;
meta.Thumbnail = await TextureFactory.GetTextureAsync(awaitCaller, GLTF, GetTextureParam.Create(GLTF, gltfMeta.texture));
meta.AllowedUser = gltfMeta.allowedUser;
meta.ViolentUssage = gltfMeta.violentUssage;
meta.SexualUssage = gltfMeta.sexualUssage;
meta.CommercialUssage = gltfMeta.commercialUssage;
meta.OtherPermissionUrl = gltfMeta.otherPermissionUrl;
meta.LicenseType = gltfMeta.licenseType;
meta.OtherLicenseUrl = gltfMeta.otherLicenseUrl;
return(meta);
}
/// <summary>
/// Load the VRM file from the binary.
///
/// You should call this on Unity main thread.
/// This will throw Exceptions (include OperationCanceledException).
/// </summary>
/// <param name="bytes">vrm file data</param>
/// <param name="canLoadVrm0X">if true, this loader can load the vrm-0.x model as vrm-1.0 model with migration.</param>
/// <param name="normalizeTransform">if true, vrm-1.0 models' transforms are normalized. (e.g. rotation, scaling)</param>
/// <param name="showMeshes">if true, show meshes when loaded.</param>
/// <param name="awaitCaller">this loader use specified await strategy.</param>
/// <param name="materialGenerator">this loader use specified material generation strategy.</param>
/// <param name="vrmMetaInformationCallback">return callback that notify meta information before loading.</param>
/// <param name="ct">CancellationToken</param>
/// <returns>vrm-1.0 instance. Maybe return null if unexpected error was raised.</returns>
public static async Task <Vrm10Instance> LoadBytesAsync(
byte[] bytes,
bool canLoadVrm0X = true,
bool normalizeTransform = true,
bool showMeshes = true,
IAwaitCaller awaitCaller = null,
IMaterialDescriptorGenerator materialGenerator = null,
VrmMetaInformationCallback vrmMetaInformationCallback = null,
CancellationToken ct = default)
{
if (awaitCaller == null)
{
awaitCaller = Application.isPlaying
? (IAwaitCaller) new RuntimeOnlyAwaitCaller()
: (IAwaitCaller) new ImmediateCaller();
}
return(await LoadAsync(
string.Empty,
bytes,
canLoadVrm0X,
normalizeTransform,
showMeshes,
awaitCaller,
materialGenerator,
vrmMetaInformationCallback,
ct));
}
public static async Task <Texture2D> LoadTextureAsync(IAwaitCaller awaitCaller, glTF gltf, IStorage storage, int textureIndex)
{
var imageBytes = await awaitCaller.Run(() =>
{
var imageIndex = gltf.textures[textureIndex].source;
var segments = gltf.GetImageBytes(storage, imageIndex);
return(ToArray(segments));
});
//
// texture from image(png etc) bytes
//
var colorSpace = gltf.GetColorSpace(textureIndex);
var texture = new Texture2D(2, 2, TextureFormat.ARGB32, false, colorSpace == RenderTextureReadWrite.Linear);
texture.name = gltf.textures[textureIndex].name;
if (imageBytes != null)
{
texture.LoadImage(imageBytes);
}
var sampler = gltf.GetSamplerFromTextureIndex(textureIndex);
if (sampler != null)
{
TextureSamplerUtil.SetSampler(texture, sampler);
}
return(texture);
}
private static async Task <Vrm10Instance> LoadVrm10DataAsync(
Vrm10Data vrm10Data,
MigrationData migrationData,
bool normalizeTransform,
bool showMeshes,
IAwaitCaller awaitCaller,
IMaterialDescriptorGenerator materialGenerator,
VrmMetaInformationCallback vrmMetaInformationCallback,
CancellationToken ct)
{
ct.ThrowIfCancellationRequested();
if (awaitCaller == null)
{
throw new ArgumentNullException();
}
if (vrm10Data == null)
{
throw new ArgumentNullException(nameof(vrm10Data));
}
using (var loader = new Vrm10Importer(vrm10Data, materialGenerator: materialGenerator, doNormalize: normalizeTransform))
{
// 1. Load meta information if callback was available.
if (vrmMetaInformationCallback != null)
{
var thumbnail = await loader.LoadVrmThumbnailAsync();
if (migrationData != null)
{
vrmMetaInformationCallback(thumbnail, default, migrationData.OriginalMetaBeforeMigration);
private static async Task <Vrm10Instance> TryLoadingAsVrm10Async(
GltfData gltfData,
bool normalizeTransform,
bool showMeshes,
IAwaitCaller awaitCaller,
IMaterialDescriptorGenerator materialGenerator,
VrmMetaInformationCallback vrmMetaInformationCallback,
CancellationToken ct)
{
ct.ThrowIfCancellationRequested();
if (awaitCaller == null)
{
throw new ArgumentNullException();
}
var vrm10Data = await awaitCaller.Run(() => Vrm10Data.Parse(gltfData));
ct.ThrowIfCancellationRequested();
if (vrm10Data == null)
{
// NOTE: Failed to parse as VRM 1.0.
return(null);
}
return(await LoadVrm10DataAsync(
vrm10Data,
null,
normalizeTransform,
showMeshes,
awaitCaller,
materialGenerator,
vrmMetaInformationCallback,
ct));
}
protected virtual async Task LoadGeometryAsync(IAwaitCaller awaitCaller, Func <string, IDisposable> MeasureTime)
{
var inverter = InvertAxis.Create();
var meshImporter = new MeshImporter();
for (int i = 0; i < GLTF.meshes.Count; ++i)
{
var index = i;
using (MeasureTime("ReadMesh"))
{
var x = meshImporter.ReadMesh(GLTF, index, inverter);
var y = await BuildMeshAsync(awaitCaller, MeasureTime, x, index);
Meshes.Add(y);
}
}
using (MeasureTime("LoadNodes"))
{
for (int i = 0; i < GLTF.nodes.Count; i++)
{
Nodes.Add(NodeImporter.ImportNode(GLTF.nodes[i], i).transform);
}
}
await awaitCaller.NextFrame();
using (MeasureTime("BuildHierarchy"))
{
var nodes = new List <NodeImporter.TransformWithSkin>();
for (int i = 0; i < Nodes.Count; ++i)
{
nodes.Add(NodeImporter.BuildHierarchy(GLTF, i, Nodes, Meshes));
}
NodeImporter.FixCoordinate(GLTF, nodes, inverter);
// skinning
for (int i = 0; i < nodes.Count; ++i)
{
NodeImporter.SetupSkinning(GLTF, nodes, i, inverter);
}
if (Root == null)
{
Root = new GameObject("GLTF");
}
if (GLTF.rootnodes != null)
{
// connect root
foreach (var x in GLTF.rootnodes)
{
var t = nodes[x].Transform;
t.SetParent(Root.transform, false);
}
}
}
await awaitCaller.NextFrame();
}
public static async Task <Material> CreateAsync(IAwaitCaller awaitCaller, GltfParser parser, int m_index, glTF_VRM_Material vrmMaterial, GetTextureAsyncFunc getTexture)
{
var item = vrmMaterial;
var shaderName = item.shader;
var shader = Shader.Find(shaderName);
if (shader == null)
{
//
// no shader
//
if (VRM_SHADER_NAMES.Contains(shaderName))
{
Debug.LogErrorFormat("shader {0} not found. set Assets/VRM/Shaders/VRMShaders to Edit - project setting - Graphics - preloaded shaders", shaderName);
}
else
{
// #if VRM_DEVELOP
// Debug.LogWarningFormat("unknown shader {0}.", shaderName);
// #endif
}
return(await MaterialFactory.DefaultCreateMaterialAsync(awaitCaller, parser, m_index, getTexture));
}
//
// restore VRM material
//
var material = new Material(shader);
// use material.name, because material name may renamed in GltfParser.
material.name = parser.GLTF.materials[m_index].name;
material.renderQueue = item.renderQueue;
foreach (var kv in item.floatProperties)
{
material.SetFloat(kv.Key, kv.Value);
}
var offsetScaleMap = new Dictionary <string, float[]>();
foreach (var kv in item.vectorProperties)
{
if (item.textureProperties.ContainsKey(kv.Key))
{
// texture offset & scale
offsetScaleMap.Add(kv.Key, kv.Value);
}
else
{
// vector4
var v = new Vector4(kv.Value[0], kv.Value[1], kv.Value[2], kv.Value[3]);
material.SetVector(kv.Key, v);
}
}
foreach (var kv in item.textureProperties)
{
var(offset, scale) = (Vector2.zero, Vector2.one);
if (offsetScaleMap.TryGetValue(kv.Key, out float[] value))
public static async Task <MeshWithMaterials> BuildMeshAndUploadAsync(
IAwaitCaller awaitCaller,
MeshData data,
Func <int, Material> materialFromIndex)
{
Profiler.BeginSample("MeshUploader.BuildMesh");
//Debug.Log(prims.ToJson());
var mesh = new Mesh
{
name = data.Name
};
UploadMeshVertices(data, mesh);
await awaitCaller.NextFrame();
UploadMeshIndices(data, mesh);
await awaitCaller.NextFrame();
// NOTE: mesh.vertices では自動的に行われていたが、SetVertexBuffer では行われないため、明示的に呼び出す.
mesh.RecalculateBounds();
await awaitCaller.NextFrame();
if (!data.HasNormal)
{
mesh.RecalculateNormals();
await awaitCaller.NextFrame();
}
mesh.RecalculateTangents();
await awaitCaller.NextFrame();
var result = new MeshWithMaterials
{
Mesh = mesh,
Materials = data.MaterialIndices.Select(materialFromIndex).ToArray(),
ShouldSetRendererNodeAsBone = data.AssignBoneWeight,
};
await awaitCaller.NextFrame();
if (data.BlendShapes.Count > 0)
{
var emptyVertices = new Vector3[mesh.vertexCount];
foreach (var blendShape in data.BlendShapes)
{
await BuildBlendShapeAsync(awaitCaller, mesh, blendShape, emptyVertices);
}
}
Profiler.EndSample();
Profiler.BeginSample("Mesh.UploadMeshData");
mesh.UploadMeshData(false);
Profiler.EndSample();
return(result);
}
public Task <Material> CreateMaterialAsync(IAwaitCaller awaitCaller, glTF gltf, int i, GetTextureAsyncFunc getTexture)
{
if (i == 0 && m_materials.Count == 0)
{
// dummy
return(MaterialFactory.DefaultCreateMaterialAsync(awaitCaller, gltf, i, getTexture));
}
return(MToonMaterialItem.CreateAsync(awaitCaller, gltf, i, m_materials[i], getTexture));
}
public async Task LoadTexturesAsync(IAwaitCaller awaitCaller = null)
{
awaitCaller = awaitCaller ?? new ImmediateCaller();
var textures = TextureDescriptorGenerator.Get().GetEnumerable();
foreach (var param in textures)
{
var tex = await TextureFactory.GetTextureAsync(param, awaitCaller);
}
}
public virtual async Task <RuntimeGltfInstance> LoadAsync(IAwaitCaller awaitCaller, Func <string, IDisposable> MeasureTime = null)
{
if (awaitCaller == null)
{
throw new ArgumentNullException();
}
if (MeasureTime == null)
{
MeasureTime = new ImporterContextSpeedLog().MeasureTime;
}
if (GLTF.extensionsRequired != null)
{
var sb = new List <string>();
foreach (var required in GLTF.extensionsRequired)
{
if (UnsupportedExtensions.Contains(required))
{
sb.Add(required);
}
}
if (sb.Any())
{
throw new UniGLTFNotSupportedException(string.Join(", ", sb) + " is not supported");
}
}
using (MeasureTime("LoadTextures"))
{
await LoadTexturesAsync(awaitCaller);
}
using (MeasureTime("LoadMaterials"))
{
await LoadMaterialsAsync(awaitCaller);
}
await LoadGeometryAsync(awaitCaller, MeasureTime);
if (LoadAnimation)
{
using (MeasureTime("AnimationImporter"))
{
await LoadAnimationAsync(awaitCaller);
await SetupAnimationsAsync(awaitCaller);
}
}
await OnLoadHierarchy(awaitCaller, MeasureTime);
return(RuntimeGltfInstance.AttachTo(Root, this));
}
async Task LoadMetaAsync(IAwaitCaller awaitCaller)
{
if (awaitCaller == null)
{
throw new ArgumentNullException();
}
var meta = await ReadMetaAsync(awaitCaller);
var _meta = Root.AddComponent <VRMMeta>();
_meta.Meta = meta;
Meta = meta;
}
public static async Task <RuntimeGltfInstance> LoadAsync(string path,
bool doMigrate,
bool doNormalize,
IAwaitCaller awaitCaller = null,
IMaterialDescriptorGenerator materialGenerator = null,
MetaCallback metaCallback = null
)
{
using (var data = Vrm10Data.ParseOrMigrate(path, doMigrate, out Vrm10Data vrm1Data, out MigrationData migration))
{
if (vrm1Data == null)
{
return(default);
public static async Task <RuntimeGltfInstance> LoadAsync(string path,
IAwaitCaller awaitCaller = null,
MaterialGeneratorCallback materialGeneratorCallback = null,
MetaCallback metaCallback = null,
bool loadAnimation = false
)
{
if (!File.Exists(path))
{
throw new FileNotFoundException(path);
}
if (awaitCaller == null)
{
Debug.LogWarning("VrmUtility.LoadAsync: awaitCaller argument is null. ImmediateCaller is used as the default fallback. When playing, we recommend RuntimeOnlyAwaitCaller.");
awaitCaller = new ImmediateCaller();
}
using (GltfData data = new AutoGltfFileParser(path).Parse())
{
try
{
var vrm = new VRMData(data);
IMaterialDescriptorGenerator materialGen = default;
if (materialGeneratorCallback != null)
{
materialGen = materialGeneratorCallback(vrm.VrmExtension);
}
using (var loader = new VRMImporterContext(vrm, materialGenerator: materialGen, loadAnimation: loadAnimation))
{
if (metaCallback != null)
{
var meta = await loader.ReadMetaAsync(awaitCaller, true);
metaCallback(meta);
}
return(await loader.LoadAsync(awaitCaller));
}
}
catch (NotVrm0Exception)
{
// retry
Debug.LogWarning("file extension is vrm. but not vrm ?");
using (var loader = new UniGLTF.ImporterContext(data))
{
return(await loader.LoadAsync(awaitCaller));
}
}
}
}
public static async Task <RuntimeGltfInstance> LoadAsync(string path, IAwaitCaller awaitCaller = null, IMaterialDescriptorGenerator materialGenerator = null)
{
if (!File.Exists(path))
{
throw new FileNotFoundException(path);
}
Debug.LogFormat("{0}", path);
using (GltfData data = new AutoGltfFileParser(path).Parse())
using (var loader = new UniGLTF.ImporterContext(data, materialGenerator: materialGenerator))
{
return(await loader.LoadAsync(awaitCaller));
}
}
public async Task LoadTexturesAsync(IAwaitCaller awaitCaller)
{
if (awaitCaller == null)
{
throw new ArgumentNullException();
}
var textures = TextureDescriptorGenerator.Get().GetEnumerable();
foreach (var param in textures)
{
var tex = await TextureFactory.GetTextureAsync(param, awaitCaller);
}
}
public virtual async Task LoadAnimationAsync(IAwaitCaller awaitCaller)
{
if (GLTF.animations != null && GLTF.animations.Any())
{
foreach (var(key, gltfAnimation) in Enumerable.Zip(AnimationImporterUtil.EnumerateSubAssetKeys(GLTF), GLTF.animations, (x, y) => (x, y)))
{
await AnimationClipFactory.LoadAnimationClipAsync(key, async() =>
{
return(AnimationImporterUtil.ConvertAnimationClip(GLTF, gltfAnimation, InvertAxis.Create()));
});
}
await awaitCaller.NextFrame();
}
}
private static async Task BuildBlendShapeAsync(IAwaitCaller awaitCaller, Mesh mesh, BlendShape blendShape,
Vector3[] emptyVertices)
{
Vector3[] positions = null;
Vector3[] normals = null;
await awaitCaller.Run(() =>
{
positions = blendShape.Positions.ToArray();
if (blendShape.Normals != null)
{
normals = blendShape.Normals.ToArray();
}
});
Profiler.BeginSample("MeshUploader.BuildBlendShapeAsync");
if (blendShape.Positions.Count > 0)
{
if (blendShape.Positions.Count == mesh.vertexCount)
{
mesh.AddBlendShapeFrame(blendShape.Name, FrameWeight,
blendShape.Positions.ToArray(),
normals.Length == mesh.vertexCount && normals.Length == positions.Length ? normals : null,
null
);
}
else
{
Debug.LogWarningFormat(
"May be partial primitive has blendShape. Require separate mesh or extend blend shape, but not implemented: {0}",
blendShape.Name);
}
}
else
{
// Debug.LogFormat("empty blendshape: {0}.{1}", mesh.name, blendShape.Name);
// add empty blend shape for keep blend shape index
mesh.AddBlendShapeFrame(blendShape.Name, FrameWeight,
emptyVertices,
null,
null
);
}
Profiler.EndSample();
}
private static async Task <Vrm10Instance> TryMigratingFromVrm0XAsync(
GltfData gltfData,
bool normalizeTransform,
bool showMeshes,
IAwaitCaller awaitCaller,
IMaterialDescriptorGenerator materialGenerator,
VrmMetaInformationCallback vrmMetaInformationCallback,
CancellationToken ct)
{
ct.ThrowIfCancellationRequested();
if (awaitCaller == null)
{
throw new ArgumentNullException();
}
Vrm10Data migratedVrm10Data = default;
MigrationData migrationData = default;
using (var migratedGltfData = await awaitCaller.Run(() => Vrm10Data.Migrate(gltfData, out migratedVrm10Data, out migrationData)))
{
ct.ThrowIfCancellationRequested();
if (migratedVrm10Data == null)
{
throw new Exception(migrationData?.Message ?? "Failed to migrate.");
}
var migratedVrm10Instance = await LoadVrm10DataAsync(
migratedVrm10Data,
migrationData,
normalizeTransform,
showMeshes,
awaitCaller,
materialGenerator,
vrmMetaInformationCallback,
ct);
if (migratedVrm10Instance == null)
{
throw new Exception(migrationData?.Message ?? "Failed to load migrated.");
}
return(migratedVrm10Instance);
}
}
public async Task LoadMaterialsAsync(IAwaitCaller awaitCaller = null)
{
awaitCaller = awaitCaller ?? new ImmediateCaller();
if (Data.GLTF.materials == null || Data.GLTF.materials.Count == 0)
{
// no material. work around.
var param = MaterialDescriptorGenerator.Get(Data, 0);
var material = await MaterialFactory.LoadAsync(param, TextureFactory.GetTextureAsync, awaitCaller);
}
else
{
for (int i = 0; i < Data.GLTF.materials.Count; ++i)
{
var param = MaterialDescriptorGenerator.Get(Data, i);
var material = await MaterialFactory.LoadAsync(param, TextureFactory.GetTextureAsync, awaitCaller);
}
}
}
public static async Task <RuntimeGltfInstance> LoadAsync(string path,
IAwaitCaller awaitCaller = null,
MaterialGeneratorCallback materialGeneratorCallback = null,
MetaCallback metaCallback = null
)
{
if (!File.Exists(path))
{
throw new FileNotFoundException(path);
}
using (GltfData data = new AutoGltfFileParser(path).Parse())
{
try
{
var vrm = new VRMData(data);
IMaterialDescriptorGenerator materialGen = default;
if (materialGeneratorCallback != null)
{
materialGen = materialGeneratorCallback(vrm.VrmExtension);
}
using (var loader = new VRMImporterContext(vrm, materialGenerator: materialGen))
{
if (metaCallback != null)
{
var meta = await loader.ReadMetaAsync(new ImmediateCaller(), true);
metaCallback(meta);
}
return(await loader.LoadAsync(awaitCaller));
}
}
catch (NotVrm0Exception)
{
// retry
Debug.LogWarning("file extension is vrm. but not vrm ?");
using (var loader = new UniGLTF.ImporterContext(data))
{
return(await loader.LoadAsync(awaitCaller));
}
}
}
}
public async Task LoadMaterialsAsync(IAwaitCaller awaitCaller = null)
{
awaitCaller = awaitCaller ?? new ImmediateCaller();
if (Data.GLTF.materials == null || Data.GLTF.materials.Count == 0)
{
// no material. work around.
// TODO: https://www.khronos.org/registry/glTF/specs/2.0/glTF-2.0.html#default-material
var param = MaterialDescriptor.Default;
var material = await MaterialFactory.LoadAsync(param, TextureFactory.GetTextureAsync, awaitCaller);
}
else
{
for (int i = 0; i < Data.GLTF.materials.Count; ++i)
{
var param = MaterialDescriptorGenerator.Get(Data, i);
var material = await MaterialFactory.LoadAsync(param, TextureFactory.GetTextureAsync, awaitCaller);
}
}
}
internal static async Task <MeshWithMaterials> BuildMeshAsync(
IAwaitCaller awaitCaller,
Func <int, Material> ctx,
MeshContext meshContext)
{
Profiler.BeginSample("MeshImporter.BuildMesh");
var(mesh, recalculateTangents) = BuildMesh(meshContext);
Profiler.EndSample();
if (recalculateTangents)
{
await awaitCaller.NextFrame();
mesh.RecalculateTangents();
await awaitCaller.NextFrame();
}
// 先にすべてのマテリアルを作成済みなのでテクスチャーは生成済み。Resultを使ってよい
var result = new MeshWithMaterials
{
Mesh = mesh,
Materials = meshContext.MaterialIndices.Select(ctx).ToArray()
};
await awaitCaller.NextFrame();
if (meshContext.BlendShapes.Count > 0)
{
var emptyVertices = new Vector3[mesh.vertexCount];
foreach (var blendShape in meshContext.BlendShapes)
{
await BuildBlendShapeAsync(awaitCaller, mesh, blendShape, emptyVertices);
}
}
Profiler.BeginSample("Mesh.UploadMeshData");
mesh.UploadMeshData(false);
Profiler.EndSample();
return(result);
}
async Task <MeshWithMaterials> BuildMeshAsync(IAwaitCaller awaitCaller, Func <string, IDisposable> MeasureTime, MeshData meshData, int i)
{
using (MeasureTime("BuildMesh"))
{
var meshWithMaterials = await MeshUploader.BuildMeshAndUploadAsync(awaitCaller, meshData, MaterialFactory.GetMaterial);
var mesh = meshWithMaterials.Mesh;
// mesh name
if (string.IsNullOrEmpty(mesh.name))
{
mesh.name = string.Format("UniGLTF import#{0}", i);
}
var originalName = mesh.name;
for (int j = 1; Meshes.Any(y => y.Mesh.name == mesh.name); ++j)
{
mesh.name = string.Format("{0}({1})", originalName, j);
}
return(meshWithMaterials);
}
}
/// <summary>
/// AnimationClips を AnimationComponent に載せる
/// </summary>
protected virtual async Task SetupAnimationsAsync(IAwaitCaller awaitCaller)
{
if (AnimationClipFactory.LoadedClipKeys.Count == 0)
{
return;
}
var animation = Root.AddComponent <Animation>();
for (var clipIdx = 0; clipIdx < AnimationClipFactory.LoadedClipKeys.Count; ++clipIdx)
{
var key = AnimationClipFactory.LoadedClipKeys[clipIdx];
var clip = AnimationClipFactory.GetAnimationClip(key);
animation.AddClip(clip, key.Name);
if (clipIdx == 0)
{
animation.clip = clip;
}
}
await awaitCaller.NextFrame();
}
public static async Task <Material> CreateAsync(IAwaitCaller awaitCaller, glTF gltf, int i, GetTextureAsyncFunc getTexture, bool hasVertexColor)
{
if (getTexture == null)
{
getTexture = (_x, _y, _z) => Task.FromResult <Texture2D>(default);
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));
}
