diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..a55c0b0
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "PhotoShopFileType/PSDModule"]
+	path = PhotoShopFileType/PSDModule
+	url = https://github.com/ChemiKhazi/UnityPSDImporterModule.git
diff --git a/Documentation/Group-Selection.png b/Documentation/Group-Selection.png
new file mode 100644
index 0000000..3441b68
Binary files /dev/null and b/Documentation/Group-Selection.png differ
diff --git a/Documentation/Import-Settings.png b/Documentation/Import-Settings.png
new file mode 100644
index 0000000..3652794
Binary files /dev/null and b/Documentation/Import-Settings.png differ
diff --git a/Documentation/Install.png b/Documentation/Install.png
new file mode 100644
index 0000000..c9e248a
Binary files /dev/null and b/Documentation/Install.png differ
diff --git a/Documentation/Launch-Importer.png b/Documentation/Launch-Importer.png
new file mode 100644
index 0000000..acd2b12
Binary files /dev/null and b/Documentation/Launch-Importer.png differ
diff --git a/Documentation/Layers-Display-Thumb.png b/Documentation/Layers-Display-Thumb.png
new file mode 100644
index 0000000..9878b71
Binary files /dev/null and b/Documentation/Layers-Display-Thumb.png differ
diff --git a/Documentation/Layers-Display.png b/Documentation/Layers-Display.png
new file mode 100644
index 0000000..0dd4afd
Binary files /dev/null and b/Documentation/Layers-Display.png differ
diff --git a/Documentation/Sprite-Creation.png b/Documentation/Sprite-Creation.png
new file mode 100644
index 0000000..c3f4331
Binary files /dev/null and b/Documentation/Sprite-Creation.png differ
diff --git a/Documentation/UI-Creation.png b/Documentation/UI-Creation.png
new file mode 100644
index 0000000..8c63b1f
Binary files /dev/null and b/Documentation/UI-Creation.png differ
diff --git a/PSDPlugin.sln b/PSDPlugin.sln
index 0d20954..87ebd96 100644
--- a/PSDPlugin.sln
+++ b/PSDPlugin.sln
@@ -1,6 +1,8 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2012
+# Visual Studio 2013
+VisualStudioVersion = 12.0.40629.0
+MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PhotoShop", "PhotoShopFileType\PhotoShop.csproj", "{A04EEDD9-E164-4941-9846-722ACF2FCCA1}"
 EndProject
 Global
