コード例 #1
0
        void LoadAssetManifest()
        {
            string path = assetPath + ASSET_MANIFEST_FILE;

            if (File.Exists(path))
            {
                string json = File.ReadAllText(assetPath + ASSET_MANIFEST_FILE);
                mAssetManifest = JsonUtility.FromJson <AssetManifest>(json);
                if (mAssetManifest != null && mAssetManifest.assetHeaders != null && mAssetManifest.assetHeaders.Count > 0)
                {
                    foreach (var header in mAssetManifest.assetHeaders)
                    {
                        header.Init();
                        if (mLocalAssets.ContainsKey(header.url))
                        {
                            mLocalAssets[header.url] = header;
                        }
                        else
                        {
                            mLocalAssets.Add(header.url, header);
                        }
                    }
                }
            }
            else
            {
                mAssetManifest = new AssetManifest();
                Debug.LogWarning("Manifest file doesn't exist!");
            }
        }
コード例 #2
0
    private IEnumerator StartGame()
    {
        yield return(AssetManifest.Init());

        ABsManager.m_AssetBundleManifest = AssetManifest.manifest;
        ResManager.Instance.m_pattern    = ResManager.Pattern.AssetBundle;
        ResManager.LoadLevel("Launch");
    }
コード例 #3
0
        private void SearchAnimations(AssetManifest pManifest, AssetSearchResultItem pBaseResultItem, List <AssetSearchResultItem> pFound)
        {
            if (_tagsRegex != null)
            {
                return;
            }

            const string PuppetAnimationToken = "PuppetAnimation";

            if ((_assetSubTypesRegex == null) || _assetSubTypesRegex.IsMatch(PuppetAnimationToken))
            {
                if ((pManifest.BodyModels != null) && (pManifest.BodyModels.Count > 0))
                {
                    foreach (BodyModelItem puppet in pManifest.BodyModels)
                    {
                        if ((puppet.Animations != null) && (puppet.Animations.Count > 0))
                        {
                            SearchAnimationsCommon(PuppetAnimationToken, puppet.PuppetName, puppet.Animations,
                                                   pBaseResultItem, pFound);
                        }
                    }
                }
            }

            const string PropAnimationToken = "PropAnimation";

            if ((_assetSubTypesRegex == null) || _assetSubTypesRegex.IsMatch(PropAnimationToken))
            {
                if ((pManifest.PropModels != null) && (pManifest.PropModels.Count > 0))
                {
                    foreach (PropModelItem prop in pManifest.PropModels)
                    {
                        if ((prop.Animations != null) && (prop.Animations.Count > 0))
                        {
                            SearchAnimationsCommon(PropAnimationToken, prop.Name, prop.Animations,
                                                   pBaseResultItem, pFound);
                        }
                    }
                }
            }
        }
コード例 #4
0
        public void LoadManifestFile(byte[] inData)
        {
            AssetManifest manifestfile = Serializer.Deserialize <AssetManifest>(inData);

            if (manifestfile != null)
            {
                AssetVersion = manifestfile.version;

                foreach (AssetManifest.BundleInfo data in manifestfile.bundles)
                {
                    for (int i = 0; i < data.guids.Length; i++)
                    {
                        if (!_assetMapping.ContainsKey(data.guids[i]))
                        {
                            _assetMapping.Add(data.guids[i], data);
                        }
                    }
                    BundleMapping.Add(data.name, data);
                }
            }
        }
