FindTypeOfAsset() public static méthode

public static FindTypeOfAsset ( string assetPath ) : Type
assetPath string
Résultat System.Type
        private void Filter(List <Asset> assets, Action <string, List <string> > FilterResultReceiver)
        {
            var exhaustiveAssets = new List <ExhaustiveAssetPathData>();

            foreach (var asset in assets)
            {
                exhaustiveAssets.Add(new ExhaustiveAssetPathData(asset.absoluteAssetPath, asset.importFrom));
            }

            for (var i = 0; i < connectionIdsFromThisNodeToChildNodesOrFakeIds.Length; i++)
            {
                // these 3 parameters depends on their contents order.
                var connectionId = connectionIdsFromThisNodeToChildNodesOrFakeIds[i];
                var keyword      = containsKeywords[i];
                var keytype      = containsKeytypes[i];

                // filter by keyword first
                List <ExhaustiveAssetPathData> keywordContainsAssets = exhaustiveAssets.Where(
                    assetData =>
                    !assetData.isFilterExhausted &&
                    Regex.IsMatch(assetData.importFrom, keyword, RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace)
                    ).ToList();

                var typeMatchedAssetsAbsolutePaths = new List <string>();

                // then, filter by type
                foreach (var containedAssetData in keywordContainsAssets)
                {
                    if (keytype != AssetBundleGraphSettings.DEFAULT_FILTER_KEYTYPE)
                    {
                        var assumedType = TypeUtility.FindTypeOfAsset(containedAssetData.importFrom);
                        if (assumedType == null || keytype != assumedType.ToString())
                        {
                            continue;
                        }
                    }
                    typeMatchedAssetsAbsolutePaths.Add(containedAssetData.absoluteAssetPath);
                }

                // mark assets as exhausted.
                foreach (var exhaustiveAsset in exhaustiveAssets)
                {
                    if (typeMatchedAssetsAbsolutePaths.Contains(exhaustiveAsset.absoluteAssetPath))
                    {
                        exhaustiveAsset.isFilterExhausted = true;
                    }
                }

                if (connectionId != AssetBundleGraphSettings.FILTER_FAKE_CONNECTION_ID)
                {
                    FilterResultReceiver(connectionId, typeMatchedAssetsAbsolutePaths);
                }
            }
        }
        private void Filter(NodeData node, Dictionary <string, List <Asset> > inputGroupAssets, Action <ConnectionData, Dictionary <string, List <Asset> >, List <string> > Output)
        {
            foreach (var connToChild in connectionsToChild)
            {
                var filter = node.FilterConditions.Find(fc => fc.ConnectionPoint.Id == connToChild.FromNodeConnectionPointId);
                UnityEngine.Assertions.Assert.IsNotNull(filter);

                var output = new Dictionary <string, List <Asset> >();

                foreach (var groupKey in inputGroupAssets.Keys)
                {
                    var assets          = inputGroupAssets[groupKey];
                    var filteringAssets = new List <FilterableAsset>();
                    assets.ForEach(a => filteringAssets.Add(new FilterableAsset(a)));


                    // filter by keyword first
                    List <FilterableAsset> keywordContainsAssets = filteringAssets.Where(
                        assetData =>
                        !assetData.isFiltered &&
                        Regex.IsMatch(assetData.asset.importFrom, filter.FilterKeyword, RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace)
                        ).ToList();

                    List <FilterableAsset> finalFilteredAsset = new List <FilterableAsset>();

                    // then, filter by type
                    foreach (var a in keywordContainsAssets)
                    {
                        if (filter.FilterKeytype != AssetBundleGraphSettings.DEFAULT_FILTER_KEYTYPE)
                        {
                            var assumedType = TypeUtility.FindTypeOfAsset(a.asset.importFrom);
                            if (assumedType == null || filter.FilterKeytype != assumedType.ToString())
                            {
                                continue;
                            }
                        }
                        finalFilteredAsset.Add(a);
                    }

                    // mark assets as exhausted.
                    foreach (var a in finalFilteredAsset)
                    {
                        a.isFiltered = true;
                    }

                    output[groupKey] = finalFilteredAsset.Select(v => v.asset).ToList();
                }

                Output(connToChild, output, null);
            }
        }
