public void AddData(IUnityAssetDataElement unityAssetDataElement)
 {
     foreach (var assetMethodData in ((AssetMethodsDataElement)unityAssetDataElement).Methods)
     {
         Methods.Add(assetMethodData);
     }
 }
        public void Merge(IPsiSourceFile currentAssetSourceFile,
                          AssetDocumentHierarchyElement assetDocumentHierarchyElement,
                          IUnityAssetDataElementPointer unityAssetDataElementPointer,
                          IUnityAssetDataElement unityAssetDataElement)
        {
            myPointers[currentAssetSourceFile] = unityAssetDataElementPointer;
            if (!(unityAssetDataElement is AnimatorUsagesDataElement animatorElement))
            {
                return;
            }
            foreach (var(guid, anchors) in animatorElement.GuidToAnchors)
            {
                if (anchors is null)
                {
                    continue;
                }
                // ReSharper disable once AssignNullToNotNullAttribute
                myUsagesCount.Add(guid, anchors.Count);
                myUsageToSourceFiles.Add(guid, currentAssetSourceFile);
            }

            var stateNames = animatorElement.StateNames;

            if (stateNames.Count == 0)
            {
                return;
            }
            foreach (var stateName in stateNames)
            {
                myStateNamesCount.Add(stateName);
            }
        }
        public void Drop(IPsiSourceFile currentAssetSourceFile,
                         AssetDocumentHierarchyElement assetDocumentHierarchyElement,
                         IUnityAssetDataElement element)
        {
            if (!(element is AnimatorUsagesDataElement animatorElement))
            {
                return;
            }
            var usagesCount        = myUsagesCount;
            var usageToSourceFiles = myUsageToSourceFiles;

            foreach (var(guid, anchors) in animatorElement.GuidToAnchors)
            {
                if (anchors is null)
                {
                    continue;
                }
                var currentCount = usagesCount.GetCount(guid);
                var anchorsCount = anchors.Count;
                usagesCount.Add(guid, anchorsCount <= currentCount ? -anchorsCount : -currentCount);
                usageToSourceFiles.Remove(guid, currentAssetSourceFile);
            }

            myPointers.Remove(currentAssetSourceFile);
            foreach (var stateName in animatorElement.StateNames)
            {
                myStateNamesCount.Remove(stateName);
            }
        }
        public void AddData(IUnityAssetDataElement unityAssetDataElement)
        {
            var valuesElement = unityAssetDataElement as AssetInspectorValuesDataElement;

            foreach (var variableUsage in valuesElement.VariableUsages)
            {
                VariableUsages.Add(variableUsage);
            }
        }
Пример #5
0
        public void AddData(IUnityAssetDataElement unityAssetDataElement)
        {
            var element = unityAssetDataElement as AssetUsagesDataElement;

            foreach (var usage in element.AssetUsages)
            {
                AssetUsages.Add(usage);
            }
        }
Пример #6
0
 public void AddDataElement(IUnityAssetDataElement dataElement)
 {
     if (UnityAssetDataElements.TryGetValue(dataElement.ContainerId, out var element))
     {
         element.AddData(dataElement);
     }
     else
     {
         UnityAssetDataElements[dataElement.ContainerId] = dataElement;
     }
 }
Пример #7
0
 public void Merge(IPsiSourceFile currentAssetSourceFile,
                   AssetDocumentHierarchyElement assetDocumentHierarchyElement,
                   IUnityAssetDataElementPointer unityAssetDataElementPointer,
                   IUnityAssetDataElement unityAssetDataElement)
 {
     myPointers[currentAssetSourceFile] = unityAssetDataElementPointer;
     if (!(unityAssetDataElement is AnimationUsagesDataElement animationElement))
     {
         return;
     }
     foreach (var @event in animationElement.Events)
     {
         myNameToGuids.Add(@event.FunctionName, @event.Guid);
         myUsageToSourceFiles.Add(Pair.Of(@event.FunctionName, @event.Guid), currentAssetSourceFile);
     }
 }
        public void AddData(IUnityAssetDataElement unityAssetDataElement)
        {
            var hierarchyElement = (AssetDocumentHierarchyElement)unityAssetDataElement;

            foreach (var element in hierarchyElement.myLocalAnchorToHierarchyElement)
            {
                myLocalAnchorToHierarchyElement[element.Key] = element.Value;
            }

            foreach (var element in hierarchyElement.myTransformHierarchies)
            {
                myTransformHierarchies.Add(element);
            }

            foreach (var element in hierarchyElement.myPrefabInstanceHierarchies)
            {
                myPrefabInstanceHierarchies.Add(element);
            }
        }