コード例 #5
0
        static void Main(string[] args)
        {
            _MetaStateSettings.Init();

            bool isCdnOnlyMode = false;


            List <string> allArgs = args == null ? new List <string>() : args.ToList();

            PlayFab.PlayFabSettings.staticSettings.DeveloperSecretKey = PlayFabSettings.DeveloperSecretKey;
            PlayFab.PlayFabSettings.staticSettings.TitleId            = PlayFabSettings.TitleId;

            BackOfficeStatusUrl = AzureSettings.StatusUrl;

            if (allArgs.Contains("-cdnonly"))
            {
                isCdnOnlyMode = true;
                Console.WriteLine("Found -cdnonly switch, will only sync files...");
            }


            if (allArgs.ElementAtOrDefault(0) != null && allArgs.ElementAtOrDefault(0) == "-appversion")
            {
                string version = allArgs.ElementAtOrDefault(1);
                string path    = allArgs.ElementAtOrDefault(2);

                if (!string.IsNullOrEmpty(version) && !string.IsNullOrEmpty(path))
                {
                    File.WriteAllText(path, version);
                }

                return;
            }

            if (allArgs.ElementAtOrDefault(0) != null && allArgs.ElementAtOrDefault(0) == "-status")
            {
                bool   online  = allArgs.ElementAtOrDefault(1) == "online" ? true : false;
                string seconds = allArgs.ElementAtOrDefault(2);

                string version = allArgs.ElementAtOrDefault(3);

                ChangeServerStatus(online, seconds, version);
                return;
            }


            var pathArg = allArgs.Where(y => y.StartsWith("-BaseUnityFolder:")).SingleOrDefault();

            if (pathArg != null)
            {
                MetaStateSettings._BaseUnityFolder = pathArg.Replace("-BaseUnityFolder:", string.Empty);
            }


            var currentManifestResult = PlayFab.PlayFabServerAPI.GetTitleDataAsync(new PlayFab.ServerModels.GetTitleDataRequest()
            {
                Keys = new List <string>()
                {
                    MetaStateSettings._TitleDataKey_CdnManifest
                }
            }).GetAwaiter().GetResult();

            Console.WriteLine("Fetching CDN content...");
            AssetManifest currentManifest = null;

            if (currentManifestResult.Result.Data.ContainsKey(MetaStateSettings._TitleDataKey_CdnManifest) && !string.IsNullOrEmpty(currentManifestResult.Result.Data[MetaStateSettings._TitleDataKey_CdnManifest]))
            {
                currentManifest = JsonConvert.DeserializeObject <AssetManifest>(currentManifestResult.Result.Data[MetaStateSettings._TitleDataKey_CdnManifest]);
            }
            else
            {
                currentManifest = new AssetManifest();
            }

            Console.WriteLine("Loading local files on " + MetaStateSettings._BaseUnityFolder + MetaStateSettings._DownloadableFolderPath);
            List <AssetFileInfo> allFiles = LocalFileHandler.GetLocalDownloadableFiles();

            var allCdnContent = PlayFabAdminAPI.GetContentListAsync(new PlayFab.AdminModels.GetContentListRequest()).GetAwaiter().GetResult();



            int           currentDataVersion;
            AssetFileInfo previousDbFileInfo = null;

            if (!isCdnOnlyMode)
            {
                //string databasePath = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location) + @"\" + MetaStateSettings._DatabaseName;

                string databasePath = MetaStateSettings._BaseUnityFolder + MetaStateSettings._DatabaseFileName;



                DataLayer.Instance.Init(databasePath);
                currentDataVersion = DataLayer.Instance.GetTable <DataVersion>().First().Version;
                DataLayer.Instance.Connection.Close();

                var databaseFileInfo = new AssetFileInfo(databasePath, MetaStateSettings._AssetManagerStartupFolder + Path.GetFileName(databasePath) + MetaStateSettings._AssetManagerVersionString + currentDataVersion.ToString(), true);

                if (currentManifest.DataVersion != currentDataVersion)
                {
                    databaseFileInfo.ForceSync = true;
                }

                allFiles.Add(databaseFileInfo);
            }
            else
            {
                currentDataVersion = currentManifest.DataVersion;
                string dbFilename = MetaStateSettings._AssetManagerStartupFolder + MetaStateSettings._DatabaseName + MetaStateSettings._AssetManagerVersionString + currentDataVersion.ToString();
                previousDbFileInfo = currentManifest.Files.Where(y => y.RelativeName == dbFilename).SingleOrDefault();

                if (previousDbFileInfo != null)
                {
                    Console.WriteLine("Will re-import " + previousDbFileInfo.RelativeName + " to manifest...");
                }
            }


            List <AssetFileInfo> allFilesToBeSynced = new List <AssetFileInfo>();

            foreach (var file in allFiles)
            {
                var cdnFile      = allCdnContent.Result.Contents.Where(y => y.Key == file.RelativeName).SingleOrDefault();
                var playFabEntry = currentManifest.GetFile(file.RelativeName);
                if (playFabEntry == null || cdnFile == null || playFabEntry.Size != file.Size || file.ForceSync)
                {
                    allFilesToBeSynced.Add(file);
                    Console.WriteLine(file.RelativeName + " must be synced.");
                }
            }

            if (allFilesToBeSynced.Count > 0)
            {
                Console.WriteLine(string.Format("{0} file(s) must be synced. Press 1 to sync, 0 to cancel:", allFilesToBeSynced.Count.ToString()));


                switch (Console.ReadKey().Key)
                {
                case ConsoleKey.D1:
                    Console.WriteLine(Environment.NewLine);
                    Console.WriteLine("Starting CDN Sync...");
                    bool hasError = false;
                    int  i        = 1;
                    foreach (var file in allFilesToBeSynced)
                    {
                        Console.WriteLine(string.Format("Uploading file {0} of {1}. ({2})", i.ToString(), allFilesToBeSynced.Count.ToString(), file.RelativeName));
                        if (!UploadFileToCDN(file.RelativeName, file.ToArray()))
                        {
                            hasError = true;
                            Console.WriteLine(string.Format("ERROR UPLOADING {0} of {1}. ({2})", i.ToString(), allFilesToBeSynced.Count.ToString(), file.RelativeName));
                            break;
                        }

                        i++;
                    }

                    if (!hasError)
                    {
                        Console.WriteLine("All files uploaded...");
                        Console.WriteLine("Creating and uploading manifest...");

                        currentManifest.ManifestVersion++;
                        currentManifest.DataVersion = currentDataVersion;
                        currentManifest.Files       = new List <AssetFileInfo>();
                        currentManifest.Files.AddRange(allFiles);

                        if (previousDbFileInfo != null)
                        {
                            currentManifest.Files.Add(previousDbFileInfo);
                        }

                        var updateData = PlayFabServerAPI.SetTitleDataAsync(new PlayFab.ServerModels.SetTitleDataRequest()
                        {
                            Key = MetaStateSettings._TitleDataKey_CdnManifest, Value = currentManifest.ToJson()
                        }).GetAwaiter().GetResult();
                        if (updateData.Error == null)
                        {
                            Console.WriteLine("Mafinest uploaded.");
                            Console.WriteLine("CDN Sync is COMPLETED.");
                        }
                        else
                        {
                            Console.WriteLine("Mafinest uploaded failed.");
                        }
                    }
                    break;
                }
            }
            else
            {
                Console.WriteLine("No files to be synced!");
            }

            //Console.WriteLine("Bruh, press any key to exit program.");
            //Console.ReadKey();
        }
