Unity3D Code Snippet: Getting the original size of a Texture2D

I was looking for a way to get the original width and height of a Texture2D in Unity (i.e. the size of the texture before it was potentially scaled up or down to power-of-two dimensions). By itself, Unity only exposes the width and height of images after they’ve been imported and rescaled.

The workaround I came up with is a little hack-ish, and it only works inside the Unity Editor (which means you could still use it to export the original texture dimensions to an XML or some such). But I didn’t find a solution on the Unity forums, so I thought I’d post mine.

The way this works is, it finds the TextureImporter for a given Texture2D, stores the way it scales the texture to a power of two in a local variable, changes the texture so that it doesn’t scale at all (like a GUI texture), re-imports, grabs the texture’s dimensions, and then changes the scale mode back to the original. Which is to say this comes with a lot of overhead, if you need to process many textures at once.

Feel free to use this piece of code in any way you want. If you need me to put an MIT license on it or something like that, please let me know. If I’ve overlooked something and there’s an easier way to accomplish this in Unity, please leave a comment!

using UnityEngine;
using System.Collections;
using UnityEditor;

// Feel free to pick your own class name:
public class TextureSizeUtil {

  /// <summary>
  /// Given a Texture2D, this returns the size of the asset that was originally imported
  /// (i.e. before it was scaled up or down to the nearest power of two). This only
  /// works inside the Unity Editor. It will return -1, -1 in any other build.
  /// </summary>
  /// <returns>
  /// A Vector2 containing the width and height of the Texture2D or -1, -1 if there was
  /// an error.
  /// </returns>
  /// <param name='texture'>
  /// A Texture2D from your assets folder.
  /// </param>
  public static Vector2 GetOriginalTextureSize(Texture2D texture) {
#if UNITY_EDITOR
    // This really needs the editor to work.
    // find the TextureImporter for the asset
    string path = AssetDatabase.GetAssetPath(texture);
    TextureImporter importer = AssetImporter.GetAtPath(path) as TextureImporter;
    
    if (importer != null) {
      // Store the way the texture was previously scaled to a power of two,
      // and set it so that the texture does not scale.
      TextureImporterNPOTScale lastScale = importer.npotScale;
      importer.npotScale = TextureImporterNPOTScale.None;
      // this is like clicking "Apply" in the texture inspector:
      AssetDatabase.ImportAsset( path, ImportAssetOptions.ForceUpdate );
      
      int width = texture.width;
      int height = texture.height;
      
      // set the scale mode back, and apply:
      importer.npotScale = lastScale;
      AssetDatabase.ImportAsset( path, ImportAssetOptions.ForceUpdate );
      
      return new Vector2(width, height);
    } else {
      Debug.LogError("TextureImporter is null!");
      // TODO: your own error handling
    }
#else
    // not in Unity Editor:
    Debug.LogError("GetOriginalTextureSize() only works in the Unity Editor!");
#endif
    return new Vector2(-1,-1); // if we end up here, the TextureImporter couldn't be found
  }
  
}