Exemple #3
0
        public static void ValidateModifier(
            NodeData node,
            BuildTarget target,
            List <Asset> incomingAssets,
            Action <Type, Type, Asset> multipleAssetTypeFound,
            Action noModiferData,
            Action failedToCreateModifier,
            Action <Type, Type> incomingTypeMismatch
            )
        {
            Type expectedType = TypeUtility.FindIncomingAssetType(incomingAssets);

            if (expectedType != null)
            {
                foreach (var a  in incomingAssets)
                {
                    Type assetType = TypeUtility.FindTypeOfAsset(a.importFrom);
                    if (assetType != expectedType)
                    {
                        multipleAssetTypeFound(expectedType, assetType, a);
                    }
                }
            }

            if (string.IsNullOrEmpty(node.InstanceData[target]))
            {
                noModiferData();
            }

            var modifier = ModifierUtility.CreateModifier(node, target);

            if (null == modifier)
            {
                failedToCreateModifier();
            }

            // if there is no incoming assets, there is no way to check if
            // right type of asset is coming in - so we'll just skip the test
            if (incomingAssets.Any())
            {
                var targetType = ModifierUtility.GetModifierTargetType(modifier);
                if (targetType != expectedType)
                {
                    incomingTypeMismatch(targetType, expectedType);
                }
            }
        }
