There is no Unity specific API for getting the project folder, but you can use System.IO.Directory.GetCurrentDirectory. The unity editor expects the current folder to be set to the project folder at all times.

If you are changing the current directory in your editor scripts using System.IO.Directory.SetCurrentDirectory you need to restore the directory back to the project folder when you are done. Otherwise the next time unity compiles your scripts it will prompt you with a dialog box and a message stating you need to restore the current directory back to the project directory and only gives you a “Quit” button to click on that will quit unity.

    // save project folder
    var projectFolder = System.IO.Directory.GetCurrentDirectory();
                   
    // set current directory to a folder of your choosing
    System.IO.Directory.SetCurrentDirectory("c:\\some folder name");
                  
    // do what you need to do
    // ...

    // restore current folder back the the project folder 
    System.IO.Directory.SetCurrentDirectory(projectFolder);

This code is designed to hook into unity’s EditorApplication.update delegate.

IRun.cs

namespace CBX.CoreProjectCode.Interfaces
{
    using CBX.CoreProjectCode.Models;

    /// <summary>
    /// Provides a interface for running a <see cref="CallbackModel{T}"/> type.
    /// </summary>
    public interface IRun
    {
        /// <summary>
        /// Runs the <see cref="CallbackModel{T}"/> type.
        /// </summary>
        void Run();                    
    }
}

CallbackModel.cs

namespace CBX.CoreProjectCode.Models
{
    using System;

    using CBX.CoreProjectCode.Interfaces;

    /// <summary>
    /// Provides a modal for callbacks.
    /// </summary>
    /// <typeparam name="T">The generic type used to represent the data type.</typeparam>
    public class CallbackModel<T> : IRun
    {
        /// <summary>
        /// A reference to a callback method.
        /// </summary>
        public Action<T> Callback;

        /// <summary>
        /// A reference to some data that will be passed to the callback method.
        /// </summary>
        public T Data;

        /// <summary>
        /// Implements <see cref="IRun.Run"/> to run the callback. 
        /// </summary>
        public void Run()
        {
            this.Callback(this.Data);
        }
    }
}

EditorCallbackService.cs

namespace CBX.CoreProjectCode.Services
{
    using System;
    using System.Collections.Generic;

    using CBX.CoreProjectCode.Interfaces;
    using CBX.CoreProjectCode.Models;

    /// <summary>
    /// The editor callback service.
    /// </summary>
    public class EditorCallbackService
    {
        /// <summary>
        /// Holds a singleton instance of the <see cref="EditorCallbackService"/> type.
        /// </summary>
        private static EditorCallbackService service;

        /// <summary>
        /// Holds a list of <see cref="CallbackModel{T}"/> types that implement <see cref="IRun"/>.
        /// </summary>
        private readonly Stack<IRun> callbacks;

        /// <summary>
        /// Initializes a new instance of the <see cref="EditorCallbackService"/> class.
        /// </summary>
        public EditorCallbackService()
        {
            this.callbacks = new Stack<IRun>();
        }

        /// <summary>
        /// Returns a singleton instance of the <see cref="EditorCallbackService"/> type.
        /// </summary>
        public static EditorCallbackService Instance
        {
            get
            {
                // if no service yet exists create one
                return service ?? (service = new EditorCallbackService());
            }
        }

        /// <summary>
        /// Runs any callbacks that have been registered.
        /// </summary>
        public void Run()
        {
            while (this.callbacks.Count > 0)
            {
                var cb = this.callbacks.Pop();
                cb.Run();
            }
        }

        /// <summary>
        /// Registers a <see cref="Action{T}"/> callback.
        /// </summary>
        /// <typeparam name="T">The type of data that the <see cref="callback"/> takes as a parameter.</typeparam>
        /// <param name="callback">A reference to a callback.</param>
        public void Register<T>(Action<T> callback)
        {
            this.Register(callback, default(T));
        }

