private void AddObjectDirectory(
            IModelDirectory <GloModelFileBundle> parentNode,
            IFileHierarchy gloverFileHierarchy,
            IFileHierarchyDirectory objectDirectory)
        {
            var objectFiles = objectDirectory.FilesWithExtension(".glo");

            var gloverSteamDirectory = gloverFileHierarchy.Root;
            var textureDirectories   = gloverSteamDirectory
                                       .TryToGetSubdir("data/textures/generic")
                                       .Subdirs.ToList();

            try {
                var levelTextureDirectory = gloverSteamDirectory.TryToGetSubdir(
                    objectDirectory.LocalPath.Replace("data\\objects",
                                                      "data\\textures"));
                textureDirectories.Add(levelTextureDirectory);
                textureDirectories.AddRange(levelTextureDirectory.Subdirs);
            } catch (Exception e) {
                ;
            }

            foreach (var objectFile in objectFiles)
            {
                parentNode.AddFileBundle(
                    new GloModelFileBundle(objectFile, textureDirectories));
            }
        }
        private void ExtractFromDriverDirectory_(
            IModelDirectory <BmdModelFileBundle> node,
            IFileHierarchyDirectory directory)
        {
            var bmdFiles = directory.FilesWithExtension(".bmd")
                           .ToArray();
            var bcxFiles = directory.FilesWithExtensions(".bca", ".bck")
                           .ToArray();

            var driverBmdFiles = bmdFiles
                                 .Where(file => file.Name.StartsWith("driver"))
                                 .ToArray();
            var driverBcxFiles =
                bcxFiles.Where(file => file.Name.StartsWith("b_") ||
                               file.Name.StartsWith("c_") ||
                               file.Name.StartsWith("all"))
                .ToArray();

            this.ExtractModels_(node,
                                driverBmdFiles,
                                driverBcxFiles);

            var otherBmdFiles = bmdFiles.Where(file => !driverBmdFiles.Contains(file))
                                .ToArray();

            if (otherBmdFiles.Length > 0)
            {
                var otherBcxFiles =
                    bcxFiles.Where(file => !driverBcxFiles.Contains(file))
                    .ToArray();
                this.ExtractModels_(node,
                                    otherBmdFiles,
                                    otherBcxFiles);
            }
        }
        public void ExtractModel_(
            IModelDirectory <CmbModelFileBundle> parentNode,
            IFileHierarchyDirectory subdir)
        {
            var cmbFiles = subdir.FilesWithExtension(".cmb").ToArray();

            if (cmbFiles.Length == 0)
            {
                return;
            }

            var csabFiles = subdir.FilesWithExtension(".csab").ToArray();
            var ctxbFiles = subdir.FilesWithExtension(".ctxb").ToArray();
            var shpaFiles = subdir.FilesWithExtension(".shpa").ToArray();

            try {
                var bundles =
                    this.separator_.Separate(subdir, cmbFiles, csabFiles);

                foreach (var bundle in bundles)
                {
                    parentNode.AddFileBundle(new CmbModelFileBundle(
                                                 bundle.ModelFile,
                                                 bundle.AnimationFiles.ToArray(),
                                                 ctxbFiles,
                                                 shpaFiles
                                                 ));
                }
            } catch { }
        }
 private void ExtractObjects_(IFileHierarchyDirectory directory)
 {
     foreach (var subdir in directory.Subdirs)
     {
         this.ExtractObject_(subdir);
     }
 }