Exemple #4
0
        public static void ValidateInputSetting(
            NodeData node,
            BuildTarget target,
            List <Asset> incomingAssets,
            Action <Type, Type, Asset> multipleAssetTypeFound,
            Action <Type> unsupportedType,
            Action <Type, Type> incomingTypeMismatch,
            Action <ConfigStatus> errorInConfig
            )
        {
            Type expectedType = TypeUtility.FindIncomingAssetType(incomingAssets);

            if (multipleAssetTypeFound != null)
            {
                if (expectedType != null)
                {
                    foreach (var a  in incomingAssets)
                    {
                        Type assetType = TypeUtility.FindTypeOfAsset(a.importFrom);
                        if (assetType != expectedType)
                        {
                            multipleAssetTypeFound(expectedType, assetType, a);
                        }
                    }
                }
            }

            if (unsupportedType != null)
            {
                if (expectedType != null)
                {
                    if (expectedType == typeof(UnityEditor.TextureImporter) ||
                        expectedType == typeof(UnityEditor.ModelImporter) ||
                        expectedType == typeof(UnityEditor.AudioImporter)
                        )
                    {
                        // good. do nothing
                    }
                    else
                    {
                        unsupportedType(expectedType);
                    }
                }
            }

            var status = GetConfigStatus(node);

            if (errorInConfig != null)
            {
                if (status != ConfigStatus.GoodSampleFound)
                {
                    errorInConfig(status);
                }
            }

            if (incomingTypeMismatch != null)
            {
                // if there is no incoming assets, there is no way to check if
                // right type of asset is coming in - so we'll just skip the test
                if (incomingAssets.Any() && status == ConfigStatus.GoodSampleFound)
                {
                    Type targetType = GetReferenceAssetImporter(node).GetType();
                    if (targetType != expectedType)
                    {
                        incomingTypeMismatch(targetType, expectedType);
                    }
                }
            }
        }
        public void Setup(string nodeName, string nodeId, string connectionIdToNextNode, Dictionary <string, List <Asset> > groupedSources, List <string> alreadyCached, Action <string, string, Dictionary <string, List <Asset> >, List <string> > Output)
        {
            if (groupedSources.Keys.Count == 0)
            {
                return;
            }

            // Modifier merges multiple incoming groups into one.
            if (1 < groupedSources.Keys.Count)
            {
                Debug.LogWarning(nodeName + " Modifier merges incoming group into \"" + groupedSources.Keys.ToList()[0]);
            }

            var groupMergeKey = groupedSources.Keys.ToList()[0];

            // merge all assets into single list.
            var inputSources = new List <Asset>();

            foreach (var groupKey in groupedSources.Keys)
            {
                inputSources.AddRange(groupedSources[groupKey]);
            }

            if (!inputSources.Any())
            {
                return;
            }

            // initialize as object.
            var modifierType = string.Empty;

            var first = true;

            foreach (var inputSource in inputSources)
            {
                var modifyTargetAssetPath = inputSource.importFrom;
                var assumedType           = TypeUtility.FindTypeOfAsset(modifyTargetAssetPath);

                if (assumedType == null || assumedType == typeof(object))
                {
                    continue;
                }

                if (first)
                {
                    first        = false;
                    modifierType = assumedType.ToString();
                    continue;
                }

                if (modifierType != assumedType.ToString())
                {
                    throw new NodeException("multiple Asset Type detected. consider reduce Asset Type number to only 1 by Filter. detected Asset Types is:" + modifierType + " , and " + assumedType.ToString(), nodeId);
                }
            }

            // modifierType is fixed.

            if (!string.IsNullOrEmpty(specifiedScriptClass))
            {
                Debug.LogError("modifierのScript版実装中。");
                return;
            }

            // check support.
            if (!TypeUtility.SupportedModifierOperatorDefinition.ContainsKey(modifierType))
            {
                throw new NodeException("current incoming Asset Type:" + modifierType + " is unsupported.", nodeId);
            }

            // generate modifierOperatorData if data is not exist yet.
            {
                var modifierOperationDataFolderPath = AssetBundleGraphSettings.MODIFIER_OPERATOR_DATAS_PLACE;
                if (!Directory.Exists(modifierOperationDataFolderPath))
                {
                    Directory.CreateDirectory(modifierOperationDataFolderPath);
                }

                var opDataFolderPath = FileUtility.PathCombine(modifierOperationDataFolderPath, nodeId);
                if (!Directory.Exists(opDataFolderPath))
                {
                    Directory.CreateDirectory(opDataFolderPath);
                }

                // ready default platform path.
                var modifierOperatorDataPathForDefaultPlatform = FileUtility.PathCombine(opDataFolderPath, ModifierOperatiorDataName(AssetBundleGraphSettings.PLATFORM_DEFAULT_NAME));

                /*
                 *      create default platform ModifierOperatorData if not exist.
                 *      default ModifierOperatorData is the target platform for every platform by default.
                 */
                if (!File.Exists(modifierOperatorDataPathForDefaultPlatform))
                {
                    var operatorType = TypeUtility.SupportedModifierOperatorDefinition[modifierType];

                    var operatorInstance = Activator.CreateInstance(operatorType) as ModifierOperators.OperatorBase;

                    var defaultRenderTextureOp = operatorInstance.DefaultSetting();

                    /*
                     *      generated json data is typed as supported ModifierOperation type.
                     */
                    var jsonData   = JsonUtility.ToJson(defaultRenderTextureOp);
                    var prettified = AssetBundleGraphEditorWindow.PrettifyJson(jsonData);
                    using (var sw = new StreamWriter(modifierOperatorDataPathForDefaultPlatform)) {
                        sw.WriteLine(prettified);
                    }
                }
            }

            // validate saved data.
            ValidateModifiyOperationData(
                nodeId,
                currentPlatformStr,
                () => {
                throw new NodeException("No ModifierOperatorData found. please Setup first.", nodeId);
            },
                () => {
                /*do nothing.*/
            }
                );

            var outputSources = new List <Asset>();

            /*
             *      all assets types are same and do nothing to assets in setup.
             */
            foreach (var asset in inputSources)
            {
                outputSources.Add(Asset.DuplicateAsset(asset));
            }

            var outputDict = new Dictionary <string, List <Asset> >();

            outputDict[groupMergeKey] = outputSources;

            Output(nodeId, connectionIdToNextNode, outputDict, new List <string>());
        }
        public void Run(string nodeName, string nodeId, string connectionIdToNextNode, Dictionary <string, List <Asset> > groupedSources, List <string> alreadyCached, Action <string, string, Dictionary <string, List <Asset> >, List <string> > Output)
        {
            if (groupedSources.Keys.Count == 0)
            {
                return;
            }

            // Modifier merges multiple incoming groups into one.
            if (1 < groupedSources.Keys.Count)
            {
                Debug.LogWarning(nodeName + " Modifier merges incoming group into \"" + groupedSources.Keys.ToList()[0]);
            }

            var groupMergeKey = groupedSources.Keys.ToList()[0];

            // merge all assets into single list.
            var inputSources = new List <Asset>();

            foreach (var groupKey in groupedSources.Keys)
            {
                inputSources.AddRange(groupedSources[groupKey]);
            }

            if (!inputSources.Any())
            {
                return;
            }

            // load type from 1st asset of flow.
            var modifierType = TypeUtility.FindTypeOfAsset(inputSources[0].importFrom).ToString();

            // modifierType is fixed.

            if (!string.IsNullOrEmpty(specifiedScriptClass))
            {
                Debug.LogError("modifierのScript版実装中。");
                return;
            }

            // check support.
            if (!TypeUtility.SupportedModifierOperatorDefinition.ContainsKey(modifierType))
            {
                throw new NodeException("current incoming Asset Type:" + modifierType + " is unsupported.", nodeId);
            }


            // validate saved data.
            ValidateModifiyOperationData(
                nodeId,
                currentPlatformStr,
                () => {
                throw new NodeException("No ModifierOperatorData found. please Setup first.", nodeId);
            },
                () => {
                /*do nothing.*/
            }
                );

            var outputSources = new List <Asset>();

            var modifierOperatorDataPathForTargetPlatform = FileUtility.PathCombine(AssetBundleGraphSettings.MODIFIER_OPERATOR_DATAS_PLACE, nodeId, ModifierOperatiorDataName(currentPlatformStr));

            // if runtime platform specified modifierOperatorData is nof found,
            // use default platform modifierOperatorData.
            if (!File.Exists(modifierOperatorDataPathForTargetPlatform))
            {
                modifierOperatorDataPathForTargetPlatform = FileUtility.PathCombine(AssetBundleGraphSettings.MODIFIER_OPERATOR_DATAS_PLACE, nodeId, ModifierOperatiorDataName(AssetBundleGraphSettings.PLATFORM_DEFAULT_NAME));
            }

            var loadedModifierOperatorData = string.Empty;

            using (var sr = new StreamReader(modifierOperatorDataPathForTargetPlatform)) {
                loadedModifierOperatorData = sr.ReadToEnd();
            }

            /*
             *      read saved modifierOperation type for detect data type.
             */
            var deserializedDataObject = JsonUtility.FromJson <ModifierOperators.OperatorBase>(loadedModifierOperatorData);
            var dataTypeString         = deserializedDataObject.operatorType;

            // sadly, if loaded assetType is no longer supported or not.
            if (!TypeUtility.SupportedModifierOperatorDefinition.ContainsKey(dataTypeString))
            {
                throw new NodeException("unsupported ModifierOperator Type:" + modifierType, nodeId);
            }

            var modifyOperatorType = TypeUtility.SupportedModifierOperatorDefinition[dataTypeString];

            /*
             *      make generic method for genearte desired typed ModifierOperator instance.
             */
            var modifyOperatorInstance = typeof(IntegratedGUIModifier)
                                         .GetMethod("FromJson")
                                         .MakeGenericMethod(modifyOperatorType)// set desired generic type here.
                                         .Invoke(this, new object[] { loadedModifierOperatorData }) as ModifierOperators.OperatorBase;

            var isChanged = false;

            foreach (var inputSource in inputSources)
            {
                var modifyTargetAssetPath = inputSource.importFrom;

                var modifyOperationTargetAsset = AssetDatabase.LoadAssetAtPath <UnityEngine.Object>(modifyTargetAssetPath);

                if (!modifyOperatorInstance.IsChanged(modifyOperationTargetAsset))
                {
                    outputSources.Add(
                        Asset.CreateNewAssetWithImportPathAndStatus(
                            inputSource.importFrom,
                            false,                            // marked as not changed.
                            false
                            )
                        );
                    continue;
                }

                isChanged = true;
                modifyOperatorInstance.Modify(modifyOperationTargetAsset);

                outputSources.Add(
                    Asset.CreateNewAssetWithImportPathAndStatus(
                        inputSource.importFrom,
                        true,                        // marked as changed.
                        false
                        )
                    );
            }

            if (isChanged)
            {
                // apply asset setting changes to AssetDatabase.
                AssetDatabase.Refresh();
            }

            var outputDict = new Dictionary <string, List <Asset> >();

            outputDict[groupMergeKey] = outputSources;

            Output(nodeId, connectionIdToNextNode, outputDict, new List <string>());
        }