Beispiel #1
0
        public async Task <List <BaseModel> > Load(string file, string group, NFSGame game)
        {
            return(await Task.Run(() =>
            {
                List <BaseModel> results;

                using (var reader = File.OpenRead(file))
                {
                    switch (game)
                    {
                    case NFSGame.MW:
                        {
                            results = new MWFileReadContainer(new BinaryReader(reader),
                                                              file,
                                                              null).Get();

                            break;
                        }

                    case NFSGame.World:
                        {
                            results = new WorldFileReadContainer(new BinaryReader(reader),
                                                                 file,
                                                                 null).Get();

                            break;
                        }

                    default:
                        throw new InvalidOperationException($"Unsupported game: {game}");
                    }
                }

                ProcessModels(results, group);

                return results;
            }));
        }
Beispiel #2
0
        public static void Main(string[] args)
        {
            /*if (args.Length < 2)
             * {
             *  Console.WriteLine("Please provide a file path and game");
             *  return;
             * }*/

            var path = args[0];
            var game = args[1];

            // leo no touchy please
            //var path = @"D:\Games\Electronic Arts\Need for Speed Most Wanted\TRACKS\STREAML2RA.BUN";
            //var game = "mw";

            if (game != "mw" && game != "ug2" && game != "uc" && game != "world" && game != "carbon" && game != "ps")
            {
                Console.Error.WriteLine("Invalid game");
                return;
            }

            ReadContainer <List <BaseModel> > container = null;

            var readStream = new FileStream(path, FileMode.Open);

            switch (game)
            {
            case "mw":
                container = new MWFileReadContainer(
                    new BinaryReader(
                        readStream
                        ),
                    path,
                    null
                    );
                break;

            case "ug2":
                container = new UG2FileReadContainer(
                    new BinaryReader(
                        readStream
                        ),
                    path,
                    null
                    );
                break;

            case "uc":
                container = new UCFileReadContainer(
                    new BinaryReader(
                        readStream
                        ),
                    path,
                    null
                    );
                break;

            case "world":
                container = new WorldFileReadContainer(
                    new BinaryReader(
                        readStream
                        ),
                    path,
                    null
                    );
                break;

            default:
                break;
            }

            if (container == null)
            {
                return;
            }

            var stopwatch = new Stopwatch();

            stopwatch.Start();

            try
            {
                var results = container.Get();
                stopwatch.Stop();

                Console.WriteLine("Results:");
                Console.WriteLine("    Chunks read in {0} ms", stopwatch.ElapsedMilliseconds);

                ProcessResults(results, path, container.GetType());

                if (game == "world")
                {
                    var writeContainer = new WorldFileWriteContainer();
                    {
                        using (var writeStream = File.OpenWrite($"{path}_mod"))
                        {
                            foreach (var model in results)
                            {
                                if (model is TexturePack tpk)
                                {
                                    foreach (var t in tpk.Textures)
                                    {
                                        var ddsFile = $"{t.Name}.dds";

                                        if (!File.Exists(ddsFile))
                                        {
                                            continue;
                                        }

                                        Console.WriteLine($"Found DDS: {ddsFile}");

                                        using (var ddsStream = new BinaryReader(File.OpenRead(ddsFile)))
                                        {
                                            var ddsHeader = BinaryUtil.ReadStruct <DDSHeader>(ddsStream);

                                            t.DataSize = (uint)(ddsStream.BaseStream.Length - 0x80);
                                            t.Data     = ddsStream.ReadBytes((int)t.DataSize);

                                            Console.WriteLine($"DDS Data Size: {t.DataSize} - Mipmap: {ddsHeader.MipMapCount}");

                                            t.MipMap = ddsHeader.MipMapCount;
                                            t.Width  = ddsHeader.Width;
                                            t.Height = ddsHeader.Height;

                                            t.CompressionType = ddsHeader.PixelFormat.Flags >= 0x40
                                                ? 0x15
                                                : ddsHeader.PixelFormat.FourCC;

                                            //t.CompressionType = ddsHeader.PixelFormat.FourCC;
                                        }
                                    }
                                }
                            }

                            writeContainer.Write(new BinaryReader(readStream), new BinaryWriter(writeStream), results);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.Error.WriteLine("Uh oh! Error:");
                Console.Error.WriteLine($"{e}");
            }
        }