コード例 #6
0
ファイル: BuildAB.cs プロジェクト: zwlstc109/ZFramework
        static void WriteData(Dictionary <string, string> resPathDic)
        {
            AssetManifest manifest = new AssetManifest();

            manifest.AssetLst = new List <AssetElement>();
            foreach (string path in resPathDic.Keys)
            {
                AssetElement element = new AssetElement();
                element.Path = path;
                //element.Crc = Crc32.GetCrc32(path);
                element.ABName    = resPathDic[path];
                element.AssetName = path.Remove(0, path.LastIndexOf("/") + 1);
                element.DependAB  = new List <string>();
                string[] resDependce = AssetDatabase.GetDependencies(path);
                for (int i = 0; i < resDependce.Length; i++)
                {
                    string tempPath = resDependce[i];

                    string abName = "";
                    if (mAllFileABNameDic.TryGetValue(tempPath, out abName))
                    {
                        if (abName == resPathDic[path])//依赖资源就在本包内 忽略   (其实就包含了过滤自己)
                        {
                            continue;
                        }

                        if (!element.DependAB.Contains(abName))
                        {
                            element.DependAB.Add(abName);
                        }
                    }
                }
                manifest.AssetLst.Add(element);
            }

            //写入xml
            string xmlPath = Application.dataPath + "/assetmanifest.xml";

            if (File.Exists(xmlPath))
            {
                File.Delete(xmlPath);
            }
            FileStream    fileStream = new FileStream(xmlPath, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);
            StreamWriter  sw         = new StreamWriter(fileStream, System.Text.Encoding.UTF8);
            XmlSerializer xs         = new XmlSerializer(manifest.GetType());

            xs.Serialize(sw, manifest);
            sw.Close();
            fileStream.Close();

            //写入二进制
            //foreach (AssetElement abBase in manifest.AssetLst)
            //{
            //    abBase.Path = "";
            //}
            FileStream fs = new FileStream(mABBinaryPath, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);

            fs.Seek(0, SeekOrigin.Begin);
            fs.SetLength(0);
            BinaryFormatter bf = new BinaryFormatter();

            bf.Serialize(fs, manifest);
            fs.Close();
            AssetDatabase.Refresh();
            setABName("assetmanifest", mABBinaryPath);
        }
