public static string GetComponentName([NotNull] IYamlDocument componentDocument) { var name = componentDocument.GetUnityObjectPropertyValue(UnityYamlConstants.NameProperty).AsString(); if (!string.IsNullOrWhiteSpace(name)) { return(name); } var scriptDocument = componentDocument.GetUnityObjectDocumentFromFileIDProperty(UnityYamlConstants.ScriptProperty); name = scriptDocument.GetUnityObjectPropertyValue(UnityYamlConstants.NameProperty).AsString(); if (!string.IsNullOrWhiteSpace(name)) { return(name); } var fileID = componentDocument.GetUnityObjectPropertyValue(UnityYamlConstants.ScriptProperty).AsFileID(); if (fileID != null && fileID.IsExternal && fileID.IsMonoScript) { var typeElement = GetTypeElementFromScriptAssetGuid(componentDocument.GetSolution(), fileID.guid); if (typeElement != null) { // TODO: Format like in Unity, by splitting the camel humps return(typeElement.ShortName + " (Script)"); } } return(scriptDocument.GetUnityObjectTypeFromRootNode() ?? componentDocument.GetUnityObjectTypeFromRootNode() ?? "Component"); }
public static IYamlDocument FindTransformComponentForGameObject([CanBeNull] IYamlDocument gameObjectDocument) { // GameObject: // m_Component: // - component: {fileID: 1234567890} // - component: {fileID: 1234567890} // - component: {fileID: 1234567890} // One of these components is the RectTransform(GUI, 2D) or Transform(3D). Most likely the first, but we can't rely on order if (gameObjectDocument?.GetUnityObjectPropertyValue("m_Component") is IBlockSequenceNode components) { var file = (IYamlFile)gameObjectDocument.GetContainingFile(); foreach (var componentEntry in components.EntriesEnumerable) { // - component: {fileID: 1234567890} var componentNode = componentEntry.Value as IBlockMappingNode; var componentFileID = componentNode?.EntriesEnumerable.FirstOrDefault()?.Content.Value.AsFileID(); if (componentFileID != null && !componentFileID.IsNullReference && !componentFileID.IsExternal) { var component = file.FindDocumentByAnchor(componentFileID.fileID); var componentName = component.GetUnityObjectTypeFromRootNode(); if (componentName != null && (componentName.Equals(UnityYamlConstants.RectTransformComponent) || componentName.Equals(UnityYamlConstants.TransformComponent))) { return(component); } } } } return(null); }
// If we add any more references, add them here, or SWEA's usage count won't pick them up!! public static bool CanContainReference([NotNull] IYamlDocument document) { var buffer = document.Body.GetTextAsBuffer(); return(UnityEventTargetReferenceFactory.CanContainReference(buffer) || MonoScriptReferenceFactory.CanContainReference(buffer)); }
public static IBlockMappingNode FindRootBlockMapEntries([CanBeNull] this IYamlDocument document) { // A YAML document is a block mapping node with a single entry. The key is usually the type of the object, // while the value is another block mapping node. Those entries are the properties of the Unity object var rootBlockMappingNode = document?.Body.BlockNode as IBlockMappingNode; return(rootBlockMappingNode?.EntriesEnumerable.FirstOrDefault()?.Content.Value as IBlockMappingNode); }
private FileID GetCorrespondingSourceObjectFileId(IYamlDocument document) { if (myVersion.GetActualVersionForSolution().Major == 2017) { return(document.GetUnityObjectPropertyValue(UnityYamlConstants.CorrespondingSourceObjectProperty2017)?.AsFileID()); } return(document.GetUnityObjectPropertyValue(UnityYamlConstants.CorrespondingSourceObjectProperty)?.AsFileID() ?? document.GetUnityObjectPropertyValue(UnityYamlConstants.CorrespondingSourceObjectProperty2017)?.AsFileID()); }
private FileID GetPrefabInstanceFileId(IYamlDocument document) { if (myVersion.GetActualVersionForSolution().Major == 2017) { return(document.GetUnityObjectPropertyValue(UnityYamlConstants.PrefabInstanceProperty2017)?.AsFileID()); } return(document.GetUnityObjectPropertyValue(UnityYamlConstants.PrefabInstanceProperty)?.AsFileID() ?? document.GetUnityObjectPropertyValue(UnityYamlConstants.PrefabInstanceProperty2017)?.AsFileID()); }
public static string GetUnityObjectTypeFromRootNode([CanBeNull] this IYamlDocument document) { // E.g. // --- !u!114 &293532596 // MonoBehaviour: // m_ObjectHideFlags: 0 // This will return "MonoBehaviour" // (Note that !u!114 is the actual type of this object - MonoBehaviour - // https://docs.unity3d.com/Manual/ClassIDReference.html) var rootBlockMappingNode = document?.Body.BlockNode as IBlockMappingNode; return(rootBlockMappingNode?.EntriesEnumerable.FirstOrDefault()?.Key.AsString()); }
public void ProcessSceneHierarchyFromComponentToRoot(IYamlDocument startComponent, IUnityCachedSceneProcessorConsumer consumer) { myShellLocks.AssertReadAccessAllowed(); var sourceFile = startComponent.GetSourceFile(); var anchor = UnitySceneDataUtil.GetAnchorFromBuffer(startComponent.GetTextAsBuffer()); if (sourceFile == null || anchor == null) { return; } ProcessSceneHierarchyFromComponentToRoot(sourceFile, new FileID(null, anchor), consumer); }
public static IYamlDocument GetUnityObjectDocumentFromFileIDProperty([CanBeNull] this IYamlDocument document, string key) { var fileID = document.GetUnityObjectPropertyValue(key).AsFileID(); if (fileID == null || fileID.IsNullReference || fileID.IsExternal) { return(null); } Assertion.AssertNotNull(document, "document != null"); var file = (IYamlFile)document.GetContainingFile(); return(file.FindDocumentByAnchor(fileID.fileID)); }
public static IYamlDocument GetTransformFromPrefabInstance(IYamlDocument prefabInstanceDocument) { // Prefab instance stores it's father in modification map var prefabModification = GetPrefabModification(prefabInstanceDocument); var fileID = prefabModification?.FindMapEntryBySimpleKey(UnityYamlConstants.TransformParentProperty)?.Content.Value.AsFileID(); if (fileID == null) { return(null); } var file = (IYamlFile)prefabInstanceDocument.GetContainingFile(); return(file.FindDocumentByAnchor(fileID.fileID)); }
public static bool CanContainReference([NotNull] IYamlDocument document) { // This document can only contain a reference if it represents a MonoBehaviour (which includes compiled // MonoBehaviours such as Button) and if it has the `m_MethodName` property. So, check the text of the // closed chameleon for "!u!114" and "m_MethodName". // TODO: Can we improve this? // When the chameleon is closed, GetTextAsBuffer returns a ProjectedBuffer over the source file element. // When open, it's a bit more expensive, by creating a StringBuffer over the result of GetText, which is // calculated by pre-initialising a StringBuilder to the correct length and calling GetText(StringBuilder) // on the child nodes. // Then we search the buffer, potentially twice. We'll limit the tag searcher to the first 100 characters of // the buffer var buffer = document.Body.GetTextAsBuffer(); return(CanContainReference(buffer)); }
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"); }
public void ProcessSceneHierarchyFromComponentToRoot(IYamlDocument startComponent, IUnitySceneProcessorConsumer consumer) { if (startComponent == null) { return; } var start = startComponent; if (!IsStripped(startComponent)) // start component can be stripped, e.g : prefab's MonoBehavior's function is passed to button event handler { // Component must be attached to game object start = start.GetUnityObjectDocumentFromFileIDProperty(UnityYamlConstants.GameObjectProperty); // GameObject could be stripped, if another prefab's gameobject is modified via adding MonoBehaviour if (!IsStripped(start)) { // Each GameObject must have Transform. We will use it to process scene hierarcy start = UnityObjectPsiUtil.FindTransformComponentForGameObject(start); } } ProcessSceneHierarchyFromComponentToRootInner(start, consumer, 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); } }
public static IBlockMappingNode GetPrefabModification(IYamlDocument yamlDocument) { // Prefab instance has a map of modifications, that stores delta of instance and prefab return(yamlDocument.GetUnityObjectPropertyValue(UnityYamlConstants.ModificationProperty) as IBlockMappingNode); }
public static string GetAttachedGameObjectName(UnitySceneDataLocalCache cache, IYamlDocument document) { var consumer = new UnityPathCachedSceneConsumer(); cache.ProcessSceneHierarchyFromComponentToRoot(document, consumer); var parts = consumer.NameParts; if (parts.Count == 0) { return("..."); } return(string.Join("/", consumer.NameParts)); }
public static INode GetUnityObjectPropertyValue([CanBeNull] this IYamlDocument document, [NotNull] string key) { return(FindRootBlockMapEntries(document).FindMapEntryBySimpleKey(key)?.Content.Value); }
public static string GetUnityObjectTag(IYamlDocument document) { var tag = (document.Body.BlockNode as IChameleonBlockMappingNode)?.Properties.TagProperty.GetText(); return(tag); }
public static string GetFileId(this IYamlDocument yamlDocument) { var properties = GetDocumentBlockNodeProperties(yamlDocument.Body.BlockNode); return(properties?.AnchorProperty?.Text?.GetText()); }
private static bool IsStripped(IYamlDocument element) { return(((element.Body.BlockNode as IChameleonBlockMappingNode)?.Properties?.LastChild as YamlTokenType.GenericTokenElement)? .GetText().Equals("stripped") == true); }
public static string GetGameObjectPathFromComponent([NotNull] UnitySceneProcessor sceneProcessor, [NotNull] IYamlDocument componentDocument) { var consumer = new UnityPathSceneConsumer(); sceneProcessor.ProcessSceneHierarchyFromComponentToRoot(componentDocument, consumer); var parts = consumer.NameParts; if (parts.Count == 0) { return("Unknown"); } if (parts.Count == 1) { return(parts[0]); } var sb = new StringBuilder(); for (var i = parts.Count - 1; i >= 0; i--) { sb.Append(parts[i]); sb.Append("\\"); } return(sb.ToString()); }
// 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 bool CanContainReference([NotNull] IYamlDocument document) { var buffer = document.GetTextAsBuffer(); return(CanContainReference(buffer)); }