Пример #9
0
        public void Drop(IPsiSourceFile currentAssetSourceFile,
                         AssetDocumentHierarchyElement assetDocumentHierarchyElement,
                         IUnityAssetDataElement element)
        {
            if (!(element is AnimationUsagesDataElement animationElement))
            {
                return;
            }
            foreach (var @event in animationElement.Events)
            {
                var functionName = @event.FunctionName;
                var guid         = @event.Guid;
                var currentCount = myNameToGuids.GetCount(functionName, guid);
                if (currentCount != 0)
                {
                    myNameToGuids.Remove(functionName, guid);
                }
                myUsageToSourceFiles.Remove(Pair.Of(functionName, guid), currentAssetSourceFile);
            }

            myPointers.Remove(currentAssetSourceFile);
        }
Пример #10
0
        public void Merge(IPsiSourceFile currentAssetSourceFile, AssetDocumentHierarchyElement hierarchyElement, IUnityAssetDataElementPointer unityAssetDataElementPointer, IUnityAssetDataElement unityAssetDataElement)
        {
            var element = unityAssetDataElement as AssetDocumentHierarchyElement;

            myAssetDocumentsHierarchy[currentAssetSourceFile] = unityAssetDataElementPointer;
            element.RestoreHierarchy(this, currentAssetSourceFile);

            myPrefabImportCache.OnHierarchyCreated(currentAssetSourceFile, element);
        }
Пример #11
0
 public void Drop(IPsiSourceFile currentAssetSourceFile, AssetDocumentHierarchyElement hierarchyElement, IUnityAssetDataElement unityAssetDataElement)
 {
     myPrefabImportCache.OnHierarchyRemoved(currentAssetSourceFile, unityAssetDataElement as AssetDocumentHierarchyElement);
     myAssetDocumentsHierarchy.TryRemove(currentAssetSourceFile, out _);
 }