@@ -9,8 +11,8 @@ Global
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{A04EEDD9-E164-4941-9846-722ACF2FCCA1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{A04EEDD9-E164-4941-9846-722ACF2FCCA1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A04EEDD9-E164-4941-9846-722ACF2FCCA1}.Debug|Any CPU.ActiveCfg = Release|Any CPU
+		{A04EEDD9-E164-4941-9846-722ACF2FCCA1}.Debug|Any CPU.Build.0 = Release|Any CPU
 		{A04EEDD9-E164-4941-9846-722ACF2FCCA1}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{A04EEDD9-E164-4941-9846-722ACF2FCCA1}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
diff --git a/PhotoShopFileType/Editor/PSDEditorWindow.cs b/PhotoShopFileType/Editor/PSDEditorWindow.cs
deleted file mode 100644
index 1ef7035..0000000
--- a/PhotoShopFileType/Editor/PSDEditorWindow.cs
+++ /dev/null
@@ -1,267 +0,0 @@
-/*
-The MIT License (MIT)
-
-Copyright (c) 2013 Banbury
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-using PhotoshopFile;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using UnityEditor;
-using UnityEngine;
-
-public class PSDEditorWindow : EditorWindow {
-    private Texture2D image;
-    private Vector2 scrollPos;
-    private PsdFile psd;
-    private int atlassize = 4096;
-    private float pixelsToUnitSize = 100.0f;
-	private string fileName;
-
-    [MenuItem("Sprites/PSD Import")]
-    public static void ShowWindow() {
-        var wnd = GetWindow<PSDEditorWindow>();
-        wnd.title = "PSD Import";
-        wnd.Show();
-    }
-
-    public void OnGUI() {
-        EditorGUI.BeginChangeCheck();
-        image = (Texture2D)EditorGUILayout.ObjectField("PSD File", image, typeof(Texture2D), true);
-        bool changed = EditorGUI.EndChangeCheck();
-
-        if (image != null) {
-            if (changed) {
-                string path = AssetDatabase.GetAssetPath(image);
-
-                if (path.ToUpper().EndsWith(".PSD")) {
-                    psd = new PsdFile(path, Encoding.Default);
-					fileName = Path.GetFileNameWithoutExtension(path);
-                } else {
-                    psd = null;
-                }
-            }
-            if (psd != null) {
-                scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
-
-                foreach (Layer layer in psd.Layers) {
-                    if (layer.Name != "</Layer set>") {
-                        layer.Visible = EditorGUILayout.ToggleLeft(layer.Name, layer.Visible);
-                    }
-                }
-
-                EditorGUILayout.EndScrollView();
-
-                if (GUILayout.Button("Export visible layers")) {
-                    ExportLayers();
-                }
-
-                atlassize = EditorGUILayout.IntField("Max. atlas size", atlassize);
-
-                if (!((atlassize != 0) && ((atlassize & (atlassize - 1)) == 0))) {
-                    EditorGUILayout.HelpBox("Atlas size should be a power of 2", MessageType.Warning);
-                }
-
-                pixelsToUnitSize = EditorGUILayout.FloatField("Pixels To Unit Size", pixelsToUnitSize);
-
-                if (pixelsToUnitSize <= 0) {
-                    EditorGUILayout.HelpBox("Pixels To Unit Size should be greater than 0.", MessageType.Warning);
-                }
-
-                if (GUILayout.Button("Create atlas")) {
-                    CreateAtlas();
-                }
-                if (GUILayout.Button("Create sprites")) {
-                    CreateSprites();
-                }
-            } else {
-                EditorGUILayout.HelpBox("This texture is not a PSD file.", MessageType.Error);
-            }
-        }
-    }
-
-    private Texture2D CreateTexture(Layer layer) {
-        if ((int)layer.Rect.width == 0 || (int)layer.Rect.height == 0)
-            return null;
-
-        Texture2D tex = new Texture2D((int)layer.Rect.width, (int)layer.Rect.height, TextureFormat.RGBA32, true);
-        Color32[] pixels = new Color32[tex.width * tex.height];
-
-        Channel red = (from l in layer.Channels where l.ID == 0 select l).First();
-        Channel green = (from l in layer.Channels where l.ID == 1 select l).First();
-        Channel blue = (from l in layer.Channels where l.ID == 2 select l).First();
-        Channel alpha = layer.AlphaChannel;
-
-        for (int i = 0; i < pixels.Length; i++) {
-            byte r = red.ImageData[i];
-            byte g = green.ImageData[i];
-            byte b = blue.ImageData[i];
-            byte a = 255;
-            
-            if (alpha != null)
-                a = alpha.ImageData[i];
-
-            int mod = i % tex.width;
-            int n = ((tex.width - mod - 1) + i) - mod;
-            pixels[pixels.Length - n - 1] = new Color32(r, g, b, a);
-        }
-
-        tex.SetPixels32(pixels);
-        tex.Apply();
-        return tex;
-    }
-
-    private void ExportLayers() {
-        foreach (Layer layer in psd.Layers) {
-            if (layer.Visible) {
-                Texture2D tex = CreateTexture(layer);
-                if (tex == null) continue;
-                SaveAsset(tex, "_" + layer.Name);
-                DestroyImmediate(tex);
-            }
-        }
-    }
-
-    private void CreateAtlas() {
-        // Texture2D[] textures = (from layer in psd.Layers where layer.Visible select CreateTexture(layer) into tex where tex != null select tex).ToArray();
-
-        List<Texture2D> textures = new List<Texture2D>();
-
-		// Track the spriteRenderers created via a List
-        List<SpriteRenderer> spriteRenderers = new List<SpriteRenderer>();
-
-		int zOrder = 0;
-		GameObject root = new GameObject(fileName);
-		foreach (var layer in psd.Layers) {
-			if (layer.Visible && layer.Rect.width > 0 && layer.Rect.height > 0) {
-				Texture2D tex = CreateTexture(layer);
-				// Add the texture to the Texture Array
-				textures.Add(tex);
-
-				GameObject go = new GameObject(layer.Name);
-				SpriteRenderer sr = go.AddComponent<SpriteRenderer>();
-				go.transform.position = new Vector3((layer.Rect.width / 2 + layer.Rect.x) / pixelsToUnitSize, (-layer.Rect.height / 2 - layer.Rect.y) / pixelsToUnitSize, 0);
-				// Add the sprite renderer to the SpriteRenderer Array
-				spriteRenderers.Add(sr);
-				sr.sortingOrder = zOrder++;
-				go.transform.parent = root.transform;
-			}
-		}
-
-		// The output of PackTextures returns a Rect array from which we can create our sprites
-		Rect[] rects;
-		Texture2D atlas = new Texture2D(atlassize, atlassize);
-		Texture2D[] textureArray = textures.ToArray();
-		rects = atlas.PackTextures(textureArray, 2, atlassize);
-		List<SpriteMetaData> Sprites = new List<SpriteMetaData>();
-
-		// For each rect in the Rect Array create the sprite and assign to the SpriteMetaData
-		for(int i = 0; i < rects.Length; i++)
-		{
-			// add the name and rectangle to the dictionary
-			SpriteMetaData smd = new SpriteMetaData();
-			smd.name = spriteRenderers[i].name;
-			smd.rect = new Rect(rects[i].xMin * atlas.width, rects[i].yMin * atlas.height, rects[i].width * atlas.width, rects[i].height * atlas.height);
-			smd.pivot = new Vector2(0.5f, 0.5f); // Center is default otherwise layers will be misaligned
-			smd.alignment = (int)SpriteAlignment.Center;
-			Sprites.Add(smd);
-		}
-
-		// Need to load the image first
-		string assetPath = AssetDatabase.GetAssetPath(image);
-		string path = Path.Combine(Path.GetDirectoryName(assetPath),
-			Path.GetFileNameWithoutExtension(assetPath) + "_atlas" + ".png");
-
-		byte[] buf = atlas.EncodeToPNG();
-        File.WriteAllBytes(path, buf);
-		AssetDatabase.Refresh();
-
-		// Get our texture that we loaded
-		atlas = (Texture2D)AssetDatabase.LoadAssetAtPath(path, typeof(Texture2D));
-		TextureImporter textureImporter = AssetImporter.GetAtPath(path) as TextureImporter;
-		// Make sure the size is the same as our atlas then create the spritesheet
-		textureImporter.maxTextureSize = atlassize;
-		textureImporter.spritesheet = Sprites.ToArray();
-		textureImporter.textureType = TextureImporterType.Sprite; 
-		textureImporter.spriteImportMode = SpriteImportMode.Multiple;
-		textureImporter.spritePivot = new Vector2(0.5f, 0.5f);
-		textureImporter.spritePixelsToUnits = pixelsToUnitSize;
-		AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
-
-		// For each rect in the Rect Array create the sprite and assign to the SpriteRenderer
-		for(int j = 0; j < textureImporter.spritesheet.Length; j++)
-		{
-			// Debug.Log(textureImporter.spritesheet[j].rect);
-			Sprite spr = Sprite.Create(atlas, textureImporter.spritesheet[j].rect, textureImporter.spritesheet[j].pivot, pixelsToUnitSize);  // The 100.0f is for the pixels to unit, maybe make that a public variable for the user to change before hand?
-
-			// Add the sprite to the sprite renderer
-			spriteRenderers[j].sprite = spr;
-		}
-
-        foreach (Texture2D tex in textureArray) {
-            DestroyImmediate(tex);
-        }
-    }
-
-    private void CreateSprites() {
-        int zOrder = 0;
-        GameObject root = new GameObject(fileName);
-		foreach (var layer in psd.Layers) {
-            if (layer.Visible && layer.Rect.width > 0 && layer.Rect.height > 0) {
-                Texture2D tex = CreateTexture(layer);
-                Sprite spr = SaveAsset(tex, "_" + layer.Name);
-                DestroyImmediate(tex);
-
-                GameObject go = new GameObject(layer.Name);
-                SpriteRenderer sr = go.AddComponent<SpriteRenderer>();
-                sr.sprite = spr;
-                sr.sortingOrder = zOrder++;
-                go.transform.position = new Vector3((layer.Rect.width / 2 + layer.Rect.x) / pixelsToUnitSize, (-layer.Rect.height / 2 - layer.Rect.y) / pixelsToUnitSize, 0);
-				go.transform.parent = root.transform;
-            }
-        }
-    }
-
-    private Sprite SaveAsset(Texture2D tex, string suffix) {
-        string assetPath = AssetDatabase.GetAssetPath(image);
-        string path = Path.Combine(Path.GetDirectoryName(assetPath),
-            Path.GetFileNameWithoutExtension(assetPath) + suffix + ".png");
-
-		byte[] buf = tex.EncodeToPNG();
-        File.WriteAllBytes(path, buf);
-		AssetDatabase.Refresh();
-		// Load the texture so we can change the type
-		AssetDatabase.LoadAssetAtPath(path, typeof(Texture2D));
-		TextureImporter textureImporter = AssetImporter.GetAtPath(path) as TextureImporter;
-		textureImporter.textureType = TextureImporterType.Sprite; 
-		textureImporter.spriteImportMode = SpriteImportMode.Single;
-		textureImporter.spritePivot = new Vector2(0.5f, 0.5f);
-		textureImporter.spritePixelsToUnits = pixelsToUnitSize;
-		AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
-
-        return (Sprite)AssetDatabase.LoadAssetAtPath(path, typeof(Sprite));
-    }
-
-}
-
diff --git a/PhotoShopFileType/PSDModule b/PhotoShopFileType/PSDModule
new file mode 160000
index 0000000..aec84e1
--- /dev/null
+++ b/PhotoShopFileType/PSDModule
@@ -0,0 +1 @@
+Subproject commit aec84e1cda3a4343afaf37791a3bcf8974c2a0ad
diff --git a/PhotoShopFileType/PhotoShop.csproj b/PhotoShopFileType/PhotoShop.csproj
index e7cb1c4..154183e 100644
--- a/PhotoShopFileType/PhotoShop.csproj
+++ b/PhotoShopFileType/PhotoShop.csproj
@@ -9,7 +9,7 @@
     <OutputType>Library</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>PhotoShop</RootNamespace>
-    <AssemblyName>PhotoShop</AssemblyName>
+    <AssemblyName>PhotoShopImporter</AssemblyName>
     <SignAssembly>false</SignAssembly>
     <AssemblyOriginatorKeyFile>
     </AssemblyOriginatorKeyFile>
@@ -41,40 +41,52 @@
     <Reference Include="System.Xml" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="UnityEditor">
-      <HintPath>C:\Program Files (x86)\Unity\Editor\Data\Managed\UnityEditor.dll</HintPath>
+      <HintPath>..\..\..\..\Program Files\Unity\Editor\Data\Managed\UnityEditor.dll</HintPath>
     </Reference>
     <Reference Include="UnityEngine">
-      <HintPath>C:\Program Files (x86)\Unity\Editor\Data\Managed\UnityEngine.dll</HintPath>
+      <HintPath>..\..\..\..\Program Files\Unity\Editor\Data\Managed\UnityEngine.dll</HintPath>
+    </Reference>
+    <Reference Include="UnityEngine.UI">
+      <HintPath>..\..\..\..\Program Files\Unity\Editor\Data\UnityExtensions\Unity\GUISystem\UnityEngine.UI.dll</HintPath>
     </Reference>
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Editor\PSDEditorWindow.cs" />
+    <Compile Include="PSDModule\Editor\Reconstructor\IPsdConstructor.cs" />
+    <Compile Include="PSDModule\Editor\Reconstructor\PsdBuilder.cs" />
+    <Compile Include="PSDModule\Editor\Reconstructor\SpriteConstructor.cs" />
+    <Compile Include="PSDModule\Editor\Reconstructor\UiImgConstructor.cs" />
+    <Compile Include="PSDModule\Editor\PSDEditorWindow.cs" />
+    <Compile Include="PSDModule\Editor\PSDExporter.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="PsdFile\Exceptions.cs" />
-    <Compile Include="PsdFile\ImageResource.cs" />
-    <Compile Include="PsdFile\ImageResources\AlphaChannelNames.cs" />
-    <Compile Include="PsdFile\ImageResources\RawImageResource.cs" />
-    <Compile Include="PsdFile\ImageResources\ResolutionInfo.cs" />
-    <Compile Include="PsdFile\ImageResources\Thumbnail.cs" />
-    <Compile Include="PsdFile\ImageResources\UnicodeAlphaNames.cs" />
-    <Compile Include="PsdFile\ImageResources\VersionInfo.cs" />
-    <Compile Include="PsdFile\Layers\BlendingRanges.cs" />
-    <Compile Include="PsdFile\Layers\Channel.cs" />
-    <Compile Include="PsdFile\Layers\Layer.cs" />
-    <Compile Include="PsdFile\Layers\LayerInfo.cs" />
-    <Compile Include="PsdFile\Layers\LayerInfo\LayerSectionInfo.cs" />
-    <Compile Include="PsdFile\Layers\LayerInfo\LayerUnicodeName.cs" />
-    <Compile Include="PsdFile\Layers\LayerInfo\RawLayerInfo.cs" />
-    <Compile Include="PsdFile\Layers\Mask.cs" />
-    <Compile Include="PsdFile\PsdBinaryReader.cs" />
-    <Compile Include="PsdFile\PsdBinaryWriter.cs" />
-    <Compile Include="PsdFile\PsdBlendMode.cs" />
-    <Compile Include="PsdFile\PsdBlockLengthWriter.cs" />
-    <Compile Include="PsdFile\PsdFile.cs" />
-    <Compile Include="PsdFile\RleReader.cs" />
-    <Compile Include="PsdFile\RleRowLengths.cs" />
-    <Compile Include="PsdFile\RleWriter.cs" />
-    <Compile Include="PsdFile\Util.cs" />
+    <Compile Include="PSDModule\Editor\PsdExportSettings.cs" />
+    <Compile Include="PSDModule\Editor\PsdFileInfo.cs" />
+    <Compile Include="PSDModule\Editor\PSDLayerGroupInfo.cs" />
+    <Compile Include="PSDModule\Editor\PSDPostProcessor.cs" />
+    <Compile Include="PSDModule\PsdFile\Exceptions.cs" />
+    <Compile Include="PSDModule\PsdFile\ImageResource.cs" />
+    <Compile Include="PSDModule\PsdFile\ImageResources\AlphaChannelNames.cs" />
+    <Compile Include="PSDModule\PsdFile\ImageResources\RawImageResource.cs" />
+    <Compile Include="PSDModule\PsdFile\ImageResources\ResolutionInfo.cs" />
+    <Compile Include="PSDModule\PsdFile\ImageResources\Thumbnail.cs" />
+    <Compile Include="PSDModule\PsdFile\ImageResources\UnicodeAlphaNames.cs" />
+    <Compile Include="PSDModule\PsdFile\ImageResources\VersionInfo.cs" />
+    <Compile Include="PSDModule\PsdFile\Layers\BlendingRanges.cs" />
+    <Compile Include="PSDModule\PsdFile\Layers\Channel.cs" />
+    <Compile Include="PSDModule\PsdFile\Layers\Layer.cs" />
+    <Compile Include="PSDModule\PsdFile\Layers\LayerInfo.cs" />
+    <Compile Include="PSDModule\PsdFile\Layers\LayerInfo\LayerSectionInfo.cs" />
+    <Compile Include="PSDModule\PsdFile\Layers\LayerInfo\LayerUnicodeName.cs" />
+    <Compile Include="PSDModule\PsdFile\Layers\LayerInfo\RawLayerInfo.cs" />
+    <Compile Include="PSDModule\PsdFile\Layers\Mask.cs" />
+    <Compile Include="PSDModule\PsdFile\PsdBinaryReader.cs" />
+    <Compile Include="PSDModule\PsdFile\PsdBinaryWriter.cs" />
+    <Compile Include="PSDModule\PsdFile\PsdBlendMode.cs" />
+    <Compile Include="PSDModule\PsdFile\PsdBlockLengthWriter.cs" />
+    <Compile Include="PSDModule\PsdFile\PsdFile.cs" />
+    <Compile Include="PSDModule\PsdFile\RleReader.cs" />
+    <Compile Include="PSDModule\PsdFile\RleRowLengths.cs" />
+    <Compile Include="PSDModule\PsdFile\RleWriter.cs" />
+    <Compile Include="PSDModule\PsdFile\Util.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Resources.resx">
@@ -86,7 +98,7 @@
   <ItemGroup />
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
-    <PostBuildEvent>xcopy "$(TargetPath)" "z:\Unity\projects\PSDFiles\Assets\PSDSprites\Scripts\" /Y /R</PostBuildEvent>
+    <PostBuildEvent>xcopy "$(TargetPath)" "$(SolutionDir)bin" /Y /R</PostBuildEvent>
   </PropertyGroup>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/PhotoShopFileType/PsdFile/Exceptions.cs b/PhotoShopFileType/PsdFile/Exceptions.cs
deleted file mode 100644
index 58d112e..0000000
--- a/PhotoShopFileType/PsdFile/Exceptions.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is perovided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2012 Tao Yue
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Text;
-
-namespace PhotoshopFile
-{
-  [Serializable]
-  public class PsdInvalidException : Exception
-  {
-    public PsdInvalidException()
-    {
-    }
-
-    public PsdInvalidException(string message)
-      : base(message)
-    {
-    }
-  }
-
-  [Serializable]
-  public class RleException : Exception
-  {
-    public RleException() { }
-
-    public RleException(string message) : base(message) { }
-  }
-}
diff --git a/PhotoShopFileType/PsdFile/ImageResource.cs b/PhotoShopFileType/PsdFile/ImageResource.cs
deleted file mode 100644
index cb28891..0000000
--- a/PhotoShopFileType/PsdFile/ImageResource.cs
+++ /dev/null
@@ -1,257 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// Portions of this file are provided under the BSD 3-clause License:
-//   Copyright (c) 2006, Jonas Beckeman
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-
-namespace PhotoshopFile
-{
-  public enum ResourceID
-  {
-    Undefined = 0,
-    MacPrintInfo = 1001,
-    ResolutionInfo = 1005,
-    AlphaChannelNames = 1006,
-    DisplayInfo = 1007,
-    Caption = 1008,
-    BorderInfo = 1009,
-    BackgroundColor = 1010,
-    PrintFlags = 1011,
-    MultichannelHalftoneInfo = 1012,
-    ColorHalftoneInfo = 1013,
-    DuotoneHalftoneInfo = 1014,
-    MultichannelTransferFunctions = 1015,
-    ColorTransferFunctions = 1016,
-    DuotoneTransferFunctions = 1017,
-    DuotoneImageInfo = 1018,
-    BlackWhiteRange = 1019,
-    EpsOptions = 1021,
-    QuickMaskInfo = 1022,
-    LayerStateInfo = 1024,
-    WorkingPathUnsaved = 1025,
-    LayersGroupInfo = 1026,
-    IptcNaa = 1028,
-    RawFormatImageMode = 1029,
-    JpegQuality = 1030,
-    GridGuidesInfo = 1032,
-    ThumbnailBgr = 1033,
-    CopyrightInfo = 1034,
-    Url = 1035,
-    ThumbnailRgb = 1036,
-    GlobalAngle = 1037,
-    ColorSamplersObsolete = 1038,
-    IccProfile = 1039,
-    Watermark = 1040,
-    IccUntagged = 1041,
-    EffectsVisible = 1042,
-    SpotHalftone = 1043,
-    DocumentSpecific = 1044,
-    UnicodeAlphaNames = 1045,
-    IndexedColorTableCount = 1046,
-    TransparentIndex = 1047,
-    GlobalAltitude = 1049,
-    Slices = 1050,
-    WorkflowUrl = 1051,
-    JumpToXpep = 1052,
-    AlphaIdentifiers = 1053,
-    UrlList = 1054,
-    VersionInfo = 1057,
-    ExifData1 = 1058,
-    ExifData3 = 1059,
-    XmpMetadata = 1060,
-    CaptionDigest = 1061,
-    PrintScale = 1062,
-    PixelAspectRatio = 1064,
-    LayerComps = 1065,
-    AlternateDuotoneColors = 1066,
-    AlternateSpotColors = 1067,
-    LayerSelectionIDs = 1069,
-    HdrToningInfo = 1070,
-    PrintInfo = 1071,
-    LayerGroupsEnabled = 1072,
-    ColorSamplers = 1073,
-    MeasurementScale = 1074,
-    TimelineInfo = 1075,
-    SheetDisclosure = 1076,
-    FloatDisplayInfo = 1077,
-    OnionSkins = 1078,
-    CountInfo = 1080,
-    PrintSettingsInfo = 1082,
-    PrintStyle = 1083,
-    MacNSPrintInfo = 1084,
-    WinDevMode = 1085,
-    AutoSaveFilePath = 1086,
-    AutoSaveFormat = 1087,
-    PathInfo = 2000,  // 2000-2999: Path Information
-    ClippingPathName = 2999,
-    LightroomWorkflow = 8000,
-    PrintFlagsInfo = 10000
-  }
-
-  /// <summary>
-  /// Abstract class for Image Resources
-  /// </summary>
-  public abstract class ImageResource
-  {
-    private string signature;
-    public string Signature
-    {
-      get { return signature; }
-      set
-      {
-        if (value.Length != 4)
-          throw new ArgumentException("Signature must have length of 4");
-        signature = value;
-      }
-    }
-
-    public string Name { get; set; }
-
-    public abstract ResourceID ID { get; }
-
-    protected ImageResource(string name)
-    {
-      Signature = "8BIM";
-      Name = name;
-    }
-
-    /// <summary>
-    /// Write out the image resource block: header and data.
-    /// </summary>
-    public void Save(PsdBinaryWriter writer)
-    {
-      writer.WriteAsciiChars(Signature);
-      writer.Write((UInt16)ID);
-      writer.WritePascalString(Name, 2);
-
-      // Length is unpadded, but data is even-padded
-      var startPosition = writer.BaseStream.Position;
-      using (new PsdBlockLengthWriter(writer))
-      {
-        WriteData(writer);
-      }
-      writer.WritePadding(startPosition, 2);
-    }
-
-    /// <summary>
-    /// Write the data for this image resource.
-    /// </summary>
-    protected abstract void WriteData(PsdBinaryWriter writer);
-
-    public override string ToString()
-    {
-      return String.Format(CultureInfo.InvariantCulture, "{0} {1}", (ResourceID)ID, Name);
-    }
-  }
-
-  /// <summary>
-  /// Creates the appropriate subclass of ImageResource.
-  /// </summary>
-  public static class ImageResourceFactory
-  {
-    public static ImageResource CreateImageResource(PsdBinaryReader reader)
-    {
-      // Debug.Print("ImageResource started at {0}", reader.BaseStream.Position);
-
-      var signature = reader.ReadAsciiChars(4);
-      var resourceIdInt = reader.ReadUInt16();
-      var name = reader.ReadPascalString(2);
-      var dataLength = (int)reader.ReadUInt32();
-
-      var dataPaddedLength = Util.RoundUp(dataLength, 2);
-      var endPosition = reader.BaseStream.Position + dataPaddedLength;
-
-      ImageResource resource = null;
-      var resourceId = (ResourceID)resourceIdInt;
-      switch (resourceId)
-      {
-        case ResourceID.ResolutionInfo:
-          resource = new ResolutionInfo(reader, name);
-          break;
-        case ResourceID.ThumbnailRgb:
-        case ResourceID.ThumbnailBgr:
-          resource = new Thumbnail(reader, resourceId, name, dataLength);
-          break;
-        case ResourceID.AlphaChannelNames:
-          resource = new AlphaChannelNames(reader, name, dataLength);
-          break;
-        case ResourceID.UnicodeAlphaNames:
-          resource = new UnicodeAlphaNames(reader, name, dataLength);
-          break;
-        case ResourceID.VersionInfo:
-          resource = new VersionInfo(reader, name);
-          break;
-        default:
-          resource = new RawImageResource(reader, signature, resourceId, name, dataLength);
-          break;
-      }
-
-      // Reposition the reader if we do not consume the full resource block.
-      // This takes care of the even-padding, and also preserves forward-
-      // compatibility in case a resource block is later extended with
-      // additional properties.
-      if (reader.BaseStream.Position < endPosition)
-        reader.BaseStream.Position = endPosition;
-
-      // However, overruns are definitely an error.
-      if (reader.BaseStream.Position > endPosition)
-        throw new PsdInvalidException("Corruption detected in resource.");
-
-      return resource;
-    }
-  }
-
-  public class ImageResources : List<ImageResource>
-  {
-    public ImageResources() : base()
-    {
-    }
-
-    public ImageResource Get(ResourceID id)
-    {
-      return Find(x => x.ID == id);
-    }
-
-    public void Set(ImageResource resource)
-    {
-      Predicate<ImageResource> matchId = delegate(ImageResource res)
-      {
-        return res.ID == resource.ID;
-      };
-      var itemIdx = this.FindIndex(matchId);
-      var lastItemIdx = this.FindLastIndex(matchId);
-
-      if (itemIdx == -1)
-      {
-        Add(resource);
-      }
-      else if (itemIdx != lastItemIdx)
-      {
-        RemoveAll(matchId);
-        Insert(itemIdx, resource);
-      }
-      else
-      {
-        this[itemIdx] = resource;
-      }
-    }
-  }
-
-}
diff --git a/PhotoShopFileType/PsdFile/ImageResources/AlphaChannelNames.cs b/PhotoShopFileType/PsdFile/ImageResources/AlphaChannelNames.cs
deleted file mode 100644
index 9e207f9..0000000
--- a/PhotoShopFileType/PsdFile/ImageResources/AlphaChannelNames.cs
+++ /dev/null
@@ -1,60 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Collections.Generic;
-
-namespace PhotoshopFile
-{
-  /// <summary>
-  /// The names of the alpha channels
-  /// </summary>
-  public class AlphaChannelNames : ImageResource
-  {
-    public override ResourceID ID
-    {
-      get { return ResourceID.AlphaChannelNames; }
-    }
-
-    private List<string> channelNames = new List<string>();
-    public List<string> ChannelNames
-    {
-      get { return channelNames; }
-    }
-
-    public AlphaChannelNames() : base(String.Empty)
-    {
-    }
-
-    public AlphaChannelNames(PsdBinaryReader reader, string name, int resourceDataLength)
-      : base(name)
-    {
-      var endPosition = reader.BaseStream.Position + resourceDataLength;
-
-      // Alpha channel names are Pascal strings, with no padding in-between.
-      while (reader.BaseStream.Position < endPosition)
-      {
-        var channelName = reader.ReadPascalString(1);
-        ChannelNames.Add(channelName);
-      }
-    }
-
-    protected override void WriteData(PsdBinaryWriter writer)
-    {
-      foreach (var channelName in ChannelNames)
-      {
-        writer.WritePascalString(channelName, 1);
-      }
-    }
-  }
-}
diff --git a/PhotoShopFileType/PsdFile/ImageResources/RawImageResource.cs b/PhotoShopFileType/PsdFile/ImageResources/RawImageResource.cs
deleted file mode 100644
index 5f00914..0000000
--- a/PhotoShopFileType/PsdFile/ImageResources/RawImageResource.cs
+++ /dev/null
@@ -1,53 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.IO;
-
-namespace PhotoshopFile
-{
-  /// <summary>
-  /// Stores the raw data for unimplemented image resource types.
-  /// </summary>
-  public class RawImageResource : ImageResource
-  {
-    public byte[] Data { get; private set; }
-
-    private ResourceID id;
-    public override ResourceID ID
-    {
-      get { return id; }
-    }
-
-    public RawImageResource(ResourceID resourceId, string name)
-      : base(name)
-    {
-      this.id = resourceId;
-    }
-
-    public RawImageResource(PsdBinaryReader reader, string signature, 
-      ResourceID resourceId, string name, int numBytes)
-      : base(name)
-    {
-      this.Signature = signature;
-      this.id = resourceId;
-      Data = reader.ReadBytes(numBytes);
-    }
-    
-    protected override void WriteData(PsdBinaryWriter writer)
-    {
-      writer.Write(Data);
-    }
-
-  }
-}
diff --git a/PhotoShopFileType/PsdFile/ImageResources/ResolutionInfo.cs b/PhotoShopFileType/PsdFile/ImageResources/ResolutionInfo.cs
deleted file mode 100644
index da3d60b..0000000
--- a/PhotoShopFileType/PsdFile/ImageResources/ResolutionInfo.cs
+++ /dev/null
@@ -1,108 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2012 Tao Yue
-//
-// Portions of this file are provided under the BSD 3-clause License:
-//   Copyright (c) 2006, Jonas Beckeman
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-
-namespace PhotoshopFile
-{
-  /// <summary>
-  /// Summary description for ResolutionInfo.
-  /// </summary>
-  public class ResolutionInfo : ImageResource
-  {
-    public override ResourceID ID
-    {
-      get { return ResourceID.ResolutionInfo; }
-    }
-
-    /// <summary>
-    /// Horizontal DPI.
-    /// </summary>
-    public UFixed16_16 HDpi { get; set; }
-
-    /// <summary>
-    /// Vertical DPI.
-    /// </summary>
-    public UFixed16_16 VDpi { get; set; }
-
-    /// <summary>
-    /// 1 = pixels per inch, 2 = pixels per centimeter
-    /// </summary>
-    public enum ResUnit
-    {
-      PxPerInch = 1,
-      PxPerCm = 2
-    }
-
-    /// <summary>
-    /// Display units for horizontal resolution.  This only affects the
-    /// user interface; the resolution is still stored in the PSD file
-    /// as pixels/inch.
-    /// </summary>
-    public ResUnit HResDisplayUnit { get; set; }
-
-    /// <summary>
-    /// Display units for vertical resolution.
-    /// </summary>
-    public ResUnit VResDisplayUnit { get; set; }
-
-    /// <summary>
-    /// Physical units.
-    /// </summary>
-    public enum Unit
-    {
-      Inches = 1,
-      Centimeters = 2,
-      Points = 3,
-      Picas = 4,
-      Columns = 5
-    }
-
-    public Unit WidthDisplayUnit { get; set; }
-
-    public Unit HeightDisplayUnit { get; set; }
-    
-    public ResolutionInfo() : base(String.Empty)
-    {
-    }
-
-    public ResolutionInfo(PsdBinaryReader reader, string name)
-      : base(name)
-    {
-      this.HDpi = new UFixed16_16(reader.ReadUInt32());
-      this.HResDisplayUnit = (ResUnit)reader.ReadInt16();
-      this.WidthDisplayUnit = (Unit)reader.ReadInt16();
-
-      this.VDpi = new UFixed16_16(reader.ReadUInt32());
-      this.VResDisplayUnit = (ResUnit)reader.ReadInt16();
-      this.HeightDisplayUnit = (Unit)reader.ReadInt16();
-    }
-
-    protected override void WriteData(PsdBinaryWriter writer)
-    {
-      writer.Write(HDpi.Integer);
-      writer.Write(HDpi.Fraction);
-      writer.Write((Int16)HResDisplayUnit);
-      writer.Write((Int16)WidthDisplayUnit);
-
-      writer.Write(VDpi.Integer);
-      writer.Write(VDpi.Fraction);
-      writer.Write((Int16)VResDisplayUnit);
-      writer.Write((Int16)HeightDisplayUnit);
-    }
-
-  }
-}
diff --git a/PhotoShopFileType/PsdFile/ImageResources/Thumbnail.cs b/PhotoShopFileType/PsdFile/ImageResources/Thumbnail.cs
deleted file mode 100644
index 72c32c9..0000000
--- a/PhotoShopFileType/PsdFile/ImageResources/Thumbnail.cs
+++ /dev/null
@@ -1,74 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// Portions of this file are provided under the BSD 3-clause License:
-//   Copyright (c) 2006, Jonas Beckeman
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.IO;
-using System.Diagnostics;
-using UnityEngine;
-
-namespace PhotoshopFile {
-    /// <summary>
-    /// Summary description for Thumbnail.
-    /// </summary>
-    public class Thumbnail : RawImageResource {
-        public Texture2D Image { get; private set; }
-
-        public Thumbnail(ResourceID id, string name)
-            : base(id, name) {
-        }
-
-        public Thumbnail(PsdBinaryReader psdReader, ResourceID id, string name, int numBytes)
-            : base(psdReader, "8BIM", id, name, numBytes) {
-            using (var memoryStream = new MemoryStream(Data))
-            using (var reader = new PsdBinaryReader(memoryStream, psdReader)) {
-                const int HEADER_LENGTH = 28;
-                var format = reader.ReadUInt32();
-                var width = reader.ReadUInt32();
-                var height = reader.ReadUInt32();
-                var widthBytes = reader.ReadUInt32();
-                var size = reader.ReadUInt32();
-                var compressedSize = reader.ReadUInt32();
-                var bitPerPixel = reader.ReadUInt16();
-                var planes = reader.ReadUInt16();
-
-                // Raw RGB bitmap
-                if (format == 0) {
-                    Image = new Texture2D((int)width, (int)height, TextureFormat.RGB24, true);
-                }
-                // JPEG bitmap
-                else if (format == 1) {
-                    byte[] imgData = reader.ReadBytes(numBytes - HEADER_LENGTH);
-                    Image = new Texture2D((int)width, (int)height, TextureFormat.RGB24, true);
-                    Image.LoadImage(imgData);
-
-                    // Reverse BGR pixels from old thumbnail format
-                    if (id == ResourceID.ThumbnailBgr) {
-                        //for(int y=0;y<m_thumbnailImage.Height;y++)
-                        //  for (int x = 0; x < m_thumbnailImage.Width; x++)
-                        //  {
-                        //    Color c=m_thumbnailImage.GetPixel(x,y);
-                        //    Color c2=Color.FromArgb(c.B, c.G, c.R);
-                        //    m_thumbnailImage.SetPixel(x, y, c);
-                        //  }
-                    }
-                }
-                else {
-                    throw new PsdInvalidException("Unknown thumbnail format.");
-                }
-            }
-        }
-    }
-}
diff --git a/PhotoShopFileType/PsdFile/ImageResources/UnicodeAlphaNames.cs b/PhotoShopFileType/PsdFile/ImageResources/UnicodeAlphaNames.cs
deleted file mode 100644
index a84b135..0000000
--- a/PhotoShopFileType/PsdFile/ImageResources/UnicodeAlphaNames.cs
+++ /dev/null
@@ -1,60 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Collections.Generic;
-
-namespace PhotoshopFile
-{
-  /// <summary>
-  /// The names of the alpha channels.
-  /// </summary>
-  public class UnicodeAlphaNames : ImageResource
-  {
-    public override ResourceID ID
-    {
-      get { return ResourceID.UnicodeAlphaNames; }
-    }
-
-    private List<string> channelNames = new List<string>();
-    public List<string> ChannelNames
-    {
-      get { return channelNames; }
-    }
-
-    public UnicodeAlphaNames()
-      : base(String.Empty)
-    {
-    }
-
-    public UnicodeAlphaNames(PsdBinaryReader reader, string name, int resourceDataLength)
-      : base(name)
-    {
-      var endPosition = reader.BaseStream.Position + resourceDataLength;
-
-      while (reader.BaseStream.Position < endPosition)
-      {
-        var channelName = reader.ReadUnicodeString();
-        ChannelNames.Add(channelName);
-      }
-    }
-
-    protected override void WriteData(PsdBinaryWriter writer)
-    {
-      foreach (var channelName in ChannelNames)
-      {
-        writer.WriteUnicodeString(channelName);
-      }
-    }
-  }
-}
diff --git a/PhotoShopFileType/PsdFile/ImageResources/VersionInfo.cs b/PhotoShopFileType/PsdFile/ImageResources/VersionInfo.cs
deleted file mode 100644
index 4042855..0000000
--- a/PhotoShopFileType/PsdFile/ImageResources/VersionInfo.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2012 Tao Yue
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace PhotoshopFile
-{
-  public class VersionInfo : ImageResource
-  {
-    public override ResourceID ID
-    {
-      get { return ResourceID.VersionInfo; }
-    }
-
-    public UInt32 Version { get; set; }
-
-    public bool HasRealMergedData { get; set; }
-
-    public string ReaderName { get; set; }
-
-    public string WriterName { get; set; }
-
-    public UInt32 FileVersion { get; set; }
-
-    
-    public VersionInfo() : base(String.Empty)
-    {
-    }
-
-    public VersionInfo(PsdBinaryReader reader, string name)
-      : base(name)
-    {
-      Version = reader.ReadUInt32();
-      HasRealMergedData = reader.ReadBoolean();
-      ReaderName = reader.ReadUnicodeString();
-      WriterName = reader.ReadUnicodeString();
-      FileVersion = reader.ReadUInt32();
-    }
-
-    protected override void WriteData(PsdBinaryWriter writer)
-    {
-      writer.Write(Version);
-      writer.Write(HasRealMergedData);
-      writer.WriteUnicodeString(ReaderName);
-      writer.WriteUnicodeString(WriterName);
-      writer.Write(FileVersion);
-    }
-  }
-}
diff --git a/PhotoShopFileType/PsdFile/Layers/BlendingRanges.cs b/PhotoShopFileType/PsdFile/Layers/BlendingRanges.cs
deleted file mode 100644
index 060be0b..0000000
--- a/PhotoShopFileType/PsdFile/Layers/BlendingRanges.cs
+++ /dev/null
@@ -1,70 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// Portions of this file are provided under the BSD 3-clause License:
-//   Copyright (c) 2006, Jonas Beckeman
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Diagnostics;
-using System.Globalization;
-
-namespace PhotoshopFile
-{
-  public class BlendingRanges
-  {
-    /// <summary>
-    /// The layer to which this channel belongs
-    /// </summary>
-    public Layer Layer { get; private set; }
-
-    public byte[] Data { get; set; }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    public BlendingRanges(Layer layer)
-    {
-      Layer = layer;
-      Data = new byte[0];
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    public BlendingRanges(PsdBinaryReader reader, Layer layer)
-    {
-      Debug.WriteLine("BlendingRanges started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
-
-      Layer = layer;
-      var dataLength = reader.ReadInt32();
-      if (dataLength <= 0)
-        return;
-
-      Data = reader.ReadBytes(dataLength);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    public void Save(PsdBinaryWriter writer)
-    {
-      Debug.WriteLine("BlendingRanges Save started at " + writer.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
-
-      if (Data == null)
-      {
-        writer.Write((UInt32)0);
-        return;
-      }
-
-      writer.Write((UInt32)Data.Length);
-      writer.Write(Data);
-    }
-  }
-}
diff --git a/PhotoShopFileType/PsdFile/Layers/Channel.cs b/PhotoShopFileType/PsdFile/Layers/Channel.cs
deleted file mode 100644
index 3e1cf92..0000000
--- a/PhotoShopFileType/PsdFile/Layers/Channel.cs
+++ /dev/null
@@ -1,412 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// Portions of this file are provided under the BSD 3-clause License:
-//   Copyright (c) 2006, Jonas Beckeman
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Globalization;
-using System.IO;
-using System.IO.Compression;
-using System.Linq;
-using System.Text;
-using UnityEngine;
-
-namespace PhotoshopFile
-{
-  public class ChannelList : List<Channel>
-  {
-    /// <summary>
-    /// Returns channels with nonnegative IDs as an array, so that accessing
-    /// a channel by Id can be optimized into pointer arithmetic rather than
-    /// being implemented as a List scan.
-    /// </summary>
-    /// <remarks>
-    /// This optimization is crucial for blitting lots of pixels back and
-    /// forth between Photoshop's per-channel representation, and Paint.NET's
-    /// per-pixel BGRA representation.
-    /// </remarks>
-    public Channel[] ToIdArray()
-    {
-      var maxId = this.Max(x => x.ID);
-      var idArray = new Channel[maxId + 1];
-      foreach (var channel in this)
-      {
-        if (channel.ID >= 0)
-          idArray[channel.ID] = channel;
-      }
-      return idArray;
-    }
-
-    public ChannelList()
-      : base()
-    {
-    }
-
-    public Channel GetId(int id)
-    {
-      return this.Single(x => x.ID == id);
-    }
-
-    public bool ContainsId(int id)
-    {
-      return this.Exists(x => x.ID == id);
-    }
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-
-  [DebuggerDisplay("ID = {ID}")]
-  public class Channel
-  {
-    /// <summary>
-    /// The layer to which this channel belongs
-    /// </summary>
-    public Layer Layer { get; private set; }
-
-    /// <summary>
-    /// Channel ID.
-    /// <list type="bullet">
-    /// <item>-1 = transparency mask</item>
-    /// <item>-2 = user-supplied layer mask, or vector mask</item>
-    /// <item>-3 = user-supplied layer mask, if channel -2 contains a vector mask</item>
-    /// <item>
-    /// Nonnegative channel IDs give the actual image channels, in the
-    /// order defined by the colormode.  For example, 0, 1, 2 = R, G, B.
-    /// </item>
-    /// </list>
-    /// </summary>
-    public short ID { get; set; }
-
-    public Rect Rect
-    {
-      get
-      {
-        switch (ID)
-        {
-          case -2:
-            return Layer.Masks.LayerMask.Rect;
-          case -3:
-            return Layer.Masks.UserMask.Rect;
-          default:
-            return Layer.Rect;
-        }
-      }
-    }
-
-    /// <summary>
-    /// Total length of the channel data, including compression headers.
-    /// </summary>
-    public int Length { get; set; }
-
-    /// <summary>
-    /// Raw image data for this color channel, in compressed on-disk format.
-    /// </summary>
-    /// <remarks>
-    /// If null, the ImageData will be automatically compressed during save.
-    /// </remarks>
-    public byte[] ImageDataRaw { get; set; }
-
-    /// <summary>
-    /// Decompressed image data for this color channel.
-    /// </summary>
-    /// <remarks>
-    /// When making changes to the ImageData, set ImageDataRaw to null so that
-    /// the correct data will be compressed during save.
-    /// </remarks>
-    public byte[] ImageData { get; set; }
-
-    /// <summary>
-    /// Image compression method used.
-    /// </summary>
-    public ImageCompression ImageCompression { get; set; }
-
-    /// <summary>
-    /// RLE-compressed length of each row.
-    /// </summary>
-    public RleRowLengths RleRowLengths { get; set; }
-
-    //////////////////////////////////////////////////////////////////
-
-    internal Channel(short id, Layer layer)
-    {
-      ID = id;
-      Layer = layer;
-    }
-
-    internal Channel(PsdBinaryReader reader, Layer layer)
-    {
-      ID = reader.ReadInt16();
-      Length = reader.ReadInt32();
-      Layer = layer;
-    }
-
-    internal void Save(PsdBinaryWriter writer)
-    {
-      writer.Write(ID);
-      writer.Write(Length);
-    }
-
-    //////////////////////////////////////////////////////////////////
-
-    internal void LoadPixelData(PsdBinaryReader reader)
-    {
-      var endPosition = reader.BaseStream.Position + this.Length;
-      ImageCompression = (ImageCompression)reader.ReadInt16();
-      var dataLength = this.Length - 2;
-
-      switch (ImageCompression)
-      {
-        case ImageCompression.Raw:
-          ImageDataRaw = reader.ReadBytes(dataLength);
-          break;
-        case ImageCompression.Rle:
-          // RLE row lengths
-          RleRowLengths = new RleRowLengths(reader, (int)Rect.height);
-          var rleDataLength = (int)(endPosition - reader.BaseStream.Position);
-
-          // The PSD specification states that rows are padded to even sizes.
-          // However, Photoshop doesn't actually do this.  RLE rows can have
-          // odd lengths in the header, and there is no padding between rows.
-          ImageDataRaw = reader.ReadBytes(rleDataLength);
-          break;
-        case ImageCompression.Zip:
-        case ImageCompression.ZipPrediction:
-          ImageDataRaw = reader.ReadBytes(dataLength);
-          break;
-      }
-
-    }
-
-    /// <summary>
-    /// Decodes the raw image data from the compressed on-disk format into
-    /// an uncompressed bitmap, in native byte order.
-    /// </summary>
-    public void DecodeImageData()
-    {
-      if (this.ImageCompression == ImageCompression.Raw)
-        ImageData = ImageDataRaw;
-      else
-        DecompressImageData();
-
-      // Rearrange the decompressed bytes into words, with native byte order.
-      if (ImageCompression == ImageCompression.ZipPrediction)
-        UnpredictImageData(Rect);
-      else
-        ReverseEndianness(ImageData, Rect);
-    }
-
-    private void DecompressImageData()
-    {
-      using (var stream = new MemoryStream(ImageDataRaw))
-      {
-        var bytesPerRow = Util.BytesPerRow(Rect, Layer.PsdFile.BitDepth);
-        var bytesTotal = (int)Rect.height * bytesPerRow;
-        ImageData = new byte[bytesTotal];
-
-        switch (this.ImageCompression)
-        {
-          case ImageCompression.Rle:
-            var rleReader = new RleReader(stream);
-            for (int i = 0; i < Rect.height; i++)
-            {
-              int rowIndex = i * bytesPerRow;
-              rleReader.Read(ImageData, rowIndex, bytesPerRow);
-            }
-            break;
-
-          case ImageCompression.Zip:
-          case ImageCompression.ZipPrediction:
-
-            // .NET implements Deflate (RFC 1951) but not zlib (RFC 1950),
-            // so we have to skip the first two bytes.
-            stream.ReadByte();
-            stream.ReadByte();
-
-            var deflateStream = new DeflateStream(stream, CompressionMode.Decompress);
-            var bytesDecompressed = deflateStream.Read(ImageData, 0, bytesTotal);
-            break;
-
-          default:
-            throw new PsdInvalidException("Unknown image compression method.");
-        }
-      }
-    }
-
-    private void ReverseEndianness(byte[] buffer, Rect rect)
-    {
-      var byteDepth = Util.BytesFromBitDepth(Layer.PsdFile.BitDepth);
-      int pixelsTotal = (int)(rect.width * rect.height);
-      if (pixelsTotal == 0)
-        return;
-
-      if (byteDepth == 2)
-      {
-        Util.SwapByteArray2(buffer, 0, pixelsTotal);
-      }
-      else if (byteDepth == 4)
-      {
-        Util.SwapByteArray4(buffer, 0, pixelsTotal);
-      }
-      else if (byteDepth > 1)
-      {
-        throw new NotImplementedException("Byte-swapping implemented only for 16-bit and 32-bit depths.");
-      }
-    }
-
-    /// <summary>
-    /// Unpredicts the raw decompressed image data into a little-endian
-    /// scanline bitmap.
-    /// </summary>
-    unsafe private void UnpredictImageData(Rect rect)
-    {
-      if (Layer.PsdFile.BitDepth == 16)
-      {
-        // 16-bitdepth images are delta-encoded word-by-word.  The deltas
-        // are thus big-endian and must be reversed for further processing.
-        ReverseEndianness(ImageData, rect);
-
-        fixed (byte* ptrData = &ImageData[0])
-        {
-          // Delta-decode each row
-          for (int iRow = 0; iRow < rect.height; iRow++)
-          {
-            UInt16* ptr = (UInt16*)(ptrData + iRow * (int)rect.width * 2);
-            UInt16* ptrEnd = (UInt16*)(ptrData + (iRow + 1) * (int)rect.width * 2);
-
-            // Start with column index 1 on each row
-            ptr++;
-            while (ptr < ptrEnd)
-            {
-              *ptr = (UInt16)(*ptr + *(ptr - 1));
-              ptr++;
-            }
-          }
-        }
-      }
-      else if (Layer.PsdFile.BitDepth == 32)
-      {
-        var reorderedData = new byte[ImageData.Length];
-        fixed (byte* ptrData = &ImageData[0]) 
-        {
-          // Delta-decode each row
-          for (int iRow = 0; iRow < rect.height; iRow++)
-          {
-            byte* ptr = ptrData + iRow * (int)rect.width * 4;
-            byte* ptrEnd = ptrData + (iRow + 1) * (int)rect.width * 4;
-
-            // Start with column index 1 on each row
-            ptr++;
-            while (ptr < ptrEnd)
-            {
-              *ptr = (byte)(*ptr + *(ptr - 1));
-              ptr++;
-            }
-          }
-
-          // Within each row, the individual bytes of the 32-bit words are
-          // packed together, high-order bytes before low-order bytes.
-          // We now unpack them into words and reverse to little-endian.
-          int offset1 = (int)rect.width;
-          int offset2 = 2 * offset1;
-          int offset3 = 3 * offset1;
-          fixed (byte* dstPtrData = &reorderedData[0])
-          {
-            for (int iRow = 0; iRow < rect.height; iRow++)
-            {
-              byte* dstPtr = dstPtrData + iRow * (int)rect.width * 4;
-              byte* dstPtrEnd = dstPtrData + (iRow + 1) * (int)rect.width * 4;
-
-              byte* srcPtr = ptrData + iRow * (int)rect.width * 4;
-
-              // Reverse to little-endian as we do the unpacking.
-              while (dstPtr < dstPtrEnd)
-              {
-                *(dstPtr++) = *(srcPtr + offset3);
-                *(dstPtr++) = *(srcPtr + offset2);
-                *(dstPtr++) = *(srcPtr + offset1);
-                *(dstPtr++) = *srcPtr;
-
-                srcPtr++;
-              }
-            }
-          }
-        }
-
-        ImageData = reorderedData;
-      }
-      else
-      {
-        throw new PsdInvalidException("ZIP with prediction is only available for 16 and 32 bit depths.");
-      }
-    }
-
-    /// <summary>
-    /// Compresses the image data.
-    /// </summary>
-    public void CompressImageData()
-    {
-      // Do not recompress if compressed data is already present.
-      if (ImageDataRaw != null)
-        return;
-
-      if (ImageData == null)
-        return;
-
-      if (ImageCompression == ImageCompression.Raw)
-      {
-        ImageDataRaw = ImageData;
-        this.Length = 2 + ImageDataRaw.Length;
-      }
-      else if (ImageCompression == ImageCompression.Rle)
-      {
-        RleRowLengths = new RleRowLengths((int)Rect.height);
-
-        using (var dataStream = new MemoryStream())
-        {
-          var rleWriter = new RleWriter(dataStream);
-          var bytesPerRow = Util.BytesPerRow(Rect, Layer.PsdFile.BitDepth);
-          for (int row = 0; row < Rect.height; row++)
-          {
-            int rowIndex = row * (int)Rect.width;
-            RleRowLengths[row] = rleWriter.Write(
-              ImageData, rowIndex, bytesPerRow);
-          }
-
-          // Save compressed data
-          dataStream.Flush();
-          ImageDataRaw = dataStream.ToArray();
-        }
-        Length = 2 + 2 * (int)Rect.height + ImageDataRaw.Length;
-      }
-      else
-      {
-        throw new NotImplementedException("Only raw and RLE compression have been implemented.");
-      }
-    }
-
-    internal void SavePixelData(PsdBinaryWriter writer)
-    {
-      writer.Write((short)ImageCompression);
-      if (ImageDataRaw == null)
-        return;
-      
-      if (ImageCompression == PhotoshopFile.ImageCompression.Rle)
-        RleRowLengths.Write(writer);
-      writer.Write(ImageDataRaw);
-    }
-
-  }
-}
\ No newline at end of file
diff --git a/PhotoShopFileType/PsdFile/Layers/Layer.cs b/PhotoShopFileType/PsdFile/Layers/Layer.cs
deleted file mode 100644
index 38ca074..0000000
--- a/PhotoShopFileType/PsdFile/Layers/Layer.cs
+++ /dev/null
@@ -1,289 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// Portions of this file are provided under the BSD 3-clause License:
-//   Copyright (c) 2006, Jonas Beckeman
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Collections.Generic;
-using System.Collections.Specialized;
-using System.Diagnostics;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using UnityEngine;
-
-namespace PhotoshopFile
-{
-
-  [DebuggerDisplay("Name = {Name}")]
-  public class Layer
-  {
-    internal PsdFile PsdFile { get; private set; }
-
-    /// <summary>
-    /// The rectangle containing the contents of the layer.
-    /// </summary>
-    public Rect Rect { get; set; }
-
-    /// <summary>
-    /// Image channels.
-    /// </summary>
-    public ChannelList Channels { get; private set; }
-
-    /// <summary>
-    /// Returns alpha channel if it exists, otherwise null.
-    /// </summary>
-    public Channel AlphaChannel
-    {
-      get
-      {
-        if (Channels.ContainsId(-1))
-          return Channels.GetId(-1);
-        else
-          return null;
-      }
-    }
-
-    private string blendModeKey;
-    /// <summary>
-    /// Photoshop blend mode key for the layer
-    /// </summary>
-    public string BlendModeKey
-    {
-      get { return blendModeKey; }
-      set
-      {
-        if (value.Length != 4) throw new ArgumentException("Key length must be 4");
-        blendModeKey = value;
-      }
-    }
-
-    /// <summary>
-    /// 0 = transparent ... 255 = opaque
-    /// </summary>
-    public byte Opacity { get; set; }
-
-    /// <summary>
-    /// false = base, true = non-base
-    /// </summary>
-    public bool Clipping { get; set; }
-
-    private static int protectTransBit = BitVector32.CreateMask();
-    private static int visibleBit = BitVector32.CreateMask(protectTransBit);
-    BitVector32 flags = new BitVector32();
-
-    /// <summary>
-    /// If true, the layer is visible.
-    /// </summary>
-    public bool Visible
-    {
-      get { return !flags[visibleBit]; }
-      set { flags[visibleBit] = !value; }
-    }
-
-    /// <summary>
-    /// Protect the transparency
-    /// </summary>
-    public bool ProtectTrans
-    {
-      get { return flags[protectTransBit]; }
-      set { flags[protectTransBit] = value; }
-    }
-
-    /// <summary>
-    /// The descriptive layer name
-    /// </summary>
-    public string Name { get; set; }
-
-    public BlendingRanges BlendingRangesData { get; set; }
-
-    public MaskInfo Masks { get; set; }
-
-    public List<LayerInfo> AdditionalInfo { get; set; }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    public Layer(PsdFile psdFile)
-    {
-      PsdFile = psdFile;
-      Rect = new Rect();
-      Channels = new ChannelList();
-      BlendModeKey = PsdBlendMode.Normal;
-      AdditionalInfo = new List<LayerInfo>();
-    }
-
-    public Layer(PsdBinaryReader reader, PsdFile psdFile)
-      : this(psdFile)
-    {
-      Rect = reader.ReadRectangle();
-
-      //-----------------------------------------------------------------------
-      // Read channel headers.  Image data comes later, after the layer header.
-
-      int numberOfChannels = reader.ReadUInt16();
-      for (int channel = 0; channel < numberOfChannels; channel++)
-      {
-        var ch = new Channel(reader, this);
-        Channels.Add(ch);
-      }
-
-      //-----------------------------------------------------------------------
-      // 
-
-      var signature = reader.ReadAsciiChars(4);
-      if (signature != "8BIM")
-        throw (new PsdInvalidException("Invalid signature in layer header."));
-
-      BlendModeKey = reader.ReadAsciiChars(4);
-      Opacity = reader.ReadByte();
-      Clipping = reader.ReadBoolean();
-
-      var flagsByte = reader.ReadByte();
-      flags = new BitVector32(flagsByte);
-      reader.ReadByte(); //padding
-
-      //-----------------------------------------------------------------------
-
-      // This is the total size of the MaskData, the BlendingRangesData, the 
-      // Name and the AdjustmentLayerInfo.
-      var extraDataSize = reader.ReadUInt32();
-      var extraDataStartPosition = reader.BaseStream.Position;
-
-      Masks = new MaskInfo(reader, this);
-      BlendingRangesData = new BlendingRanges(reader, this);
-      Name = reader.ReadPascalString(4);
-
-      //-----------------------------------------------------------------------
-      // Process Additional Layer Information
-
-      long adjustmentLayerEndPos = extraDataStartPosition + extraDataSize;
-      while (reader.BaseStream.Position < adjustmentLayerEndPos)
-      {
-        var layerInfo = LayerInfoFactory.Load(reader);
-        AdditionalInfo.Add(layerInfo);
-      }
-
-      foreach (var adjustmentInfo in AdditionalInfo)
-      {
-        switch (adjustmentInfo.Key)
-        {
-          case "luni":
-            Name = ((LayerUnicodeName)adjustmentInfo).Name;
-            break;
-        }
-      }
-
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    /// <summary>
-    /// Create ImageData for any missing channels.
-    /// </summary>
-    public void CreateMissingChannels()
-    {
-      var channelCount = this.PsdFile.ColorMode.MinChannelCount();
-      for (short id = 0; id < channelCount; id++)
-      {
-        if (!this.Channels.ContainsId(id))
-        {
-          var size = (int)(this.Rect.height * this.Rect.width);
-
-          var ch = new Channel(id, this);
-          ch.ImageData = new byte[size];
-          unsafe
-          {
-            fixed (byte* ptr = &ch.ImageData[0])
-            {
-              Util.Fill(ptr, ptr + size, (byte)255);
-            }
-          }
-
-          this.Channels.Add(ch);
-        }
-      }
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    public void PrepareSave()
-    {
-      foreach (var ch in Channels)
-      {
-        ch.CompressImageData();
-      }
-
-      // Create or update the Unicode layer name to be consistent with the
-      // ANSI layer name.
-      var layerUnicodeNames = AdditionalInfo.Where(x => x is LayerUnicodeName);
-      if (layerUnicodeNames.Count() > 1)
-        throw new PsdInvalidException("Layer has more than one LayerUnicodeName.");
-
-      var layerUnicodeName = (LayerUnicodeName) layerUnicodeNames.FirstOrDefault();
-      if (layerUnicodeName == null)
-      {
-        layerUnicodeName = new LayerUnicodeName(Name);
-        AdditionalInfo.Add(layerUnicodeName);
-      }
-      else if (layerUnicodeName.Name != Name)
-      {
-        layerUnicodeName.Name = Name;
-      }
-    }
-
-    public void Save(PsdBinaryWriter writer)
-    {
-      writer.Write(Rect);
-
-      //-----------------------------------------------------------------------
-
-      writer.Write((short)Channels.Count);
-      foreach (var ch in Channels)
-        ch.Save(writer);
-
-      //-----------------------------------------------------------------------
-
-      writer.WriteAsciiChars("8BIM");
-      writer.WriteAsciiChars(BlendModeKey);
-      writer.Write(Opacity);
-      writer.Write(Clipping);
-
-      writer.Write((byte)flags.Data);
-
-      //-----------------------------------------------------------------------
-
-      writer.Write((byte)0);
-
-      //-----------------------------------------------------------------------
-
-      using (new PsdBlockLengthWriter(writer))
-      {
-        Masks.Save(writer);
-        BlendingRangesData.Save(writer);
-
-        var namePosition = writer.BaseStream.Position;
-
-        // Legacy layer name is limited to 31 bytes.  Unicode layer name
-        // can be much longer.
-        writer.WritePascalString(Name, 4, 31);
-
-        foreach (LayerInfo info in AdditionalInfo)
-        {
-          info.Save(writer);
-        }
-      }
-    }
-  }
-}
diff --git a/PhotoShopFileType/PsdFile/Layers/LayerInfo.cs b/PhotoShopFileType/PsdFile/Layers/LayerInfo.cs
deleted file mode 100644
index 603ae80..0000000
--- a/PhotoShopFileType/PsdFile/Layers/LayerInfo.cs
+++ /dev/null
@@ -1,94 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Diagnostics;
-using System.IO;
-
-namespace PhotoshopFile
-{
-  public static class LayerInfoFactory
-  {
-    public static LayerInfo Load(PsdBinaryReader reader)
-    {
-      Debug.WriteLine("LayerInfoFactory.Load started at " + reader.BaseStream.Position);
-      
-      var signature = reader.ReadAsciiChars(4);
-      if (signature != "8BIM")
-        throw new PsdInvalidException("Could not read LayerInfo due to signature mismatch.");
-
-      var key = reader.ReadAsciiChars(4);
-      var length = reader.ReadInt32();
-      var startPosition = reader.BaseStream.Position;
-
-      LayerInfo result;
-      switch (key)
-      {
-        case "lsct":
-        case "lsdk":
-          result = new LayerSectionInfo(reader, key, length);
-          break;
-        case "luni":
-          result = new LayerUnicodeName(reader);
-          break;
-        default:
-          result = new RawLayerInfo(reader, key, length);
-          break;
-      }
-
-      // May have additional padding applied.
-      var endPosition = startPosition + length;
-      if (reader.BaseStream.Position < endPosition)
-        reader.BaseStream.Position = endPosition;
-
-      // Documentation states that the length is even-padded.  Actually:
-      //   1. Most keys have 4-padded lengths.
-      //   2. However, some keys (LMsk) have even-padded lengths.
-      //   3. Other keys (Txt2, Lr16, Lr32) have unpadded lengths.
-      //
-      // The data is always 4-padded, regardless of the stated length.
-
-      reader.ReadPadding(startPosition, 4);
-
-      return result;
-    }
-  }
-
-  public abstract class LayerInfo
-  {
-    public abstract string Key { get; }
-
-    protected abstract void WriteData(PsdBinaryWriter writer);
-
-    public void Save(PsdBinaryWriter writer)
-    {
-      Debug.WriteLine("LayerInfo.Save started at " + writer.BaseStream.Position);
-
-      writer.WriteAsciiChars("8BIM");
-      writer.WriteAsciiChars(Key);
-
-      var startPosition = writer.BaseStream.Position;
-      using (var lengthWriter = new PsdBlockLengthWriter(writer))
-      {
-        // Depending on the key, the length may be unpadded, 2-padded, or
-        // 4-padded.  Thus, it is up to each implementation of WriteData to
-        // pad the length correctly.
-        WriteData(writer);
-      }
-
-      // Regardless of how the length is padded, the data is always padded to
-      // a multiple of 4.
-      writer.WritePadding(startPosition, 4);
-    }
-  }
-}
diff --git a/PhotoShopFileType/PsdFile/Layers/LayerInfo/LayerSectionInfo.cs b/PhotoShopFileType/PsdFile/Layers/LayerInfo/LayerSectionInfo.cs
deleted file mode 100644
index 8da5059..0000000
--- a/PhotoShopFileType/PsdFile/Layers/LayerInfo/LayerSectionInfo.cs
+++ /dev/null
@@ -1,98 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-
-namespace PhotoshopFile
-{
-  public enum LayerSectionType
-  {
-    Layer = 0,
-    OpenFolder = 1,
-    ClosedFolder = 2,
-    SectionDivider = 3
-  }
-
-  public enum LayerSectionSubtype
-  {
-    Normal = 0,
-    SceneGroup = 1
-  }
-
-  /// <summary>
-  /// Layer sections are known as Groups in the Photoshop UI.
-  /// </summary>
-  public class LayerSectionInfo : LayerInfo
-  {
-    private string key;
-    public override string Key
-    {
-      get { return key; }
-    }
-
-    public LayerSectionType SectionType { get; set; }
-
-    private LayerSectionSubtype? subtype;
-    public LayerSectionSubtype Subtype
-    {
-      get { return subtype ?? LayerSectionSubtype.Normal; }
-      set { subtype = value; }
-    }
-
-    private string blendModeKey;
-    public string BlendModeKey
-    {
-      get { return blendModeKey; }
-      set
-      {
-        if (value.Length != 4)
-          throw new ArgumentException("Blend mode key must have a length of 4.");
-        blendModeKey = value;
-      }
-    }
-
-    public LayerSectionInfo(PsdBinaryReader reader, string key, int dataLength)
-    {
-      // The key for layer section info is documented to be "lsct".  However,
-      // some Photoshop files use the undocumented key "lsdk", with apparently
-      // the same data format.
-      this.key = key;
-
-      SectionType = (LayerSectionType)reader.ReadInt32();
-      if (dataLength >= 12)
-      {
-        var signature = reader.ReadAsciiChars(4);
-        if (signature != "8BIM")
-          throw new PsdInvalidException("Invalid section divider signature.");
-
-        BlendModeKey = reader.ReadAsciiChars(4);
-        if (dataLength >= 16)
-        {
-          Subtype = (LayerSectionSubtype)reader.ReadInt32();
-        }
-      }
-    }
-
-    protected override void WriteData(PsdBinaryWriter writer)
-    {
-      writer.Write((Int32)SectionType);
-      if (BlendModeKey != null)
-      {
-        writer.WriteAsciiChars("8BIM");
-        writer.WriteAsciiChars(BlendModeKey);
-        if (subtype != null)
-          writer.Write((Int32)Subtype);
-      }
-    }
-  }
-}
diff --git a/PhotoShopFileType/PsdFile/Layers/LayerInfo/LayerUnicodeName.cs b/PhotoShopFileType/PsdFile/Layers/LayerInfo/LayerUnicodeName.cs
deleted file mode 100644
index 00c5e3b..0000000
--- a/PhotoShopFileType/PsdFile/Layers/LayerInfo/LayerUnicodeName.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-
-namespace PhotoshopFile
-{
-  public class LayerUnicodeName : LayerInfo
-  {
-    public override string Key
-    {
-      get { return "luni"; }
-    }
-
-    public string Name { get; set; }
-
-    public LayerUnicodeName(string name)
-    {
-      Name = name;
-    }
-
-    public LayerUnicodeName(PsdBinaryReader reader)
-    {
-      Name = reader.ReadUnicodeString();
-    }
-
-    protected override void WriteData(PsdBinaryWriter writer)
-    {
-      var startPosition = writer.BaseStream.Position;
-
-      writer.WriteUnicodeString(Name);
-      writer.WritePadding(startPosition, 4);
-    }
-  }
-}
diff --git a/PhotoShopFileType/PsdFile/Layers/LayerInfo/RawLayerInfo.cs b/PhotoShopFileType/PsdFile/Layers/LayerInfo/RawLayerInfo.cs
deleted file mode 100644
index 8f9400d..0000000
--- a/PhotoShopFileType/PsdFile/Layers/LayerInfo/RawLayerInfo.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Diagnostics;
-
-namespace PhotoshopFile
-{
-  [DebuggerDisplay("Layer Info: { key }")]
-  public class RawLayerInfo : LayerInfo
-  {
-    private string key;
-    public override string Key
-    {
-      get { return key; }
-    }
-
-    public byte[] Data { get; private set; }
-
-    public RawLayerInfo(string key)
-    {
-      this.key = key;
-    }
-
-    public RawLayerInfo(PsdBinaryReader reader, string key, int dataLength)
-    {
-      this.key = key;
-      Data = reader.ReadBytes((int)dataLength);
-    }
-
-    protected override void WriteData(PsdBinaryWriter writer)
-    {
-      writer.Write(Data);
-    }
-  }
-}
diff --git a/PhotoShopFileType/PsdFile/Layers/Mask.cs b/PhotoShopFileType/PsdFile/Layers/Mask.cs
deleted file mode 100644
index 3bd725d..0000000
--- a/PhotoShopFileType/PsdFile/Layers/Mask.cs
+++ /dev/null
@@ -1,176 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// Portions of this file are provided under the BSD 3-clause License:
-//   Copyright (c) 2006, Jonas Beckeman
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Collections.Specialized;
-using System.Diagnostics;
-using System.Globalization;
-using UnityEngine;
-
-namespace PhotoshopFile
-{
-  public class Mask
-  {
-    /// <summary>
-    /// The layer to which this mask belongs
-    /// </summary>
-    public Layer Layer { get; private set; }
-
-    /// <summary>
-    /// The rectangle enclosing the mask.
-    /// </summary>
-    public Rect Rect { get; set; }
-
-    private byte backgroundColor;
-    public byte BackgroundColor
-    {
-      get { return backgroundColor; }
-      set
-      {
-        if ((value != 0) && (value != 255))
-          throw new PsdInvalidException("Mask background must be fully-opaque or fully-transparent.");
-        backgroundColor = value;
-      }
-    }
-
-    private static int positionVsLayerBit = BitVector32.CreateMask();
-    private static int disabledBit = BitVector32.CreateMask(positionVsLayerBit);
-    private static int invertOnBlendBit = BitVector32.CreateMask(disabledBit);
-
-    private BitVector32 flags;
-    public BitVector32 Flags { get { return flags; } }
-
-    /// <summary>
-    /// If true, the position of the mask is relative to the layer.
-    /// </summary>
-    public bool PositionVsLayer
-    {
-      get { return flags[positionVsLayerBit]; }
-      set { flags[positionVsLayerBit] = value; }
-    }
-
-    public bool Disabled
-    {
-      get { return flags[disabledBit]; }
-      set { flags[disabledBit] = value; }
-    }
-
-    /// <summary>
-    /// if true, invert the mask when blending.
-    /// </summary>
-    public bool InvertOnBlend
-    {
-      get { return flags[invertOnBlendBit]; }
-      set { flags[invertOnBlendBit] = value; }
-    }
-
-    /// <summary>
-    /// Mask image data.
-    /// </summary>
-    public byte[] ImageData { get; set; }
-
-    public Mask(Layer layer)
-    {
-      Layer = layer;
-      this.flags = new BitVector32();
-    }
-
-    public Mask(Layer layer, Rect rect, byte color, BitVector32 flags)
-    {
-      Layer = layer;
-      Rect = rect;
-      BackgroundColor = color;
-      this.flags = flags;
-    }
-  }
-
-  /// <summary>
-  /// Mask info for a layer.  Contains both the layer and user masks.
-  /// </summary>
-  public class MaskInfo
-  {
-    public Mask LayerMask { get; set; }
-
-    public Mask UserMask { get; set; }
-
-    /// <summary>
-    /// Construct MaskInfo with null masks.
-    /// </summary>
-    public MaskInfo()
-    {
-    }
-
-    public MaskInfo(PsdBinaryReader reader, Layer layer)
-    {
-      var maskLength = reader.ReadUInt32();
-      if (maskLength <= 0)
-        return;
-
-      var startPosition = reader.BaseStream.Position;
-      var endPosition = startPosition + maskLength;
-
-      // Read layer mask
-      var rectangle = reader.ReadRectangle();
-      var backgroundColor = reader.ReadByte();
-      var flagsByte = reader.ReadByte();
-      LayerMask = new Mask(layer, rectangle, backgroundColor, new BitVector32(flagsByte));
-
-      // User mask is supplied separately when there is also a vector mask.
-      if (maskLength == 36)
-      {
-        var userFlagsByte = reader.ReadByte();
-        var userBackgroundColor = reader.ReadByte();
-        var userRectangle = reader.ReadRectangle();
-        UserMask = new Mask(layer, userRectangle, userBackgroundColor,
-          new BitVector32(userFlagsByte));
-      }
-
-      // 20-byte mask data will end with padding.
-      reader.BaseStream.Position = endPosition;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    public void Save(PsdBinaryWriter writer)
-    {
-      if (LayerMask == null)
-      {
-        writer.Write((UInt32)0);
-        return;
-      }
-
-      using (new PsdBlockLengthWriter(writer))
-      {
-        writer.Write(LayerMask.Rect);
-        writer.Write(LayerMask.BackgroundColor);
-        writer.Write((byte)LayerMask.Flags.Data);
-
-        if (UserMask == null)
-        {
-          // Pad by 2 bytes to make the block length 20
-          writer.Write((UInt16)0);
-        }
-        else
-        {
-          writer.Write((byte)UserMask.Flags.Data);
-          writer.Write(UserMask.BackgroundColor);
-          writer.Write(UserMask.Rect);
-        }
-      }
-    }
-
-  }
-}
\ No newline at end of file
diff --git a/PhotoShopFileType/PsdFile/PsdBinaryReader.cs b/PhotoShopFileType/PsdFile/PsdBinaryReader.cs
deleted file mode 100644
index 3b368ec..0000000
--- a/PhotoShopFileType/PsdFile/PsdBinaryReader.cs
+++ /dev/null
@@ -1,225 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// Portions of this file are provided under the BSD 3-clause License:
-//   Copyright (c) 2006, Jonas Beckeman
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.IO;
-using System.Text;
-using UnityEngine;
-
-namespace PhotoshopFile
-{
-  /// <summary>
-  /// Reads PSD data types in big-endian byte order.
-  /// </summary>
-  public class PsdBinaryReader : IDisposable
-  {
-    private BinaryReader reader;
-    private Encoding encoding;
-
-    public Stream BaseStream
-    {
-      get { return reader.BaseStream; }
-    }
-
-    public PsdBinaryReader(Stream stream, PsdBinaryReader reader)
-      : this (stream, reader.encoding)
-    {
-    }
-    
-    public PsdBinaryReader(Stream stream, Encoding encoding)
-    {
-      this.encoding = encoding;
-
-      // ReadPascalString and ReadUnicodeString handle encoding explicitly.
-      // BinaryReader.ReadString() is never called, so it is constructed with
-      // ASCII encoding to make accidental usage obvious.
-      reader = new BinaryReader(stream, Encoding.ASCII);
-    }
-
-    public byte ReadByte()
-    {
-      return reader.ReadByte();
-    }
-
-    public byte[] ReadBytes(int count)
-    {
-      return reader.ReadBytes(count);
-    }
-
-    public bool ReadBoolean()
-    {
-      return reader.ReadBoolean();
-    }
-
-    public Int16 ReadInt16()
-    {
-      var val = reader.ReadInt16();
-      unsafe
-      {
-        Util.SwapBytes((byte*)&val, 2);
-      }
-      return val;
-    }
-
-    public Int32 ReadInt32()
-    {
-      var val = reader.ReadInt32();
-      unsafe
-      {
-        Util.SwapBytes((byte*)&val, 4);
-      }
-      return val;
-    }
-
-    public Int64 ReadInt64()
-    {
-      var val = reader.ReadInt64();
-      unsafe
-      {
-        Util.SwapBytes((byte*)&val, 8);
-      }
-      return val;
-    }
-
-    public UInt16 ReadUInt16()
-    {
-      var val = reader.ReadUInt16();
-      unsafe
-      {
-        Util.SwapBytes((byte*)&val, 2);
-      }
-      return val;
-    }
-
-    public UInt32 ReadUInt32()
-    {
-      var val = reader.ReadUInt32();
-      unsafe
-      {
-        Util.SwapBytes((byte*)&val, 4);
-      }
-      return val;
-    }
-
-    public UInt64 ReadUInt64()
-    {
-      var val = reader.ReadUInt64();
-      unsafe
-      {
-        Util.SwapBytes((byte*)&val, 8);
-      }
-      return val;
-    }
-
-    //////////////////////////////////////////////////////////////////
-
-    /// <summary>
-    /// Read padding to get to the byte multiple for the block.
-    /// </summary>
-    /// <param name="startPosition">Starting position of the padded block.</param>
-    /// <param name="padMultiple">Byte multiple that the block is padded to.</param>
-    public void ReadPadding(long startPosition, int padMultiple)
-    {
-      // Pad to specified byte multiple
-      var totalLength = reader.BaseStream.Position - startPosition;
-      var padBytes = Util.GetPadding((int)totalLength, padMultiple);
-      ReadBytes(padBytes);
-    }
-
-    public Rect ReadRectangle()
-    {
-      var rect = new Rect();
-      rect.y = ReadInt32();
-      rect.x = ReadInt32();
-      rect.height = ReadInt32() - rect.y;
-      rect.width = ReadInt32() - rect.x;
-      return rect;
-    }
-
-    /// <summary>
-    /// Read a fixed-length ASCII string.
-    /// </summary>
-    public string ReadAsciiChars(int count)
-    {
-      var bytes = reader.ReadBytes(count); ;
-      var s = Encoding.ASCII.GetString(bytes);
-      return s;
-    }
-
-    /// <summary>
-    /// Read a Pascal string using the specified encoding.
-    /// </summary>
-    /// <param name="padMultiple">Byte multiple that the Pascal string is padded to.</param>
-    public string ReadPascalString(int padMultiple)
-    {
-      var startPosition = reader.BaseStream.Position;
-
-      byte stringLength = ReadByte();
-      var bytes = ReadBytes(stringLength);
-      ReadPadding(startPosition, padMultiple);
-
-      // Default decoder uses best-fit fallback, so it will not throw any
-      // exceptions if unknown characters are encountered.
-      var str = encoding.GetString(bytes);
-      return str;
-    }
-
-    public string ReadUnicodeString()
-    {
-      var numChars = ReadInt32();
-      var length = 2 * numChars;
-      var data = ReadBytes(length);
-      var str = Encoding.BigEndianUnicode.GetString(data, 0, length);
-
-      return str;
-    }
-
-    //////////////////////////////////////////////////////////////////
-
-    # region IDisposable
-
-    private bool disposed = false;
-
-    public void Dispose()
-    {
-      Dispose(true);
-      GC.SuppressFinalize(this);
-    }
-
-    protected virtual void Dispose(bool disposing)
-    {
-      // Check to see if Dispose has already been called. 
-      if (disposed)
-        return;
-
-      if (disposing)
-      {
-        if (reader != null)
-        {
-          // BinaryReader.Dispose() is protected.
-          reader.Close();
-          reader = null;
-        }
-      }
-
-      disposed = true;
-    }
-
-    #endregion
-
-  }
-
-}
\ No newline at end of file
diff --git a/PhotoShopFileType/PsdFile/PsdBinaryWriter.cs b/PhotoShopFileType/PsdFile/PsdBinaryWriter.cs
deleted file mode 100644
index 1c772d2..0000000
--- a/PhotoShopFileType/PsdFile/PsdBinaryWriter.cs
+++ /dev/null
@@ -1,255 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// Portions of this file are provided under the BSD 3-clause License:
-//   Copyright (c) 2006, Jonas Beckeman
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.IO;
-using System.Text;
-using UnityEngine;
-
-namespace PhotoshopFile
-{
-  /// <summary>
-  /// Writes PSD data types in big-endian byte order.
-  /// </summary>
-  public class PsdBinaryWriter : IDisposable
-  {
-    private BinaryWriter writer;
-    private Encoding encoding;
-
-    public Stream BaseStream
-    {
-      get { return writer.BaseStream; }
-    }
-
-    public bool AutoFlush { get; set; }
-
-    public PsdBinaryWriter(Stream stream, Encoding encoding)
-    {
-      this.encoding = encoding;
-
-      // BinaryWriter.Write(String) cannot be used, as it writes a UTF-7
-      // (variable-sized) length integer, while PSD strings have a fixed-size
-      // length field.  Encoding is set to ASCII to catch any accidental usage.
-      writer = new BinaryWriter(stream, Encoding.ASCII);
-    }
-
-    public void Flush()
-    {
-      writer.Flush();
-    }
-
-    public void Write(Rect rect)
-    {
-      Write((int)rect.top);
-      Write((int)rect.left);
-      Write((int)rect.bottom);
-      Write((int)rect.right);
-    }
-
-    /// <summary>
-    /// Pad the length of a block to a multiple.
-    /// </summary>
-    /// <param name="startPosition">Starting position of the padded block.</param>
-    /// <param name="padMultiple">Byte multiple to pad to.</param>
-    public void WritePadding(long startPosition, int padMultiple)
-    {
-      var length = writer.BaseStream.Position - startPosition;
-      var padBytes = Util.GetPadding((int)length, padMultiple);
-      for (long i = 0; i < padBytes; i++)
-        writer.Write((byte)0);
-
-      if (AutoFlush)
-        Flush();
-    }
-
-    /// <summary>
-    /// Write string as ASCII characters, without a length prefix.
-    /// </summary>
-    public void WriteAsciiChars(string s)
-    {
-      var bytes = Encoding.ASCII.GetBytes(s);
-      writer.Write(bytes);
-
-      if (AutoFlush)
-        Flush();
-    }
-
-
-    /// <summary>
-    /// Writes a Pascal string using the specified encoding.
-    /// </summary>
-    /// <param name="s">Unicode string to convert to the encoding.</param>
-    /// <param name="padMultiple">Byte multiple that the Pascal string is padded to.</param>
-    /// <param name="maxBytes">Maximum number of bytes to write.</param>
-    public void WritePascalString(string s, int padMultiple, byte maxBytes = 255)
-    {
-      var startPosition = writer.BaseStream.Position;
-
-      byte[] bytesArray = encoding.GetBytes(s);
-      if (bytesArray.Length > maxBytes)
-      {
-        var tempArray = new byte[maxBytes];
-        Array.Copy(bytesArray, tempArray, maxBytes);
-        bytesArray = tempArray;
-      }
-
-      writer.Write((byte)bytesArray.Length);
-      writer.Write(bytesArray);
-      WritePadding(startPosition, padMultiple);
-    }
-
-    /// <summary>
-    /// Write a Unicode string to the stream.
-    /// </summary>
-    public void WriteUnicodeString(string s)
-    {
-      Write(s.Length);
-      var data = Encoding.BigEndianUnicode.GetBytes(s);
-      Write(data);
-    }
-
-    public void Write(bool value)
-    {
-      writer.Write(value);
-
-      if (AutoFlush)
-        Flush();
-    }
-
-    public void Write(byte[] value)
-    {
-      writer.Write(value);
-
-      if (AutoFlush)
-        Flush();
-    }
-
-    public void Write(byte value)
-    {
-      writer.Write(value);
-
-      if (AutoFlush)
-        Flush();
-    }
-
-    public void Write(Int16 value)
-    {
-      unsafe
-      {
-        Util.SwapBytes2((byte*)&value);
-      }
-      writer.Write(value);
-
-      if (AutoFlush)
-        Flush();
-    }
-
-    public void Write(Int32 value)
-    {
-      unsafe
-      {
-        Util.SwapBytes4((byte*)&value);
-      }
-      writer.Write(value);
-
-      if (AutoFlush)
-        Flush();
-    }
-
-    public void Write(Int64 value)
-    {
-      unsafe
-      {
-        Util.SwapBytes((byte*)&value, 8);
-      }
-      writer.Write(value);
-
-      if (AutoFlush)
-        Flush();
-    }
-
-    public void Write(UInt16 value)
-    {
-      unsafe
-      {
-        Util.SwapBytes2((byte*)&value);
-      }
-      writer.Write(value);
-
-      if (AutoFlush)
-        Flush();
-    }
-
-    public void Write(UInt32 value)
-    {
-      unsafe
-      {
-        Util.SwapBytes4((byte*)&value);
-      }
-      writer.Write(value);
-
-      if (AutoFlush)
-        Flush();
-    }
-
-    public void Write(UInt64 value)
-    {
-      unsafe
-      {
-        Util.SwapBytes((byte*)&value, 8);
-      }
-      writer.Write(value);
-
-      if (AutoFlush)
-        Flush();
-    }
-
-
-    //////////////////////////////////////////////////////////////////
-
-    # region IDisposable
-
-    private bool disposed = false;
-
-    public void Dispose()
-    {
-      Dispose(true);
-      GC.SuppressFinalize(this);
-    }
-
-    protected virtual void Dispose(bool disposing)
-    {
-      // Check to see if Dispose has already been called. 
-      if (disposed)
-        return;
-
-      if (disposing)
-      {
-        if (writer != null)
-        {
-          // BinaryWriter.Dispose() is protected.
-          writer.Close();
-          writer = null;
-        }
-      }
-
-      disposed = true;
-    }
-
-    #endregion
-
-  }
-}
\ No newline at end of file
diff --git a/PhotoShopFileType/PsdFile/PsdBlendMode.cs b/PhotoShopFileType/PsdFile/PsdBlendMode.cs
deleted file mode 100644
index 4948a18..0000000
--- a/PhotoShopFileType/PsdFile/PsdBlendMode.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2012 Tao Yue
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace PhotoshopFile
-{
-  public static class PsdBlendMode
-  {
-    public const string Normal = "norm";
-    public const string Darken = "dark";
-    public const string Lighten = "lite";
-    public const string Hue = "hue ";
-    public const string Saturation = "sat ";
-    public const string Color = "colr";
-    public const string Luminosity = "lum ";
-    public const string Multiply = "mul ";
-    public const string Screen = "scrn";
-    public const string Dissolve = "diss";
-    public const string Overlay = "over";
-    public const string HardLight = "hLit";
-    public const string SoftLight = "sLit";
-    public const string Difference = "diff";
-    public const string Exclusion = "smud";
-    public const string ColorDodge = "div ";
-    public const string ColorBurn = "idiv";
-    public const string LinearBurn = "lbrn";
-    public const string LinearDodge = "lddg";
-    public const string VividLight = "vLit";
-    public const string LinearLight = "lLit";
-    public const string PinLight = "pLit";
-    public const string HardMix = "hMix";
-    public const string PassThrough = "pass";
-    public const string DarkerColor = "dkCl";
-    public const string LighterColor = "lgCl";
-    public const string Subtract = "fsub";
-    public const string Divide = "fdiv";
-  }
-}
diff --git a/PhotoShopFileType/PsdFile/PsdBlockLengthWriter.cs b/PhotoShopFileType/PsdFile/PsdBlockLengthWriter.cs
deleted file mode 100644
index 8d49d2d..0000000
--- a/PhotoShopFileType/PsdFile/PsdBlockLengthWriter.cs
+++ /dev/null
@@ -1,70 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2012 Tao Yue
-//
-// Portions of this file are provided under the BSD 3-clause License:
-//   Copyright (c) 2006, Jonas Beckeman
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.IO;
-using System.Text;
-
-namespace PhotoshopFile
-{
-  /// <summary>
-  /// Writes the actual length in front of the data block upon disposal.
-  /// </summary>
-  class PsdBlockLengthWriter : IDisposable
-  {
-    private bool disposed = false;
-
-    long lengthPosition;
-    long startPosition;
-    PsdBinaryWriter writer;
-
-    public PsdBlockLengthWriter(PsdBinaryWriter writer)
-    {
-      this.writer = writer;
-
-      // Store position so that we can return to it when the length is known.
-      lengthPosition = writer.BaseStream.Position;
-
-      // Write a sentinel value as a placeholder for the length.
-      writer.Write((UInt32)0xFEEDFEED);
-
-      // Store the start position of the data block so that we can calculate
-      // its length when we're done writing.
-      startPosition = writer.BaseStream.Position;
-    }
-
-    public void Write()
-    {
-      var endPosition = writer.BaseStream.Position;
-
-      writer.BaseStream.Position = lengthPosition;
-      long length = endPosition - startPosition;
-      writer.Write((UInt32)length);
-
-      writer.BaseStream.Position = endPosition;
-    }
-
-    public void Dispose()
-    {
-      if (!this.disposed)
-      {
-        Write();
-        this.disposed = true;
-      }
-    }
-  }
-
-}
\ No newline at end of file
diff --git a/PhotoShopFileType/PsdFile/PsdFile.cs b/PhotoShopFileType/PsdFile/PsdFile.cs
deleted file mode 100644
index 50baadd..0000000
--- a/PhotoShopFileType/PsdFile/PsdFile.cs
+++ /dev/null
@@ -1,661 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// Portions of this file are provided under the BSD 3-clause License:
-//   Copyright (c) 2006, Jonas Beckeman
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading;
-using UnityEngine;
-
-
-namespace PhotoshopFile {
-    public enum PsdColorMode {
-        Bitmap = 0,
-        Grayscale = 1,
-        Indexed = 2,
-        RGB = 3,
-        CMYK = 4,
-        Multichannel = 7,
-        Duotone = 8,
-        Lab = 9
-    };
-
-
-    public class PsdFile {
-        /// <summary>
-        /// Represents the composite image.
-        /// </summary>
-        public Layer BaseLayer { get; set; }
-
-        public ImageCompression ImageCompression { get; set; }
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        public PsdFile() {
-            Version = 1;
-            BaseLayer = new Layer(this);
-
-            ImageResources = new ImageResources();
-            Layers = new List<Layer>();
-            AdditionalInfo = new List<LayerInfo>();
-        }
-
-        public PsdFile(string filename, Encoding encoding)
-            : this() {
-            using (var stream = new FileStream(filename, FileMode.Open)) {
-                Load(stream, encoding);
-            }
-        }
-
-        public PsdFile(Stream stream, Encoding encoding)
-            : this() {
-            Load(stream, encoding);
-        }
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        private void Load(Stream stream, Encoding encoding) {
-            var reader = new PsdBinaryReader(stream, encoding);
-
-            LoadHeader(reader);
-            LoadColorModeData(reader);
-            LoadImageResources(reader);
-            LoadLayerAndMaskInfo(reader);
-
-            LoadImage(reader);
-            DecompressImages();
-        }
-
-        public void Save(string fileName, Encoding encoding) {
-            using (var stream = new FileStream(fileName, FileMode.Create)) {
-                Save(stream, encoding);
-            }
-        }
-
-        public void Save(Stream stream, Encoding encoding) {
-            if (BitDepth != 8)
-                throw new NotImplementedException("Only 8-bit color has been implemented for saving.");
-
-            var writer = new PsdBinaryWriter(stream, encoding);
-            writer.AutoFlush = true;
-
-            PrepareSave();
-
-            SaveHeader(writer);
-            SaveColorModeData(writer);
-            SaveImageResources(writer);
-            SaveLayerAndMaskInfo(writer);
-            SaveImage(writer);
-        }
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        #region Header
-
-        /// <summary>
-        /// Always equal to 1.
-        /// </summary>
-        public Int16 Version { get; private set; }
-
-        private Int16 channelCount;
-        /// <summary>
-        /// The number of channels in the image, including any alpha channels.
-        /// </summary>
-        public Int16 ChannelCount {
-            get { return channelCount; }
-            set {
-                if (value < 1 || value > 56)
-                    throw new ArgumentException("Number of channels must be from 1 to 56.");
-                channelCount = value;
-            }
-        }
-
-        /// <summary>
-        /// The height of the image in pixels.
-        /// </summary>
-        public int RowCount {
-            get { return (int)this.BaseLayer.Rect.height; }
-            set {
-                if (value < 0 || value > 30000)
-                    throw new ArgumentException("Number of rows must be from 1 to 30000.");
-                BaseLayer.Rect = new Rect(0, 0, BaseLayer.Rect.width, value);
-            }
-        }
-
-
-        /// <summary>
-        /// The width of the image in pixels. 
-        /// </summary>
-        public int ColumnCount {
-            get { return (int)this.BaseLayer.Rect.width; }
-            set {
-                if (value < 0 || value > 30000)
-                    throw new ArgumentException("Number of columns must be from 1 to 30000.");
-                this.BaseLayer.Rect = new Rect(0, 0, value, this.BaseLayer.Rect.height);
-            }
-        }
-
-        private int bitDepth;
-        /// <summary>
-        /// The number of bits per channel. Supported values are 1, 8, 16, and 32.
-        /// </summary>
-        public int BitDepth {
-            get { return bitDepth; }
-            set {
-                switch (value) {
-                    case 1:
-                    case 8:
-                    case 16:
-                    case 32:
-                        bitDepth = value;
-                        break;
-                    default:
-                        throw new NotImplementedException("Invalid bit depth.");
-                }
-            }
-        }
-
-        /// <summary>
-        /// The color mode of the file.
-        /// </summary>
-        public PsdColorMode ColorMode { get; set; }
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        private void LoadHeader(PsdBinaryReader reader) {
-            var signature = reader.ReadAsciiChars(4);
-            if (signature != "8BPS")
-                throw new PsdInvalidException("The given stream is not a valid PSD file");
-
-            Version = reader.ReadInt16();
-            if (Version != 1)
-                throw new PsdInvalidException("The PSD file has an unknown version");
-
-            //6 bytes reserved
-            reader.BaseStream.Position += 6;
-
-            this.ChannelCount = reader.ReadInt16();
-            this.RowCount = reader.ReadInt32();
-            this.ColumnCount = reader.ReadInt32();
-            BitDepth = reader.ReadInt16();
-            ColorMode = (PsdColorMode)reader.ReadInt16();
-        }
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        private void SaveHeader(PsdBinaryWriter writer) {
-            string signature = "8BPS";
-            writer.WriteAsciiChars(signature);
-            writer.Write(Version);
-            writer.Write(new byte[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, });
-            writer.Write(ChannelCount);
-            writer.Write(RowCount);
-            writer.Write(ColumnCount);
-            writer.Write((Int16)BitDepth);
-            writer.Write((Int16)ColorMode);
-        }
-
-        #endregion
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        #region ColorModeData
-
-        /// <summary>
-        /// If ColorMode is ColorModes.Indexed, the following 768 bytes will contain 
-        /// a 256-color palette. If the ColorMode is ColorModes.Duotone, the data 
-        /// following presumably consists of screen parameters and other related information. 
-        /// Unfortunately, it is intentionally not documented by Adobe, and non-Photoshop 
-        /// readers are advised to treat duotone images as gray-scale images.
-        /// </summary>
-        public byte[] ColorModeData = new byte[0];
-
-        private void LoadColorModeData(PsdBinaryReader reader) {
-            var paletteLength = reader.ReadUInt32();
-            if (paletteLength > 0) {
-                ColorModeData = reader.ReadBytes((int)paletteLength);
-            }
-        }
-
-        private void SaveColorModeData(PsdBinaryWriter writer) {
-            writer.Write((UInt32)ColorModeData.Length);
-            writer.Write(ColorModeData);
-        }
-
-        #endregion
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        #region ImageResources
-
-        /// <summary>
-        /// The Image resource blocks for the file
-        /// </summary>
-        public ImageResources ImageResources { get; set; }
-
-        public ResolutionInfo Resolution {
-            get {
-                return (ResolutionInfo)ImageResources.Get(ResourceID.ResolutionInfo);
-            }
-
-            set {
-                ImageResources.Set(value);
-            }
-        }
-
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        private void LoadImageResources(PsdBinaryReader reader) {
-            var imageResourcesLength = reader.ReadUInt32();
-            if (imageResourcesLength <= 0)
-                return;
-
-            var startPosition = reader.BaseStream.Position;
-            var endPosition = startPosition + imageResourcesLength;
-            while (reader.BaseStream.Position < endPosition) {
-                var imageResource = ImageResourceFactory.CreateImageResource(reader);
-                ImageResources.Add(imageResource);
-            }
-
-            //-----------------------------------------------------------------------
-            // make sure we are not on a wrong offset, so set the stream position 
-            // manually
-            reader.BaseStream.Position = startPosition + imageResourcesLength;
-        }
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        private void SaveImageResources(PsdBinaryWriter writer) {
-            using (new PsdBlockLengthWriter(writer)) {
-                foreach (var imgRes in ImageResources)
-                    imgRes.Save(writer);
-            }
-        }
-
-        #endregion
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        #region LayerAndMaskInfo
-
-        public List<Layer> Layers { get; private set; }
-
-        public List<LayerInfo> AdditionalInfo { get; private set; }
-
-        public bool AbsoluteAlpha { get; set; }
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        private void LoadLayerAndMaskInfo(PsdBinaryReader reader) {
-            var layersAndMaskLength = reader.ReadUInt32();
-            if (layersAndMaskLength <= 0)
-                return;
-
-            var startPosition = reader.BaseStream.Position;
-            var endPosition = startPosition + layersAndMaskLength;
-
-            LoadLayers(reader, true);
-            LoadGlobalLayerMask(reader);
-
-            //-----------------------------------------------------------------------
-            // Load Additional Layer Information
-
-            while (reader.BaseStream.Position < endPosition) {
-                var info = LayerInfoFactory.Load(reader);
-                AdditionalInfo.Add(info);
-
-                if (info is RawLayerInfo) {
-                    var layerInfo = (RawLayerInfo)info;
-                    switch (info.Key) {
-                        case "Layr":
-                        case "Lr16":
-                        case "Lr32":
-                            using (var memoryStream = new MemoryStream(layerInfo.Data))
-                            using (var memoryReader = new PsdBinaryReader(memoryStream, reader)) {
-                                LoadLayers(memoryReader, false);
-                            }
-                            break;
-
-                        case "LMsk":
-                            GlobalLayerMaskData = layerInfo.Data;
-                            break;
-                    }
-                }
-            }
-
-            //-----------------------------------------------------------------------
-            // make sure we are not on a wrong offset, so set the stream position 
-            // manually
-            reader.BaseStream.Position = startPosition + layersAndMaskLength;
-        }
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        private void SaveLayerAndMaskInfo(PsdBinaryWriter writer) {
-            using (new PsdBlockLengthWriter(writer)) {
-                var startPosition = writer.BaseStream.Position;
-
-                SaveLayers(writer);
-                SaveGlobalLayerMask(writer);
-
-                foreach (var info in AdditionalInfo)
-                    info.Save(writer);
-
-                writer.WritePadding(startPosition, 2);
-            }
-        }
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        /// <summary>
-        /// Load Layers Info section, including image data.
-        /// </summary>
-        /// <param name="reader">PSD reader.</param>
-        /// <param name="hasHeader">Whether the Layers Info section has a length header.</param>
-        private void LoadLayers(PsdBinaryReader reader, bool hasHeader) {
-            UInt32 sectionLength = 0;
-            if (hasHeader) {
-                sectionLength = reader.ReadUInt32();
-                if (sectionLength <= 0)
-                    return;
-            }
-
-            var startPosition = reader.BaseStream.Position;
-            var numLayers = reader.ReadInt16();
-
-            // If numLayers < 0, then number of layers is absolute value,
-            // and the first alpha channel contains the transparency data for
-            // the merged result.
-            if (numLayers < 0) {
-                AbsoluteAlpha = true;
-                numLayers = Math.Abs(numLayers);
-            }
-            if (numLayers == 0)
-                return;
-
-            for (int i = 0; i < numLayers; i++) {
-                var layer = new Layer(reader, this);
-                Layers.Add(layer);
-            }
-
-            //-----------------------------------------------------------------------
-
-            // Load image data for all channels.
-            foreach (var layer in Layers) {
-                foreach (var channel in layer.Channels) {
-                    channel.LoadPixelData(reader);
-                }
-            }
-
-            // Length is set to 0 when called on higher bitdepth layers.
-            if (sectionLength > 0) {
-                // Layers Info section is documented to be even-padded, but Photoshop
-                // actually pads to 4 bytes.
-                var endPosition = startPosition + sectionLength;
-                var positionOffset = reader.BaseStream.Position - endPosition;
-
-                if (reader.BaseStream.Position < endPosition)
-                    reader.BaseStream.Position = endPosition;
-            }
-        }
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        /// <summary>
-        /// Decompress the document image data and all the layers' image data, in parallel.
-        /// </summary>
-        private void DecompressImages() {
-            var imageLayers = Layers.Concat(new List<Layer>() { this.BaseLayer });
-            foreach (var layer in imageLayers) {
-                foreach (var channel in layer.Channels) {
-                    var dcc = new DecompressChannelContext(channel);
-                    var waitCallback = new WaitCallback(dcc.DecompressChannel);
-                    ThreadPool.QueueUserWorkItem(waitCallback);
-                }
-            }
-
-            foreach (var layer in Layers) {
-                foreach (var channel in layer.Channels) {
-                    if (channel.ID == -2)
-                        layer.Masks.LayerMask.ImageData = channel.ImageData;
-                    else if (channel.ID == -3)
-                        layer.Masks.UserMask.ImageData = channel.ImageData;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Check the validity of the PSD file and generate necessary data.
-        /// </summary>
-        public void PrepareSave() {
-            var imageLayers = Layers.Concat(new List<Layer>() { this.BaseLayer }).ToList();
-
-            foreach (var layer in imageLayers) {
-                layer.PrepareSave();
-            }
-
-            SetVersionInfo();
-            VerifyLayerSections();
-        }
-
-        /// <summary>
-        /// Verify validity of layer sections.  Each start marker should have a
-        /// matching end marker.
-        /// </summary>
-        internal void VerifyLayerSections() {
-            int depth = 0;
-            foreach (var layer in Enumerable.Reverse(Layers)) {
-                var layerSectionInfo = layer.AdditionalInfo.SingleOrDefault(
-                  x => x is LayerSectionInfo);
-                if (layerSectionInfo == null)
-                    continue;
-
-                var sectionInfo = (LayerSectionInfo)layerSectionInfo;
-                switch (sectionInfo.SectionType) {
-                    case LayerSectionType.OpenFolder:
-                    case LayerSectionType.ClosedFolder:
-                        depth++;
-                        break;
-
-                    case LayerSectionType.SectionDivider:
-                        depth--;
-                        if (depth < 0)
-                            throw new PsdInvalidException("Layer section ended without matching start marker.");
-                        break;
-
-                    default:
-                        throw new PsdInvalidException("Unrecognized layer section type.");
-                }
-            }
-
-            if (depth != 0)
-                throw new PsdInvalidException("Layer section not closed by end marker.");
-        }
-
-        /// <summary>
-        /// Set the VersionInfo resource on the file.
-        /// </summary>
-        public void SetVersionInfo() {
-            var versionInfo = (VersionInfo)ImageResources.Get(ResourceID.VersionInfo);
-            if (versionInfo == null) {
-                versionInfo = new VersionInfo();
-                ImageResources.Set(versionInfo);
-
-                // Get the version string.  We don't use the fourth part (revision).
-                var assembly = System.Reflection.Assembly.GetExecutingAssembly();
-                var version = assembly.GetName().Version;
-                var versionString = version.Major + "." + version.Minor + "." + version.Build;
-
-                // Strings are not localized since they are not shown to the user.
-                versionInfo.Version = 1;
-                versionInfo.HasRealMergedData = true;
-                versionInfo.ReaderName = "Paint.NET PSD Plugin";
-                versionInfo.WriterName = "Paint.NET PSD Plugin " + versionString;
-                versionInfo.FileVersion = 1;
-            }
-        }
-
-        private void SaveLayers(PsdBinaryWriter writer) {
-            using (new PsdBlockLengthWriter(writer)) {
-                var numLayers = (Int16)Layers.Count;
-                if (AbsoluteAlpha)
-                    numLayers = (Int16)(-numLayers);
-
-                // Layers section must be empty if the color mode doesn't allow layers.
-                // Photoshop will refuse to load indexed and multichannel images if
-                // there is a nonempty layers section with a layer count of 0.
-                if (numLayers == 0)
-                    return;
-
-                var startPosition = writer.BaseStream.Position;
-                writer.Write(numLayers);
-
-                foreach (var layer in Layers) {
-                    layer.Save(writer);
-                }
-
-                foreach (var layer in Layers) {
-                    foreach (var channel in layer.Channels) {
-                        channel.SavePixelData(writer);
-                    }
-                }
-
-                // Documentation states that the Layers Info section is even-padded,
-                // but it is actually padded to a multiple of 4.
-                writer.WritePadding(startPosition, 4);
-            }
-        }
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        byte[] GlobalLayerMaskData = new byte[0];
-
-        private void LoadGlobalLayerMask(PsdBinaryReader reader) {
-            var maskLength = reader.ReadUInt32();
-            if (maskLength <= 0)
-                return;
-
-            GlobalLayerMaskData = reader.ReadBytes((int)maskLength);
-        }
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        private void SaveGlobalLayerMask(PsdBinaryWriter writer) {
-            writer.Write((UInt32)GlobalLayerMaskData.Length);
-            writer.Write(GlobalLayerMaskData);
-        }
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        #endregion
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        #region ImageData
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        private void LoadImage(PsdBinaryReader reader) {
-            ImageCompression = (ImageCompression)reader.ReadInt16();
-
-            // Create channels
-            for (Int16 i = 0; i < ChannelCount; i++) {
-                var channel = new Channel(i, this.BaseLayer);
-                channel.ImageCompression = ImageCompression;
-                channel.Length = this.RowCount * Util.BytesPerRow(BaseLayer.Rect, BitDepth);
-
-                // The composite image stores all RLE headers up-front, rather than
-                // with each channel.
-                if (ImageCompression == ImageCompression.Rle) {
-                    channel.RleRowLengths = new RleRowLengths(reader, RowCount);
-                    channel.Length = channel.RleRowLengths.Total;
-                }
-
-                BaseLayer.Channels.Add(channel);
-            }
-
-            foreach (var channel in this.BaseLayer.Channels) {
-                channel.ImageDataRaw = reader.ReadBytes(channel.Length);
-            }
-
-            // If there is exactly one more channel than we need, then it is the
-            // alpha channel.
-            if ((ColorMode != PsdColorMode.Multichannel)
-              && (ChannelCount == ColorMode.MinChannelCount() + 1)) {
-                var alphaChannel = BaseLayer.Channels.Last();
-                alphaChannel.ID = -1;
-            }
-        }
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        private void SaveImage(PsdBinaryWriter writer) {
-            writer.Write((short)this.ImageCompression);
-            if (this.ImageCompression == PhotoshopFile.ImageCompression.Rle) {
-                foreach (var channel in this.BaseLayer.Channels)
-                    channel.RleRowLengths.Write(writer);
-            }
-            foreach (var channel in this.BaseLayer.Channels) {
-                writer.Write(channel.ImageDataRaw);
-            }
-        }
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        private class DecompressChannelContext {
-            private Channel ch;
-
-            public DecompressChannelContext(Channel ch) {
-                this.ch = ch;
-            }
-
-            public void DecompressChannel(object context) {
-                ch.DecodeImageData();
-            }
-        }
-
-        #endregion
-    }
-
-
-    /// <summary>
-    /// The possible Compression methods.
-    /// </summary>
-    public enum ImageCompression {
-        /// <summary>
-        /// Raw data
-        /// </summary>
-        Raw = 0,
-        /// <summary>
-        /// RLE compressed
-        /// </summary>
-        Rle = 1,
-        /// <summary>
-        /// ZIP without prediction.
-        /// </summary>
-        Zip = 2,
-        /// <summary>
-        /// ZIP with prediction.
-        /// </summary>
-        ZipPrediction = 3
-    }
-
-}
diff --git a/PhotoShopFileType/PsdFile/RleReader.cs b/PhotoShopFileType/PsdFile/RleReader.cs
deleted file mode 100644
index ee6668f..0000000
--- a/PhotoShopFileType/PsdFile/RleReader.cs
+++ /dev/null
@@ -1,98 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// Portions of this file are provided under the BSD 3-clause License:
-//   Copyright (c) 2006, Jonas Beckeman
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Diagnostics;
-using System.IO;
-
-
-namespace PhotoshopFile
-{
-  public class RleReader
-  {
-    private Stream stream;
-
-    public RleReader(Stream stream)
-    {
-      this.stream = stream;
-    }
-
-    /// <summary>
-    /// Decodes a PackBits RLE stream.
-    /// </summary>
-    /// <param name="buffer">Output buffer for decoded data.</param>
-    /// <param name="offset">Offset at which to begin writing.</param>
-    /// <param name="count">Number of bytes to decode from the stream.</param>
-    unsafe public int Read(byte[] buffer, int offset, int count)
-    {
-      if (!Util.CheckBufferBounds(buffer, offset, count))
-        throw new ArgumentOutOfRangeException();
-
-      // Pin the entire buffer now, so that we don't keep pinning and unpinning
-      // for each RLE packet.
-      fixed (byte* ptrBuffer = &buffer[0])
-      {
-        int bytesLeft = count;
-        int bufferIdx = offset;
-        while (bytesLeft > 0)
-        {
-          // ReadByte returns an unsigned byte, but we want a signed byte.
-          var flagCounter = unchecked((sbyte)stream.ReadByte());
-
-          // Raw packet
-          if (flagCounter > 0)
-          {
-            var readLength = flagCounter + 1;
-            if (bytesLeft < readLength)
-              throw new RleException("Raw packet overruns the decode window.");
-
-            stream.Read(buffer, bufferIdx, readLength);
-
-            bufferIdx += readLength;
-            bytesLeft -= readLength;
-          }
-          // RLE packet
-          else if (flagCounter > -128)
-          {
-            var runLength = 1 - flagCounter;
-            var byteValue = (byte)stream.ReadByte();
-            if (runLength > bytesLeft)
-              throw new RleException("RLE packet overruns the decode window.");
-
-            byte* ptr = ptrBuffer + bufferIdx;
-            byte* ptrEnd = ptr + runLength;
-            while (ptr < ptrEnd)
-            {
-              *ptr = byteValue;
-              ptr++;
-            }
-
-            bufferIdx += runLength;
-            bytesLeft -= runLength;
-          }
-          else
-          {
-            // The canonical PackBits algorithm will never emit 0x80 (-128), but
-            // some programs do.  Simply skip over the byte.
-          }
-        }
-
-        Debug.Assert(bytesLeft == 0);
-        return count - bytesLeft;
-      }
-    }
-  }
-}
diff --git a/PhotoShopFileType/PsdFile/RleRowLengths.cs b/PhotoShopFileType/PsdFile/RleRowLengths.cs
deleted file mode 100644
index 34e8f79..0000000
--- a/PhotoShopFileType/PsdFile/RleRowLengths.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Linq;
-
-namespace PhotoshopFile
-{
-  public class RleRowLengths
-  {
-    public int[] Values { get; private set; }
-
-    public int Total
-    {
-      get { return Values.Sum(); }
-    }
-
-    public int this[int i]
-    {
-      get { return Values[i]; }
-      set { Values[i] = value; }
-    }
-
-    public RleRowLengths(int rowCount)
-    {
-      Values = new int[rowCount];
-    }
-
-    public RleRowLengths(PsdBinaryReader reader, int rowCount)
-      : this(rowCount)
-    {
-      for (int i = 0; i < rowCount; i++)
-      {
-        Values[i] = reader.ReadUInt16();
-      }
-    }
-
-    public void Write(PsdBinaryWriter writer)
-    {
-      for (int i = 0; i < Values.Length; i++)
-      {
-        writer.Write((UInt16)Values[i]);
-      }
-    }
-  }
-
-}
diff --git a/PhotoShopFileType/PsdFile/RleWriter.cs b/PhotoShopFileType/PsdFile/RleWriter.cs
deleted file mode 100644
index 4ce1ccf..0000000
--- a/PhotoShopFileType/PsdFile/RleWriter.cs
+++ /dev/null
@@ -1,226 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// Portions of this file are provided under the BSD 3-clause License:
-//   Copyright (c) 2006, Jonas Beckeman
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Diagnostics;
-using System.IO;
-
-
-namespace PhotoshopFile
-{
-  public class RleWriter
-  {
-    private int maxPacketLength = 128;
-
-    // Current task
-    private object rleLock;
-    private Stream stream;
-    private byte[] data;
-    private int offset;
-
-    // Current packet
-    private bool isRepeatPacket;
-    private int idxPacketStart;
-    private int packetLength;
-
-    private byte runValue;
-    private int runLength;
-
-    public RleWriter(Stream stream)
-    {
-      rleLock = new object();
-      this.stream = stream;
-    }
-
-    /// <summary>
-    /// Encodes byte data using PackBits RLE compression.
-    /// </summary>
-    /// <param name="data">Raw data to be encoded.</param>
-    /// <param name="offset">Offset at which to begin transferring data.</param>
-    /// <param name="count">Number of bytes of data to transfer.</param>
-    /// <returns>Number of compressed bytes written to the stream.</returns>
-    /// <remarks>
-    /// There are multiple ways to encode two-byte runs:
-    ///   1. Apple PackBits only encodes three-byte runs as repeats.
-    ///   2. Adobe Photoshop encodes two-byte runs as repeats, unless preceded
-    ///      by literals.
-    ///   3. TIFF PackBits recommends that two-byte runs be encoded as repeats,
-    ///      unless preceded *and* followed by literals.
-    ///
-    /// This class adopts the Photoshop behavior, as it has slightly better
-    /// compression efficiency than Apple PackBits, and is easier to implement
-    /// than TIFF PackBits.
-    /// </remarks>
-    unsafe public int Write(byte[] data, int offset, int count)
-    {
-      if (!Util.CheckBufferBounds(data, offset, count))
-        throw new ArgumentOutOfRangeException();
-
-      // We cannot encode a count of 0, because the PackBits flag-counter byte
-      // uses 0 to indicate a length of 1.
-      if (count == 0)
-        throw new ArgumentOutOfRangeException("count");
-
-      lock (rleLock)
-      {
-        var startPosition = stream.Position;
-
-        this.data = data;
-        this.offset = offset;
-        fixed (byte* ptrData = &data[0])
-        {
-          byte* ptr = ptrData + offset;
-          byte* ptrEnd = ptr + count;
-          var bytesEncoded = EncodeToStream(ptr, ptrEnd);
-          Debug.Assert(bytesEncoded == count, "Encoded byte count should match the argument.");
-        }
-
-        return (int)(stream.Position - startPosition);
-      }
-    }
-
-    private void ClearPacket()
-    {
-      this.isRepeatPacket = false;
-      this.packetLength = 0;
-    }
-
-    private void WriteRepeatPacket(int length)
-    {
-      var header = unchecked((byte)(1 - length));
-      stream.WriteByte(header);
-      stream.WriteByte(runValue);
-    }
-
-    private void WriteLiteralPacket(int length)
-    {
-      var header = unchecked((byte)(length - 1));
-      stream.WriteByte(header);
-      stream.Write(data, idxPacketStart, length);
-    }
-
-    private void WritePacket()
-    {
-      if (isRepeatPacket)
-        WriteRepeatPacket(packetLength);
-      else
-        WriteLiteralPacket(packetLength);
-    }
-
-    private void StartPacket(int count,
-      bool isRepeatPacket, int runLength, byte value)
-    {
-      this.isRepeatPacket = isRepeatPacket;
-
-      this.packetLength = runLength;
-      this.runLength = runLength;
-      this.runValue = value;
-
-      this.idxPacketStart = offset + count;
-    }
-
-    private void ExtendPacketAndRun(byte value)
-    {
-      packetLength++;
-      runLength++;
-    }
-
-    private void ExtendPacketStartNewRun(byte value)
-    {
-      packetLength++;
-      runLength = 1;
-      runValue = value;
-    }
-
-    unsafe private int EncodeToStream(byte* ptr, byte* ptrEnd)
-    {
-      // Begin the first packet.
-      StartPacket(0, false, 1, *ptr);
-      int numBytesEncoded = 1;
-      ptr++;
-
-      // Loop invariant: Packet is never empty.
-      while (ptr < ptrEnd)
-      {
-        var value = *ptr;
-
-        if (packetLength == 1)
-        {
-          isRepeatPacket = (value == runValue);
-          if (isRepeatPacket)
-            ExtendPacketAndRun(value);
-          else
-            ExtendPacketStartNewRun(value);
-        }
-        else if (packetLength == maxPacketLength)
-        {
-          // Packet is full, so write it out and start a new one.
-          WritePacket();
-          StartPacket(numBytesEncoded, false, 1, value);
-        }
-        else if (isRepeatPacket)
-        {
-          // Decide whether to continue the repeat packet.
-          if (value == runValue)
-            ExtendPacketAndRun(value);
-          else
-          {
-            // Different color, so terminate the run and start a new packet.
-            WriteRepeatPacket(packetLength);
-            StartPacket(numBytesEncoded, false, 1, value);
-          }
-        }
-        else
-        {
-          // Decide whether to continue the literal packet.
-          if (value == runValue)
-          {
-            ExtendPacketAndRun(value);
-
-            // A 3-byte run terminates the literal and starts a new repeat
-            // packet.  That's because the 3-byte run can be encoded as a
-            // 2-byte repeat.  So even if the run ends at 3, we've already
-            // paid for the next flag-counter byte.
-            if (runLength == 3)
-            {
-              // The 3-byte run can come in the middle of a literal packet,
-              // but not at the beginning.  The first 2 bytes of the run
-              // should've triggered a repeat packet.
-              Debug.Assert(packetLength > 3);
-
-              // -2 because numBytesEncoded has not yet been incremented
-              WriteLiteralPacket(packetLength - 3);
-              StartPacket(numBytesEncoded - 2, true, 3, value);
-            }
-          }
-          else
-          {
-            ExtendPacketStartNewRun(value);
-          }
-        }
-
-        ptr++;
-        numBytesEncoded++;
-      }
-
-      // Loop terminates with a non-empty packet waiting to be written out.
-      WritePacket();
-      ClearPacket();
-
-      return numBytesEncoded;
-    }
-  }
-}
diff --git a/PhotoShopFileType/PsdFile/Util.cs b/PhotoShopFileType/PsdFile/Util.cs
deleted file mode 100644
index 4326083..0000000
--- a/PhotoShopFileType/PsdFile/Util.cs
+++ /dev/null
@@ -1,290 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// Photoshop PSD FileType Plugin for Paint.NET
-// http://psdplugin.codeplex.com/
-//
-// This software is provided under the MIT License:
-//   Copyright (c) 2006-2007 Frank Blumenberg
-//   Copyright (c) 2010-2013 Tao Yue
-//
-// See LICENSE.txt for complete licensing and attribution information.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Text;
-using UnityEngine;
-
-namespace PhotoshopFile
-{
-  public static class Util
-  {
-    [DebuggerDisplay("Top = {Top}, Bottom = {Bottom}, Left = {Left}, Right = {Right}")]
-    public struct RectanglePosition
-    {
-      public int Top { get; set; }
-      public int Bottom { get; set; }
-      public int Left { get; set; }
-      public int Right { get; set; }
-    }
-
-    /////////////////////////////////////////////////////////////////////////// 
-
-    /// <summary>
-    /// Fills a buffer with a byte value.
-    /// </summary>
-    unsafe static public void Fill(byte* ptr, byte* ptrEnd, byte value)
-    {
-      while (ptr < ptrEnd)
-      {
-        *ptr = value;
-        ptr++;
-      }
-    }
-
-    /////////////////////////////////////////////////////////////////////////// 
-
-    /// <summary>
-    /// Reverses the endianness of a 2-byte word.
-    /// </summary>
-    unsafe static public void SwapBytes2(byte* ptr)
-    {
-      byte byte0 = *ptr;
-      *ptr = *(ptr + 1);
-      *(ptr + 1) = byte0;
-    }
-
-    /////////////////////////////////////////////////////////////////////////// 
-
-    /// <summary>
-    /// Reverses the endianness of a 4-byte word.
-    /// </summary>
-    unsafe static public void SwapBytes4(byte* ptr)
-    {
-      byte byte0 = *ptr;
-      byte byte1 = *(ptr + 1);
-
-      *ptr = *(ptr + 3);
-      *(ptr + 1) = *(ptr + 2);
-      *(ptr + 2) = byte1;
-      *(ptr + 3) = byte0;
-    }
-
-    /// <summary>
-    /// Reverses the endianness of a word of arbitrary length.
-    /// </summary>
-    unsafe static public void SwapBytes(byte* ptr, int nLength)
-    {
-      for (long i = 0; i < nLength / 2; ++i)
-      {
-        byte t = *(ptr + i);
-        *(ptr + i) = *(ptr + nLength - i - 1);
-        *(ptr + nLength - i - 1) = t;
-      }
-    }
-
-    /////////////////////////////////////////////////////////////////////////// 
-
-    /// <summary>
-    /// Reverses the endianness of 2-byte words in a byte array.
-    /// </summary>
-    /// <param name="byteArray">Byte array containing the sequence on which to swap endianness</param>
-    /// <param name="startIdx">Byte index of the first word to swap</param>
-    /// <param name="count">Number of words to swap</param>
-    public static void SwapByteArray2(byte[] byteArray, int startIdx, int count)
-    {
-      int endIdx = startIdx + count * 2;
-      if (byteArray.Length < endIdx)
-        throw new IndexOutOfRangeException();
-
-      unsafe
-      {
-        fixed (byte* arrayPtr = &byteArray[0])
-        {
-          byte* ptr = arrayPtr + startIdx;
-          byte* endPtr = arrayPtr + endIdx;
-          while (ptr < endPtr)
-          {
-            SwapBytes2(ptr);
-            ptr += 2;
-          }
-        }
-      }
-    }
-
-    /// <summary>
-    /// Reverses the endianness of 4-byte words in a byte array.
-    /// </summary>
-    /// <param name="byteArray">Byte array containing the sequence on which to swap endianness</param>
-    /// <param name="startIdx">Byte index of the first word to swap</param>
-    /// <param name="count">Number of words to swap</param>
-    public static void SwapByteArray4(byte[] byteArray, int startIdx, int count)
-    {
-      int endIdx = startIdx + count * 4;
-      if (byteArray.Length < endIdx)
-        throw new IndexOutOfRangeException();
-
-      unsafe
-      {
-        fixed (byte* arrayPtr = &byteArray[0])
-        {
-          byte* ptr = arrayPtr + startIdx;
-          byte* endPtr = arrayPtr + endIdx;
-          while (ptr < endPtr)
-          {
-            SwapBytes4(ptr);
-            ptr += 4;
-          }
-        }
-      }
-    }
-
-    /////////////////////////////////////////////////////////////////////////// 
-
-    public static int BytesPerRow(Rect rect, int depth)
-    {
-      switch (depth)
-      {
-        case 1:
-          return ((int)rect.width + 7) / 8;
-        default:
-          return (int)rect.width * BytesFromBitDepth(depth);
-      }
-    }
-
-    /// <summary>
-    /// Round the integer to a multiple.
-    /// </summary>
-    public static int RoundUp(int value, int multiple)
-    {
-      if (value == 0)
-        return 0;
-
-      if (Math.Sign(value) != Math.Sign(multiple))
-        throw new ArgumentException("value and multiple cannot have opposite signs.");
-
-      var remainder = value % multiple;
-      if (remainder > 0)
-      {
-        value += (multiple - remainder);
-      }
-      return value;
-    }
-
-    /// <summary>
-    /// Get number of bytes required to pad to the specified multiple.
-    /// </summary>
-    public static int GetPadding(int length, int padMultiple)
-    {
-      if ((length < 0) || (padMultiple < 0))
-        throw new ArgumentException();
-
-      var remainder = length % padMultiple;
-      if (remainder == 0)
-        return 0;
-
-      var padding = padMultiple - remainder;
-      return padding;
-    }
-
-    public static int BytesFromBitDepth(int depth)
-    {
-      switch (depth)
-      {
-        case 1:
-        case 8:
-          return 1;
-        case 16:
-          return 2;
-        case 32:
-          return 4;
-        default:
-          throw new ArgumentException("Invalid bit depth.");
-      }
-    }
-
-    public static short MinChannelCount(this PsdColorMode colorMode)
-    {
-      switch (colorMode)
-      {
-        case PsdColorMode.Bitmap:
-        case PsdColorMode.Duotone:
-        case PsdColorMode.Grayscale:
-        case PsdColorMode.Indexed:
-        case PsdColorMode.Multichannel:
-          return 1;
-        case PsdColorMode.Lab:
-        case PsdColorMode.RGB:
-          return 3;
-        case PsdColorMode.CMYK:
-          return 4;
-      }
-
-      throw new ArgumentException("Unknown color mode.");
-    }
-
-    /// <summary>
-    /// Verify that the offset and count will remain within the bounds of the
-    /// buffer.
-    /// </summary>
-    /// <returns>True if in bounds, false if out of bounds.</returns>
-    public static bool CheckBufferBounds(byte[] data, int offset, int count)
-    {
-      if (offset < 0)
-        return false;
-      if (count < 0)
-        return false;
-      if (offset + count > data.Length)
-        return false;
-
-      return true;
-    }
-  }
-
-  /// <summary>
-  /// Fixed-point decimal, with 16-bit integer and 16-bit fraction.
-  /// </summary>
-  public class UFixed16_16
-  {
-    public UInt16 Integer { get; set; }
-    public UInt16 Fraction { get; set; }
-
-    public UFixed16_16(UInt16 integer, UInt16 fraction)
-    {
-      Integer = integer;
-      Fraction = fraction;
-    }
-
-    /// <summary>
-    /// Split the high and low words of a 32-bit unsigned integer into a
-    /// fixed-point number.
-    /// </summary>
-    public UFixed16_16(UInt32 value)
-    {
-      Integer = (UInt16)(value >> 16);
-      Fraction = (UInt16)(value & 0x0000ffff);
-    }
-
-    public UFixed16_16(double value)
-    {
-      if (value >= 65536.0) throw new OverflowException();
-      if (value < 0) throw new OverflowException();
-
-      Integer = (UInt16)value;
-
-      // Round instead of truncate, because doubles may not represent the
-      // fraction exactly.
-      Fraction = (UInt16)((value - Integer) * 65536 + 0.5);  
-    }
-
-    public static implicit operator double(UFixed16_16 value)
-    {
-      return (double)value.Integer + value.Fraction / 65536.0;
-    }
-
-  }
-  
-}
diff --git a/README.md b/README.md
index a9c41e9..4b35b2f 100644
--- a/README.md
+++ b/README.md
@@ -1,25 +1,115 @@
-Unity Psd Importer
-==================
+# Unity Psd Importer #
 
-Unity Psd Importer is an addon for Unity3D. It provides an editor window from which individual layers can be selected 
-and exported. The layers are exported either as individual PNGs or as an atlas image.
+## ⛔⚠️ Deprecation Alert ⚠️⛔
 
-To compile the Unity PSD Importer in the Unity3D Editor you must have the files gmcs.rsp and smcs.rsp with "-unsafe" in the first line of the files in the root directory of your project.  Otherwise you can compile the code as a DLL and it will also work in the editor.
+This project is considered deprecated and unsupported. Work is moving to the [Psd2Unity importer](https://github.com/ChemiKhazi/Psd2UnityImporter). This repo is being kept for documentation purposes.
 
-To use the Unity PSD Importer, in the Unity3D Editor go to Sprites > PSD Import to access the importer, then drag and drop or search for the PSD file you wish to import.  
+**End warning**
 
-To only export the layers to PNG files, click on the "Export Visible Layers" button and it will only create the PNG files with the sprites that are visible.  You can individually check which layers you want to import.
+Unity PSD Importer allows Unity to import individual layers from a PSD, as well as reconstruct Photoshop Layer Groups inside Unity to simplify workflows.
 
-To create a root gameobject with all the layers as child sprites and the layers compiled in an atlas, click on the "Create atlas" button.  All the layers will be saved to an atlas texture with sprites as children that is autogenerated with the atlas size you define under "Max. atlas size".  A root gameobject with the filename of the PSD file is created and all the layers as sprites will be as children gameobjects under the root gameobject.
+[Demo Video](https://www.youtube.com/watch?v=9rSxRf2SNeU)
 
-To create PNG files individually with each sprite assigned to the PNG files, click on the "Create sprites" button.  This will create a root gameobject with the filename of the PSD file and all the layers as sprites under the root gameobject.
+[Tutorial Video](https://www.youtube.com/watch?v=d7d52Vizc0U)
 
-All sprites are created with a center pivot so that they will import in their correct alignment with the PSD file layers' positions.
+## Installation ##
 
-Some notes on the PSD support:
+Install the importer by placing the [compiled DLL](/bin/PhotoShopImporter.dll) either in an existing `Editor` directory of your Unity project or creating a new `Editor` directory.
 
-It should support all image layers, however text, layer groups, or other special layers will not be supported. It is best to flatten layer groups and text before importing.
+![Install](Documentation/Install.png)
 
-All the imported layers should be imported at their same positions as in the PSD file.
-    
-When importing as an atlas, if the layers cannot collectively fit in the atlas they will be scaled down to fit the atlas texture, therefore it is preferable to import the layers using "Create sprites" to have the layers imported as separate PNG files.
+## Usage ##
+
+To use the importer, right click on a PSD in the Project Explorer and select `PSD Importer`.
+
+![Launch Importer](Documentation/Launch-Importer.png)
+
+### Layers Settings ###
+
+![Layers Display](Documentation/Layers-Display-Thumb.png)
+
+The layers display reflects the state of the PSD file as it was saved. Visible layers are imported when the Import Layers button is pressed.
+
+When a layer will be imported, additional settings will appear beside the layer.
+
+The **size drop down** reduces the image size of an imported layer, while retaining the same display size in relation to the other layers. This can be useful for resizing less important images as an optimization.
+
+The **layer pivot drop** down lets you set the pivot point of the layer when imported to Unity.
+
+### Import Settings ###
+
+These are global settings that are applied to the layers when importing from the PSD.
+
+![Import Settings](Documentation/Import-Settings.png)
+
+**Source Image Scale**
+
+The source PSD might be scaled larger than the target size for the images in Unity. This setting allows you to scale down the imported layers.
+
+The *1X, 2X, 4X* setting indicates how the layers are scaled during import.
+
+- 1X means no reduction, 100%
+- 2X will scale down to 50%
+- 4X will scale it down to 25%.
+
+**Auto Re-Import**
+
+If this is checked, whenever Unity detects that a PSD is modified, the visible layers will automatically be re-imported.
+
+**Pixels to unit size**
+
+The Pixels Per Unit applied by default to the imported layers.
+
+**Packing Tag**
+
+The tag to apply for Unity's atlas packing system.
+
+**Default Pivot**
+
+The pivot point applied by default to imported layers, unless specified
+
+**Import Path**
+
+If import path is empty, the imported layers are placed in the same directory as the PSD file. If not, you can set a directory for the imported layers to go to.
+
+### Sprite Creation ###
+
+Sprite creation recreates the layouts of layer groups in the PSD document inside Unity. It can create either 2D Sprite objects or Unity UI Image objects.
+
+![Sprite Creation](Documentation/Sprite-Creation.png)
+
+First, select a `Layer Group` in the layers portion of the importer. Selecting a Layer Group will also select PSD Layers and Layer Groups that are contained by it.
+
+![Group Selection](Documentation/Group-Selection.png)
+
+*Alignment* determines where the root object of the layer group will be aligned, relative to the layer group layout.
+
+If an object is selected in the `Scene Hierarchy`, the layer group will be recreated on the selected object. If no object is selected, the layer group will be created without a parent in the Scene Hierarchy.
+
+To create `UI Images` for use with Unity UI, first select an object that is part of a UI hierarchy. When a valid object is selected, the `Create UI Images` button can be clicked.
+
+![UI Creation](Documentation/UI-Creation.png)
+
+## Known Limitations ##
+
+The PSD importer might not be able to handle PSD files generated by software aside from Photoshop.
+
+Layers with the same name will conflict and only one will be imported.
+
+## Contributing ##
+
+This repository contains the release DLL and the Visual Studio project used to compile the importer into a DLL.
+
+The main importer code resides in the [UnityPsdImporterModule repository](https://github.com/ChemiKhazi/UnityPsdImporterModule). It is recommended to use that repository as a git submodule in a Unity project for working on the PSD importer.
+
+### Unity Editor Compilation ###
+
+To compile the Unity PSD Importer in the Unity3D Editor put the files `gmcs.rsp` and `smcs.rsp` found in this repository in the root `Assets` directory of your project.
+
+These files will allow Unity to compile the PSD importer code in the editor.
+
+## Acknowledgements ##
+
+[@BanBury](https://github.com/Banbury) for the [PSD Importer](https://github.com/Banbury/UnityPsdImporter) that this project was forked from
+
+The [PSD Filetype plugin](http://psdplugin.codeplex.com/) that makes reading PSD files inside Unity possible
diff --git a/bin/PhotoShopImporter.dll b/bin/PhotoShopImporter.dll
new file mode 100644
index 0000000..ff44125
Binary files /dev/null and b/bin/PhotoShopImporter.dll differ