Пример #1
0
 public void TestAddAllObj()
 {
     LoadingTaskMan.DoLoadingTask($"{nameof(TestAddAllObj)}", "Loading lineup of all objects...", prog =>
     {
         ModelLineup(DbgMenus.DbgMenuItemSpawnObj.IDList, InterrootLoader.LoadModelObj, prog);
         if (InterrootLoader.Type == InterrootLoader.InterrootType.InterrootDS1)
         {
             TexturePool.AddAllExternalDS1TexturesInBackground();
         }
     });
 }
        public static void LoadMapInBackground(string mapName, bool excludeScenery, Action <ModelInstance> addMapModel)
        {
            if (Type == InterrootType.InterrootDS1)
            {
                LoadingTaskMan.DoLoadingTask($"{nameof(LoadMapInBackground)}_Models[{mapName}]", $"Loading {mapName} models...", prog =>
                {
                    LoadDS1MapInBackground(mapName, excludeScenery, addMapModel, prog);
                });
            }
            else if (Type == InterrootType.InterrootDS1R)
            {
                LoadingTaskMan.DoLoadingTask($"{nameof(LoadMapInBackground)}_Models[{mapName}]", $"Loading {mapName} models...", prog =>
                {
                    LoadDS1MapInBackground(mapName, excludeScenery, addMapModel, prog);
                });

                LoadingTaskMan.DoLoadingTask($"{nameof(LoadMapInBackground)}_Textures[{mapName}]", $"Loading {mapName} textures...", prog =>
                {
                    if (int.TryParse(mapName.Substring(1, 2), out int area))
                    {
                        TexturePool.AddMapTexBXF3(area, prog);
                    }
                });
            }
            else if (Type == InterrootType.InterrootBloodborne || Type == InterrootType.InterrootDS3)
            {
                LoadingTaskMan.DoLoadingTask($"{nameof(LoadMapInBackground)}_Models[{mapName}]", $"Loading {mapName} models...", prog =>
                {
                    LoadBBMapInBackground(mapName, excludeScenery, addMapModel, prog);
                });

                LoadingTaskMan.DoLoadingTask($"{nameof(LoadMapInBackground)}_Textures[{mapName}]", $"Loading {mapName} textures...", prog =>
                {
                    if (int.TryParse(mapName.Substring(1, 2), out int area))
                    {
                        TexturePool.AddMapTexBXF4(area, prog);
                    }
                });
            }
        }
        public void TestAddAllChr()
        {
            LoadingTaskMan.DoLoadingTask($"{nameof(TestAddAllChr)}", "Loading lineup of all characters...", prog =>
            {
                float currentX = 0;

                //TexturePool.AddChrBndsThatEndIn9();
                int i = 0;
                foreach (int ID in DbgMenus.DbgMenuItemSpawnChr.IDList)
                {
                    var newModels = AddChr(ID, new Transform(currentX, 0, 0, 0, 0, 0));
                    foreach (var mdl in newModels)
                    {
                        float thisModelWidth = new Vector3(mdl.Model.Bounds.Max.X, 0, mdl.Model.Bounds.Max.Z).Length()
                                               + new Vector3(mdl.Model.Bounds.Min.X, 0, mdl.Model.Bounds.Min.Z).Length();
                        mdl.Transform.Position.X += thisModelWidth / 2;
                        currentX += thisModelWidth;
                    }

                    prog?.Report(1.0 * (++i) / DbgMenus.DbgMenuItemSpawnChr.IDList.Count);
                }
            });
        }
 public static void LoadDragDroppedFiles(string[] fileNames)
 {
     LoadingTaskMan.DoLoadingTask("LoadDragDroppedFiles_" + DateTime.Now.Ticks, "Loading dropped models...", prog =>
     {
         var spawnTransform = GFX.World.GetSpawnPointFromMouseCursor(10.0f, false, true, true);
         int i = 0;
         foreach (var fn in fileNames)
         {
             var shortName = Path.GetFileNameWithoutExtension(fn);
             var upper     = fn.ToUpper();
             if (upper.EndsWith(".CHRBND") || upper.EndsWith(".OBJBND") || upper.EndsWith(".PARTSBND"))
             {
                 BND bnd = null;
                 lock (_lock_IO)
                 {
                     bnd = DataFile.LoadFromFile <BND>(fn);
                 }
                 TexturePool.AddTextureBnd(bnd, null);
                 var models = LoadModelsFromBnd(bnd);
                 foreach (var m in models)
                 {
                     GFX.ModelDrawer.AddModelInstance(
                         new ModelInstance(shortName, m, spawnTransform, -1, -1, -1, -1));
                 }
             }
             else if (upper.EndsWith(".FLVER") || upper.EndsWith(".FLVER.DCX"))
             {
                 var flver         = SoulsFormats.FLVER.Read(File.ReadAllBytes(fn));
                 var model         = new Model(flver);
                 var modelInstance = new ModelInstance(shortName, model, spawnTransform, -1, -1, -1, -1);
                 GFX.ModelDrawer.AddModelInstance(modelInstance);
             }
             prog?.Report(1.0 * (++i) / fileNames.Length);
         }
     });
 }