Пример #12
0
        public void Merge(IPsiSourceFile currentAssetSourceFile, AssetDocumentHierarchyElement assetDocumentHierarchyElement, IUnityAssetDataElementPointer unityAssetDataElementPointer, IUnityAssetDataElement unityAssetDataElement)
        {
            myPointers[currentAssetSourceFile] = unityAssetDataElementPointer;
            var dataElement = unityAssetDataElement as AssetUsagesDataElement;

            foreach (var assetUsagePointer in dataElement.EnumerateAssetUsages())
            {
                var guid = assetUsagePointer.UsageTarget.ExternalAssetGuid;
                myUsagesCount.Add(guid);
                myUsageToSourceFiles.Add(guid, currentAssetSourceFile);
            }
        }
        public void Drop(IPsiSourceFile sourceFile, AssetDocumentHierarchyElement assetDocumentHierarchyElement, IUnityAssetDataElement unityAssetDataElement)
        {
            var element = unityAssetDataElement as AssetMethodsDataElement;

            foreach (var method in element.Methods)
            {
                myShortNameToScriptTarget.Remove(method.MethodName, method);

                if (method.TargetScriptReference is ExternalReference)
                {
                    myExternalCount.Remove(method.MethodName);
                }
                else if (method.TargetScriptReference is LocalReference localReference)
                {
                    if (assetDocumentHierarchyElement.GetHierarchyElement(null, localReference.LocalDocumentAnchor, null) is IScriptComponentHierarchy script)
                    {
                        if (script.IsStripped)
                        {
                            myExternalCount.Remove(method.MethodName);
                        }
                        else
                        {
                            myLocalUsages.Remove(method.MethodName, new AssetMethodData(LocalReference.Null,
                                                                                        method.MethodName, TextRange.InvalidRange,
                                                                                        method.Mode, method.Type, script.ScriptReference));
                        }
                    }
                }
            }

            myPsiSourceFileToMethods.Remove(sourceFile);
        }
        public void Merge(IPsiSourceFile currentAssetSourceFile, AssetDocumentHierarchyElement assetDocumentHierarchyElement, IUnityAssetDataElementPointer unityAssetDataElementPointer, IUnityAssetDataElement unityAssetDataElement)
        {
            myPointers[currentAssetSourceFile] = unityAssetDataElementPointer;

            var element = unityAssetDataElement as AssetInspectorValuesDataElement;


            foreach (var variableUsage in element.VariableUsages)
            {
                var scriptReference = variableUsage.ScriptReference;
                var guid            = scriptReference.ExternalAssetGuid;

                myNameToSourceFile.Add(variableUsage.Name, currentAssetSourceFile);

                var mbField = new MonoBehaviourField(guid, variableUsage.Name.GetPlatformIndependentHashCode());
                AddUniqueValue(mbField, variableUsage);
                myChangesInFiles.Add(mbField, currentAssetSourceFile);
                AddChangesPerFile(new MonoBehaviourField(guid, variableUsage.Name.GetPlatformIndependentHashCode(), currentAssetSourceFile), variableUsage);

                myNameHashToGuids.Add(variableUsage.Name.GetPlatformIndependentHashCode(), scriptReference.ExternalAssetGuid);
            }

            foreach (var(reference, _) in element.ImportedInspectorValues.Modifications)
            {
                myNamesInPrefabModifications.Add(reference.Name);
                myNameToSourceFile.Add(reference.Name, currentAssetSourceFile);
            }
        }
        public void Drop(IPsiSourceFile currentAssetSourceFile, AssetDocumentHierarchyElement assetDocumentHierarchyElement, IUnityAssetDataElement unityAssetDataElement)
        {
            var element = unityAssetDataElement as AssetInspectorValuesDataElement;
            var usages  = element.VariableUsages;

            // inverted order is matter for Remove/AddUniqueValue
            for (int i = usages.Count - 1; i >= 0; i--)
            {
                var variableUsage   = usages[i];
                var scriptReference = variableUsage.ScriptReference;
                var guid            = scriptReference.ExternalAssetGuid;

                myNameToSourceFile.Remove(variableUsage.Name, currentAssetSourceFile);
                var mbField = new MonoBehaviourField(guid, variableUsage.Name.GetPlatformIndependentHashCode());

                RemoveUniqueValue(mbField, variableUsage);
                myChangesInFiles.Remove(mbField, currentAssetSourceFile);
                RemoveChangesPerFile(new MonoBehaviourField(guid, variableUsage.Name.GetPlatformIndependentHashCode(), currentAssetSourceFile), variableUsage);

                myNameHashToGuids.Remove(variableUsage.Name.GetPlatformIndependentHashCode(), scriptReference.ExternalAssetGuid);
            }

            foreach (var(reference, _) in element.ImportedInspectorValues.Modifications)
            {
                myNamesInPrefabModifications.Remove(reference.Name);
            }

            myPointers.Remove(currentAssetSourceFile);
        }
        public void Merge(IPsiSourceFile sourceFile, AssetDocumentHierarchyElement hierarchyElement, IUnityAssetDataElement unityAssetDataElement)
        {
            var element = unityAssetDataElement as AssetDocumentHierarchyElement;

            element.AssetDocumentHierarchyElementContainer = this;
            element.IsScene = sourceFile.GetLocation().ExtensionWithDot.Equals(UnityYamlConstants.Scene);
            myAssetDocumentsHierarchy[sourceFile] = element;
            element.RestoreHierarchy();

            myPrefabImportCache.Add(sourceFile, element);
        }
        public void Drop(IPsiSourceFile sourceFile, AssetDocumentHierarchyElement assetDocumentHierarchyElement, IUnityAssetDataElement unityAssetDataElement)
        {
            var dataElement = unityAssetDataElement as AssetUsagesDataElement;

            foreach (var assetUsage in dataElement.AssetUsages)
            {
                foreach (var dependency in assetUsage.Dependencies)
                {
                    if (dependency is ExternalReference externalReference)
                    {
                        myAssetUsages.Remove(externalReference.ExternalAssetGuid, assetUsage);

                        var set = myAssetUsagesPerFile[sourceFile];
                        set.Remove(externalReference.ExternalAssetGuid, assetUsage);
                        if (set.Count == 0)
                        {
                            myAssetUsagesPerFile.Remove(sourceFile);
                        }
                    }
                }
            }
        }
        public void Merge(IPsiSourceFile sourceFile, AssetDocumentHierarchyElement assetDocumentHierarchyElement, IUnityAssetDataElement unityAssetDataElement)
        {
            var dataElement = unityAssetDataElement as AssetUsagesDataElement;

            foreach (var assetUsage in dataElement.AssetUsages)
            {
                foreach (var dependency in assetUsage.Dependencies)
                {
                    if (dependency is ExternalReference externalReference)
                    {
                        myAssetUsages.Add(externalReference.ExternalAssetGuid, assetUsage);

                        if (!myAssetUsagesPerFile.TryGetValue(sourceFile, out var set))
                        {
                            set = new OneToCompactCountingSet <string, AssetUsage>();
                            myAssetUsagesPerFile[sourceFile] = set;
                        }

                        set.Add(externalReference.ExternalAssetGuid, assetUsage);
                    }
                }
            }
        }
        public void Merge(IPsiSourceFile sourceFile, AssetDocumentHierarchyElement assetDocumentHierarchyElement, IUnityAssetDataElement unityAssetDataElement)
        {
            var element      = (unityAssetDataElement as AssetMethodsDataElement).NotNull("element != null");
            var groupMethods = new OneToListMap <string, AssetMethodData>();

            foreach (var method in element.Methods)
            {
                myShortNameToScriptTarget.Add(method.MethodName, method);
                groupMethods.Add(method.MethodName, method);

                if (method.TargetScriptReference is ExternalReference)
                {
                    myExternalCount.Add(method.MethodName);
                }
                else if (method.TargetScriptReference is LocalReference localReference)
                {
                    if (assetDocumentHierarchyElement.GetHierarchyElement(null, localReference.LocalDocumentAnchor, null) is IScriptComponentHierarchy script)
                    {
                        if (script.IsStripped)
                        {
                            myExternalCount.Add(method.MethodName);
                        }
                        else
                        {
                            myLocalUsages.Add(method.MethodName, new AssetMethodData(LocalReference.Null,
                                                                                     method.MethodName, TextRange.InvalidRange,
                                                                                     method.Mode, method.Type, script.ScriptReference));
                        }
                    }
                }
            }

            myPsiSourceFileToMethods.Add(sourceFile, groupMethods);
        }
