Anonymous avatar Anonymous committed f822323

Shows a character that moves, with a camera that follows it.

Comments (0)

Files changed (161)

Assembly-CSharp-Editor-vs.csproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+	<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+	<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+	<ProductVersion>10.0.20506</ProductVersion>
+	<SchemaVersion>2.0</SchemaVersion>
+	<ProjectGuid>{360AD0B0-0B7F-9E63-660B-D96E5771AD17}</ProjectGuid>
+	<OutputType>Library</OutputType>
+	<AppDesignerFolder>Properties</AppDesignerFolder>
+	<RootNamespace></RootNamespace>
+	<AssemblyName>Assembly-CSharp-Editor</AssemblyName>
+	<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+	<FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+	<DebugSymbols>true</DebugSymbols>
+	<DebugType>full</DebugType>
+	<Optimize>false</Optimize>
+	<OutputPath>Temp\bin\Debug\</OutputPath>
+	<DefineConstants>DEBUG;TRACE;UNITY_3_5_4;UNITY_3_5;UNITY_EDITOR;ENABLE_PROFILER;UNITY_WEBPLAYER;ENABLE_GENERICS;ENABLE_DUCK_TYPING;ENABLE_TERRAIN;ENABLE_MOVIES;ENABLE_WEBCAM;ENABLE_MICROPHONE;ENABLE_NETWORK;ENABLE_CLOTH;ENABLE_WWW;ENABLE_SUBSTANCE</DefineConstants>
+	<ErrorReport>prompt</ErrorReport>
+	<WarningLevel>4</WarningLevel>
+	<NoWarn>0169</NoWarn>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+	<DebugType>pdbonly</DebugType>
+	<Optimize>true</Optimize>
+	<OutputPath>Temp\bin\Release\</OutputPath>
+	<DefineConstants>TRACE</DefineConstants>
+	<ErrorReport>prompt</ErrorReport>
+	<WarningLevel>4</WarningLevel>
+	<NoWarn>0169</NoWarn>
+  </PropertyGroup>
+  <ItemGroup>
+	<Reference Include="System" />
+    <Reference Include="System.XML" />
+	<Reference Include="System.Core" />
+	<Reference Include="UnityEngine">
+	  <HintPath>/Applications/Unity/Unity.app/Contents/Frameworks/Managed/UnityEngine.dll</HintPath>
+	</Reference>
+	<Reference Include="UnityEditor">
+	  <HintPath>/Applications/Unity/Unity.app/Contents/Frameworks/Managed/UnityEditor.dll</HintPath>
+	</Reference>
+  </ItemGroup>
+  <ItemGroup>
+     <Compile Include="Assets\RagePixel\Editor\RagePixelAnimStripGUI.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelCameraEditor.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelColorPickerGUI.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelGUIIcons.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelHSBColor.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelPaletteGUI.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelSpriteEditor.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelSpriteSheetEditorWindow.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelSpriteSheetGUI.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelTexel.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelTexelRect.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelTransformInspector.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelUtil.cs" />
+     <None Include="Assets\RagePixel\readme.txt" />
+     <None Include="Assets\RagePixel\Code\RagePixelBasicFlash.shader" />
+     <None Include="Assets\RagePixel\Code\RagePixelBasic.shader" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="Assembly-CSharp-vs.csproj">
+      <Project>{B210263A-6BC4-671D-064D-23E6D7A3EC8B}</Project>      <Name>Assembly-CSharp-vs</Name>    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- 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.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  
+</Project>

Assembly-CSharp-Editor.csproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+	<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+	<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+	<ProductVersion>10.0.20506</ProductVersion>
+	<SchemaVersion>2.0</SchemaVersion>
+	<ProjectGuid>{360AD0B0-0B7F-9E63-660B-D96E5771AD17}</ProjectGuid>
+	<OutputType>Library</OutputType>
+	<AppDesignerFolder>Properties</AppDesignerFolder>
+	<RootNamespace></RootNamespace>
+	<AssemblyName>Assembly-CSharp-Editor</AssemblyName>
+	<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+	<FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+	<DebugSymbols>true</DebugSymbols>
+	<DebugType>full</DebugType>
+	<Optimize>false</Optimize>
+	<OutputPath>Temp\bin\Debug\</OutputPath>
+	<DefineConstants>DEBUG;TRACE;UNITY_3_5_4;UNITY_3_5;UNITY_EDITOR;ENABLE_PROFILER;UNITY_WEBPLAYER;ENABLE_GENERICS;ENABLE_DUCK_TYPING;ENABLE_TERRAIN;ENABLE_MOVIES;ENABLE_WEBCAM;ENABLE_MICROPHONE;ENABLE_NETWORK;ENABLE_CLOTH;ENABLE_WWW;ENABLE_SUBSTANCE</DefineConstants>
+	<ErrorReport>prompt</ErrorReport>
+	<WarningLevel>4</WarningLevel>
+	<NoWarn>0169</NoWarn>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+	<DebugType>pdbonly</DebugType>
+	<Optimize>true</Optimize>
+	<OutputPath>Temp\bin\Release\</OutputPath>
+	<DefineConstants>TRACE</DefineConstants>
+	<ErrorReport>prompt</ErrorReport>
+	<WarningLevel>4</WarningLevel>
+	<NoWarn>0169</NoWarn>
+  </PropertyGroup>
+  <ItemGroup>
+	<Reference Include="System" />
+    <Reference Include="System.XML" />
+	<Reference Include="System.Core" />
+	<Reference Include="UnityEngine">
+	  <HintPath>/Applications/Unity/Unity.app/Contents/Frameworks/Managed/UnityEngine.dll</HintPath>
+	</Reference>
+	<Reference Include="UnityEditor">
+	  <HintPath>/Applications/Unity/Unity.app/Contents/Frameworks/Managed/UnityEditor.dll</HintPath>
+	</Reference>
+  </ItemGroup>
+  <ItemGroup>
+     <Compile Include="Assets\RagePixel\Editor\RagePixelAnimStripGUI.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelCameraEditor.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelColorPickerGUI.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelGUIIcons.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelHSBColor.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelPaletteGUI.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelSpriteEditor.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelSpriteSheetEditorWindow.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelSpriteSheetGUI.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelTexel.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelTexelRect.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelTransformInspector.cs" />
+     <Compile Include="Assets\RagePixel\Editor\RagePixelUtil.cs" />
+     <None Include="Assets\RagePixel\readme.txt" />
+     <None Include="Assets\RagePixel\Code\RagePixelBasicFlash.shader" />
+     <None Include="Assets\RagePixel\Code\RagePixelBasic.shader" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="Assembly-CSharp.csproj">
+      <Project>{B210263A-6BC4-671D-064D-23E6D7A3EC8B}</Project>      <Name>Assembly-CSharp</Name>    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- 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.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  
+</Project>
Add a comment to this file

Assembly-CSharp-Editor.pidb

Binary file added.

Assembly-CSharp-vs.csproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+	<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+	<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+	<ProductVersion>10.0.20506</ProductVersion>
+	<SchemaVersion>2.0</SchemaVersion>
+	<ProjectGuid>{B210263A-6BC4-671D-064D-23E6D7A3EC8B}</ProjectGuid>
+	<OutputType>Library</OutputType>
+	<AppDesignerFolder>Properties</AppDesignerFolder>
+	<RootNamespace></RootNamespace>
+	<AssemblyName>Assembly-CSharp</AssemblyName>
+	<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+	<FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+	<DebugSymbols>true</DebugSymbols>
+	<DebugType>full</DebugType>
+	<Optimize>false</Optimize>
+	<OutputPath>Temp\bin\Debug\</OutputPath>
+	<DefineConstants>DEBUG;TRACE;UNITY_3_5_4;UNITY_3_5;UNITY_EDITOR;ENABLE_PROFILER;UNITY_WEBPLAYER;ENABLE_GENERICS;ENABLE_DUCK_TYPING;ENABLE_TERRAIN;ENABLE_MOVIES;ENABLE_WEBCAM;ENABLE_MICROPHONE;ENABLE_NETWORK;ENABLE_CLOTH;ENABLE_WWW;ENABLE_SUBSTANCE</DefineConstants>
+	<ErrorReport>prompt</ErrorReport>
+	<WarningLevel>4</WarningLevel>
+	<NoWarn>0169</NoWarn>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+	<DebugType>pdbonly</DebugType>
+	<Optimize>true</Optimize>
+	<OutputPath>Temp\bin\Release\</OutputPath>
+	<DefineConstants>TRACE</DefineConstants>
+	<ErrorReport>prompt</ErrorReport>
+	<WarningLevel>4</WarningLevel>
+	<NoWarn>0169</NoWarn>
+  </PropertyGroup>
+  <ItemGroup>
+	<Reference Include="System" />
+    <Reference Include="System.XML" />
+	<Reference Include="System.Core" />
+	<Reference Include="UnityEngine">
+	  <HintPath>/Applications/Unity/Unity.app/Contents/Frameworks/Managed/UnityEngine.dll</HintPath>
+	</Reference>
+	<Reference Include="UnityEditor">
+	  <HintPath>/Applications/Unity/Unity.app/Contents/Frameworks/Managed/UnityEditor.dll</HintPath>
+	</Reference>
+  </ItemGroup>
+  <ItemGroup>
+     <Compile Include="Assets\RagePixel\Code\IRagePixel.cs" />
+     <Compile Include="Assets\RagePixel\Code\RagePixelAnimation.cs" />
+     <Compile Include="Assets\RagePixel\Code\RagePixelBitmap.cs" />
+     <Compile Include="Assets\RagePixel\Code\RagePixelCamera.cs" />
+     <Compile Include="Assets\RagePixel\Code\RagePixelCell.cs" />
+     <Compile Include="Assets\RagePixel\Code\RagePixelRow.cs" />
+     <Compile Include="Assets\RagePixel\Code\RagePixelSettings.cs" />
+     <Compile Include="Assets\RagePixel\Code\RagePixelSprite.cs" />
+     <Compile Include="Assets\RagePixel\Code\RagePixelSpriteSheet.cs" />
+     <Compile Include="Assets\scripts\CameraFollow.cs" />
+     <Compile Include="Assets\scripts\PlayerChar.cs" />
+     <Compile Include="Assets\scripts\VirtualPad.cs" />
+     <None Include="Assets\RagePixel\readme.txt" />
+     <None Include="Assets\RagePixel\Code\RagePixelBasicFlash.shader" />
+     <None Include="Assets\RagePixel\Code\RagePixelBasic.shader" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- 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.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  
+</Project>