        /// <summary>
        /// Registers a <see cref="Action{T}"/> callback.
        /// </summary>
        /// <typeparam name="T">
        /// The type of data that the <see cref="callback"/> takes as a parameter.
        /// </typeparam>
        /// <param name="callback">
        /// A reference to a callback.
        /// </param>
        /// <param name="data">
        /// The data that will be passed as a parameter when the <see cref="callback"/> is invoked.
        /// </param>
        public void Register<T>(Action<T> callback, T data)
        {
            if (callback == null)
            {
                throw new ArgumentNullException("callback");
            }

            var modal = new CallbackModel<T> { Callback = callback, Data = data };
            this.callbacks.Push(modal);
        }

        /// <summary>
        /// Registers a <see cref="Action"/> callback.
        /// </summary>
        /// <param name="callback">A reference to a callback.</param>
        public void Register(Action callback)
        {
            this.Register<object>(x => callback(), null);
        }
    }
}

Usage scenario …

    [InitializeOnLoad]
    public class EditorInitialization
    {
        /// <summary>
        /// Holds a value indicating whether the RunCallbacks method has been called at least once before.
        /// </summary>
        private static bool ranOnce;

        /// <summary>
        /// Initializes static members of the <see cref="EditorInitialization"/> class.
        /// </summary>
        static EditorInitialization()
        {
            EditorApplication.update += RunCallbacks;
        }

        private static void RunCallbacks()
        {
            if (!ranOnce)
            {
                // setup the settings system
                SetupSettings();

                // load localization strings
                LoadLocalizationData();

                ranOnce = true;
                return;
            }

            // invoke callbacks from editor callback service     
            EditorCallbackService.Instance.Run();
        }
    }

See the project page at http://www.codefarts.com/CBXGridMapping/

Current Features

• Can use your own prefabs
• Includes simple prefab shapes
• Customizable prefab quick select grid
• Recently used lists for quick re-selection
• Support for layering
• Can name, lock, show/hide, reorder layers
• Structured prefab naming convention
• Preset rotations when drawing
• 3 draw tools Pencil/Rectangle/Fill Rectangle
• Supports Undo
• Full off line documentation included
• Built in feedback tool
• Includes preliminary API & developer tools
• Can auto scale and auto center prefabs
• Lots of settings for customization
• Fully commented & organized C# source code included
• 95+% of source code conforms to default StyleCop settings

NOTE: The current version of this tool does not contain a grid or tile mapping/management system. It is a in editor creation tool designed to make it easy to rapidly place prefabs within a grid based layout. A future update will include editor & run time API's.

Version Notes

Items starting with "Completed" are items that have been fully implemented as they were intended
Items starting with "Partial" are items that have only been partially implemented.

v2.0.1

• Completed - Fixed bug upon first installation of the package. See related post here.

v2.0

• Completed - Fixed bug if build settings were set to WebPlayer. File.GetLastWriteTime was not available under WebPlayer.
• Completed - Complete reshuffling of the code base to make it easier to publish and the code is more organized. The code base now lives in it's own folder under "CBX Game\CBX.GridMapping".
• Completed - All CBX.GridMapping specific code now lives under the CBX.GridMapping name space.
• Completed - Added additional prefabs to the quick prefab selection drop down.
• Completed - Fixed issue with the 2D mesh plane prefab. Collider is now properly aligned to the mesh.
• Completed - Temporarily removed the Quick Tools Beta preview from the code base. It will make an reappearance in a future update.
• Completed - Removed dead code from numerous code files.
• Completed - Numerous improvements to the layers system.
• Partial - Automatic Material Creation window is partially implemented but not recommended for production use just yet. It pretty much works as intended but there is no way to save the materials it creates internally as actual unity *.mat files.
• Completed - Ability to hide and show individual layers
• Completed - Have setting to hide show the foldout control for hiding map information
• Completed - Ability to lock a layer so it can not be drawn or erased
• Completed - Ability to change the order of layers in the layer list
• Completed - Ability to delete a specific layer
• Completed - Added 2 additional draw modes Rectangle & FillRectangle
• Completed - Added additional settings for more customization
• Completed - Tile Material Creation, Scene view auto pan, & Hidden Game object tools are no longer part of CBX.GridMapping but instead have migrated over to a free utility library called CBX.GeneralTools available at the Codefarts website.
• Completed - Fixed bug when changing cell size. The map grid did not automatically update.
• Completed - Fixed bug where setting the cell size to a non square value prefabs that were drawn were scaled to the minimum dimensions of the cell.

