Craxic

TransistorTest

Jan 2nd, 2015
752
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. // LICENCE: A lot of this was decompiled from https://github.com/mono/MonoGame so its licened under the Microsoft Public License (Ms-PL). Everything else: http://www.wtfpl.net/txt/copying/
  2.  
  3. using System;
  4. using System.Reflection;
  5. using Microsoft.Xna.Framework;
  6. using Microsoft.Xna.Framework.Content;
  7. using System.Collections.Generic;
  8. using System.IO;
  9. using System.Runtime.InteropServices;
  10. using Microsoft.Xna.Framework.Graphics;
  11. using System.Text.RegularExpressions;
  12. using System.Diagnostics;
  13.  
  14. namespace TransistorTest
  15. {
  16.     class DDSWriter {
  17.         const uint DDSD_CAPS        = 0x1;      // Required in every .dds file.
  18.         const uint DDSD_HEIGHT      = 0x2;      // Required in every .dds file.
  19.         const uint DDSD_WIDTH       = 0x4;      // Required in every .dds file.
  20.         const uint DDSD_PITCH       = 0x8;      // Required when pitch is provided for an uncompressed texture.
  21.         const uint DDSD_PIXELFORMAT = 0x1000;   // Required in every .dds file.
  22.         const uint DDSD_MIPMAPCOUNT = 0x20000;  // Required in a mipmapped texture.
  23.         const uint DDSD_LINEARSIZE  = 0x80000;  // Required when pitch is provided for a compressed texture.
  24.         const uint DDSD_DEPTH       = 0x800000; // Required in a depth texture.
  25.  
  26.         const uint DDPF_ALPHAPIXELS = 0x1;      // Texture contains alpha data; dwRGBAlphaBitMask contains valid data.
  27.         const uint DDPF_ALPHA       = 0x2;      // Used in some older DDS files for alpha channel only uncompressed data (dwRGBBitCount contains the alpha channel bitcount; dwABitMask contains valid data)
  28.         const uint DDPF_FOURCC      = 0x4;      // Texture contains compressed RGB data; dwFourCC contains valid data.
  29.         const uint DDPF_RGB         = 0x40;     // Texture contains uncompressed RGB data; dwRGBBitCount and the RGB masks (dwRBitMask, dwGBitMask, dwBBitMask) contain valid data.
  30.         const uint DDPF_YUV         = 0x200;    // Used in some older DDS files for YUV uncompressed data (dwRGBBitCount contains the YUV bit count; dwRBitMask contains the Y mask, dwGBitMask contains the U mask, dwBBitMask contains the V mask)
  31.         const uint DDPF_LUMINANCE   = 0x20000;  // Used in some older DDS files for single channel color uncompressed data (dwRGBBitCount contains the luminance channel bit count; dwRBitMask contains the channel mask). Can be combined with DDPF_ALPHAPIXELS for a two channel DDS file.
  32.        
  33.         const uint DDSCAPS_COMPLEX  = 0x8;      // Optional; must be used on any file that contains more than one surface (a mipmap, a cubic environment map, or mipmapped volume texture).
  34.         const uint DDSCAPS_MIPMAP   = 0x400000; // Optional; should be used for a mipmap.
  35.         const uint DDSCAPS_TEXTURE  = 0x1000;   // Required
  36.         public static void WriteDDS(string filename, uint width, uint height, byte[] textureData) {
  37.             FileStream fs = new FileStream(filename, FileMode.Create);
  38.             BinaryWriter bw = new BinaryWriter(fs);
  39.  
  40.             uint dwPitchOrLinearSize = 0x4000;
  41.  
  42.             bw.Write((uint)0x20534444); // dwMagic = 'DDS '
  43.             bw.Write((uint)124); // header.dwSize = 124
  44.             bw.Write(DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_MIPMAPCOUNT | DDSD_LINEARSIZE); // header.dwFlags
  45.             bw.Write(height); // header.dwHeight
  46.             bw.Write(width); // header.dwWidth
  47.             bw.Write(dwPitchOrLinearSize); // header.dwPitchOrLinearSize
  48.             bw.Write((uint)0); // header.dwDepth
  49.             bw.Write((uint)0); // header.dwMipMapCount
  50.             // header.dwReserved1[11]
  51.             for (int i = 0; i < 11; i++) {
  52.                 bw.Write((uint)0);
  53.             }
  54.  
  55.             bw.Write((uint)32); // header.ddspf.dwSize
  56.             bw.Write(DDPF_FOURCC); // header.ddspf.dwFlags
  57.             bw.Write(System.Text.ASCIIEncoding.ASCII.GetBytes("DXT5")); // header.ddspf.dwFourCC
  58.             bw.Write((uint)0); // header.ddspf.dwRGBBitCount
  59.             bw.Write((uint)0x00000000); // header.ddspf.dwRBitMask
  60.             bw.Write((uint)0x00000000); // header.ddspf.dwGBitMask
  61.             bw.Write((uint)0x00000000); // header.ddspf.dwBBitMask
  62.             bw.Write((uint)0x00000000); // header.ddspf.dwABitMask
  63.            
  64.             bw.Write(DDSCAPS_TEXTURE); // header.ddspf.dwCaps
  65.             bw.Write((uint)0); // header.ddspf.dwCaps2
  66.             bw.Write((uint)0); // header.ddspf.dwCaps3
  67.             bw.Write((uint)0); // header.ddspf.dwCaps4
  68.             bw.Write((uint)0); // header.ddspf.dwReserved2
  69.            
  70.             //bw.Write((uint)0); // header.ddspf.bdata
  71.             //bw.Write((uint)0); // header.ddspf.bdata2
  72.  
  73.             //bw.Write((uint)0xFFFFFFFF);
  74.             bw.Write(textureData);
  75.         }
  76.     }
  77.  
  78.     abstract class  ContentTypeReader {
  79.         public abstract object Read(BinaryReader reader, string file);
  80.     }
  81.  
  82.     class RippedTexture2D : Texture2D {
  83.         public RippedTexture2D() : base() {
  84.  
  85.         }
  86.     }
  87.  
  88.     class Texture2DRipperReader : ContentTypeReader {
  89.         public override object Read(BinaryReader reader, string file)
  90.         {
  91.             SurfaceFormat pixelFormat = (SurfaceFormat)reader.ReadInt32();
  92.             int width = reader.ReadInt32();
  93.             int height = reader.ReadInt32();
  94.             reader.ReadInt32();
  95.             int num = reader.ReadInt32();
  96.             byte[] array = new byte[num];
  97.             int num2 = reader.Read(array, 0, num);
  98.  
  99.             string outfbland = MainClass.OUT_DIR + file.Replace("\\","/").Replace(":","");
  100.             string outf = outfbland + "." + width + "." + height + "." + pixelFormat.ToString();
  101.             System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(outf));
  102.             System.IO.File.WriteAllBytes(outf, array);
  103.  
  104.             if (pixelFormat == SurfaceFormat.Dxt5) {
  105.                 DDSWriter.WriteDDS(outfbland + ".dds", (uint)width, (uint)height, array);
  106.                 Console.WriteLine("Ripped: " + outfbland + ".dds");
  107.             } else if (pixelFormat == SurfaceFormat.Color) {
  108.                 var bitmap = new System.Drawing.Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
  109.                 var locked = bitmap.LockBits(new System.Drawing.Rectangle(0, 0, width, height), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
  110.                 if (array.Length != width * height * 4)
  111.                     throw new Exception();
  112.                 unsafe {
  113.                     byte* bytes = (byte*)locked.Scan0;
  114.                     for (int i=0; i<width * height * 4; i++) {
  115.                         bytes[i] = array[i];
  116.                     }
  117.                 }
  118.                 bitmap.UnlockBits(locked);
  119.                 bitmap.Save(outfbland + ".png");
  120.                 Console.WriteLine("Ripped: " + outfbland + ".png");
  121.             } else {
  122.                 Console.WriteLine("!!!FAILED!!!: " + pixelFormat + "");
  123.                 throw new Exception();
  124.             }
  125.  
  126.             return new RippedTexture2D();
  127.         }
  128.     }
  129.  
  130.     public sealed class ContentTypeReaderManager
  131.     {
  132.         //
  133.         // Fields
  134.         //
  135.         private ContentReader _reader;
  136.         private ContentTypeReader[] contentReaders;
  137.         //
  138.         // Constructors
  139.         //
  140.         public ContentTypeReaderManager(ContentReader reader)
  141.         {
  142.             this._reader = reader;
  143.         }
  144.         internal ContentTypeReader[] LoadAssetReaders()
  145.         {
  146.             int num = this._reader.Read7BitEncodedInt();
  147.             this.contentReaders = new ContentTypeReader[num];
  148.             for (int i = 0; i < num; i++)
  149.             {
  150.                 string text = this._reader.ReadString();
  151.                 if (text == "Microsoft.Xna.Framework.Content.Texture2DReader")
  152.                     this.contentReaders[i] = new Texture2DRipperReader();
  153.                 else
  154.                     throw new Exception();
  155.                 int num2 = this._reader.ReadInt32();
  156.             }
  157.             return this.contentReaders;
  158.         }
  159.     }
  160.  
  161.     public sealed class ContentReader : BinaryReader
  162.     {
  163.         //
  164.         // Fields
  165.         //
  166.         private ContentManager contentManager;
  167.         private ContentTypeReader[] typeReaders;
  168.         private List<KeyValuePair<int, Action<object>>> sharedResourceFixups;
  169.         private string assetName;
  170.         private GraphicsDevice graphicsDevice;
  171.         private ContentTypeReaderManager typeReaderManager;
  172.         //
  173.         // Properties
  174.         //
  175.         public string AssetName
  176.         {
  177.             get
  178.             {
  179.                 return this.assetName;
  180.             }
  181.         }
  182.         public ContentManager ContentManager
  183.         {
  184.             get
  185.             {
  186.                 return this.contentManager;
  187.             }
  188.         }
  189.         internal GraphicsDevice GraphicsDevice
  190.         {
  191.             get
  192.             {
  193.                 return this.graphicsDevice;
  194.             }
  195.         }
  196.         internal ContentTypeReader[] TypeReaders
  197.         {
  198.             get
  199.             {
  200.                 return this.typeReaders;
  201.             }
  202.         }
  203.         //
  204.         // Constructors
  205.         //
  206.         internal ContentReader(ContentManager manager, Stream stream, GraphicsDevice graphicsDevice, string assetName) : base(stream)
  207.         {
  208.             this.graphicsDevice = graphicsDevice;
  209.             this.contentManager = manager;
  210.             this.assetName = assetName;
  211.         }
  212.         //
  213.         // Methods
  214.         //
  215.         internal object ReadAsset<T>(string file) where T : class
  216.         {
  217.             object result = null;
  218.             this.typeReaderManager = new ContentTypeReaderManager(this);
  219.             this.typeReaders = this.typeReaderManager.LoadAssetReaders();
  220.             ContentTypeReader[] array = this.typeReaders;
  221.             //for (int i = 0; i < array.Length; i++)
  222.             //{
  223.                 //ContentTypeReader contentTypeReader = array[i];
  224.                 //contentTypeReader.Initialize(this.typeReaderManager);
  225.             //}
  226.             int num = base.Read7BitEncodedInt();
  227.             this.sharedResourceFixups = new List<KeyValuePair<int, Action<object>>>();
  228.             int num2 = base.Read7BitEncodedInt();
  229.             if (num2 > 0)
  230.             {
  231.                 result = this.typeReaders[num2 - 1].Read(this, file);
  232.             }
  233.             if (num > 0)
  234.             {
  235.                 this.ReadSharedResources(num);
  236.             }
  237.             return result;
  238.         }
  239.  
  240.         private void ReadSharedResources(int sharedResourceCount)
  241.         {
  242.             /*object[] array = new object[sharedResourceCount];
  243.             for (int i = 0; i < sharedResourceCount; i++)
  244.             {
  245.                 int num = base.Read7BitEncodedInt();
  246.                 if (num > 0)
  247.                 {
  248.                     ContentTypeReader typeReader = this.typeReaders[num - 1];
  249.                     array[i] = this.ReadObject<object>(typeReader);
  250.                 }
  251.                 else
  252.                 {
  253.                     array[i] = null;
  254.                 }
  255.             }
  256.             foreach (KeyValuePair<int, Action<object>> current in this.sharedResourceFixups)
  257.             {
  258.                 current.Value(array[current.Key]);
  259.             }*/
  260.             throw new Exception("STUB");
  261.         }
  262.     }
  263.  
  264.     class ExtractorGameAssetManager : GSGE.GameAssetManager {
  265.         public ExtractorGameAssetManager(Game game, IServiceProvider serviceProvider, string rootDirectory, string packageDirectory)
  266.             : base(game, serviceProvider, rootDirectory, packageDirectory)
  267.         {
  268.         }
  269.  
  270.         protected new T ReadAsset<T>(string assetName, Action<IDisposable> recordDisposableObject, object existingPrimaryObject = null) where T : class
  271.         {
  272.             if (string.IsNullOrEmpty(assetName))
  273.             {
  274.                 throw new ArgumentNullException("assetName");
  275.             }
  276.             object obj = null;
  277.             using (Stream stream = this.OpenStream(assetName))
  278.             {
  279.                 using (BinaryReader binaryReader = new BinaryReader(stream))
  280.                 {
  281.                     byte b = binaryReader.ReadByte();
  282.                     byte b2 = binaryReader.ReadByte();
  283.                     byte b3 = binaryReader.ReadByte();
  284.                     byte b4 = binaryReader.ReadByte();
  285.                     if (b != 88 || b2 != 78 || b3 != 66 || (b4 != 119 && b4 != 120 && b4 != 109 && b4 != 112))
  286.                     {
  287.                         throw new ContentLoadException("Asset does not appear to be a valid XNB file. Did you process your content for Windows?");
  288.                     }
  289.                     byte b5 = binaryReader.ReadByte();
  290.                     byte b6 = binaryReader.ReadByte();
  291.                     bool flag = (b6 & 128) != 0;
  292.                     if (b5 != 5 && b5 != 4)
  293.                     {
  294.                         throw new ContentLoadException("Invalid XNB version");
  295.                     }
  296.                     int num = binaryReader.ReadInt32();
  297.                     ContentReader contentReader;
  298.                     if (flag)
  299.                     {
  300.                         LzxDecoder lzxDecoder = new LzxDecoder(16);
  301.                         int num2 = num - 14;
  302.                         int num3 = binaryReader.ReadInt32();
  303.                         int num4 = num3 + 10;
  304.                         MemoryStream memoryStream = new MemoryStream(num3);
  305.                         int num5 = 0;
  306.                         int i = 0;
  307.                         while (i < num2)
  308.                         {
  309.                             stream.Seek((long)(i + 14), SeekOrigin.Begin);
  310.                             int num6 = stream.ReadByte();
  311.                             int num7 = stream.ReadByte();
  312.                             int num8 = num6 << 8 | num7;
  313.                             int num9 = 32768;
  314.                             if (num6 == 255)
  315.                             {
  316.                                 num6 = num7;
  317.                                 num7 = (int)((byte)stream.ReadByte());
  318.                                 num9 = (num6 << 8 | num7);
  319.                                 num6 = (int)((byte)stream.ReadByte());
  320.                                 num7 = (int)((byte)stream.ReadByte());
  321.                                 num8 = (num6 << 8 | num7);
  322.                                 i += 5;
  323.                             }
  324.                             else
  325.                             {
  326.                                 i += 2;
  327.                             }
  328.                             if (num8 == 0 || num9 == 0)
  329.                             {
  330.                                 break;
  331.                             }
  332.                             int num10 = lzxDecoder.Decompress(stream, num8, memoryStream, num9);
  333.                             i += num8;
  334.                             num5 += num9;
  335.                         }
  336.                         if (memoryStream.Position != (long)num3)
  337.                         {
  338.                             throw new ContentLoadException("Decompression of " + assetName + "failed.  Try decompressing with nativeDecompressXnb first.");
  339.                         }
  340.                         memoryStream.Seek(0L, SeekOrigin.Begin);
  341.                         contentReader = new ContentReader(this, memoryStream, null, assetName);
  342.                     }
  343.                     else
  344.                     {
  345.                         Console.WriteLine("Reading: " + assetName + ".dds");
  346.                         contentReader = new ContentReader(this, stream, null, assetName);
  347.                     }
  348.  
  349.                     using (contentReader)
  350.                     {
  351.                         obj = contentReader.ReadAsset<T>(assetName);
  352.                     }
  353.                 }
  354.             }
  355.             return (T)((object)obj);
  356.         }
  357.  
  358.         public override T Load<T>(string assetName)
  359.         {
  360.             object _loadLock
  361.                 = MainClass.GetInstanceField(typeof(GSGE.GameAssetManager), this, "_loadLock");
  362.             Dictionary<string, object> _loadedAssets
  363.                 = MainClass.GetInstanceField(typeof(GSGE.GameAssetManager), this, "_loadedAssets") as Dictionary<string, object>;
  364.  
  365.             object asset = null;
  366.             string name = ContentManager.CleanPath(assetName);
  367.             T result;
  368.             lock (_loadLock)
  369.             {
  370.                 if (_loadedAssets.TryGetValue(name, out asset))
  371.                 {
  372.                     result = (T)((object)asset);
  373.                     return result;
  374.                 }
  375.             }
  376.             asset = this.ReadAsset<T>(name, null, null);
  377.             lock (_loadLock)
  378.             {
  379.                 _loadedAssets[name] = asset;
  380.             }
  381.             result = (T)((object)asset);
  382.             return result;
  383.         }
  384.     }
  385.  
  386.     class MainClass
  387.     {
  388.         public const string OUT_DIR = "/home/matthew/Documents/TransistorUnpacked/";
  389.  
  390.         /// <summary>
  391.         /// Uses reflection to get the field value from an object.
  392.         /// </summary>
  393.         ///
  394.         /// <param name="type">The instance type.</param>
  395.         /// <param name="instance">The instance object.</param>
  396.         /// <param name="fieldName">The field's name which is to be fetched.</param>
  397.         ///
  398.         /// <returns>The field value from the object.</returns>
  399.         internal static object GetInstanceField(Type type, object instance, string fieldName)
  400.         {
  401.             BindingFlags bindFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
  402.                 | BindingFlags.Static;
  403.             FieldInfo field = type.GetField(fieldName, bindFlags);
  404.             return field.GetValue(instance);
  405.         }
  406.  
  407.         public static void Main(string[] args)
  408.         {
  409.             Directory.Delete(OUT_DIR, true);
  410.             Directory.CreateDirectory(OUT_DIR);
  411.  
  412.             var game = new Game();
  413.             {
  414.                 GSGE.TextureHandleManager.Init(16384);
  415.                 ExtractorGameAssetManager gameAssetManager = new ExtractorGameAssetManager(null, game.Services, "Content", "Win\\Packages");
  416.                 GSGE.AssetManager.Initialize(gameAssetManager);
  417.             }
  418.             {
  419.                 var files = Directory.EnumerateFiles("Content/Win/Packages/", "*.pkg", SearchOption.TopDirectoryOnly);
  420.                 List<string> list = new List<string>();
  421.                 foreach (string f in files) {
  422.                     if (f.EndsWith(".pkg")) {
  423.                         list.Add(f.Substring(0, f.Length - 4));
  424.                     }
  425.                 }
  426.  
  427.                 var files2 = Directory.EnumerateFiles("Content/Win/Packages/720p/", "*.pkg", SearchOption.TopDirectoryOnly);
  428.                 List<string> list2 = new List<string>();
  429.                 foreach (string f in files2) {
  430.                     if (f.EndsWith(".pkg")) {
  431.                         list2.Add(f.Substring(0, f.Length - 4));
  432.                     }
  433.                 }
  434.  
  435.                 foreach (var f in list) {
  436.                     list2.Remove(f.Replace("Content/Win/Packages/", "Content/Win/Packages/720p/"));
  437.                 }
  438.                
  439.                 foreach (var f in list) {
  440.                     var f2 = f.Replace("Content/Win/Packages/", "");
  441.                     Console.WriteLine("Loading Package: " + f2);
  442.                     GSGE.AssetManager.LoadPackage(f2, GSGE.PackageGroup.Base);
  443.                 }
  444.             }
  445.  
  446.         }
  447.     }
  448. }
RAW Paste Data

Adblocker detected! Please consider disabling it...

We've detected AdBlock Plus or some other adblocking software preventing Pastebin.com from fully loading.

We don't have any obnoxious sound, or popup ads, we actively block these annoying types of ads!

Please add Pastebin.com to your ad blocker whitelist or disable your adblocking software.

×