コード例 #7
0
        public static void BuildAssetBundles(string inOutputDir, BuildTarget inBuildTarget)
        {
            // This will force the AssetDB to pick up any changes
            AssetDatabase.Refresh();

            List <AssetManifest.BundleInfo> bundleInfoList = new List <AssetManifest.BundleInfo>();
            List <AssetBundleBuild>         bundleList     = new List <AssetBundleBuild>();

            Dictionary <string, Bundle> dataBundles = new Dictionary <string, Bundle>();

            EditorDataUtil.ProcessAcrossAllData(info =>
            {
                string bundleName = info.Data.Name + info.Data.GetType().Name;

                List <string> guids      = new List <string>();
                List <string> assetPaths = new List <string>();

                // we always have the base bundle at index 0
                dataBundles[bundleName] = new Bundle(bundleName, guids, assetPaths);

                ExtractBundleReference(bundleName, info.Data, ref dataBundles);
            });

            foreach (KeyValuePair <string, Bundle> b in dataBundles)
            {
                Bundle currentBundle = b.Value;

                if (currentBundle.Guids.Count > 0)
                {
                    AssetBundleBuild bundle = new AssetBundleBuild
                    {
                        assetBundleName = b.Key,
                        assetNames      = currentBundle.AssetPaths.Distinct().ToArray()
                    };
                    bundleList.Add(bundle);

                    AssetManifest.BundleInfo bundleInfo = new AssetManifest.BundleInfo
                    {
                        assetNames   = bundle.assetNames,
                        guids        = currentBundle.Guids.Distinct().ToArray(),
                        name         = b.Key.ToLower(),
                        dependencies = currentBundle.Dependecies.ToArray()
                    };
                    // the files are case sensitive on the web under unix systems! Thus we use lowercase
                    bundleInfoList.Add(bundleInfo);
                }
            }

            if (!Directory.Exists(inOutputDir))
            {
                Directory.CreateDirectory(inOutputDir);
            }

            // Uncompress bundles on android are a must due to the slow IO :(
            // outside that we should always used the chunk based compression.
            BuildAssetBundleOptions options = BuildAssetBundleOptions.UncompressedAssetBundle;

            if (inBuildTarget != BuildTarget.Android)
            {
                options = BuildAssetBundleOptions.ChunkBasedCompression;
            }

            AssetBundleManifest unityManifestFile = BuildPipeline.BuildAssetBundles(inOutputDir, bundleList.ToArray(), options,
                                                                                    inBuildTarget);

            // no new bundles were generated during this build.
            if (unityManifestFile == null)
            {
                return;
            }

            string[]      files    = Directory.GetFiles(inOutputDir, "*.manifest");
            AssetManifest manifest = new AssetManifest {
                bundles = bundleInfoList.ToArray()
            };

            foreach (AssetManifest.BundleInfo bundleInfo in manifest.bundles)
            {
                string hash       = string.Empty;
                string bundlePath = files.FirstOrDefault(x => Path.GetFileNameWithoutExtension(x) == bundleInfo.name);
                if (!string.IsNullOrEmpty(bundlePath))
                {
                    hash = GetFileCRC(bundlePath);
                }

                // we use the hash included in the bundle manifest so we can then use it for versioning
                // when passing into LoadFromCacheOrDownload ?
                bundleInfo.hash = hash;
                string[] dependencies = unityManifestFile.GetAllDependencies(bundleInfo.name);

                // messy but oh well :P
                bundleInfo.dependencies = bundleInfo.dependencies.Concat(dependencies).Distinct().ToArray();
            }

            // Set some version number!
            int version = 0;

            manifest.version = version;

            Serializer.Serialize(manifest, inOutputDir + Path.DirectorySeparatorChar + "AssetManifest.xml");
        }
コード例 #8
0
 public void OnPreprocessBuild(BuildReport report)
 {
     AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
     byte[] bytes = AssetManifest.Export();
     File.WriteAllBytes($"{report.summary.outputPath}/AssetManifest", bytes);
 }