Exemple #5
0
        private void ExtractModelsInDirectoryAutomatically_(
            IModelDirectory <BmdModelFileBundle> parentNode,
            IFileHierarchyDirectory directory)
        {
            var bmdFiles = directory.FilesWithExtension(".bmd").ToArray();

            if (bmdFiles.Length > 0)
            {
                var bcxFiles = directory.FilesWithExtensions(".bca", ".bck")
                               .ToList();
                var btiFiles = directory.FilesWithExtension(".bti").ToList();
                this.ExtractModels_(parentNode, bmdFiles, bcxFiles, btiFiles);
            }
        }
 public static void LogExtracting <T>(
     ILogger logger,
     IFileHierarchyDirectory directory,
     IReadOnlyList <T> rawModels)
 {
     if (rawModels.Count == 1)
     {
         LogExtracting(logger, rawModels[0]);
     }
     else
     {
         logger.LogInformation(
             $"Extracting models from {directory.LocalPath}");
     }
 }
 public static void LogAlreadyProcessed <T>(
     ILogger logger,
     IFileHierarchyDirectory directory,
     IReadOnlyList <T> rawModels)
 {
     if (rawModels.Count == 1)
     {
         LogAlreadyProcessed(logger, rawModels[0]);
     }
     else
     {
         logger.LogInformation(
             $"Already processed models from {directory.LocalPath}");
     }
 }
        private void ExtractFromSeparateDriverDirectories_(
            IModelDirectory <BmdModelFileBundle> node,
            IFileHierarchyDirectory directory,
            IFileHierarchyDirectory common)
        {
            Asserts.Nonnull(common);

            var bmdFiles = directory.FilesWithExtension(".bmd")
                           .ToArray();
            var commonBcxFiles = common.FilesWithExtensions(".bca", ".bck")
                                 .ToArray();
            var localBcxFiles = directory.FilesWithExtensions(".bca", ".bck")
                                .ToArray();

            this.ExtractModels_(node,
                                bmdFiles,
                                commonBcxFiles.Concat(localBcxFiles).ToArray());
        }
Exemple #9
0
        private void ExtractPrimaryAndSecondaryModels_(
            IModelDirectory <BmdModelFileBundle> node,
            IFileHierarchyDirectory directory,
            Func <IFileHierarchyFile, bool> primaryIdentifier
            )
        {
            var bmdFiles = directory.Files.Where(
                file => file.Extension == ".bmd")
                           .ToArray();
            var bcxFiles = directory
                           .Files.Where(
                file => file.Extension == ".bck" ||
                file.Extension == ".bca")
                           .ToArray();

            this.ExtractPrimaryAndSecondaryModels_(node,
                                                   primaryIdentifier,
                                                   bmdFiles,
                                                   bcxFiles);
        }
        private void ExtractFilesByOrganizing_(
            IFileHierarchyDirectory directory,
            IList <IFileHierarchyFile> bmdFiles,
            IList <IFileHierarchyFile> bckFiles,
            IOrganizeMethod organizeMethod)
        {
            if (organizeMethod is PrefixOrganizeMethod)
            {
                bmdFiles.OrderByDescending(
                    file => StringUtil
                    .UpTo(file.NameWithoutExtension, "_")
                    .Length);
            }

            var unclaimedBckFiles = new HashSet <IFileHierarchyFile>(bckFiles);

            var bmdFileToBckFiles =
                new Dictionary <IFileHierarchyFile, IList <IFileHierarchyFile> >();

            foreach (var bmdFile in bmdFiles)
            {
                var claimedBckFiles = organizeMethod.GetBcksForBmd(bmdFile, bckFiles);
                bmdFileToBckFiles[bmdFile] = claimedBckFiles;

                foreach (var bckFile in claimedBckFiles)
                {
                    unclaimedBckFiles.Remove(bckFile);
                }
            }

            Asserts.Equal(0, unclaimedBckFiles.Count);

            foreach (var(bmdFile, claimedBckFiles) in bmdFileToBckFiles)
            {
                this.ExtractModels_(directory,
                                    new[] { bmdFile },
                                    claimedBckFiles.Select(file => file.Impl)
                                    .ToArray());
            }
        }