Пример #20
0
        public void Merge(IPsiSourceFile sourceFile, AssetDocumentHierarchyElement assetDocumentHierarchyElement, IUnityAssetDataElement unityAssetDataElement)
        {
            var element         = unityAssetDataElement as AssetInspectorValuesDataElement;
            var inspectorUsages = new OneToListMap <string, InspectorVariableUsage>();

            foreach (var variableUsage in element.VariableUsages)
            {
                var guid = (variableUsage.ScriptReference as ExternalReference)?.ExternalAssetGuid;
                if (guid == null)
                {
                    continue;
                }

                myNameToSourceFile.Add(variableUsage.Name, sourceFile);

                var mbField = new MonoBehaviourField(guid, variableUsage.Name);
                myUniqueValuesCount.Add(mbField, variableUsage.Value);
                AddUniqueValue(mbField, variableUsage);
                myChangesInFiles.Add(mbField, sourceFile);
                AddChangesPerFile(new MonoBehaviourField(guid, variableUsage.Name, sourceFile), variableUsage);

                inspectorUsages.Add(variableUsage.Name, variableUsage);

                if (variableUsage.ScriptReference is ExternalReference externalReference)
                {
                    myNameToGuids.Add(variableUsage.Name, externalReference.ExternalAssetGuid);
                }
            }

            myPsiSourceFileToInspectorValues.Add(sourceFile, inspectorUsages);
        }
Пример #21
0
        public void Drop(IPsiSourceFile sourceFile, AssetDocumentHierarchyElement assetDocumentHierarchyElement, IUnityAssetDataElement unityAssetDataElement)
        {
            var element = unityAssetDataElement as AssetInspectorValuesDataElement;

            foreach (var variableUsage in element.VariableUsages)
            {
                var guid = (variableUsage.ScriptReference as ExternalReference)?.ExternalAssetGuid;
                if (guid == null)
                {
                    continue;
                }

                myNameToSourceFile.Remove(variableUsage.Name, sourceFile);

                var mbField = new MonoBehaviourField(guid, variableUsage.Name);
                myUniqueValuesCount.Remove(mbField, variableUsage.Value);
                RemoveUniqueValue(mbField, variableUsage);
                myChangesInFiles.Remove(mbField, sourceFile);
                RemoveChangesPerFile(new MonoBehaviourField(guid, variableUsage.Name, sourceFile), variableUsage);

                if (variableUsage.ScriptReference is ExternalReference externalReference)
                {
                    myNameToGuids.Remove(variableUsage.Name, externalReference.ExternalAssetGuid);
                }
            }

            myPsiSourceFileToInspectorValues.Remove(sourceFile);
        }
Пример #22
0
        public void Drop(IPsiSourceFile currentAssetSourceFile, AssetDocumentHierarchyElement assetDocumentHierarchyElement, IUnityAssetDataElement unityAssetDataElement)
        {
            var dataElement = unityAssetDataElement as AssetScriptUsagesDataElement;

            foreach (var assetUsagePointer in dataElement.EnumerateAssetUsages())
            {
                if (!(assetUsagePointer is AssetScriptUsage assetScriptUsages))
                {
                    continue;
                }
                var guid = assetScriptUsages.UsageTarget.ExternalAssetGuid;
                myUsagesCount.Remove(guid);
                myUsageToSourceFiles.Remove(guid, currentAssetSourceFile);
            }

            myPointers.Remove(currentAssetSourceFile);
        }