public override void PreprocessTask(ImportContext context, ImportDefinitionProfile profile)
        {
            UserDataSerialization data = UserDataSerialization.Get(context.AssetPath);
            string profileGuid         = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(profile));

            data.UpdateProcessing(new UserDataSerialization.PostprocessorData(profileGuid, ImportTaskName, Method.AssemblyName, Method.TypeName, Method.Version));
        }
Esempio n. 2
0
        public virtual void PreprocessTask(ImportContext context, ImportDefinitionProfile profile)
        {
            UserDataSerialization data = UserDataSerialization.Get(context.AssetPath);
            string profileGuid         = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(profile));

            data.UpdateProcessing(new UserDataSerialization.ImportTaskData(profileGuid, ImportTaskName, Version));
        }
        private void SetUserData(AssetImporter importer, ImportDefinitionProfile profile)
        {
            UserDataSerialization data = UserDataSerialization.Get(importer.assetPath);
            string profileGuid         = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(profile));

            data.m_ImporterPostprocessorData.UpdateOrAdd(new UserDataSerialization.PostprocessorData(profileGuid, kImportTaskName, Method.AssemblyName, Method.TypeName, Method.Version));
            data.UpdateImporterUserData();
        }
        public override List <IConformObject> GetConformObjects(string asset, ImportDefinitionProfile profile)
        {
            // Preprocessor versionCode comparison
            // will need someway to store this. It could not work well if imported not using it
            // 1: add it to meta data. Only option is userData, which could conflict with other code packages. This would make it included in the hash for cache server. Which would be required.
            // 2: store a database of imported version data. Could be tricky to keep in sync
            // 3: AssetDatabaseV2 supports asset dependencies

            List <IConformObject> infos = new List <IConformObject>();

            if (Method == null)
            {
                PreprocessorConformObject conformObject = new PreprocessorConformObject("None Selected", 0);
                infos.Add(conformObject);
                return(infos);
            }

            UserDataSerialization userData = UserDataSerialization.Get(asset);
            List <UserDataSerialization.PostprocessorData> data = userData.GetProcessedMethodsData();
            string profileGuid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(profile));

            if (data != null)
            {
                for (int i = 0; i < data.Count; ++i)
                {
                    if (data[i].moduleName != ImportTaskName ||
                        data[i].typeName != Method.TypeName ||
                        data[i].assemblyName != Method.AssemblyName ||
                        data[i].importDefinitionGUID != profileGuid)
                    {
                        continue;
                    }

                    PreprocessorConformObject conformObject = new PreprocessorConformObject(Method.TypeName, Method.Version, data[i].version);
                    infos.Add(conformObject);
                    break;
                }
            }
            else
            {
                PreprocessorConformObject conformObject = new PreprocessorConformObject(Method.TypeName, Method.Version);
                infos.Add(conformObject);
            }
            return(infos);
        }
        public void PreprocessAsset(ImportContext context, bool checkForConformity = true)
        {
            if (checkForConformity)
            {
                if (m_FilterToFolder)
                {
                    List <Filter> filters = new List <Filter>(m_Filters);
                    filters.Add(new Filter(Filter.ConditionTarget.Directory, Filter.Condition.StartsWith, DirectoryPath));
                    if (Filter.Conforms(context.Importer, filters) == false)
                    {
                        return;
                    }
                }
                else if (Filter.Conforms(context.Importer, m_Filters) == false)
                {
                    return;
                }
            }

            bool saveMeta = false;

            if (m_RunOnImport)
            {
                for (int i = 0; i < m_ImportTasks.Count; ++i)
                {
                    if (m_ImportTasks[i] != null)
                    {
                        m_ImportTasks[i].PreprocessTask(context, this);
                        saveMeta = true;
                        if (m_ImportTasks[i].TaskProcessType == BaseImportTask.ProcessingType.Pre)
                        {
                            m_ImportTasks[i].Apply(context, this);
                            m_ImportTasks[i].SetManuallyProcessing(context.AssetPath, false);
                        }
                    }
                }
            }
            else
            {
                for (int i = 0; i < m_ImportTasks.Count; ++i)
                {
                    if (m_ImportTasks[i] != null && m_ImportTasks[i].IsManuallyProcessing(context.Importer))
                    {
                        m_ImportTasks[i].PreprocessTask(context, this);
                        saveMeta = true;
                        if (m_ImportTasks[i].TaskProcessType == BaseImportTask.ProcessingType.Pre)
                        {
                            m_ImportTasks[i].Apply(context, this);
                            m_ImportTasks[i].SetManuallyProcessing(context.AssetPath, false);
                        }
                    }
                }
            }

            if (saveMeta)
            {
                UserDataSerialization data = UserDataSerialization.Get(context.AssetPath);
                if (data != null)
                {
                    data.SaveMetaData();
                }
            }
        }