Assembly-CSharp.csproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+	<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+	<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+	<ProductVersion>10.0.20506</ProductVersion>
+	<SchemaVersion>2.0</SchemaVersion>
+	<ProjectGuid>{B210263A-6BC4-671D-064D-23E6D7A3EC8B}</ProjectGuid>
+	<OutputType>Library</OutputType>
+	<AppDesignerFolder>Properties</AppDesignerFolder>
+	<RootNamespace></RootNamespace>
+	<AssemblyName>Assembly-CSharp</AssemblyName>
+	<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+	<FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+	<DebugSymbols>true</DebugSymbols>
+	<DebugType>full</DebugType>
+	<Optimize>false</Optimize>
+	<OutputPath>Temp\bin\Debug\</OutputPath>
+	<DefineConstants>DEBUG;TRACE;UNITY_3_5_4;UNITY_3_5;UNITY_EDITOR;ENABLE_PROFILER;UNITY_WEBPLAYER;ENABLE_GENERICS;ENABLE_DUCK_TYPING;ENABLE_TERRAIN;ENABLE_MOVIES;ENABLE_WEBCAM;ENABLE_MICROPHONE;ENABLE_NETWORK;ENABLE_CLOTH;ENABLE_WWW;ENABLE_SUBSTANCE</DefineConstants>
+	<ErrorReport>prompt</ErrorReport>
+	<WarningLevel>4</WarningLevel>
+	<NoWarn>0169</NoWarn>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+	<DebugType>pdbonly</DebugType>
+	<Optimize>true</Optimize>
+	<OutputPath>Temp\bin\Release\</OutputPath>
+	<DefineConstants>TRACE</DefineConstants>
+	<ErrorReport>prompt</ErrorReport>
+	<WarningLevel>4</WarningLevel>
+	<NoWarn>0169</NoWarn>
+  </PropertyGroup>
+  <ItemGroup>
+	<Reference Include="System" />
+    <Reference Include="System.XML" />
+	<Reference Include="System.Core" />
+	<Reference Include="UnityEngine">
+	  <HintPath>/Applications/Unity/Unity.app/Contents/Frameworks/Managed/UnityEngine.dll</HintPath>
+	</Reference>
+	<Reference Include="UnityEditor">
+	  <HintPath>/Applications/Unity/Unity.app/Contents/Frameworks/Managed/UnityEditor.dll</HintPath>
+	</Reference>
+  </ItemGroup>
+  <ItemGroup>
+     <Compile Include="Assets\RagePixel\Code\IRagePixel.cs" />
+     <Compile Include="Assets\RagePixel\Code\RagePixelAnimation.cs" />
+     <Compile Include="Assets\RagePixel\Code\RagePixelBitmap.cs" />
+     <Compile Include="Assets\RagePixel\Code\RagePixelCamera.cs" />
+     <Compile Include="Assets\RagePixel\Code\RagePixelCell.cs" />
+     <Compile Include="Assets\RagePixel\Code\RagePixelRow.cs" />
+     <Compile Include="Assets\RagePixel\Code\RagePixelSettings.cs" />
+     <Compile Include="Assets\RagePixel\Code\RagePixelSprite.cs" />
+     <Compile Include="Assets\RagePixel\Code\RagePixelSpriteSheet.cs" />
+     <Compile Include="Assets\scripts\CameraFollow.cs" />
+     <Compile Include="Assets\scripts\PlayerChar.cs" />
+     <Compile Include="Assets\scripts\VirtualPad.cs" />
+     <None Include="Assets\RagePixel\readme.txt" />
+     <None Include="Assets\RagePixel\Code\RagePixelBasicFlash.shader" />
+     <None Include="Assets\RagePixel\Code\RagePixelBasic.shader" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- 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.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  
+</Project>

Binary file added.

Assembly-UnityScript-vs.unityproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+	<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+	<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+	<ProductVersion>10.0.20506</ProductVersion>
+	<SchemaVersion>2.0</SchemaVersion>
+	<ProjectGuid>{08EE59BA-D179-7211-B978-E85A6577AFA0}</ProjectGuid>
+	<OutputType>Library</OutputType>
+	<AppDesignerFolder>Properties</AppDesignerFolder>
+	<RootNamespace></RootNamespace>
+	<AssemblyName>Assembly-UnityScript</AssemblyName>
+	<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+	<FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+	<DebugSymbols>true</DebugSymbols>
+	<DebugType>full</DebugType>
+	<Optimize>false</Optimize>
+	<OutputPath>Temp\bin\Debug\</OutputPath>
+	<DefineConstants>DEBUG;TRACE;UNITY_3_5_4;UNITY_3_5;UNITY_EDITOR;ENABLE_PROFILER;UNITY_ANDROID;ENABLE_GENERICS;ENABLE_TERRAIN;ENABLE_WEBCAM;ENABLE_NETWORK;ENABLE_CLOTH;ENABLE_WWW</DefineConstants>
+	<ErrorReport>prompt</ErrorReport>
+	<WarningLevel>4</WarningLevel>
+	<NoWarn>0169</NoWarn>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+	<DebugType>pdbonly</DebugType>
+	<Optimize>true</Optimize>
+	<OutputPath>Temp\bin\Release\</OutputPath>
+	<DefineConstants>TRACE</DefineConstants>
+	<ErrorReport>prompt</ErrorReport>
+	<WarningLevel>4</WarningLevel>
+	<NoWarn>0169</NoWarn>
+  </PropertyGroup>
+  <ItemGroup>
+	<Reference Include="System" />
+    <Reference Include="System.XML" />
+	<Reference Include="System.Core" />
+	<Reference Include="UnityEngine">
+	  <HintPath>/Applications/Unity/Unity.app/Contents/Frameworks/Managed/UnityEngine.dll</HintPath>
+	</Reference>
+	<Reference Include="UnityEditor">
+	  <HintPath>/Applications/Unity/Unity.app/Contents/Frameworks/Managed/UnityEditor.dll</HintPath>
+	</Reference>
+  </ItemGroup>
+  <ItemGroup>
+     <Compile Include="Assets\camerafollow.js" />
+     <None Include="Assets\RagePixel\readme.txt" />
+     <None Include="Assets\RagePixel\Code\RagePixelBasicFlash.shader" />
+     <None Include="Assets\RagePixel\Code\RagePixelBasic.shader" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- 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.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  
+</Project>
Add a comment to this file

Assembly-UnityScript.pidb

Binary file added.