Пример #5
0
        public static void AddAllExternalDS1TexturesInBackground()
        {
            LoadingTaskMan.DoLoadingTask($"AddAllExternalDS1TexturesInBackground_UDSFM_MAP", $"Loading external map textures for DS1...", prog =>
            {
                //UDSFM MAP TEX
                var dir = InterrootLoader.GetInterrootPath(@"map\tx");
                if (Directory.Exists(dir))
                {
                    var mapTpfFileNames = Directory.GetFiles(dir);
                    int i = 0;
                    foreach (var t in mapTpfFileNames)
                    {
                        AddTpfFromPath(t);
                        prog?.Report(1.0 * (++i) / mapTpfFileNames.Length);
                    }
                }
                GFX.ModelDrawer.RequestTextureLoad();
            });

            LoadingTaskMan.DoLoadingTask($"AddAllExternalDS1TexturesInBackground_UDSFM_CHR", $"Loading external boss character textures for DS1...", prog =>
            {
                // UDSFM CHR TEX
                var udsfmTexFolderPath = InterrootLoader.GetInterrootPath($@"chr");
                if (Directory.Exists(udsfmTexFolderPath))
                {
                    var subDirectories = Directory.GetDirectories(udsfmTexFolderPath);
                    int i = 0;
                    foreach (var subDir in subDirectories)
                    {
                        var chrTpfFileNames = Directory.GetFiles(subDir, "*.tpf");
                        foreach (var t in chrTpfFileNames)
                        {
                            AddTpfFromPath(t);
                        }
                        prog?.Report(1.0 * (++i) / subDirectories.Length);
                    }
                }

                GFX.ModelDrawer.RequestTextureLoad();
            });

            LoadingTaskMan.DoLoadingTask($"AddAllExternalDS1TexturesInBackground_CHRBND_9", $"Loading external character textures for DS1...", prog =>
            {
                // CHRBND-9
                var chrbndsThatEndWith9 = Directory.GetFiles(InterrootLoader.GetInterrootPath(@"chr"), "*9.chrbnd");
                foreach (var ctew9 in chrbndsThatEndWith9)
                {
                    BND entityBnd = null;
                    lock (_lock_IO)
                    {
                        entityBnd = DataFile.LoadFromFile <BND>(ctew9);
                    }
                    AddTextureBnd(entityBnd, prog);
                }

                GFX.ModelDrawer.RequestTextureLoad();
            });

            LoadingTaskMan.DoLoadingTask($"AddAllExternalDS1TexturesInBackground_OBJBND_9", $"Loading external object textures for DS1...", prog =>
            {
                // CHRBND-9
                var chrbndsThatEndWith9 = Directory.GetFiles(InterrootLoader.GetInterrootPath(@"obj"), "*9.objbnd");
                foreach (var ctew9 in chrbndsThatEndWith9)
                {
                    BND entityBnd = null;
                    lock (_lock_IO)
                    {
                        entityBnd = DataFile.LoadFromFile <BND>(ctew9);
                    }
                    AddTextureBnd(entityBnd, prog);
                }

                GFX.ModelDrawer.RequestTextureLoad();
            });
        }