/// <summary>
/// Parses the specified file.
/// </summary>
public override void ParseFile(string absolutePath)
{
Guid guid = Guid.Empty;
if (Path.GetExtension(absolutePath) != ".meta")
{
// find the meta file
string metaFilePath = absolutePath + ".meta";
if (File.Exists(metaFilePath))
{
guid = UnityMetaParser.ReadGuidFromMeta(metaFilePath);
}
}
// create a project object for the document
string uniqueId = guid != Guid.Empty ? guid.ToString() : absolutePath;
ObjectDatabase.AddObject(uniqueId, new UnityAsset(absolutePath, uniqueId));
using (StreamReader fileReader = new StreamReader(new FileStream(absolutePath, FileMode.Open, FileAccess.Read)))
{
YamlStream stream = new YamlStream();
stream.Load(new UnityTextReader(fileReader));
// each document is one UnityEngine.Object
foreach (YamlDocument document in stream.Documents)
{
YamlMappingNode documentNode = (YamlMappingNode)document.RootNode;
if (documentNode.Anchor == null)
{
// might be a JSON file (XRSettings.asset), skip for now
continue;
}
long fileId = long.Parse(documentNode.Anchor);
UnityObjectKey key = new UnityObjectKey(guid, fileId);
KeyValuePair <YamlNode, YamlNode> rootNode = documentNode.Children.First();
YamlScalarNode rootNodeScalar = (YamlScalarNode)rootNode.Key;
if (rootNodeScalar.Value == "GameObject")
{
ObjectDatabase.AddObject(key, new UnityGameObject(uniqueId, document, key));
}
else if (rootNodeScalar.Value == "Prefab")
{
ObjectDatabase.AddObject(key, new UnityPrefabInstance(uniqueId, document, key));
}
else
{
ObjectDatabase.AddObject(key, new UnityComponent(uniqueId, document, key));
}
}
}
}
/// <summary>
/// Gets the absolute path of the file this object belongs to.
/// </summary>
public override string GetFilePath()
{
ProjectObject document;
if (ObjectDatabase.TryGetObject(DocumentId, out document))
{
return(document.GetFilePath());
}
else
{
return("");
}
}
public override string ToString()
{
ProjectObject scriptObject;
if (ObjectDatabase.TryGetObject(m_scriptKey, out scriptObject) &&
!(scriptObject is NullObject))
{
return(scriptObject.ToString());
}
else
{
return(TypeName);
}
}
/// <summary>
/// Parses the specified file.
/// </summary>
public override void ParseFile(string absolutePath)
{
using (StreamReader fileReader = new StreamReader(new FileStream(absolutePath, FileMode.Open, FileAccess.Read)))
{
YamlStream stream = new YamlStream();
stream.Load(fileReader);
YamlDocument document = stream.Documents[0];
YamlMappingNode rootNode = (YamlMappingNode)document.RootNode;
YamlScalarNode guidNode = (YamlScalarNode)rootNode.Children["guid"];
Guid assetGuid = new Guid(guidNode.Value);
string assetUniqueId = assetGuid.ToString();
// determine the asset's default file id
int defaultFileId = 0;
foreach (string key in rootNode.Children.Keys)
{
if (key.EndsWith("Importer", StringComparison.OrdinalIgnoreCase))
{
int classId;
if (UnityClassIds.TryGetClassIdByImporterName(key, out classId))
{
defaultFileId = classId * 100000;
break;
}
}
}
UnityObjectKey defaultAssetKey = new UnityObjectKey(assetGuid, defaultFileId);
bool isFolderAsset = false;
YamlNode folderAssetNode;
if (rootNode.Children.TryGetValue("folderAsset", out folderAssetNode))
{
YamlScalarNode folderAssetScalarNode = (YamlScalarNode)folderAssetNode;
isFolderAsset = folderAssetScalarNode.Value == "yes";
}
if (isFolderAsset)
{
string folderPath = Path.Combine(Path.GetDirectoryName(absolutePath), Path.GetFileNameWithoutExtension(absolutePath));
ObjectDatabase.MapFolderObject(folderPath, assetUniqueId);
ObjectDatabase.AddObject(assetUniqueId, new UnityFolder(absolutePath, assetGuid));
}
else
{
// metas shouldn't override assets we've already parsed
ObjectDatabase.AddPlaceholderObject(assetUniqueId, new UnityAsset(absolutePath, assetUniqueId));
if (defaultAssetKey.FileId != 0)
{
ObjectDatabase.AddObject(defaultAssetKey.ToString(), new UnityDefaultAsset(assetUniqueId, defaultAssetKey));
}
}
// check for sprites
YamlNode textureImporterNode;
if (rootNode.Children.TryGetValue("TextureImporter", out textureImporterNode))
{
YamlMappingNode textureImporterMappingNode = (YamlMappingNode)textureImporterNode;
YamlNode fileIDToRecycleNameNode;
if (textureImporterMappingNode.Children.TryGetValue("fileIDToRecycleName", out fileIDToRecycleNameNode))
{
YamlMappingNode fileIDToRecycleNameMappingNode = (YamlMappingNode)fileIDToRecycleNameNode;
foreach (var kv in fileIDToRecycleNameMappingNode.Children)
{
string fileIdStr = ((YamlScalarNode)kv.Key).Value;
string name = ((YamlScalarNode)kv.Value).Value;
long fileId = long.Parse(fileIdStr);
UnityObjectKey spriteKey = new UnityObjectKey(assetGuid, fileId);
ObjectDatabase.AddObject(spriteKey.ToString(), new UnitySprite(assetUniqueId, name, spriteKey));
}
}
YamlNode spriteModeNode;
if (textureImporterMappingNode.Children.TryGetValue("spriteMode", out spriteModeNode))
{
YamlScalarNode spriteModeScalarNode = (YamlScalarNode)spriteModeNode;
if (spriteModeScalarNode.Value == "1")
{
// single sprite
string name = Path.GetFileNameWithoutExtension(absolutePath);
UnityObjectKey spriteKey = new UnityObjectKey(assetGuid, 21300000);
ObjectDatabase.AddObject(spriteKey.ToString(), new UnitySprite(assetUniqueId, name, spriteKey));
}
}
}
}
}
/// <summary>
/// Adds a new relationship to this object.
/// </summary>
public void AddRelationship(ObjectRelationship relationship)
{
ObjectDatabase.AddRelationship(UniqueId, relationship);
}
/// <summary>
/// Sets the root directory of the project to load.
/// </summary>
public static void SetProjectPath(string projectPath)
{
//TODO: path compare
if (string.Equals(ProjectPath, projectPath, StringComparison.OrdinalIgnoreCase))
{
return;
}
// check that the target path is a Unity project
if (!IsUnityProject(projectPath))
{
throw new NotAUnityProjectException(projectPath);
}
// check that assets are text serialized
{
string projectSettings = Path.Combine(projectPath, "ProjectSettings", "ProjectSettings.asset");
using (StreamReader fileReader = new StreamReader(new FileStream(projectSettings, FileMode.Open, FileAccess.Read)))
{
try
{
YamlStream stream = new YamlStream();
stream.Load(new UnityTextReader(fileReader));
}
catch (YamlDotNet.Core.SyntaxErrorException)
{
throw new UnityProjectNotTextException(projectPath);
}
}
}
// kill feeders
foreach (IParserFeeder feeder in s_feeders)
{
feeder.Dispose();
}
s_feeders.Clear();
// empty queue
s_queuedFiles.Clear();
// stop parsers
foreach (IParserPool parserPool in s_parsers.Values)
{
parserPool.Stop();
}
// wait for all parsers to stop
bool isParserActive = false;
do
{
if (isParserActive)
{
Thread.Sleep(100);
}
isParserActive = false;
foreach (IParserPool parserPool in s_parsers.Values)
{
if (parserPool.GetOutstandingFileCount() > 0)
{
isParserActive = true;
break;
}
}
} while (isParserActive);
// unload database
ObjectDatabase.Clear();
ProjectPath = projectPath;
// start up new feeders
AddFeederType <UnityAssetParser>(
Path.Combine(ProjectPath, "Assets"),
new string[] { "*.unity", "*.prefab", "*.asset", "*.anim", "*.controller", "*.overridecontroller", "*.mat" });
AddFeederType <UnityAssetParser>(
Path.Combine(ProjectPath, "ProjectSettings"),
new string[] { "*.asset" });
AddFeederType <UnityMetaParser>(
Path.Combine(ProjectPath, "Assets"),
new string[] { "*.meta" });
// start up new parsers
AddParserType <UnityAssetParser>(4);
AddParserType <UnityMetaParser>(4);
//TODO: detect if there are no parsers for added feeders
}