Assembly-UnityScript.unityproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+	<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+	<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+	<ProductVersion>10.0.20506</ProductVersion>
+	<SchemaVersion>2.0</SchemaVersion>
+	<ProjectGuid>{08EE59BA-D179-7211-B978-E85A6577AFA0}</ProjectGuid>
+	<OutputType>Library</OutputType>
+	<AppDesignerFolder>Properties</AppDesignerFolder>
+	<RootNamespace></RootNamespace>
+	<AssemblyName>Assembly-UnityScript</AssemblyName>
+	<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+	<FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+	<DebugSymbols>true</DebugSymbols>
+	<DebugType>full</DebugType>
+	<Optimize>false</Optimize>
+	<OutputPath>Temp\bin\Debug\</OutputPath>
+	<DefineConstants>DEBUG;TRACE;UNITY_3_5_4;UNITY_3_5;UNITY_EDITOR;ENABLE_PROFILER;UNITY_ANDROID;ENABLE_GENERICS;ENABLE_TERRAIN;ENABLE_WEBCAM;ENABLE_NETWORK;ENABLE_CLOTH;ENABLE_WWW</DefineConstants>
+	<ErrorReport>prompt</ErrorReport>
+	<WarningLevel>4</WarningLevel>
+	<NoWarn>0169</NoWarn>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+	<DebugType>pdbonly</DebugType>
+	<Optimize>true</Optimize>
+	<OutputPath>Temp\bin\Release\</OutputPath>
+	<DefineConstants>TRACE</DefineConstants>
+	<ErrorReport>prompt</ErrorReport>
+	<WarningLevel>4</WarningLevel>
+	<NoWarn>0169</NoWarn>
+  </PropertyGroup>
+  <ItemGroup>
+	<Reference Include="System" />
+    <Reference Include="System.XML" />
+	<Reference Include="System.Core" />
+	<Reference Include="UnityEngine">
+	  <HintPath>/Applications/Unity/Unity.app/Contents/Frameworks/Managed/UnityEngine.dll</HintPath>
+	</Reference>
+	<Reference Include="UnityEditor">
+	  <HintPath>/Applications/Unity/Unity.app/Contents/Frameworks/Managed/UnityEditor.dll</HintPath>
+	</Reference>
+  </ItemGroup>
+  <ItemGroup>
+     <Compile Include="Assets\camerafollow.js" />
+     <None Include="Assets\RagePixel\readme.txt" />
+     <None Include="Assets\RagePixel\Code\RagePixelBasicFlash.shader" />
+     <None Include="Assets\RagePixel\Code\RagePixelBasic.shader" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- 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.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  
+</Project>

Assets/RagePixel/Code/IRagePixel.cs

+using UnityEngine;
+using System.Collections;
+
+public interface IRagePixel {
+    void SetSprite(string name);
+    void SetSprite(string name, int frameIndex);
+    void PlayAnimation();
+    void PlayAnimation(bool forceRestart);
+    void PlayNamedAnimation(string name);
+    void PlayNamedAnimation(string name, bool forceRestart);
+    void PlayNamedAnimation(string name, bool forceRestart, float delayFirstFrame);
+    bool isPlaying();
+    void StopAnimation();
+    void SetSize(int width, int height);
+    Rect GetRect();
+    void SetHorizontalFlip(bool value);
+    void SetVerticalFlip(bool value);
+    void SetTintColor(Color color);
+}

Assets/RagePixel/Code/RagePixelAnimation.cs

+using UnityEngine;
+using System.Collections;
+
+[System.Serializable]
+public class RagePixelAnimation {
+
+    public string name;
+    public RagePixelSprite.AnimationMode mode;
+    public int startIndex;
+    public int endIndex;
+
+}

Assets/RagePixel/Code/RagePixelBasic.shader

+Shader "RagePixel/Basic" {
+	Properties {
+		_MainTex ("Texture1 (RGB)", 2D) = "white" {}
+	}
+
+	Category {
+		Tags {"RenderType"="Transparent" "Queue"="Transparent"}
+		Lighting Off
+		BindChannels {
+			Bind "Color", color
+			Bind "Vertex", vertex
+			Bind "Texcoord", Texcoord
+		}
+		
+		SubShader {
+			Pass {
+				ZWrite Off
+				Cull off
+				Blend SrcAlpha OneMinusSrcAlpha
+				SetTexture [_MainTex] {
+					Combine texture * primary, texture * primary
+				}
+			}
+		}
+	}
+}

Assets/RagePixel/Code/RagePixelBasicFlash.shader