Source –> https://gist.github.com/chkn/4748252

using System;
using System.Linq;

public static class JSON 
{
    public static string Stringify (object obj)
    {
        string str;
        if (obj == null) return "null";
        if (obj is ValueType) return obj.ToString ().ToLowerInvariant ();
        if ((str = obj as string) != null) return System.Text.RegularExpressions.Regex.Escape (str);

        // assume it's a POCO
        return "{" + string.Join (",",
            from p in obj.GetType ().GetProperties ()
            let json = (JSONAttribute) p.GetCustomAttributes (typeof (JSONAttribute), true).FirstOrDefault ()
            where json != null
            select "\"" + (json.Key ?? p.Name) + "\":" + Stringify (p.GetValue (obj, null))
        ) + "}";
    }
}

public class JSONAttribute : Attribute
{
    public string Key { get; set; }
    public JSONAttribute () {}    
    public JSONAttribute (string key) { Key = key; }
}

        /// <summary>
        /// Determines if this rectangle intersects with rect.
        /// </summary>
        /// <param name="rect">
        /// The rectangle to test.
        /// </param>
        /// <returns>
        /// This method returns true if there is any intersection, otherwise false.
        /// </returns>
        public bool Intersects(RectangleF rect)
        {
            return !((this.X > rect.Right) || (this.Right < rect.Left) || (this.Y > rect.Bottom) || (this.Bottom < rect.Top));
        }

        /// <summary>
        /// Replaces this RectangleF with the intersection of itself and the specified RectangleF.
        /// </summary>
        /// <param name="rect">
        /// The RectangleF with which to intersect.
        /// </param>
        public void Intersect(RectangleF rect)
        {
            this.X = Math.Max(this.Left, rect.Left);
            this.Y = Math.Max(this.Top, rect.Top);
            this.Width = Math.Min(this.Right, rect.Right) - this.X;
            this.Height = Math.Min(this.Bottom, rect.Bottom) - this.Y;
        }

        /// <summary>
        /// Returns a third RectangleF structure that represents the intersection of two other RectangleF structures. 
        /// If there is no intersection, an empty RectangleF is returned.
        /// </summary>
        /// <param name="a">
        /// A rectangle to intersect.   
        /// </param>
        /// <param name="b">
        /// B rectangle to intersect.  
        /// </param>
        /// <returns>
        /// A RectangleF that represents the intersection of a and b.
        /// </returns>
        public static RectangleF Intersect(RectangleF a, RectangleF b)
        {
            float x = Math.Max((sbyte)a.X, (sbyte)b.X);
            float num2 = Math.Min(a.X + a.Width, b.X + b.Width);
            float y = Math.Max((sbyte)a.Y, (sbyte)b.Y);
            float num4 = Math.Min(a.Y + a.Height, b.Y + b.Height);
            if ((num2 >= x) && (num4 >= y))
            {
                return new RectangleF(x, y, num2 - x, num4 - y);
            }

            return Empty;
        }

I’ve recently come across what initially seems like a bug with the Unity 4 editor. it involves the use of the Resources.Load method from within a class marked InitializeOnLoad.

Take the fallowing example code …

namespace CBX.CoreProjectCode
{
    using UnityEditor;

    using UnityEngine;

    [InitializeOnLoad]
    public class EditorInitialization
    {
        static EditorInitialization()
        {
            LoadData(); // this will fail to see the test.txt file in the resource folder
        }     