Exemple #11
0
        private void ExtractFromSeparateDirectories_(
            IModelDirectory <BmdModelFileBundle> node,
            IFileHierarchyDirectory directory,
            IFileHierarchyDirectory common)
        {
            Asserts.Nonnull(common);

            var bmdFiles = directory.FilesWithExtension(".bmd")
                           .ToArray();
            var commonBcxFiles = common.FilesWithExtensions(".bca", ".bck")
                                 .ToArray();
            var commonBtiFiles = common.FilesWithExtension(".bti")
                                 .ToArray();

            var localBcxFiles = directory.FilesWithExtensions(".bca", ".bck")
                                .ToArray();

            if (bmdFiles.Length == 1)
            {
                this.ExtractModels_(node,
                                    bmdFiles,
                                    commonBcxFiles.Concat(localBcxFiles).ToArray(),
                                    commonBtiFiles);
                return;
            }

            try {
                Asserts.True(localBcxFiles.Length == 0);

                this.ExtractPrimaryAndSecondaryModels_(
                    node,
                    bmdFile => bmdFile.Name.StartsWith(
                        "default"),
                    bmdFiles,
                    commonBcxFiles);
            } catch {
                ;
            }
        }
Exemple #12
0
        private void ExtractModelsAndAnimationsFromSceneObject_(
            IModelDirectory <BmdModelFileBundle> node,
            IFileHierarchyDirectory directory)
        {
            var bmdFiles = directory.Files.Where(
                file => file.Extension == ".bmd")
                           .OrderByDescending(file => file.Name.Length)
                           .ToArray();

            var allBcxFiles = directory
                              .Files.Where(
                file => file.Extension == ".bck" ||
                file.Extension == ".bca")
                              .ToArray();

            var specialCase = false;

            if (allBcxFiles.Length == 1 &&
                allBcxFiles[0].Name == "fish_swim.bck" &&
                bmdFiles.All(file => file.Name.StartsWith("fish")))
            {
                specialCase = true;
            }
            if (allBcxFiles.Length == 1 &&
                allBcxFiles[0].Name == "butterfly_fly.bck" &&
                bmdFiles.All(file => file.Name.StartsWith("butterfly")))
            {
                specialCase = true;
            }
            if (allBcxFiles.All(file => file.Name.StartsWith("popo_")) &&
                bmdFiles.All(file => file.Name.StartsWith("popo")))
            {
                specialCase = true;
            }

            // If there is only one model or 0 animations, it's easy to tell which
            // animations go with which model.
            if (bmdFiles.Length == 1 || allBcxFiles.Length == 0 || specialCase)
            {
                foreach (var bmdFile in bmdFiles)
                {
                    this.ExtractModels_(node,
                                        new[] {
                        bmdFile
                    },
                                        allBcxFiles);
                }
                return;
            }

            if (directory.Name == "montemcommon" ||
                directory.Name == "montewcommon")
            {
                foreach (var bmdFile in bmdFiles)
                {
                    this.ExtractModels_(node,
                                        new[] {
                        bmdFile
                    });
                }
                return;
            }

            var unclaimedBcxFiles = allBcxFiles.ToHashSet();
            var bmdAndBcxFiles    = new Dictionary <IFileHierarchyFile, IFileHierarchyFile[]>();

            foreach (var bmdFile in bmdFiles)
            {
                var prefix = bmdFile.Name;
                prefix = prefix.Substring(0, prefix.Length - ".bmd".Length);

                // Blegh. These special cases are gross.
                {
                    var modelIndex = prefix.IndexOf("_model");
                    if (modelIndex != -1)
                    {
                        prefix = prefix.Substring(0, modelIndex);
                    }

                    var bodyIndex = prefix.IndexOf("_body");
                    if (bodyIndex != -1)
                    {
                        prefix = prefix.Substring(0, bodyIndex);
                    }

                    prefix = prefix.Replace("peach_hair_ponytail", "peach_hair_pony");
                    prefix = prefix.Replace("eggyoshi_normal", "eggyoshi");
                }

                var claimedBcxFiles = unclaimedBcxFiles
                                      .Where(bcxFile => bcxFile.Name.StartsWith(prefix))
                                      .ToArray();

                foreach (var claimedBcxFile in claimedBcxFiles)
                {
                    unclaimedBcxFiles.Remove(claimedBcxFile);
                }

                bmdAndBcxFiles[bmdFile] = claimedBcxFiles;
            }
            //Asserts.True(unclaimedBcxFiles.Count == 0);
            foreach (var(bmdFile, bcxFiles) in bmdAndBcxFiles)
            {
                this.ExtractModels_(node, new[] { bmdFile }, bcxFiles);
            }
        }
        private void ExtractModelsAndAnimationsFromSceneObject_(
            IModelDirectory <BmdModelFileBundle> node,
            IFileHierarchyDirectory directory)
        {
            var bmdFiles = directory.Files.Where(
                file => file.Extension == ".bmd")
                           .OrderByDescending(file => file.Name.Length)
                           .ToArray();
            var allBcxFiles = directory
                              .Files.Where(
                file => file.Extension == ".bck" ||
                file.Extension == ".bca")
                              .ToArray();
            var btiFiles = directory.FilesWithExtension(".bti")
                           .ToArray();

            // If there is only one model or 0 animations, it's easy to tell which
            // animations go with which model.
            if (bmdFiles.Length == 1 || allBcxFiles.Length == 0)
            {
                foreach (var bmdFile in bmdFiles)
                {
                    this.ExtractModels_(node,
                                        new[] {
                        bmdFile
                    },
                                        allBcxFiles,
                                        btiFiles);
                }
                return;
            }

            var unclaimedBcxFiles = allBcxFiles.ToHashSet();
            var bmdAndBcxFiles    = new Dictionary <IFileHierarchyFile, IFileHierarchyFile[]>();

            foreach (var bmdFile in bmdFiles)
            {
                var prefix = bmdFile.Name;
                prefix = prefix.Substring(0, prefix.Length - ".bmd".Length);

                // Blegh. These special cases are gross.
                {
                    var modelIndex = prefix.IndexOf("_model");
                    if (modelIndex != -1)
                    {
                        prefix = prefix.Substring(0, modelIndex);
                    }

                    var babyIndex = prefix.IndexOf("_body");
                    if (babyIndex != -1)
                    {
                        prefix = prefix.Substring(0, babyIndex);
                    }

                    // TODO: Fix animations shared by piantas
                }

                var claimedBcxFiles = unclaimedBcxFiles
                                      .Where(bcxFile => bcxFile.Name.StartsWith(prefix))
                                      .ToArray();

                foreach (var claimedBcxFile in claimedBcxFiles)
                {
                    unclaimedBcxFiles.Remove(claimedBcxFile);
                }

                bmdAndBcxFiles[bmdFile] = claimedBcxFiles;
            }
            Asserts.True(unclaimedBcxFiles.Count == 0);
            foreach (var(bmdFile, bcxFiles) in bmdAndBcxFiles)
            {
                this.ExtractModels_(node, new[] { bmdFile }, bcxFiles, btiFiles);
            }
        }
        private void ExtractModels_(
            IFileHierarchyDirectory directory,
            IReadOnlyList <IFileHierarchyFile> bmdFiles,
            IReadOnlyList <IFile>?bcxFiles   = null,
            IReadOnlyList <IFile>?btiFiles   = null,
            bool allowMultipleAnimatedModels = false
            )
        {
            Asserts.True(bmdFiles.Count > 0);

            var outputDirectory =
                GameFileHierarchyUtil.GetOutputDirectoryForDirectory(directory);

            var matches            = 0;
            var existingModelFiles =
                outputDirectory.GetExistingFiles()
                .Where(file => file.Extension == ".fbx" ||
                       file.Extension == ".glb")
                .ToArray();

            foreach (var bmdFile in bmdFiles)
            {
                if (existingModelFiles.Any(
                        existingModelFile => {
                    var existingName = existingModelFile.Name.Substring(
                        0,
                        existingModelFile.Name.Length -
                        existingModelFile.Extension.Length);
                    var bmdName =
                        bmdFile.Name.Substring(0,
                                               bmdFile.Name.Length -
                                               ".mod".Length);

                    return(bmdName == existingName ||
                           bmdName + "_gltf" == existingName);
                }))
                {
                    ++matches;
                }
            }

            if (matches == bmdFiles.Count)
            {
                this.logger_.LogInformation(
                    $"Model(s) already processed from {directory.LocalPath}");
                return;
            }

            bcxFiles ??= new List <IFile>();
            btiFiles ??= new List <IFile>();

            if (bmdFiles.Count == 1)
            {
                MessageUtil.LogExtracting(this.logger_, bmdFiles[0]);
            }
            else
            {
                MessageUtil.LogExtracting(this.logger_, directory, bmdFiles);
            }

            try {
                /*new ManualBmd2FbxApi().Process(outputDirectory,
                 *                             bmdFiles.Select(file => file.FullName)
                 *                                     .ToArray(),
                 *                             bcxFiles.Select(file => file.FullName)
                 *                                     .ToArray(),
                 *                             btiFiles.Select(file => file.FullName)
                 *                                     .ToArray(),
                 *                             !allowMultipleAnimatedModels,
                 *                             60);*/
            } catch (Exception e) {
                this.logger_.LogError(e.ToString());
            }
            this.logger_.LogInformation(" ");
        }
        private void ExtractObject_(IFileHierarchyDirectory directory)
        {
            // TODO: What the heck is the difference between these directories?
            // Is there any besides the model type within?
            var bdlSubdir =
                directory.Subdirs.SingleOrDefault(subdir => subdir.Name == "bdl");
            var bdlmSubdir =
                directory.Subdirs.SingleOrDefault(subdir => subdir.Name == "bdlm");
            var bmdSubdir =
                directory.Subdirs.SingleOrDefault(subdir => subdir.Name == "bmd");
            var bmdcSubdir =
                directory.Subdirs.SingleOrDefault(subdir => subdir.Name == "bmdc");
            var bmdmSubdir =
                directory.Subdirs.SingleOrDefault(subdir => subdir.Name == "bmdm");

            var bmdOrBdlFiles = ListUtil.ReadonlyConcat(
                //bdlSubdir?.FilesWithExtension(".bdl").ToArray(),
                //bdlmSubdir?.FilesWithExtension(".bdl").ToArray(),
                bmdSubdir?.FilesWithExtension(".bmd").ToArray(),
                bmdcSubdir?.FilesWithExtension(".bmd").ToArray(),
                bmdmSubdir?.FilesWithExtension(".bmd").ToArray());

            var bckSubdir =
                directory.Subdirs.SingleOrDefault(
                    subdir => subdir.Name == "bck" || subdir.Name == "bcks");
            var bckFiles = bckSubdir?.FilesWithExtension(".bck").ToList();

            if (bmdOrBdlFiles.Count == 1 ||
                (bckFiles == null && bmdOrBdlFiles.Count > 0))
            {
                this.ExtractModels_(directory,
                                    bmdOrBdlFiles,
                                    bckFiles?
                                    .Select(file => file.Impl)
                                    .ToArray());
            }
            else if (bmdOrBdlFiles.Count > 0)
            {
                IOrganizeMethod organizeMethod;
                switch (directory.Name)
                {
                case "Sh": {
                        organizeMethod = new SuffixOrganizeMethod(1);
                        break;
                }

                case "Oq": {
                    organizeMethod = new NameMatchOrganizeMethod(directory.Name);
                    break;
                }

                case "Ylesr00": {
                    organizeMethod = new PrefixOrganizeMethod();
                    break;
                }

                default:
                    throw new NotImplementedException();
                }

                this.ExtractFilesByOrganizing_(directory,
                                               bmdOrBdlFiles.ToArray(),
                                               bckFiles,
                                               organizeMethod);
            }
        }