Esempio n. 1
0
        private RestoredAssetsRoot GetOrCreateRoot(RestoredAssetsRoot.ContainingType assetType)
        {
            var root = Utils.FindAssetsOfType <RestoredAssetsRoot>(m_dataDirectory).FirstOrDefault(r => r != null &&
                                                                                                   r.Type == assetType);

            if (root == null)
            {
                root = RestoredAssetsRoot.Create(m_filename, assetType);

                // Re-import of previous version without root if there are assets
                // of the given type. Add root and set it as main object.
                var existingAssets = GetAssets(assetType);
                if (existingAssets.Length == 0)
                {
                    AssetDatabase.CreateAsset(root, GetAssetPath(root));
                }
                else
                {
                    AssetDatabase.AddObjectToAsset(root,
                                                   System.Array.Find(existingAssets,
                                                                     asset => AssetDatabase.IsMainAsset(asset)) ??
                                                   existingAssets[0]);
                    m_statistics.RootsAddedToExistingAssets = true;
                }
            }

            return(m_assetRoots[(int)assetType] = root);
        }
Esempio n. 2
0
        public static Object[] GetAssets(string dataDirectory, RestoredAssetsRoot.ContainingType assetType)
        {
            var root   = Utils.FindAssetsOfType <RestoredAssetsRoot>(dataDirectory).FirstOrDefault(assetRoot => assetRoot.Type == assetType);
            var assets = new List <Object>();

            if (root != null)
            {
                assets.Add(root);
            }
            if (assetType == RestoredAssetsRoot.ContainingType.Unknown)
            {
                assets.AddRange(from type in s_unknownTypes
                                from asset in Utils.FindAssetsOfType(dataDirectory, type)
                                select asset);
            }
            else
            {
                assets.AddRange(from asset in Utils.FindAssetsOfType(dataDirectory, RestoredAssetsRoot.GetType(assetType))
                                where asset.GetType() == RestoredAssetsRoot.GetType(assetType)
                                select asset);
            }
            return(assets.ToArray());
        }
Esempio n. 3
0
        private void Initialize(RestoredAssetsRoot.ContainingType assetType)
        {
            var dict = m_assets[(int)assetType] = new Dictionary <int, AssetDbData>();

            GetOrCreateRoot(assetType);

            var assets = GetAssets(assetType);

            foreach (var asset in assets)
            {
                if (asset is RestoredAssetsRoot)
                {
                    continue;
                }

                Debug.Assert(!dict.ContainsKey(asset.GetHashCode()));
                dict.Add(asset.GetHashCode(),
                         new AssetDbData()
                {
                    Asset    = asset,
                    RefCount = 0
                });
            }
        }
Esempio n. 4
0
 private RestoredAssetsRoot GetRoot(RestoredAssetsRoot.ContainingType assetType)
 {
     Debug.Assert(m_assetRoots[(int)assetType] != null);
     return(m_assetRoots[(int)assetType]);
 }
Esempio n. 5
0
 private Object[] GetAssets(RestoredAssetsRoot.ContainingType assetType)
 {
     return(GetAssets(m_dataDirectory, assetType));
 }