public static void OnGUIMaterial(ScriptedImporter importer, GltfParser parser)
{
var canExtract = !importer.GetExternalObjectMap().Any(x => x.Value is Material || x.Value is Texture2D);
using (new TmpGuiEnable(canExtract))
{
if (GUILayout.Button("Extract Materials And Textures ..."))
{
ExtractMaterialsAndTextures(importer);
}
}
//
// Draw ExternalObjectMap
//
s_foldMaterials = EditorGUILayout.Foldout(s_foldMaterials, "Remapped Materials");
if (s_foldMaterials)
{
DrawRemapGUI <UnityEngine.Material>(importer, parser.GLTF.materials.Select(x => x.name));
}
s_foldTextures = EditorGUILayout.Foldout(s_foldTextures, "Remapped Textures");
if (s_foldTextures)
{
DrawRemapGUI <UnityEngine.Texture2D>(importer, GltfTextureEnumerator.Enumerate(parser.GLTF).Select(x => x.ConvertedName));
}
if (GUILayout.Button("Clear"))
{
importer.ClearExternalObjects <UnityEngine.Material>();
importer.ClearExternalObjects <UnityEngine.Texture2D>();
}
}
/// <summary>
/// Callback called on the Implemented IESImporterEditor (currently on HDRP Only)
/// </summary>
/// <param name="background">Background of the Preview</param>
/// <param name="r">Rect of the Preview</param>
/// <param name="target">ScriptedImporter targeted</param>
/// <param name="setupRenderPipelinePreviewLightIntensity">Delegate provided by the Rendering Pipeline to setup the Light Intensity</param>
public void CommonOnPreviewGUI(Rect r, GUIStyle background, ScriptedImporter target,
SetupRenderPipelinePreviewLightIntensity setupRenderPipelinePreviewLightIntensity)
{
if (Event.current.type == EventType.Repaint)
{
Texture cookieTexture = null;
Texture previewTexture = null;
if (m_PrefabLightTypeProp.enumValueIndex == (int)IESLightType.Point)
{
foreach (var subAsset in AssetDatabase.LoadAllAssetRepresentationsAtPath(target.assetPath))
{
if (subAsset.name.EndsWith("-Cube-IES"))
{
cookieTexture = subAsset as Texture;
break;
}
}
}
else // LightType.Spot
{
foreach (var subAsset in AssetDatabase.LoadAllAssetRepresentationsAtPath(target.assetPath))
{
if (subAsset.name.EndsWith("-2D-IES"))
{
cookieTexture = subAsset as Texture;
break;
}
}
}
if (cookieTexture != null)
{
m_PreviewRenderUtility.lights[0].transform.localEulerAngles = new Vector3(90f, 0f, m_LightAimAxisRotationProp.floatValue);
setupRenderPipelinePreviewLightIntensity(m_PreviewRenderUtility.lights[0], m_UseIESMaximumIntensityProp, m_IESMaximumIntensityUnitProp, m_IESMaximumIntensityProp);
m_PreviewRenderUtility.lights[0].cookie = cookieTexture;
m_PreviewRenderUtility.lights[0].type = m_PrefabLightTypeProp.enumValueIndex == (int)IESLightType.Point ? LightType.Point : LightType.Spot;
m_PreviewRenderUtility.BeginPreview(r, background);
bool fog = RenderSettings.fog;
Unsupported.SetRenderSettingsUseFogNoDirty(false);
m_PreviewRenderUtility.camera.Render();
Unsupported.SetRenderSettingsUseFogNoDirty(fog);
previewTexture = m_PreviewRenderUtility.EndPreview();
}
if (previewTexture == null)
{
GUI.DrawTexture(r, Texture2D.blackTexture, ScaleMode.StretchToFill, false);
}
else
{
GUI.DrawTexture(r, previewTexture, ScaleMode.ScaleToFit, false);
}
}
}
public static void OnGUI(ScriptedImporter importer, GltfParser parser, UniGLTF.Extensions.VRMC_vrm.VRMC_vrm vrm)
{
var hasExternal = importer.GetExternalObjectMap().Any(x => x.Value is VRM10MetaObject || x.Value is VRM10ExpressionAvatar || x.Value is VRM10Expression);
using (new TmpGuiEnable(!hasExternal))
{
if (GUILayout.Button("Extract Meta And Expressions ..."))
{
Extract(importer, parser);
}
}
// meta
importer.DrawRemapGUI <VRM10MetaObject>(new SubAssetKey[] { VRM10MetaObject.SubAssetKey });
// expression avatar
importer.DrawRemapGUI <VRM10ExpressionAvatar>(new SubAssetKey[] { VRM10ExpressionAvatar.SubAssetKey });
// expressions
importer.DrawRemapGUI <VRM10Expression>(vrm.Expressions.Select(x => CreateKey(x).SubAssetKey));
if (GUILayout.Button("Clear"))
{
importer.ClearExternalObjects <VRM10MetaObject>();
importer.ClearExternalObjects <VRM10ExpressionAvatar>();
importer.ClearExternalObjects <VRM10Expression>();
}
}
static void ExtractMaterialsAndTextures(ScriptedImporter self, GltfParser parser)
{
if (string.IsNullOrEmpty(self.assetPath))
{
return;
}
Action <Texture2D> addRemap = externalObject =>
{
self.AddRemap(new AssetImporter.SourceAssetIdentifier(typeof(UnityEngine.Texture2D), externalObject.name), externalObject);
};
Action <IEnumerable <UnityPath> > onCompleted = _ =>
{
AssetDatabase.ImportAsset(self.assetPath, ImportAssetOptions.ForceUpdate);
self.ExtractMaterials();
AssetDatabase.ImportAsset(self.assetPath, ImportAssetOptions.ForceUpdate);
};
var assetPath = UnityPath.FromFullpath(parser.TargetPath);
var dirName = $"{assetPath.FileNameWithoutExtension}.Textures";
TextureExtractor.ExtractTextures(parser, assetPath.Parent.Child(dirName),
GltfTextureEnumerator.Enumerate,
self.GetSubAssets <UnityEngine.Texture2D>(self.assetPath).ToArray(),
addRemap,
onCompleted
);
}
static void ExtractMaterialsAndTextures(ScriptedImporter self)
{
if (string.IsNullOrEmpty(self.assetPath))
{
return;
}
Action <Texture2D> addRemap = externalObject =>
{
self.AddRemap(new AssetImporter.SourceAssetIdentifier(typeof(UnityEngine.Texture2D), externalObject.name), externalObject);
};
Action <IEnumerable <string> > onCompleted = _ =>
{
AssetDatabase.ImportAsset(self.assetPath, ImportAssetOptions.ForceUpdate);
self.ExtractMaterials();
AssetDatabase.ImportAsset(self.assetPath, ImportAssetOptions.ForceUpdate);
};
TextureExtractor.ExtractTextures(self.assetPath,
GltfTextureEnumerator.Enumerate,
self.GetSubAssets <UnityEngine.Texture2D>(self.assetPath).ToArray(),
addRemap,
onCompleted
);
}
/// <summary>
/// SubAssetを外部ファイルに展開する
/// </summary>
public static void Extract(ScriptedImporter importer, GltfParser parser)
{
if (string.IsNullOrEmpty(importer.assetPath))
{
return;
}
// meta
{
var path = GetAndCreateFolder(importer.assetPath, ".vrm1.Meta");
foreach (var(key, asset) in importer.GetSubAssets <VRM10MetaObject>(importer.assetPath))
{
asset.ExtractSubAsset($"{path}/{asset.name}.asset", false);
}
}
{
// expressions
var path = GetAndCreateFolder(importer.assetPath, ".vrm1.Expressions");
foreach (var(key, asset) in importer.GetSubAssets <VRM10Expression>(importer.assetPath))
{
asset.ExtractSubAsset($"{path}/{asset.name}.asset", false);
}
}
AssetDatabase.ImportAsset(importer.assetPath, ImportAssetOptions.ForceUpdate);
}
static void ExtractMaterialsAndTextures(ScriptedImporter self, GltfParser parser, EnumerateAllTexturesDistinctFunc enumTextures, Func <string, string> textureDir, Func <string, string> materialDir)
{
if (string.IsNullOrEmpty(self.assetPath))
{
return;
}
Action <SubAssetKey, Texture2D> addRemap = (key, externalObject) =>
{
self.AddRemap(new AssetImporter.SourceAssetIdentifier(key.Type, key.Name), externalObject);
};
Action <IEnumerable <UnityPath> > onCompleted = _ =>
{
AssetDatabase.ImportAsset(self.assetPath, ImportAssetOptions.ForceUpdate);
self.ExtractMaterials(materialDir);
AssetDatabase.ImportAsset(self.assetPath, ImportAssetOptions.ForceUpdate);
};
var assetPath = UnityPath.FromFullpath(parser.TargetPath);
var dirName = textureDir(assetPath.Value); // $"{assetPath.FileNameWithoutExtension}.Textures";
TextureExtractor.ExtractTextures(parser, assetPath.Parent.Child(dirName),
enumTextures,
self.GetSubAssets <UnityEngine.Texture2D>(self.assetPath).ToArray(),
addRemap,
onCompleted
);
}
/// <summary>
///
/// * VRM10Object
/// * VRM10Expression[]
///
/// が Extract 対象となる
///
/// </summary>
public static void Extract(ScriptedImporter importer, GltfData data)
{
if (string.IsNullOrEmpty(importer.assetPath))
{
return;
}
var path = GetAndCreateFolder(importer.assetPath, ".vrm1.Assets");
// expression を extract し置き換え map を作る
var map = new Dictionary <VRM10Expression, VRM10Expression>();
foreach (var asset in AssetDatabase.LoadAllAssetsAtPath(importer.assetPath))
{
if (asset is VRM10Expression expression)
{
var clone = ExtractSubAsset(asset, $"{path}/{asset.name}.asset", false);
map.Add(expression, clone as VRM10Expression);
}
}
// vrmObject の expression を置き換える
var vrmObject = AssetDatabase.LoadAllAssetsAtPath(importer.assetPath).First(x => x is VRM10Object) as VRM10Object;
vrmObject.Expression.Replace(map);
// extract
ExtractSubAsset(vrmObject, $"{path}/{vrmObject.name}.asset", false);
AssetDatabase.ImportAsset(importer.assetPath, ImportAssetOptions.ForceUpdate);
}
public void OnGUI(ScriptedImporter importer, GltfData data)
{
if (!HasKeys)
{
EditorGUILayout.HelpBox("no animations", MessageType.Info);
return;
}
if (CanExtract(importer))
{
if (GUILayout.Button("Extract Animation ..."))
{
Extract(importer, data);
}
EditorGUILayout.HelpBox("Extract subasset to external object and overwrite remap", MessageType.Info);
}
else
{
if (GUILayout.Button("Clear extraction"))
{
ClearExternalObjects(importer, typeof(AnimationClip));
}
EditorGUILayout.HelpBox("Clear remap. All remap use subAsset", MessageType.Info);
}
DrawRemapGUI <AnimationClip>(importer.GetExternalObjectMap());
}
static void Process(Vrm10Data result, ScriptedImporter scriptedImporter, AssetImportContext context, RenderPipelineTypes renderPipeline, bool doNormalize)
{
//
// Import(create unity objects)
//
var extractedObjects = scriptedImporter.GetExternalObjectMap()
.Where(kv => kv.Value != null)
.ToDictionary(kv => new SubAssetKey(kv.Value.GetType(), kv.Key.name), kv => kv.Value);
var materialGenerator = GetMaterialDescriptorGenerator(renderPipeline);
using (var loader = new Vrm10Importer(result, extractedObjects,
materialGenerator: materialGenerator,
doNormalize: doNormalize))
{
// settings TextureImporters
foreach (var textureInfo in loader.TextureDescriptorGenerator.Get().GetEnumerable())
{
VRMShaders.TextureImporterConfigurator.Configure(textureInfo, loader.TextureFactory.ExternalTextures);
}
var loaded = loader.Load();
loaded.ShowMeshes();
loaded.TransferOwnership((key, o) =>
{
context.AddObjectToAsset(key.Name, o);
});
var root = loaded.Root;
GameObject.DestroyImmediate(loaded);
context.AddObjectToAsset(root.name, root);
context.SetMainObject(root);
}
}
static void DrawRemapGUI <T>(ScriptedImporter importer, IEnumerable <string> names) where T : UnityEngine.Object
{
EditorGUI.indentLevel++;
var map = importer.GetExternalObjectMap()
.Select(x => (x.Key.name, x.Value as T))
.Where(x => x.Item2 != null)
.ToDictionary(x => x.Item1, x => x.Item2)
;
foreach (var name in names)
{
if (string.IsNullOrEmpty(name))
{
throw new System.ArgumentNullException();
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel(name);
map.TryGetValue(name, out T value);
var asset = EditorGUILayout.ObjectField(value, typeof(T), true) as T;
if (asset != value)
{
importer.SetExternalUnityObject(new AssetImporter.SourceAssetIdentifier(value), asset);
}
EditorGUILayout.EndHorizontal();
}
EditorGUI.indentLevel--;
}
public static DirectoryInfo SafeCreateDirectory(this ScriptedImporter importer, string path)
{
if (Directory.Exists(path))
{
return(null);
}
return(Directory.CreateDirectory(path));
}
public static IEnumerable <T> GetSubAssets <T>(this ScriptedImporter importer, string assetPath) where T : UnityEngine.Object
{
return(AssetDatabase
.LoadAllAssetsAtPath(assetPath)
.Where(x => AssetDatabase.IsSubAsset(x))
.Where(x => x is T)
.Select(x => x as T));
}
public TextureExtractor(ScriptedImporter importer)
{
// parse GLTF
m_parser = new GltfParser();
m_parser.ParsePath(importer.assetPath);
m_path = $"{Path.GetDirectoryName(importer.assetPath)}/{Path.GetFileNameWithoutExtension(importer.assetPath)}.Textures";
m_subAssets = importer.GetSubAssets <UnityEngine.Texture2D>(importer.assetPath).ToArray();
}
public static void ClearExtarnalObjects(this ScriptedImporter importer)
{
foreach (var extarnalObject in importer.GetExternalObjectMap())
{
importer.RemoveRemap(extarnalObject.Key);
}
AssetDatabase.WriteImportSettingsIfDirty(importer.assetPath);
AssetDatabase.ImportAsset(importer.assetPath, ImportAssetOptions.ForceUpdate);
}
public static void ClearExternalObjects <T>(this ScriptedImporter importer) where T : UnityEngine.Object
{
foreach (var externalObject in importer.GetExternalObjectMap().Where(x => x.Key.type == typeof(T)))
{
importer.RemoveRemap(externalObject.Key);
}
AssetDatabase.WriteImportSettingsIfDirty(importer.assetPath);
AssetDatabase.ImportAsset(importer.assetPath, ImportAssetOptions.ForceUpdate);
}
public static void OnGUIMaterial(ScriptedImporter importer, GltfParser parser)
{
var canExtract = !importer.GetExternalObjectMap().Any(x => x.Value is Material || x.Value is Texture2D);
using (new TmpGuiEnable(canExtract))
{
if (GUILayout.Button("Extract Materials And Textures ..."))
{
ExtractMaterialsAndTextures(importer, parser);
}
}
//
// Draw ExternalObjectMap
//
s_foldMaterials = EditorGUILayout.Foldout(s_foldMaterials, "Remapped Materials");
if (s_foldMaterials)
{
DrawRemapGUI <UnityEngine.Material>(importer, parser.GLTF.materials.Select(x => x.name));
}
s_foldTextures = EditorGUILayout.Foldout(s_foldTextures, "Remapped Textures");
if (s_foldTextures)
{
var names = GltfTextureEnumerator.Enumerate(parser)
.Select(x =>
{
if (x.TextureType != TextureImportTypes.StandardMap && !string.IsNullOrEmpty(x.Uri))
{
// GLTF の 無変換テクスチャーをスキップする
return(null);
}
switch (x.TextureType)
{
case TextureImportTypes.NormalMap:
return(x.GltfName);
default:
return(x.ConvertedName);
}
})
.Where(x => !string.IsNullOrEmpty(x))
;
DrawRemapGUI <UnityEngine.Texture2D>(importer, names);
}
if (GUILayout.Button("Clear"))
{
importer.ClearExternalObjects <UnityEngine.Material>();
importer.ClearExternalObjects <UnityEngine.Texture2D>();
}
}
public static void ExtractTextures(this ScriptedImporter importer, string dirName, Action onCompleted = null)
{
if (string.IsNullOrEmpty(importer.assetPath))
{
return;
}
var path = string.Format("{0}/{1}.{2}",
Path.GetDirectoryName(importer.assetPath),
Path.GetFileNameWithoutExtension(importer.assetPath),
dirName
);
importer.SafeCreateDirectory(path);
// Reload Model
var extractor = new TextureExtractor(importer);
foreach (var material in extractor.GLTF.materials)
{
foreach (var x in extractor.Parser.EnumerateTextures(material))
{
extractor.Extract(x);
}
}
EditorApplication.delayCall += () =>
{
foreach (var extracted in extractor.Textures)
{
// TextureImporter
var targetTextureImporter = AssetImporter.GetAtPath(extracted.Path) as TextureImporter;
targetTextureImporter.sRGBTexture = extracted.sRGB;
if (extracted.IsNormalMap)
{
targetTextureImporter.textureType = TextureImporterType.NormalMap;
}
targetTextureImporter.SaveAndReimport();
// remap
var externalObject = AssetDatabase.LoadAssetAtPath <UnityEngine.Texture2D>(extracted.Path);
importer.AddRemap(new AssetImporter.SourceAssetIdentifier(typeof(UnityEngine.Texture2D), externalObject.name), externalObject);
}
AssetDatabase.ImportAsset(importer.assetPath, ImportAssetOptions.ForceUpdate);
if (onCompleted != null)
{
onCompleted();
}
};
}
public void YarnImporter_OnValidYarnFile_ShouldCompile()
{
const string textYarnAsset = "title: Start\ntags:\ncolorID: 0\nposition: 0,0\n--- \nSpieler: Kannst du mich hören? #line:0e3dc4b\nNPC: Klar und deutlich. #line:0967160\n[[Mir reicht es.| Exit]] #line:04e806e\n[[Nochmal!|Start]] #line:0901fb2\n===\ntitle: Exit\ntags: \ncolorID: 0\nposition: 0,0\n--- \n===";
string fileName = Path.GetRandomFileName();
File.WriteAllText(Application.dataPath + "/" + fileName + ".yarn", textYarnAsset);
AssetDatabase.Refresh();
var result = ScriptedImporter.GetAtPath("Assets/" + fileName + ".yarn") as YarnImporter;
Assert.That(result.isSuccesfullyCompiled);
AssetDatabase.DeleteAsset("Assets/" + fileName + ".yarn");
}
public void YarnImporter_OnValidYarnFile_GetExpectedStrings()
{
const string textYarnAsset = "title: Start\ntags:\ncolorID: 0\nposition: 0,0\n--- \nSpieler: Kannst du mich hören? #line:0e3dc4b\nNPC: Klar und deutlich. #line:0967160\n[[Mir reicht es.| Exit]] #line:04e806e\n[[Nochmal!|Start]] #line:0901fb2\n===\ntitle: Exit\ntags: \ncolorID: 0\nposition: 0,0\n--- \n===";
string fileName = Path.GetRandomFileName();
string expectedStringTable = "id,text,file,node,lineNumber\r\nline:0e3dc4b,Spieler: Kannst du mich hören?," + fileName + ",Start,6\r\nline:0967160,NPC: Klar und deutlich.," + fileName + ",Start,7\r\nline:04e806e,Mir reicht es.," + fileName + ",Start,8\r\nline:0901fb2,Nochmal!," + fileName + ",Start,9\r\n";
File.WriteAllText(Application.dataPath + "/" + fileName + ".yarn", textYarnAsset);
AssetDatabase.Refresh();
var result = ScriptedImporter.GetAtPath("Assets/" + fileName + ".yarn") as YarnImporter;
Assert.That(Equals(result.baseLanguage.text, expectedStringTable));
AssetDatabase.DeleteAsset("Assets/" + fileName + ".yarn");
}
public static void ExtractMaterials(this ScriptedImporter importer)
{
if (string.IsNullOrEmpty(importer.assetPath))
{
return;
}
var path = $"{Path.GetDirectoryName(importer.assetPath)}/{Path.GetFileNameWithoutExtension(importer.assetPath)}.Materials";
var info = TextureExtractor.SafeCreateDirectory(path);
foreach (var asset in importer.GetSubAssets <Material>(importer.assetPath))
{
ExtractSubAsset(asset, $"{path}/{asset.name}.mat", false);
}
}
/// <summary>
/// SubAssetを外部ファイルに展開する
/// </summary>
public static void Extract(ScriptedImporter importer, GltfParser parser)
{
if (string.IsNullOrEmpty(importer.assetPath))
{
return;
}
var path = $"{Path.GetDirectoryName(importer.assetPath)}/{Path.GetFileNameWithoutExtension(importer.assetPath)}.Extracted";
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
// meta
{
foreach (var asset in importer.GetSubAssets <VRM10MetaObject>(importer.assetPath))
{
asset.ExtractSubAsset($"{path}/{asset.name}.asset", false);
}
}
{
// expressions
foreach (var asset in importer.GetSubAssets <VRM10Expression>(importer.assetPath))
{
asset.ExtractSubAsset($"{path}/{asset.name}.asset", false);
}
// expressions
foreach (var asset in importer.GetSubAssets <VRM10ExpressionAvatar>(importer.assetPath))
{
asset.ExtractSubAsset($"{path}/{asset.name}.asset", false);
}
// external な expressionAvatar.Clips に 再代入する
var expressionAvatar = importer.GetExternalObjectMap().Select(x => x.Value as VRM10ExpressionAvatar).FirstOrDefault(x => x != null);
var expressions = importer.GetExternalObjectMap().Select(x => x.Value as VRM10Expression).Where(x => x != null).ToList();
expressionAvatar.Clips = expressions;
var avatarPath = AssetDatabase.GetAssetPath(expressionAvatar);
if (!string.IsNullOrEmpty(avatarPath))
{
EditorUtility.SetDirty(expressionAvatar);
AssetDatabase.WriteImportSettingsIfDirty(avatarPath);
}
}
AssetDatabase.ImportAsset(importer.assetPath, ImportAssetOptions.ForceUpdate);
}
/// <summary>
/// Extract 対象がすべて SubAsset に含まれるときに可能である
/// </summary>
/// <param name="importer"></param>
/// <returns></returns>
protected bool CanExtract(ScriptedImporter importer)
{
foreach (var(k, v) in importer.GetExternalObjectMap())
{
foreach (var key in m_keys)
{
if (k.type.IsAssignableFrom(key.Type))
{
return(false);
}
}
}
return(true);
}
public void YarnImporter_OnInvalidYarnFile_ShouldNotCompile()
{
const string textYarnAsset = "This is not a valid yarn file and thus compilation should fail.";
string fileName = Path.GetRandomFileName();
File.WriteAllText(Application.dataPath + "/" + fileName + ".yarn", textYarnAsset);
LogAssert.ignoreFailingMessages = true;
AssetDatabase.Refresh();
LogAssert.ignoreFailingMessages = false;
var result = ScriptedImporter.GetAtPath("Assets/" + fileName + ".yarn") as YarnImporter;
Assert.That(!result.isSuccesfullyCompiled);
AssetDatabase.DeleteAsset("Assets/" + fileName + ".yarn");
}
/// <summary>
///
/// </summary>
/// <param name="scriptedImporter"></param>
/// <param name="context"></param>
/// <param name="migrateToVrm1">vrm0 だった場合に vrm1 化する</param>
/// <param name="renderPipeline"></param>
/// <param name="doNormalize">normalize する</param>
public static void Import(ScriptedImporter scriptedImporter, AssetImportContext context, bool migrateToVrm1, RenderPipelineTypes renderPipeline, bool doNormalize)
{
#if VRM_DEVELOP
Debug.Log("OnImportAsset to " + scriptedImporter.assetPath);
#endif
using (var data = Vrm10Data.ParseOrMigrate(scriptedImporter.assetPath, migrateToVrm1, out Vrm10Data result, out MigrationData migration))
{
if (result == null)
{
// fail to parse vrm1
return;
}
//
// Import(create unity objects)
//
var extractedObjects = scriptedImporter.GetExternalObjectMap()
.Where(kv => kv.Value != null)
.ToDictionary(kv => new SubAssetKey(kv.Value.GetType(), kv.Key.name), kv => kv.Value);
var materialGenerator = GetMaterialDescriptorGenerator(renderPipeline);
using (var loader = new Vrm10Importer(result, extractedObjects,
materialGenerator: materialGenerator,
doNormalize: doNormalize))
{
// settings TextureImporters
foreach (var textureInfo in loader.TextureDescriptorGenerator.Get().GetEnumerable())
{
VRMShaders.TextureImporterConfigurator.Configure(textureInfo, loader.TextureFactory.ExternalTextures);
}
var loaded = loader.Load();
loaded.ShowMeshes();
loaded.TransferOwnership((key, o) =>
{
context.AddObjectToAsset(key.Name, o);
});
var root = loaded.Root;
GameObject.DestroyImmediate(loaded);
context.AddObjectToAsset(root.name, root);
context.SetMainObject(root);
}
}
}
/// <summary>
/// glb をパースして、UnityObject化、さらにAsset化する
/// </summary>
/// <param name="scriptedImporter"></param>
/// <param name="context"></param>
/// <param name="reverseAxis"></param>
public static void Import(ScriptedImporter scriptedImporter, AssetImportContext context, Axises reverseAxis)
{
#if VRM_DEVELOP
Debug.Log("OnImportAsset to " + scriptedImporter.assetPath);
#endif
//
// Parse(parse glb, parser gltf json)
//
var parser = new GltfParser();
parser.ParsePath(scriptedImporter.assetPath);
//
// Import(create unity objects)
//
var externalObjectMap = scriptedImporter.GetExternalObjectMap();
using (var loaded = new ImporterContext(parser, null,
externalObjectMap.Where(x => x.Value != null).Select(x => (x.Value.name, x.Value)).Concat(
EnumerateTexturesFromUri(externalObjectMap, parser, UnityPath.FromUnityPath(scriptedImporter.assetPath).Parent))))
{
// settings TextureImporters
foreach (var textureInfo in GltfTextureEnumerator.Enumerate(parser.GLTF))
{
TextureImporterConfigurator.Configure(textureInfo, loaded.TextureFactory.ExternalMap);
}
loaded.InvertAxis = reverseAxis;
loaded.Load();
loaded.ShowMeshes();
loaded.TransferOwnership(o =>
{
#if VRM_DEVELOP
Debug.Log($"[{o.GetType().Name}] {o.name} will not destroy");
#endif
context.AddObjectToAsset(o.name, o);
if (o is GameObject)
{
// Root GameObject is main object
context.SetMainObject(loaded.Root);
}
return(true);
});
}
}
/// <summary>
/// glb をパースして、UnityObject化、さらにAsset化する
/// </summary>
/// <param name="scriptedImporter"></param>
/// <param name="context"></param>
/// <param name="reverseAxis"></param>
protected static void Import(ScriptedImporter scriptedImporter, AssetImportContext context, Axes reverseAxis, RenderPipelineTypes renderPipeline)
{
#if VRM_DEVELOP
Debug.Log("OnImportAsset to " + scriptedImporter.assetPath);
#endif
//
// Parse(parse glb, parser gltf json)
//
var data = new AutoGltfFileParser(scriptedImporter.assetPath).Parse();
//
// Import(create unity objects)
//
// 2 回目以降の Asset Import において、 Importer の設定で Extract した UnityEngine.Object が入る
var extractedObjects = scriptedImporter.GetExternalObjectMap()
.Where(x => x.Value != null)
.ToDictionary(kv => new SubAssetKey(kv.Value.GetType(), kv.Key.name), kv => kv.Value);
IMaterialDescriptorGenerator materialGenerator = GetMaterialGenerator(renderPipeline);
using (var loader = new ImporterContext(data, extractedObjects, materialGenerator: materialGenerator))
{
// Configure TextureImporter to Extracted Textures.
foreach (var textureInfo in loader.TextureDescriptorGenerator.Get().GetEnumerable())
{
TextureImporterConfigurator.Configure(textureInfo, loader.TextureFactory.ExternalTextures);
}
loader.InvertAxis = reverseAxis;
var loaded = loader.Load();
loaded.ShowMeshes();
loaded.TransferOwnership((k, o) =>
{
context.AddObjectToAsset(k.Name, o);
});
var root = loaded.Root;
GameObject.DestroyImmediate(loaded);
context.AddObjectToAsset(root.name, root);
context.SetMainObject(root);
}
}
public void ApplyRemap(ScriptedImporter importer)
{
foreach (var kv in m_editMap)
{
if (kv.Object != null)
{
importer.AddRemap(kv.ID, kv.Object);
}
else
{
importer.RemoveRemap(kv.ID);
}
}
m_editMap.Clear();
AssetDatabase.WriteImportSettingsIfDirty(importer.assetPath);
AssetDatabase.ImportAsset(importer.assetPath, ImportAssetOptions.ForceUpdate);
}
public void RevertApplyRemapGUI(ScriptedImporter importer)
{
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
using (new EditorGUI.DisabledScope(m_editMap.Count == 0))
{
if (GUILayout.Button("Revert"))
{
RevertRemap();
}
if (GUILayout.Button("Apply"))
{
ApplyRemap(importer);
}
}
GUILayout.EndHorizontal();
}
/// <summary>
/// SubAssetを外部ファイルに展開する
/// </summary>
public static void Extract(ScriptedImporter importer, GltfParser parser)
{
if (string.IsNullOrEmpty(importer.assetPath))
{
return;
}
// meta
{
var path = GetAndCreateFolder(importer.assetPath, ".Meta");
foreach (var(key, asset) in importer.GetSubAssets <VRM10MetaObject>(importer.assetPath))
{
asset.ExtractSubAsset($"{path}/{asset.name}.asset", false);
}
}
{
// expressions
var path = GetAndCreateFolder(importer.assetPath, ".Expressions");
foreach (var(key, asset) in importer.GetSubAssets <VRM10Expression>(importer.assetPath))
{
asset.ExtractSubAsset($"{path}/{asset.name}.asset", false);
}
}
{
// expressions
var path = GetAndCreateFolder(importer.assetPath, ".ExpressionAvatar");
foreach (var(key, asset) in importer.GetSubAssets <VRM10ExpressionAvatar>(importer.assetPath))
{
asset.ExtractSubAsset($"{path}/{asset.name}.asset", false);
}
// external な expressionAvatar.Clips に 再代入する
var expressionAvatar = importer.GetExternalObjectMap().Select(x => x.Value as VRM10ExpressionAvatar).FirstOrDefault(x => x != null);
var expressions = importer.GetExternalObjectMap().Select(x => x.Value as VRM10Expression).Where(x => x != null).ToList();
expressionAvatar.Clips = expressions;
var avatarPath = AssetDatabase.GetAssetPath(expressionAvatar);
if (!string.IsNullOrEmpty(avatarPath))
{
EditorUtility.SetDirty(expressionAvatar);
AssetDatabase.WriteImportSettingsIfDirty(avatarPath);
}
}
AssetDatabase.ImportAsset(importer.assetPath, ImportAssetOptions.ForceUpdate);
}