        private static void LoadData()
        {
            // try to load data
            var data = Resources.Load("test", typeof(TextAsset)) as TextAsset;
            if (data == null)
            {
                Debug.LogWarning("No data found");
                return;
            }

            Debug.Log(data.text);
        }
    }
}

After Unity compiles the scripts it will invoke any static constructors of classes marked with InitializeOnLoad. But at this point I suspect that Unity has not yet identified assets you have within any Resources folders. When the class constructor calls the Resources.Load method it will fail to read the test.txt resource file and return a warning message out to the console.

What you could do at this point is right click the “Assets” folder in the project window and select “Reimport”. Unity will reimport the assets and again call classes marked with InitializeOnLoad. But this time Resources.load will successfully load the test.txt file resource and display it’s contents out to the Unity console window.

One work around to this is to hook into the EditorApplication.update callback and make a call to the LoadData method from there.  An example is provided below …

namespace CBX.CoreProjectCode
{
    using UnityEditor;

    using UnityEngine;

    [InitializeOnLoad]
    public class EditorInitialization
    {
        private static bool ranOnce;

        static EditorInitialization()
        {
            EditorApplication.update += RunCallbacks;
        }

        private static void RunCallbacks()
        {
            if (!ranOnce)
            {
                // this will see the test.txt file in the Resource folder and display
                // its contents
                LoadData();
                ranOnce = true;

                // return or don't it’s up to you
                return;
            }

            // do some work here
        }

        private static void LoadData()
        {
            var data = Resources.Load("test", typeof(TextAsset)) as TextAsset;
            if (data == null)
            {
                Debug.LogWarning("No data found");
                return;
            }

            Debug.Log(data.text);
        }
    }
}

Again I am unsure whether this is an actual bug or not but I have submitted a Unity bug report anyway just in case. Here is a link to the my bug report https://fogbugz.unity3d.com/default.asp?525005_eroka98ru2v4netm

/// <summary>
/// Blends two colors together.
/// </summary>
/// <param name="color">
/// The source color.
/// </param>
/// <param name="src">
/// The blend color.
/// </param>
/// <returns>
/// Returns the result as a <see cref="Color"/> type.
/// </returns>
/// <remarks>
/// From Wikipedia https://en.wikipedia.org/wiki/Alpha_compositing -> "Alpha blending" 
/// </remarks>
public static Color Blend(this Color color, Color src)
{
    float sr = src.R / 255f;
    float sg = src.G / 255f;
    float sb = src.B / 255f;
    float sa = src.A / 255f;
    float dr = color.R / 255f;
    float dg = color.G / 255f;
    float db = color.B / 255f;
    float da = color.A / 255f;

    float oa = sa + (da * (1 - sa));
    float r = ((sr * sa) + ((dr * da) * (1 - sa))) / oa;
    float g = ((sg * sa) + ((dg * da) * (1 - sa))) / oa;
    float b = ((sb * sa) + ((db * da) * (1 - sa))) / oa;
    float a = oa;

    return new Color((byte)(r * 255), (byte)(g * 255), (byte)(b * 255), (byte)(a * 255));
}

The code below allows you to scale a GameObject transform to a specific size along the x & z axis by taking into account the GameObjects renderer bounds if a renderer component is attached.

/// <summary>
/// Scales a transform to specific dimensions along the x & z axis.
/// </summary>
/// <param name="transform">
/// Reference to the transform to scale.
/// </param>
/// <param name="width">The width along the x axis that represents the target size.</param>
/// <param name="height">The height along the z axis that represents the target size.</param>
public static void ScaleTransform(Transform transform, float width, float height)
{
    // get bounds of the prefab
    var bounds = new Bounds();
    var encapsulate = false;
    if (!Utilities.Helpers.GetBoundWithChildren(transform, ref bounds, ref encapsulate))
    {
        return;
    }

    // get minimum size from the size dimensions
    var min = Mathf.Min(width, height);

    // get the maximum x or z size of the transform
    var max = Mathf.Max(bounds.size.x, bounds.size.z);

    // calculate the scale factor 
    var scaleFactor = min / max;

    // apply scaling to the transform
    transform.localScale *= scaleFactor;
}

