private static int ExtractSampleRateFrom([NotNull] IBlockMappingNode root)
{
var sampleRateText = root.FindMapEntryBySimpleKey("m_SampleRate")?.Content?.Value.GetPlainScalarText();
var foundSampleRate = int.TryParse(sampleRateText, out var sampleRate);
return(foundSampleRate ? sampleRate : throw new AnimationExtractorException());
}
public static INode GetCollection([CanBeNull] IBlockMappingNode blockMappingNode, string documentName, string name)
{
var documentEntry = blockMappingNode?.Entries.FirstOrDefault(
t => documentName.Equals(t.Key.GetPlainScalarText()))?.Content.Value as IBlockMappingNode;
var collection = documentEntry?.Entries.FirstOrDefault(t => name.Equals(t.Key.GetPlainScalarText()))?.Content.Value;
return(collection);
}
private static LocalList <long> ExtractStateMachineBehavioursAnchorsFrom([NotNull] IBlockMappingNode root)
{
var node = root.FindMapEntryBySimpleKey("m_StateMachineBehaviours")?.Content?.Value;
if (!(node is IBlockSequenceNode record))
{
return(new LocalList <long>());
}
return(record.Entries.Aggregate(new LocalList <long>(), AddAnchor));
}
private static string ExtractAnimatorStateNameFrom([NotNull] IBlockMappingNode root)
{
var name = root.FindMapEntryBySimpleKey("m_Name")?.Content?.Value?.GetPlainScalarText();
if (name is null)
{
throw new AnimatorExtractorException();
}
return(name);
}
public static IBlockMappingEntry FindMapEntryBySimpleKey([CanBeNull] this IBlockMappingNode mapNode, string keyName)
{
if (mapNode == null)
{
return(null);
}
foreach (var mappingEntry in mapNode.EntriesEnumerable)
{
if (mappingEntry.Key.MatchesPlainScalarText(keyName))
{
return(mappingEntry);
}
}
return(null);
}
public void ConsumeGameObject(IYamlDocument gameObject, IBlockMappingNode modifications)
{
string name = null;
if (modifications != null)
{
var documentId = gameObject.GetFileId();
name = UnityObjectPsiUtil.GetValueFromModifications(modifications, documentId, UnityYamlConstants.NameProperty);
}
if (name == null)
{
name = gameObject.GetUnityObjectPropertyValue(UnityYamlConstants.NameProperty).AsString();
}
if (name?.Equals(string.Empty) == true)
{
name = null;
}
NameParts.Add(name ?? "Unknown");
}
private static LocalList <long> ExtractChildAnchors(
[NotNull] IBlockMappingNode root, string recordKey, string innerRecordKey)
{
var anchors = (root.FindMapEntryBySimpleKey(recordKey)?.Content?.Value as IBlockSequenceNode)?
.Entries
.SelectNotNull(t => t?.Value as IBlockMappingNode)
.SelectNotNull(t => t.FindMapEntryBySimpleKey(innerRecordKey)?.Content?.Value as IFlowMappingNode)
.SelectNotNull(t => t.FindMapEntryBySimpleKey("fileID")?.Value as IPlainScalarNode)
.SelectNotNull(t => long.TryParse(t?.GetPlainScalarText(), out var anchor) ? anchor : (long?)null);
var list = new LocalList <long>();
if (anchors is null)
{
return(list);
}
foreach (var anchor in anchors)
{
list.Add(anchor);
}
return(list);
}
public static string GetValueFromModifications(IBlockMappingNode modification, string targetFileId, string value)
{
if (targetFileId != null && modification.FindMapEntryBySimpleKey(UnityYamlConstants.ModificationsProperty)?.Value is IBlockSequenceNode modifications)
{
foreach (var element in modifications.Entries)
{
if (!(element.Value is IBlockMappingNode mod))
{
return(null);
}
var type = (mod.FindMapEntryBySimpleKey(UnityYamlConstants.PropertyPathProperty)?.Value as IPlainScalarNode)
?.Text.GetText();
var target = mod.FindMapEntryBySimpleKey(UnityYamlConstants.TargetProperty)?.Value?.AsFileID();
if (type?.Equals(value) == true && target?.fileID.Equals(targetFileId) == true)
{
return((mod.FindMapEntryBySimpleKey(UnityYamlConstants.ValueProperty)?.Value as IPlainScalarNode)?.Text.GetText());
}
}
}
return(null);
}
public void ConsumeGameObject(IYamlDocument gameObject, IBlockMappingNode modifications)
{
{
int rootOrder = -1;
var transform = UnityObjectPsiUtil.FindTransformComponentForGameObject(gameObject);
if (modifications != null)
{
if (!int.TryParse(UnityObjectPsiUtil.GetValueFromModifications(modifications, transform.GetFileId(), UnityYamlConstants.RootOrderProperty)
, out rootOrder))
{
rootOrder = -1;
}
}
if (rootOrder == -1)
{
var rootOrderAsString = transform.GetUnityObjectPropertyValue(UnityYamlConstants.RootOrderProperty).AsString();
if (!int.TryParse(rootOrderAsString, out rootOrder))
{
rootOrder = -1;
}
}
RootIndices.Add(rootOrder);
}
}
// Invariant : startGameObject is Transform Component if it is not stripped
// This method traverse scene hierarchy via visiting transform components and push corresponding to transform GameObject into consumer
private void ProcessSceneHierarchyFromComponentToRootInner(IYamlDocument startUnityObject, IUnitySceneProcessorConsumer consumer, IBlockMappingNode modifications)
{
var currentUnityObject = startUnityObject;
while (currentUnityObject != null)
{
// Unity object could be stripped, it means, that corresponding real object belongs to another yaml file
// Also, it has reference to prefab instance in current file, which stores all prefab modification
if (IsStripped(currentUnityObject))
{
var file = (IYamlFile)currentUnityObject.GetContainingFile();
var correspondingId = currentUnityObject.GetUnityObjectPropertyValue(GetCorrespondingSourceObjectProperty())?.AsFileID();
var prefabInstanceId = currentUnityObject.GetUnityObjectPropertyValue(GetPrefabInstanceProperty())?.AsFileID();
// assert not null
if (correspondingId == null || prefabInstanceId == null)
{
return;
}
var prefabInstance = file.FindDocumentByAnchor(prefabInstanceId.fileID);
var prefabSourceFile = myMetaFileGuidCache.GetAssetFilePathsFromGuid(correspondingId.guid);
if (prefabSourceFile.Count > 1 || prefabSourceFile.Count == 0)
{
return;
}
myFactory.PsiModule.NotNull("externalFilesModuleFactory.PsiModule != null")
.TryGetFileByPath(prefabSourceFile.First(), out var sourceFile);
if (sourceFile == null)
{
return;
}
// [TODO] Is prefab file committed???
var prefabFile = (IYamlFile)sourceFile.GetDominantPsiFile <YamlLanguage>();
var prefabStartGameObject = prefabFile.FindDocumentByAnchor(correspondingId.fileID);
if (!IsStripped(prefabStartGameObject))
{
// !u!4 is transform. If tag is different, let's extract transform, there are two cases:
// 1) prefabStartGameObject is GameObject(!u!1), take its transform
// 2) prefabStartGameObject is Component, so get attached gameobject and from this gameobject take transform component
if (!GetUnityObjectTag(prefabStartGameObject).Equals("!u!4"))
{
var attachedGameObject = prefabStartGameObject;
if (!GetUnityObjectTag(prefabStartGameObject).Equals("!u!1"))
{
attachedGameObject =
attachedGameObject.GetUnityObjectDocumentFromFileIDProperty(UnityYamlConstants
.GameObjectProperty);
}
prefabStartGameObject = UnityObjectPsiUtil.FindTransformComponentForGameObject(attachedGameObject);
}
}
var localModifications = UnityObjectPsiUtil.GetPrefabModification(prefabInstance);
ProcessSceneHierarchyFromComponentToRootInner(prefabStartGameObject, consumer, localModifications);
currentUnityObject = UnityObjectPsiUtil.GetTransformFromPrefabInstance(prefabInstance);
}
else
{
// assert that startGameObject is GameObject
var father = currentUnityObject.GetUnityObjectDocumentFromFileIDProperty(UnityYamlConstants.FatherProperty);
var gameObject = currentUnityObject.GetUnityObjectDocumentFromFileIDProperty(UnityYamlConstants.GameObjectProperty);
consumer.ConsumeGameObject(gameObject, modifications);
currentUnityObject = father;
}
}
}
public static INode GetValue(this IBlockMappingNode document, string key)
{
return(document?.Entries.FirstOrDefault(t => t.Key.MatchesPlainScalarText(key))?.Content?.Value);
}
public static INode GetSceneCollection([CanBeNull] IBlockMappingNode blockMappingNode)
{
return(GetCollection(blockMappingNode, "EditorBuildSettings", "m_Scenes"));
}
private static LocalList <long> ExtractChildStateMachinesAnchors([NotNull] IBlockMappingNode root)
{
return(ExtractChildAnchors(root, "m_ChildStateMachines", "m_StateMachine"));
}