+Shader "RagePixel/Basic (Flash)" {
+	Properties {
+		_MainTex ("Base (RGB)", 2D) = "white" {}
+		_TexWidth ("Texture width", Float) = 128.0
+		_TexHeight ("Texture height", Float) = 128.0
+
+	}
+	SubShader {
+		Tags { "Queue" = "Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+
+		Pass {
+			ZWrite Off
+			Cull off
+			Blend SrcAlpha OneMinusSrcAlpha
+
+			CGPROGRAM
+				#pragma vertex vert
+				#pragma fragment frag
+				#include "UnityCG.cginc"
+
+				sampler2D _MainTex;
+				float _TexWidth;
+				float _TexHeight;
+
+				struct VertOut
+				{
+					float4 position : POSITION;
+					float4 color : COLOR;
+					float4 texcoord : TEXCOORD0;
+				};
+
+				struct VertIn
+				{
+					float4 vertex : POSITION;
+					float4 color : COLOR;
+					float4 texcoord : TEXCOORD0;
+				};
+
+				VertOut vert(VertIn input)
+				{
+					VertOut output;
+					output.position = mul(UNITY_MATRIX_MVP,input.vertex);
+					output.color = input.color;
+					output.texcoord = float4( input.texcoord.xy, 0, 0);
+					return output;
+				}
+
+				struct FragOut
+				{
+					float4 color : COLOR;
+				};
+								
+				FragOut frag(VertIn input)
+				{
+					FragOut output;
+					half4 texcol = tex2D(_MainTex, float2(float(int(input.texcoord.x * _TexWidth) + 0.5) / _TexWidth, float(int(input.texcoord.y * _TexHeight) + 0.5) / _TexHeight));
+					//output.color = half4(input.color.b * texcol.r, input.color.g * texcol.g, input.color.r * texcol.b, input.color.a * texcol.a);
+					output.color = texcol * input.color;
+					return output;
+				}
+            ENDCG
+		}
+
+	} 
+	FallBack "Diffuse"
+}

Assets/RagePixel/Code/RagePixelBitmap.cs

+using UnityEngine;
+
+public class RagePixelBitmap {
+
+    private int W;
+    private int H;
+    public Color[] pixels;
+    
+    public RagePixelBitmap(Color[] _pixels, int width, int height)
+    {
+        W = width;
+        H = height;
+        pixels = new Color[_pixels.Length];
+        _pixels.CopyTo(pixels, 0);
+    }
+
+    public RagePixelBitmap GetSubImage(int X, int Y, int width, int height)
+    {
+        Color[] _pixels = new Color[width*height];
+        for(int _y = Y; _y < H; _y++) {
+            for(int _x = X; _x < W; _x++) {
+                _pixels[(_y - Y) * width + (_x - X)] = pixels[_y * W + _x];
+            }
+        }
+        return new RagePixelBitmap(_pixels, width, height);
+    }
+
+    public void PasteBitmap(int X, int Y, RagePixelBitmap bitmap)
+    {
+        for (int y = Mathf.Max(Y, 0); (y - Y) < bitmap.Height() && y < H; y++)
+        {
+            for (int x = Mathf.Max(X, 0); (x - X) < bitmap.Width() && x < W; x++)
+            {
+                pixels[y * W + x] = bitmap.pixels[(y - Y) * bitmap.Width() + (x - X)];
+                //SetPixel(x, y, bitmap.GetPixel(x - X, y - Y));
+            }
+        }
+    }
+
+    public void PasteBitmapAlpha(int X, int Y, RagePixelBitmap bitmap)
+    {
+        for (int y = Mathf.Max(Y, 0); (y - Y) < bitmap.Height() && y < H; y++)
+        {
+            for (int x = Mathf.Max(X, 0); (x - X) < bitmap.Width() && x < W; x++)
+            {
+                Color src = bitmap.pixels[(y - Y) * bitmap.Width() + (x - X)];
+
+                pixels[y * W + x] = (1f - src.a) * pixels[y * W + x] + src.a*src;
+            }
+        }
+    }
+
+    public void PasteToTextureWithBounds(int X, int Y, int minX, int minY, int maxX, int maxY, Texture2D tex, Color multiplyWith)
+    {
+        for (int y = Mathf.Max(Y, minY, 0); y < Mathf.Min(tex.height, maxY) && (y - Y) < H; y++)
+        {
+            for (int x = Mathf.Max(X, minX, 0); x < Mathf.Min(tex.width, maxX) && (x - X) < W; x++)
+            {
+                /*
+                if(!Mathf.Approximately(multiplyWith.a, 0f)) 
+                {
+                    Color src = pixels[(y - Y) * Width() + (x - X)] * multiplyWith;
+                    tex.SetPixel(x, y, (1f - src.a) * tex.GetPixel(x, y) + src.a * src);
+                } else 
+                {
+                    Color src = pixels[(y - Y) * Width() + (x - X)];
+                    tex.SetPixel(x, y, (1f - src.a) * tex.GetPixel(x, y) + src.a * multiplyWith);
+                }
+                */
+                Color src = pixels[(y - Y) * Width() + (x - X)];
+
+                if (!Mathf.Approximately(multiplyWith.a, 0f))
+                {
+                    if (!Mathf.Approximately(src.a, 0f))
+                    {
+                        tex.SetPixel(x, y, src * multiplyWith);
+                    }
+                }
+                else
+                {
+                    if (!Mathf.Approximately(src.a, 0f))
+                    {
+                        tex.SetPixel(x, y, multiplyWith);
+                    }
+                }
+            }
+        }
+    }
+
+    public int Width()
+    {
+        return W;
+    }
+
+    public int Height()
+    {
+        return H;
+    }
+
+    public Color GetPixel(int x, int y)
+    {
+        int index = y * W + x;
+        if (index >= 0 && index < pixels.Length)
+        {
+            return pixels[index];
+        }
+        else
+        {
+            Debug.Log("ERROR: array too small (" + pixels.Length + ") (x:"+x+",y:"+y+")");
+            return Color.black;
+        }
+    }
+
+    public void SetPixel(int x, int y, Color color)
+    {
+        int index = y * W + x;
+        if (index < pixels.Length)
+        {
+            pixels[y * W + x] = color;
+        }
+        else
+        {
+            Debug.Log("ERROR: array too small (" + pixels.Length + ") (x:" + x + ",y:" + y + ")");
+        }
+    }
+
+}

Assets/RagePixel/Code/RagePixelCamera.cs

+using UnityEngine;
+using System.Collections;
+
+[ExecuteInEditMode]
+public class RagePixelCamera : MonoBehaviour {
+
+    public int pixelSize=1;
+    public int resolutionPixelWidth = 1024;
+    public int resolutionPixelHeight = 768;
+
+    public void SnapToIntegerPosition()
+    {
+        transform.position = new Vector3(Mathf.RoundToInt(transform.position.x) + 0.05f, Mathf.RoundToInt(transform.position.y) - 0.05f, transform.position.z);
+    }
+
+    void Awake()
+    {
+     
+    }
+
+	void Start () {
+	    
+	}
+
+    public void OnPostRender()
+    {
+
+    }
+
+	void Update () 
+    {
+        SnapToIntegerPosition();
+	}
+
+    public void OnDrawGizmosSelected()
+    {
+        SnapToIntegerPosition();
+    }
+
+    public void ResetCamera()
+    {
+
+    }
+
+}

Assets/RagePixel/Code/RagePixelCell.cs

+using UnityEngine;
+using System.Collections;
+
+[System.Serializable]
+public class RagePixelCell {
+
+    [System.NonSerialized]
+    public ArrayList undoHistory;
+
+    public int key;
+    public Rect uv;
+    public int delay;
+
+    public void ClearUndoHistory()
+    {
+        if (undoHistory == null)
+        {
+            undoHistory = new ArrayList();
+        }
+        else
+        {
+            undoHistory.Clear();
+        }
+    }
+
+    public ArrayList GetUndoHistory()
+    {
+        if (undoHistory == null)
+        {
+            undoHistory = new ArrayList();
+        }
+        return undoHistory;
+    }
+}

Assets/RagePixel/Code/RagePixelRow.cs

+using UnityEngine;
+using System.Collections;
+
+[System.Serializable]
+public class RagePixelRow  {
+    public int pixelSizeX;
+    public int pixelSizeY;
+    public int newPixelSizeX;
+    public int newPixelSizeY;
+    public int key;
+    public string name;
+    [HideInInspector]
+    public string fontCharacter = "";
+    [HideInInspector]
+    public int fontYOffset = 0;
+
+    [SerializeField]
+    private RagePixelAnimation[] _animations;
+    public RagePixelAnimation[] animations
+    {
+        get
+        {
+            if (_animations == null)
+            {
+                _animations = new RagePixelAnimation[0];
+            }
+            return _animations;
+        }
+        set
+        {
+            _animations = value;
+        }
+    }
+
+    [SerializeField]
+    private RagePixelCell[] _cells;
+    public RagePixelCell[] cells
+    {
+        get
+        {
+            if (_cells == null)
+            {
+                _cells = new RagePixelCell[0];
+            }
+            return _cells;
+        }
+        set
+        {
+            _cells = value;
+        }
+    }
+
+    public RagePixelCell InsertCell(int index, int key)
+    {
+        RagePixelCell newCell = new RagePixelCell();
+        newCell.delay = 200;
+        newCell.uv = new Rect();
+        newCell.key = key;
+
+        RagePixelCell[] tmpArr = new RagePixelCell[cells.Length + 1];
+
+        for (int i = 0; i < tmpArr.Length; i++)
+        {
+            if (i < index)
+            {
+                tmpArr[i] = cells[i];
+                
+                if (i == index - 1)
+                {
+                    newCell.uv = cells[i].uv;
+                }
+                
+            }
+            else if (i > index)
+            {
+                tmpArr[i] = cells[i - 1];
+            }
+            else
+            {
+                tmpArr[i] = newCell;
+            }
+        }
+        
+        cells = tmpArr;
+        return newCell;
+    }
+
+    public void RemoveCellByKey(int key)
+    {
+        int toBeRemovedIndex = -1;
+
+        if (cells.Length > 1)
+        {
+            for (int i = 0; i < cells.Length; i++)
+            {
+                if (cells[i].key.Equals(key))
+                {
+                    toBeRemovedIndex = i;
+                }
+            }
+
+            if (toBeRemovedIndex >= 0)
+            {
+                RemoveCellByIndex(toBeRemovedIndex);
+            }
+        }
+        else
+        {
+            Debug.Log("Error: Can't remove the last cell. Remove row instead");
+        }
+    }
+
+    public void MoveCell(int fromIndex, int toIndex)
+    {
+        if (fromIndex >= 0 && fromIndex < cells.Length && toIndex >= 0 && toIndex <= cells.Length)
+        {
+            RagePixelCell[] tmpArr = new RagePixelCell[cells.Length];
+
+            for (int i = 0; i < tmpArr.Length; i++)
+            {
+                if (i == toIndex)
+                {
+                    tmpArr[toIndex] = cells[fromIndex];
+                }
+                else if (i < fromIndex && i < toIndex || i > fromIndex && i > toIndex)
+                {
+                    tmpArr[i] = cells[i];
+                }
+                else if (i >= fromIndex && i < toIndex)
+                {
+                    tmpArr[i] = cells[i + 1];
+                }
+                else if (i <= fromIndex && i > toIndex)
+                {
+                    tmpArr[i] = cells[i - 1];
+                }
+            }
+            cells = tmpArr;
+        }
+    } 
+
+    public int GetKey(int index)
+    {
+        if (cells.Length > index)
+        {
+            return cells[index].key;
+        }
+
+        Debug.Log("Error: Indvalid array size");
+
+        return cells[0].key;
+    }
+
+    public int GetIndex(int key)
+    {
+        if (cells.Length > 0)
+        {
+            for (int i = 0; i < cells.Length; i++)
+            {
+                if (cells[i].key.Equals(key))
+                {
+                    return i;
+                }
+            }
+        }
+
+        return 0;
+    }
+
+    public RagePixelCell GetCell(int key)
+    {
+        if (cells.Length > 0)
+        {
+            for (int i = 0; i < cells.Length; i++)
+            {
+                if (cells[i].key.Equals(key))
+                {
+                    return cells[i];
+                }
+            }
+        }
+
+        return cells[0];
+    }
+
+    public void RemoveCellByIndex(int index)
+    {
+        if (cells.Length > 0)
+        {
+            RagePixelCell[] tmpArr = new RagePixelCell[cells.Length - 1];
+
+            for (int i = 0; i < cells.Length; i++)
+            {
+                if (i < index)
+                {
+                    tmpArr[i] = cells[i];
+                }
+                else if (i > index)
+                {
+                    tmpArr[i-1] = cells[i];
+                }
+            }
+
+            cells = tmpArr;
+        }
+    }
+
+    public void AddAnimation()
+    {
+        RagePixelAnimation newAnim = new RagePixelAnimation();
+        newAnim.mode = RagePixelSprite.AnimationMode.PlayOnce;
+        newAnim.startIndex = 0;
+        newAnim.endIndex = cells.Length - 1;
+        newAnim.name = "New animation";
+
+        RagePixelAnimation[] tmpArr = new RagePixelAnimation[animations.Length + 1];
+
+        for (int i = 0; i < tmpArr.Length-1; i++)
+        {
+            tmpArr[i] = animations[i];
+        }
+
+        tmpArr[tmpArr.Length - 1] = newAnim;
+
+        animations = tmpArr;
+    }
+
+    public void RemoveAnimation(int index)
+    {
+        if (animations.Length > 0)
+        {
+            RagePixelAnimation[] tmpArr = new RagePixelAnimation[animations.Length - 1];
+
+            for (int i = 0; i < animations.Length; i++)
+            {
+                if (i < index)
+                {
+                    tmpArr[i] = animations[i];
+                }
+                else if (i > index)
+                {
+                    tmpArr[i - 1] = animations[i];
+                }
+            }
+
+            animations = tmpArr;
+        }
+    }
+
+    public RagePixelAnimation GetAnimationByName(string name)
+    {
+        if (animations.Length > 0)
+        {
+            for (int i = 0; i < animations.Length; i++)
+            {
+                if (animations[i].name.Equals(name))
+                {
+                    return animations[i];
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public void ClearUndoHistory()
+    {
+        for (int i = 0; i < cells.Length; i++)
+        {
+            if (cells[i].undoHistory == null)
+            {
+                cells[i].undoHistory = new ArrayList();
+            }
+            else
+            {
+                cells[i].undoHistory.Clear();
+            }
+        }
+    }
+}

Assets/RagePixel/Code/RagePixelSettings.cs

+using UnityEngine;
+using System.Collections;
+
+public class RagePixelSettings : ScriptableObject {
+    public bool showCameraWarnings = true;
+    public bool initialSpritesheetGenerated = false;
+
+    private RagePixelBitmap _clipboard;
+    public RagePixelBitmap clipboard
+    {
+        get
+        {
+            if (_clipboard == null)
+            {
+                _clipboard = new RagePixelBitmap(new Color[0], 0, 0);
+            }
+            return _clipboard;
+        }
+        set
+        {
+            _clipboard = value;
+        }
+    }
+
+    [SerializeField]
+    private Color[] _palette;
+    public Color[] palette
+    {
+        get
+        {
+            if (_palette == null)
+            {
+                _palette = new Color[2];
+                _palette[0] = new Color(0f, 0f, 0f, 1f);
+                _palette[1] = new Color(1f, 1f, 1f, 1f);
+            }
+            return _palette;
+        }
+        set
+        {
+            if (value == null)
+            {
+                //Debug.Log("SET AS NULL");
+            }
+            _palette = value;
+        }
+    }
+        
+}

Assets/RagePixel/Code/RagePixelSprite.cs

+using UnityEngine;
+using System.Collections;
+
+[ExecuteInEditMode]
+public class RagePixelSprite : MonoBehaviour, IRagePixel {
+
+    public Vector3 accuratePosition;
+    public RagePixelSpriteSheet spriteSheet;
+
+    public enum Mode { Default = 0, Grid9 };
+    public Mode mode = Mode.Default;
+
+    public enum PivotMode { BottomLeft = 0, Bottom, Middle };
+    public PivotMode pivotMode = PivotMode.BottomLeft;
+    
+    public enum AnimationMode { PlayOnce = 0, PlayOnceReverse, Loop, LoopReverse, PingPong };
+    public AnimationMode animationMode = 0;
+
+    public int animationMinIndex = -1;
+    public int animationMaxIndex = -1;
+    private int animationPingPongDirection = 1;
+
+    private RagePixelSpriteSheet lastCellSpriteSheetCache;
+    private RagePixelCell lastCellCache;
+    private int lastCellCacheKey;
+    private RagePixelSpriteSheet lastRowSpriteSheetCache;
+    private RagePixelRow lastRowCache;
+    private int lastRowCacheKey;
+
+    public int grid9Left;
+    public int grid9Top;
+    public int grid9Right;
+    public int grid9Bottom;
+
+    public int currentRowKey;
+    public int currentCellKey;
+    public int ZLayer;
+    public int pixelSizeX = 16;
+    public int pixelSizeY = 16;
+    public bool meshIsDirty = false;
+    public bool vertexColorsAreDirty = false;
+    
+    public Color tintColor = new Color(1f, 1f, 1f, 1f);
+    public bool flipHorizontal;
+    public bool flipVertical;
+
+    public float nextAnimFrame = 0f;
+    public bool playAnimation = false;
+    
+    private bool toBeRefreshed;
+    private float myTime=0f;
+
+    void Awake() {
+        lastRowSpriteSheetCache = null;
+        lastCellSpriteSheetCache = null;
+        lastRowCache = null;
+        lastCellCache = null;
+        lastCellCacheKey = 0;
+        lastRowCacheKey = 0;
+        
+        meshIsDirty = true;
+        vertexColorsAreDirty = true;
+
+        if (!Application.isPlaying)
+        {
+            MeshFilter meshFilter = null;
+            MeshRenderer meshRenderer = null;
+
+            meshRenderer = gameObject.GetComponent("MeshRenderer") as MeshRenderer;
+            if (meshRenderer == null)
+            {
+                meshRenderer = gameObject.AddComponent("MeshRenderer") as MeshRenderer;
+            }
+
+            meshFilter = gameObject.GetComponent("MeshFilter") as MeshFilter;
+            if (meshFilter == null)
+            {
+                meshFilter = gameObject.AddComponent("MeshFilter") as MeshFilter;
+            }
+
+            if (meshFilter.sharedMesh != null)
+            {
+                RagePixelSprite[] ragePixelSprites = GameObject.FindObjectsOfType(typeof(RagePixelSprite)) as RagePixelSprite[];
+
+                foreach (RagePixelSprite ragePixelSprite in ragePixelSprites)
+                {
+                    MeshFilter otherMeshFilter = ragePixelSprite.GetComponent(typeof(MeshFilter)) as MeshFilter;
+                    if (otherMeshFilter != null)
+                    {
+                        if (otherMeshFilter.sharedMesh == meshFilter.sharedMesh && otherMeshFilter != meshFilter)
+                        {
+                            meshFilter.mesh = new Mesh();
+                            toBeRefreshed = true;
+                        }
+                    }
+                }
+            }
+
+            if (meshFilter.sharedMesh == null)
+            {
+                meshFilter.sharedMesh = new Mesh();
+                toBeRefreshed = true;
+            }
+        }
+        else
+        {
+            meshIsDirty = true;
+            refreshMesh();
+        }
+    }
+
+	void Start () {
+        if (Application.isPlaying && playAnimation && gameObject.active)
+        {
+            nextAnimFrame = myTime + GetCurrentCell().delay / 1000f;
+        }
+	}
+
+    void OnEnable()
+    {
+        if (Application.isPlaying && playAnimation)
+        {
+            nextAnimFrame = myTime + GetCurrentCell().delay / 1000f;
+        }
+    }
+
+    public void SnapToScale()
+    {
+        transform.localScale = new Vector3(1f, 1f, 1f);
+    }
+
+    public void SnapToIntegerPosition()
+    {
+        if (!Application.isPlaying)
+        {
+            //transform.rotation = Quaternion.identity;
+            transform.localEulerAngles = new Vector3(0f, 0f, transform.localEulerAngles.z);
+        }
+        //SnapToScale();
+        transform.localPosition = new Vector3(Mathf.RoundToInt(transform.localPosition.x), Mathf.RoundToInt(transform.localPosition.y), ZLayer);
+    }
+
+    public void SnapToIntegerPosition(float divider)
+    {
+        transform.rotation = Quaternion.identity; 
+        //SnapToScale();
+        transform.localPosition = new Vector3(Mathf.RoundToInt(transform.localPosition.x * divider) / divider, Mathf.RoundToInt(transform.localPosition.y * divider) / divider, ZLayer);
+    }
+        
+    public void refreshMesh()
+    {
+        MeshRenderer meshRenderer = GetComponent(typeof(MeshRenderer)) as MeshRenderer;
+        MeshFilter meshFilter = GetComponent(typeof(MeshFilter)) as MeshFilter;
+
+        if (meshRenderer == null)
+        {
+            meshRenderer = gameObject.AddComponent("MeshRenderer") as MeshRenderer;
+        }
+        if (meshFilter == null)
+        {
+            meshFilter = gameObject.AddComponent("MeshFilter") as MeshFilter;
+        }
+
+        if (meshFilter.sharedMesh == null)
+        {
+            DestroyImmediate(meshFilter.sharedMesh);
+            meshFilter.mesh = new Mesh();
+        }
+
+        if (meshFilter.sharedMesh.vertexCount == 0)
+        {
+            meshIsDirty = true;
+        }
+
+        if (spriteSheet != null)
+        {
+            GenerateMesh(meshFilter.sharedMesh);
+        }
+
+        if (!Application.isPlaying)
+        {
+            SnapToIntegerPosition();
+            //SnapToScale();
+        }
+        else
+        {
+            //SnapToScale();
+        }
+
+        if (spriteSheet != null)
+        {
+            if (meshRenderer.sharedMaterial != spriteSheet.atlas)
+            {
+                meshRenderer.sharedMaterial = spriteSheet.atlas;
+            }
+        }
+    }
+
+    public void GenerateMesh(Mesh mesh)
+    {
+        if (meshIsDirty)
+        {
+            mesh.Clear();
+        }
+
+        Rect uv = new Rect();
+        int[] triangles = null;
+        Vector3[] verts = null;
+        Vector2[] uvs = null;
+        Color[] colors = null;
+
+        int tIndex = 0;
+        int uvIndex = 0;
+        int vIndex = 0;
+        int cIndex = 0;
+
+        int quadCountX;
+        int quadCountY;
+        int quadCount;
+
+        float pivotOffsetX;
+        float pivotOffsetY;
+
+        float xMin;
+        float yMin;
+        float uvWidth;
+        float uvHeight;
+
+        float left;
+        float top;
+        float offX;
+        float offY;
+
+        RagePixelRow currentRow = GetCurrentRow();
+        RagePixelCell currentCell = GetCurrentCell(); 
+
+        if (pixelSizeX > 0 && pixelSizeY > 0)
+        {
+            switch (mode)
+            {
+                case(Mode.Default):                
+                    /*
+                    if (spriteSheet.rows.Length == 1 && currentRow.cells.Length == 1)
+                    {
+                        triangles = new int[6];
+                        verts = new Vector3[4];
+                        uvs = new Vector2[4];
+                        colors = new Color[4];
+
+                        int tIndex = 0;
+                        int uvIndex = 0;
+                        int vIndex = 0;
+                        int cIndex = 0;
+
+                        triangles[tIndex++] = 0;
+                        triangles[tIndex++] = 1;
+                        triangles[tIndex++] = 2;
+                        triangles[tIndex++] = 0;
+                        triangles[tIndex++] = 2;
+                        triangles[tIndex++] = 3;
+
+                        float left = 0f;
+                        float top = 0f;
+                        float offY = pixelSizeY;
+                        float offX = pixelSizeX;
+
+                        verts[vIndex++] = new Vector3(left, top + offY, 0f);
+                        verts[vIndex++] = new Vector3(left + offX, top + offY, 0f);
+                        verts[vIndex++] = new Vector3(left + offX, top, 0f);
+                        verts[vIndex++] = new Vector3(left, top, 0f);
+
+                        Rect uv = new Rect(0f, 0f, 1f, 1f);
+
+                        uvs[uvIndex++] = new Vector2(0f, uv.yMin + (offY / (float)currentRow.pixelSizeY));
+                        uvs[uvIndex++] = new Vector2(0f + (offX / (float)currentRow.pixelSizeX), 0f + (offY / (float)currentRow.pixelSizeY));
+                        uvs[uvIndex++] = new Vector2(0f + (offX / (float)currentRow.pixelSizeX), 0f);
+                        uvs[uvIndex++] = new Vector2(0f, 0f);
+
+                        if (flipHorizontal)
+                        {
+                            Vector2 tmp = uvs[uvIndex - 1];
+                            uvs[uvIndex - 1] = uvs[uvIndex - 2];
+                            uvs[uvIndex - 2] = tmp;
+                            Vector2 tmp2 = uvs[uvIndex - 3];
+                            uvs[uvIndex - 3] = uvs[uvIndex - 4];
+                            uvs[uvIndex - 4] = tmp2;
+                        }
+
+                        if (flipVertical)
+                        {
+                            Vector2 tmp = uvs[uvIndex - 1];
+                            uvs[uvIndex - 1] = uvs[uvIndex - 4];
+                            uvs[uvIndex - 4] = tmp;
+                            Vector2 tmp2 = uvs[uvIndex - 2];
+                            uvs[uvIndex - 2] = uvs[uvIndex - 3];
+                            uvs[uvIndex - 3] = tmp2;
+                        }
+
+                        if (vertexColorsAreDirty || meshIsDirty)
+                        {
+                            colors[cIndex++] = tintColor;
+                            colors[cIndex++] = tintColor;
+                            colors[cIndex++] = tintColor;
+                            colors[cIndex++] = tintColor;
+                        }
+                    }*/
+                        
+                    quadCountX = Mathf.CeilToInt((float)pixelSizeX / (float)currentRow.pixelSizeX);
+                    quadCountY = Mathf.CeilToInt((float)pixelSizeY / (float)currentRow.pixelSizeY);
+                    quadCount = quadCountX * quadCountY;
+
+                    pivotOffsetX = 0f;
+                    pivotOffsetY = 0f;
+
+                    switch (pivotMode)
+                    {
+                        case(PivotMode.BottomLeft):
+                            pivotOffsetX = 0f;
+                            pivotOffsetY = 0f;
+                            break;
+                        case (PivotMode.Bottom):
+                            pivotOffsetX = -pixelSizeX / 2f;
+                            pivotOffsetY = 0f;
+                            break;
+                        case (PivotMode.Middle):
+                            pivotOffsetX = -pixelSizeX / 2f;
+                            pivotOffsetY = -pixelSizeY / 2f;
+                            break;
+                    }
+
+                    triangles = new int[quadCount * 6];
+                    verts = new Vector3[quadCount * 4];
+                    uvs = new Vector2[quadCount * 4];
+                    colors = new Color[quadCount * 4];
+                    
+                    uv = currentCell.uv;
+                    xMin = uv.xMin;
+                    yMin = uv.yMin;
+                    uvWidth = uv.width;
+                    uvHeight = uv.height;
+
+                    for (int qy = 0; qy < quadCountY; qy++)
+                    {
+                        for (int qx = 0; qx < quadCountX; qx++)
+                        {
+                            left = (float)qx * (float)currentRow.pixelSizeX + pivotOffsetX;
+                            top = (float)qy * (float)currentRow.pixelSizeY + pivotOffsetY;
+                            offX = (float)currentRow.pixelSizeX;
+                            offY = (float)currentRow.pixelSizeY;
+
+                            if (qy == quadCountY - 1)
+                            {
+                                offY = (float)(pixelSizeY % currentRow.pixelSizeY);
+                                if (Mathf.Approximately(offY, 0f))
+                                {
+                                    offY = (float)currentRow.pixelSizeY;
+                                }
+                            }
+                            if (qx == quadCountX - 1)
+                            {
+                                offX = (float)(pixelSizeX % currentRow.pixelSizeX);
+                                if (Mathf.Approximately(offX, 0f))
+                                {
+                                    offX = (float)currentRow.pixelSizeX;
+                                }
+                            }
+
+                            if (meshIsDirty)
+                            {
+                                int triangleTmp = (qy * quadCountX + qx) * 4;
+                                triangles[tIndex++] = triangleTmp + 0;
+                                triangles[tIndex++] = triangleTmp + 1;
+                                triangles[tIndex++] = triangleTmp + 2;
+                                triangles[tIndex++] = triangleTmp + 0;
+                                triangles[tIndex++] = triangleTmp + 2;
+                                triangles[tIndex++] = triangleTmp + 3;
+
+                                verts[vIndex++] = new Vector3(left, top + offY, 0f);
+                                verts[vIndex++] = new Vector3(left + offX, top + offY, 0f);
+                                verts[vIndex++] = new Vector3(left + offX, top, 0f);
+                                verts[vIndex++] = new Vector3(left, top, 0f);
+                            }
+
+                            uvs[uvIndex++] = new Vector2(xMin, yMin + uvHeight * (offY / (float)currentRow.pixelSizeY));
+                            uvs[uvIndex++] = new Vector2(xMin + uvWidth * (offX / (float)currentRow.pixelSizeX), yMin + uvHeight * (offY / (float)currentRow.pixelSizeY));
+                            uvs[uvIndex++] = new Vector2(xMin + uvWidth * (offX / (float)currentRow.pixelSizeX), yMin);
+                            uvs[uvIndex++] = new Vector2(xMin, yMin);
+
+                            if (flipHorizontal)
+                            {
+                                Vector2 tmp = uvs[uvIndex - 1];
+                                uvs[uvIndex - 1] = uvs[uvIndex - 2];
+                                uvs[uvIndex - 2] = tmp;
+                                Vector2 tmp2 = uvs[uvIndex - 3];
+                                uvs[uvIndex - 3] = uvs[uvIndex - 4];
+                                uvs[uvIndex - 4] = tmp2;
+                            }
+
+                            if (flipVertical)
+                            {
+                                Vector2 tmp = uvs[uvIndex - 1];
+                                uvs[uvIndex - 1] = uvs[uvIndex - 4];
+                                uvs[uvIndex - 4] = tmp;
+                                Vector2 tmp2 = uvs[uvIndex - 2];
+                                uvs[uvIndex - 2] = uvs[uvIndex - 3];
+                                uvs[uvIndex - 3] = tmp2;
+                            }
+
+                            if (vertexColorsAreDirty || meshIsDirty)
+                            {
+                                colors[cIndex++] = tintColor;
+                                colors[cIndex++] = tintColor;
+                                colors[cIndex++] = tintColor;
+                                colors[cIndex++] = tintColor;
+                            }
+                        }
+                    }
+                    break;
+                case (Mode.Grid9):
+                    quadCountX = Mathf.CeilToInt((float)(pixelSizeX - grid9Left - grid9Right) / ((float)currentRow.pixelSizeX - grid9Left - grid9Right));
+                    quadCountY = Mathf.CeilToInt((float)(pixelSizeY - grid9Bottom - grid9Top) / ((float)currentRow.pixelSizeY - grid9Bottom - grid9Top));
+                    quadCount = quadCountX * quadCountY;
+
+                    pivotOffsetX = 0f;
+                    pivotOffsetY = 0f;
+
+                    switch (pivotMode)
+                    {
+                        case(PivotMode.BottomLeft):
+                            pivotOffsetX = 0f;
+                            pivotOffsetY = 0f;
+                            break;
+                        case (PivotMode.Bottom):
+                            pivotOffsetX = -pixelSizeX / 2f;
+                            pivotOffsetY = 0f;
+                            break;
+                        case (PivotMode.Middle):
+                            pivotOffsetX = -pixelSizeX / 2f;
+                            pivotOffsetY = -pixelSizeY / 2f;
+                            break;
+                    }
+
+                    int edgeQuadCount = 0;
+                    if (grid9Bottom > 0f && grid9Left > 0f)
+                    {
+                        edgeQuadCount++;
+                    }
+                    if (grid9Bottom > 0f && grid9Right > 0f) 
+                    {
+                        edgeQuadCount++;
+                    }
+                    if (grid9Top > 0f && grid9Left > 0f)
+                    {
+                        edgeQuadCount++;
+                    }
+                    if (grid9Top > 0f && grid9Right > 0f)
+                    {
+                        edgeQuadCount++;
+                    }
+                    if (grid9Bottom > 0f)
+                    {
+                        edgeQuadCount += quadCountX; 
+                    }
+                    if (grid9Top > 0f)
+                    {
+                        edgeQuadCount += quadCountX;
+                    }
+                    if (grid9Left > 0f)
+                    {
+                        edgeQuadCount += quadCountY; 
+                    }
+                    if (grid9Right > 0f)
+                    {
+                        edgeQuadCount += quadCountY;
+                    }
+
+                    triangles = new int[quadCount * 6 + edgeQuadCount * 6];
+                    verts = new Vector3[quadCount * 4 + edgeQuadCount * 4];
+                    uvs = new Vector2[quadCount * 4 + edgeQuadCount * 4];
+                    colors = new Color[quadCount * 4 + edgeQuadCount * 4];
+
+                    //Debug.Log("verts.length: " + verts.Length);
+
+                    uv = currentCell.uv;
+                    xMin = uv.xMin;
+                    yMin = uv.yMin;
+                    uvWidth = uv.width;
+                    uvHeight = uv.height;
+                                        
+                    for (int qy = 0; qy < quadCountY; qy++)
+                    {
+                        for (int qx = 0; qx < quadCountX; qx++)
+                        {
+                            if ( qy==0 && grid9Bottom > 0f)
+                            {
+                                left = (float)qx * (float)(currentRow.pixelSizeX - grid9Left - grid9Right) + pivotOffsetX + grid9Left;
+                                top = pivotOffsetY;
+                                offX = (float)(currentRow.pixelSizeX - grid9Left - grid9Right);
+                                offY = grid9Bottom;
+
+                                if (qx == quadCountX - 1)
+                                {
+                                    offX = (float)((pixelSizeX - grid9Left - grid9Right) % (currentRow.pixelSizeX - grid9Left - grid9Right));
+                                    if (Mathf.Approximately(offX, 0f))
+                                    {
+                                        offX = (float)(currentRow.pixelSizeX - grid9Left - grid9Right);
+                                    }
+                                }
+
+                                if (meshIsDirty)
+                                {
+                                    triangles[tIndex++] = vIndex + 0;
+                                    triangles[tIndex++] = vIndex + 1;
+                                    triangles[tIndex++] = vIndex + 2;
+                                    triangles[tIndex++] = vIndex + 0;
+                                    triangles[tIndex++] = vIndex + 2;
+                                    triangles[tIndex++] = vIndex + 3;
+                                }
+
+                                verts[vIndex++] = new Vector3(left, top + offY, 0f);
+                                verts[vIndex++] = new Vector3(left + offX, top + offY, 0f);
+                                verts[vIndex++] = new Vector3(left + offX, top, 0f);
+                                verts[vIndex++] = new Vector3(left, top, 0f);
+
+                                uvs[uvIndex++] = new Vector2(xMin + uvWidth * ((float)grid9Left / (float)currentRow.pixelSizeX), yMin + uvHeight * ((float)grid9Bottom / (float)currentRow.pixelSizeY));
+                                uvs[uvIndex++] = new Vector2(xMin + uvWidth * ((float)(offX + grid9Left) / (float)currentRow.pixelSizeX), yMin + uvHeight * ((float)grid9Bottom / (float)currentRow.pixelSizeY));
+                                uvs[uvIndex++] = new Vector2(xMin + uvWidth * ((float)(offX + grid9Left) / (float)currentRow.pixelSizeX), yMin);
+                                uvs[uvIndex++] = new Vector2(xMin + uvWidth * ((float)grid9Left / (float)currentRow.pixelSizeX), yMin);
+                                
+                                if (vertexColorsAreDirty || meshIsDirty)
+                                {
+                                    colors[cIndex++] = tintColor;
+                                    colors[cIndex++] = tintColor;
+                                    colors[cIndex++] = tintColor;
+                                    colors[cIndex++] = tintColor;
+                                }
+                            }
+
+                            if (qy == quadCountY - 1 && grid9Top > 0f)
+                            {
+                                left = (float)qx * (float)(currentRow.pixelSizeX - grid9Left - grid9Right) + pivotOffsetX + grid9Left;
+                                top = pivotOffsetY+pixelSizeY-grid9Top;
+                                offX = (float)(currentRow.pixelSizeX - grid9Left - grid9Right);
+                                offY = grid9Top;
+
+                                if (qx == quadCountX - 1)
+                                {
+                                    offX = (float)((pixelSizeX - grid9Left - grid9Right) % (currentRow.pixelSizeX - grid9Left - grid9Right));
+                                    if (Mathf.Approximately(offX, 0f))
+                                    {
+                                        offX = (float)(currentRow.pixelSizeX - grid9Left - grid9Right);
+                                    }
+                                }
+
+                                if (meshIsDirty)
+                                {
+                                    triangles[tIndex++] = vIndex + 0;
+                                    triangles[tIndex++] = vIndex + 1;
+                                    triangles[tIndex++] = vIndex + 2;
+                                    triangles[tIndex++] = vIndex + 0;
+                                    triangles[tIndex++] = vIndex + 2;
+                                    triangles[tIndex++] = vIndex + 3;
+                                }
+
+                                verts[vIndex++] = new Vector3(left, top + offY, 0f);
+                                verts[vIndex++] = new Vector3(left + offX, top + offY, 0f);
+                                verts[vIndex++] = new Vector3(left + offX, top, 0f);
+                                verts[vIndex++] = new Vector3(left, top, 0f);
+
+                                uvs[uvIndex++] = new Vector2(xMin + uvWidth * ((float)grid9Left / (float)currentRow.pixelSizeX), yMin + uvHeight);
+                                uvs[uvIndex++] = new Vector2(xMin + uvWidth * ((float)(offX + grid9Left) / (float)currentRow.pixelSizeX), yMin + uvHeight);
+                                uvs[uvIndex++] = new Vector2(xMin + uvWidth * ((float)(offX + grid9Left) / (float)currentRow.pixelSizeX), yMin + uvHeight * ((float)(currentRow.pixelSizeY - grid9Top) / (float)currentRow.pixelSizeY));
+                                uvs[uvIndex++] = new Vector2(xMin + uvWidth * ((float)grid9Left / (float)currentRow.pixelSizeX), yMin + uvHeight * ((float)(currentRow.pixelSizeY - grid9Top) / (float)currentRow.pixelSizeY));
+                                
+                                if (vertexColorsAreDirty || meshIsDirty)
+                                {
+                                    colors[cIndex++] = tintColor;
+                                    colors[cIndex++] = tintColor;
+                                    colors[cIndex++] = tintColor;
+                                    colors[cIndex++] = tintColor;
+                                }
+                            }
+
+                            if (qx == 0 && grid9Left > 0f)
+                            {
+                                left = pivotOffsetX;
+                                top = (float)qy * (float)(currentRow.pixelSizeY - grid9Bottom - grid9Top) + pivotOffsetY + grid9Bottom;
+                                offX = grid9Left;
+                                offY = (float)(currentRow.pixelSizeY - grid9Bottom - grid9Top);
+
+                                if (qy == quadCountY - 1)
+                                {
+                                    offY = (float)((pixelSizeY - grid9Bottom - grid9Top) % (currentRow.pixelSizeY - grid9Bottom - grid9Top));
+                                    if (Mathf.Approximately(offY, 0f))
+                                    {
+                                        offY = (float)(currentRow.pixelSizeY - grid9Bottom - grid9Top);
+                                    }
+                                }
+
+                                if (meshIsDirty)
+                                {
+                                    triangles[tIndex++] = vIndex + 0;
+                                    triangles[tIndex++] = vIndex + 1;
+                                    triangles[tIndex++] = vIndex + 2;
+                                    triangles[tIndex++] = vIndex + 0;
+                                    triangles[tIndex++] = vIndex + 2;
+                                    triangles[tIndex++] = vIndex + 3;
+                                }
+
+                                verts[vIndex++] = new Vector3(left, top + offY, 0f);
+                                verts[vIndex++] = new Vector3(left + offX, top + offY, 0f);
+                                verts[vIndex++] = new Vector3(left + offX, top, 0f);
+                                verts[vIndex++] = new Vector3(left, top, 0f);
+
+                                uvs[uvIndex++] = new Vector2(xMin, yMin + uvHeight * ((float)(offY + grid9Bottom) / (float)currentRow.pixelSizeY));
+                                uvs[uvIndex++] = new Vector2(xMin + uvWidth * ((float)grid9Left / (float)currentRow.pixelSizeX), yMin + uvHeight * ((float)(offY + grid9Bottom) / (float)currentRow.pixelSizeY));
+                                uvs[uvIndex++] = new Vector2(xMin + uvWidth * ((float)grid9Left / (float)currentRow.pixelSizeX), yMin + uvHeight * ((float)grid9Bottom / (float)currentRow.pixelSizeY));
+                                uvs[uvIndex++] = new Vector2(xMin, yMin + uvHeight * ((float)grid9Bottom / (float)currentRow.pixelSizeY));
+
+                                if (vertexColorsAreDirty || meshIsDirty)
+                                {
+                                    colors[cIndex++] = tintColor;
+                                    colors[cIndex++] = tintColor;
+                                    colors[cIndex++] = tintColor;
+                                    colors[cIndex++] = tintColor;
+                                }
+                            }
+
+                            if (qx == quadCountX-1 && grid9Right > 0f)
+                            {
+                                left = (float)(pivotOffsetX + pixelSizeX - grid9Right);
+                                top = (float)qy * (float)(currentRow.pixelSizeY - grid9Bottom - grid9Top) + pivotOffsetY + grid9Bottom;
+                                offX = (float)grid9Right;
+                                offY = (float)(currentRow.pixelSizeY - grid9Bottom - grid9Top);
+
+                                if (qy == quadCountY - 1)
+                                {
+                                    offY = (float)((pixelSizeY - grid9Bottom - grid9Top) % (currentRow.pixelSizeY - grid9Bottom - grid9Top));
+                                    if (Mathf.Approximately(offY, 0f))
+                                    {
+                                        offY = (float)(currentRow.pixelSizeY - grid9Bottom - grid9Top);
+                                    }
+                                }
+
+                                if (meshIsDirty)
+                                {
+                                    triangles[tIndex++] = vIndex + 0;
+                                    triangles[tIndex++] = vIndex + 1;
+                                    triangles[tIndex++] = vIndex + 2;
+                                    triangles[tIndex++] = vIndex + 0;
+                                    triangles[tIndex++] = vIndex + 2;
+                                    triangles[tIndex++] = vIndex + 3;
+                                }
+
+                                verts[vIndex++] = new Vector3(left, top + offY, 0f);
+                                verts[vIndex++] = new Vector3(left + offX, top + offY, 0f);
+                                verts[vIndex++] = new Vector3(left + offX, top, 0f);
+                                verts[vIndex++] = new Vector3(left, top, 0f);
+
+                                uvs[uvIndex++] = new Vector2(xMin + uvWidth * ((float)(currentRow.pixelSizeX - grid9Right) / (float)currentRow.pixelSizeX), yMin + uvHeight * ((float)(offY + grid9Bottom) / (float)currentRow.pixelSizeY));
+                                uvs[uvIndex++] = new Vector2(xMin + uvWidth, yMin + uvHeight * ((float)(offY + grid9Bottom) / (float)currentRow.pixelSizeY));
+                                uvs[uvIndex++] = new Vector2(xMin + uvWidth, yMin + uvHeight * ((float)grid9Bottom / (float)currentRow.pixelSizeY));
+                                uvs[uvIndex++] = new Vector2(xMin + uvWidth * ((float)(currentRow.pixelSizeX - grid9Right) / (float)currentRow.pixelSizeX), yMin + uvHeight * ((float)grid9Bottom / (float)currentRow.pixelSizeY));
+                                
+                                if (vertexColorsAreDirty || meshIsDirty)
+                                {
+                                    colors[cIndex++] = tintColor;
+                                    colors[cIndex++] = tintColor;
+                                    colors[cIndex++] = tintColor;
+                                    colors[cIndex++] = tintColor;
+                                }
+                            }
+
+                            left = (float)qx * (float)(currentRow.pixelSizeX - grid9Left - grid9Right) + pivotOffsetX + grid9Left;
+                            top = (float)qy * (float)(currentRow.pixelSizeY - grid9Bottom - grid9Top) + pivotOffsetY + grid9Bottom;
+                            offX = (float)(currentRow.pixelSizeX - grid9Left - grid9Right);
+                            offY = (float)(currentRow.pixelSizeY - grid9Bottom - grid9Top);
+
+                            if (qy == quadCountY - 1)
+                            {
+                                offY = (float)((pixelSizeY- grid9Bottom - grid9Top) % (currentRow.pixelSizeY - grid9Bottom - grid9Top));
+                                if (Mathf.Approximately(offY, 0f))
+                                {
+                                    offY = (float)(currentRow.pixelSizeY - grid9Bottom - grid9Top);
+                                }
+                            }
+                            if (qx == quadCountX - 1)
+                            {
+                                offX = (float)((pixelSizeX- grid9Left - grid9Right) % (currentRow.pixelSizeX - grid9Left - grid9Right));
+                                if (Mathf.Approximately(offX, 0f))
+                                {
+                                    offX = (float)(currentRow.pixelSizeX - grid9Left - grid9Right);
+                                }
+                            }
+                                                        
+                            if (meshIsDirty)
+                            {
+                                //int triangleTmp = (qy * quadCountX + qx) * 4;
+                                triangles[tIndex++] = vIndex + 0;
+                                triangles[tIndex++] = vIndex + 1;
+                                triangles[tIndex++] = vIndex + 2;
+                                triangles[tIndex++] = vIndex + 0;
+                                triangles[tIndex++] = vIndex + 2;
+                                triangles[tIndex++] = vIndex + 3;
+
+                                verts[vIndex++] = new Vector3(left, top + offY, 0f);
+                                verts[vIndex++] = new Vector3(left + offX, top + offY, 0f);
+                                verts[vIndex++] = new Vector3(left + offX, top, 0f);
+                                verts[vIndex++] = new Vector3(left, top, 0f);
+                            }
+
+                            uvs[uvIndex++] = new Vector2(xMin + uvWidth * ((float)grid9Left / (float)currentRow.pixelSizeX), yMin + uvHeight * ((float)(offY + grid9Bottom) / (float)currentRow.pixelSizeY));
+                            uvs[uvIndex++] = new Vector2(xMin + uvWidth * ((float)(offX + grid9Left) / (float)currentRow.pixelSizeX), yMin + uvHeight * ((float)(offY + grid9Bottom) / (float)currentRow.pixelSizeY));
+                            uvs[uvIndex++] = new Vector2(xMin + uvWidth * ((float)(offX + grid9Left) / (float)currentRow.pixelSizeX), yMin + uvHeight * ((float)grid9Bottom / (float)currentRow.pixelSizeY));
+                            uvs[uvIndex++] = new Vector2(xMin + uvWidth * ((float)grid9Left / (float)currentRow.pixelSizeX), yMin + uvHeight * ((float)grid9Bottom / (float)currentRow.pixelSizeY));
+
+                            if (flipHorizontal)
+                            {
+                                Vector2 tmp = uvs[uvIndex - 1];
+                                uvs[uvIndex - 1] = uvs[uvIndex - 2];
+                                uvs[uvIndex - 2] = tmp;
+                                Vector2 tmp2 = uvs[uvIndex - 3];
+                                uvs[uvIndex - 3] = uvs[uvIndex - 4];
+                                uvs[uvIndex - 4] = tmp2;
+                            }
+
+                            if (flipVertical)
+                            {
+                                Vector2 tmp = uvs[uvIndex - 1];
+                                uvs[uvIndex - 1] = uvs[uvIndex - 4];
+                                uvs[uvIndex - 4] = tmp;
+                                Vector2 tmp2 = uvs[uvIndex - 2];
+                                uvs[uvIn