/// <summary>
/// Gets the rendering bounds of the transform.
/// </summary>
/// <param name="transform">The game object to get the bounding box for.</param>
/// <param name="pBound">The bounding box reference that will </param>
/// <param name="encapsulate">Used to determine if the first bounding box to be 
/// calculated should be encapsulated into the <see cref="pBound"/> argument.</param>
/// <returns>Returns true if at least one bounding box was calculated.</returns>
public static bool GetBoundWithChildren(Transform transform, ref Bounds pBound, ref bool encapsulate)
{
    var didOne = false;

    // get 'this' bound
    if (transform.gameObject.renderer != null)
    {
        var bound = transform.gameObject.renderer.bounds;
        if (encapsulate)
        {
            pBound.Encapsulate(bound.min);
            pBound.Encapsulate(bound.max);
        }
        else
        {
            pBound.min = bound.min;
            pBound.max = bound.max;
            encapsulate = true;
        }

        didOne = true;
    }

    // union with bound(s) of any/all children
    foreach (Transform child in transform)
    {
        if (GetBoundWithChildren(child, ref pBound, ref encapsulate))
        {
            didOne = true;
        }
    }

    return didOne;
}

Using the Undo.IncrementCurrentEventIndex allows your editor scripts to undo a single action rather then have unity undo many actions that may have occurred in rapid succession. Place the code below into a “Editor” folder for it to run.

The “create object” button will create 10 cubes and call Undo.RegisterCreatedObjectUndo for each of them. Click this button then press ctrl+z to undo all of the objects that were created.

The second button “create single object” will also create 10 cubes but will also call the Undo.IncrementCurrentEventIndex method notifying unity that each object that is created should have a separate undo action. Click “create single object” to create 10 cubes then press ctrl+z to undo each object creation individually.

NOTE: At the time of this writing the unity documentation does not have information on the Undo.IncrementCurrentEventIndex method and searching for it also comes back with zero results.

    using UnityEngine;
    using UnityEditor;

    public class UndoTest : EditorWindow
    {

        public void OnGUI()
        {
            if (GUILayout.Button("create object"))
            {
                this.Create(false);
            }
            if (GUILayout.Button("create single object"))
            {
                this.Create(true);
            }

            GUILayout.Label("use ctrl+z to undo each action");
        }

        private void Create(bool single)
        {
            for (int i = 0; i < 10; i++)
            {
                if (single)
                {
                    Undo.IncrementCurrentEventIndex();
                }

                var obj = GameObject.CreatePrimitive(PrimitiveType.Cube);
                obj.transform.position = new Vector3(Random.Range(-10, 10), Random.Range(-10, 10), Random.Range(-10, 10));

                Undo.RegisterCreatedObjectUndo(obj, "create " + obj.name);
            }
        }

        [MenuItem("CBX/UndoTest")]
        public static void ShowWindow()
        {
            GetWindow<UndoTest>("UndoTest").Show();
        }
    }

/// <summary>
/// Packs color components into a <see cref="uint"/> type.
/// </summary>
/// <param name="r">The red component.</param>
/// <param name="g">The green component.</param>
/// <param name="b">The blue component.</param>
/// <param name="a">The alpha component.</param>
/// <returns>Returns a uint representing the color.</returns>
public static uint Pack(int r, int g, int b, int a)
{
    return (((uint)r & 0xff)) | (((uint)g & 0xff) << 8) | (((uint)b & 0xff) << 16) | (((uint)a & 0xff) << 24);
}

/// <summary>
/// Unpacks a <see cref="uint"/> type into a color type.
/// </summary>
/// <param name="value">The packed color value to unpack.</param>
/// <returns>Returns a color type from the unpacked values.</returns>
public static Color Unpack(uint value)
{
    var r = (byte)(value);
    var g = (byte)(value >> 8);
    var b = (byte)(value >> 16);
    var a = (byte)(value >> 24);

    return new Color(r, g, b, a);
}