Tag Archives: Unity

Unity: Rotate Tool axis display

UnityUsing the Rotate Tool in Unity hides the axis arrows which display the object orientation. I find this a bit hard to follow, so I wrote me a little editor extension to fix it.

It’s the little arrows in the center of the cube in the image below. As you rotate the object, the axis rotates too, as you would expect. I find this much easier to understand.



Unity: Screen transition shader example

UnityA few days ago, I was providing help in the Unity forum, where someone ask how to do a specific screen transition effect. So, I put together an image effect example that uses a texture to describe the transition of a certain pixel.

I think it’s a common and pretty generic approach to this problem and one of the things I like most is that it’s totally content driven. The screen transition is basically encoded in a mask (gray-scale texture, black pixels blends in first, white last), which allows to change the transition by just authoring the texture in a different way. Since the transition is encoded in just one texture channel (alpha) in the example, it cuts down to just 256 individual steps for the transition, but it’s often enough to yield decent results. If you need more, there would be still the option to use more than only¬† the alpha channel though.

In case you’re interested in the example (Unity 5), you can find the download link at the bottom of this post. Please note that it’s an example and might not be ready or the best fit for your game. I believe image effects are a bit heavy on mobile.


Forum Answer

Unity: GrabPass distortion shader example updated

UnityA few months ago, I was providing help in the Unity forums where someone asked how to add animated distortions to his game. Since I’m a big fan of distortion effects, I couldn’t resist to create a simple shader example.

The example was created in Unity 4 at this time and I recently have been made aware it doesn’t work well in new and shiny Unity 5, so I updated it to support just that. I also extended the shader slightly, which now accepts an optional intensity mask that describes where distortions are applied.

Here is the initial video I recorded showing the effect in Unity 4. Keep in mind, it’s just an example and most likely not ready to be used in your upcoming triple-A mobile title ūüėČ

Download example project

Visit forum post

Unity: Texture Overview 3.3 released

Texture Overview Plugin for UnityTexture Overview 3.3 is available in the Unity Asset Store now.

This update adds a bunch of new features and also contains a few bug-fixes. Please see the change-log below for details.

Don’t miss to take a look at the updated documentation as well.


  • Added detection/handling of .exr and .hdr assets.
  • Added “Tools > Advanced” option, see “Handle Rgb24 as Rgba32 for graphics memory calculus” documentation.
  • Added Graphics Memory column. Displays how many space the texture costs during runtime in graphics memory.
  • Added Main Memory column. Displays how many space the texture costs during runtime in main memory.
  • Added Graphics and Main Memory to “Memory Usage‚ÄĚ overlay.
    Fixed Runtime and Main Memory calculation for ARGB4444, RGB565 and RGBA4444 texture formats.
  • Fixed installation window sometimes displaying an error for a second, but then complete¬† installation successfully.
  • Fixed Memory Usage chart colors being all white when player settings were set to Colorspace=Linear.

Texture Overview

Texture Overview Pro

Unity: Texture Overview 3.2 released

Texture Overview Plugin for UnityTexture Overview 3.2 is available in the Unity Asset Store now.

This update improves Unity 5 compatibility and fixes a build error that occurred when compiling the provided source code (Pro only). Please see the change-log below for details.



  • Texture Overview Pro: Fixed error that occurred when compiling the provided source code found in TextureOverviewSource.zip using Unity 5 DLL’s.
  • Texture Overview Pro: Updated readme.txt in TextureOverviewSource.zip that explains how to build Texture Overview.
  • Added an ‚Äěinstallation window‚Äú that appears when starting Texture Overview after having imported a new version from the Asset Store. The installation window is responsible to install the proper plugin for your Unity version.
  • Renamed column ‚ÄěSprite Pixels to Units‚Äú to ‚ÄěSprite Pixels per Unit‚Äú as it’s found in Unity’s documentation.

Texture Overview

Texture Overview Pro

Unity: Texture Overview 3.1 released

Texture Overview Plugin for UnityTexture Overview 3.1 is available in the Unity Asset Store now.

This update is a bug-fix release. It fixes a warning that occurred when the plugin was running in Unity 5 beta, where the warning was printed to the Console window every time you opened Texture Overview.



  • Fixed warning “Invalid AssetDatabase path: <FullPath>/UnityEditor.UI.dll. Use path relative to the project folder.”

Texture Overview

Texture Overview Pro

Unity: Reporting UI progress properly

UnityEditorUtility.DisplayCancableProgressBar can be used to report progress of an operation, but updating the progressbar itself comes with a performance overhead and can affect the performance of your application.

In this post, I’d like to share how I prefer to update a progressbar to minimize the time spent on the UI. It’s so simple, that I was even uncertain if it’s worth a post, but since I see every now and then Unity extensions that report progress inefficiently imo, I decided to put it online. It’s also related to my previous posts (1 2 3), where I describe what I changed to make my Unity plugins perform faster.

Let’s assume we have x tasks we need to complete and want to report the progress. The simplest, but also naive way to do this is something like this:

Unity EditorUtility.DisplayCancableProgressBar

If calling DoWorkOfOneTask() is¬†particularly expensive, the overhead of updating the progressbar every loop-iteration is to neglect. However, if DoWorkOfOneTask() is fast, you most likely end up spending more time updating the UI than “doing the work”.

Let’s take the following editor script example, which you can copy&paste and run in Unity yourself:

Both methods basically do the same, except one reports the progress while the other does not.

Executing NoProgressbar() takes about 1 millisecond to complete, whereas WithProgressbar() requires more than 10 seconds. These 10 seconds are spent just on updating the progressbar UI. It’s sort of artificially made slower due to the progressbar.

It’s often not known in advance how long a certain operation takes to complete. For example, if DoWorkOfOneTask() uses some sort of caching, the first few calls might be slow, but subsequent calls could be much faster. So it does make sense to display progress when the operation takes a bit longer, but makes no sense when it would be finished instantly.

What I find useful is to update the UI in timed intervals, only after a certain amount of time elapsed. This ensures fast operations stay fast, because there is either no or at least not much overhead of updating the UI and for slow operations, updating the UI isn’t an issue anyway.

Here is my personal choice how I like to report progress in my applications:

The code above displays a progressbar only, when the total time of operations takes longer than 1 second and then updates the UI in 100 ms intervals at most. This assumes each of the DoWorkOfOneTask() calls isn’t particulary expensive. If such call takes eg 1 minute to complete, the progressbar wouldn’t be displayed until the first DoWorkOfOneTask() completed.

Reporting progress like this works like a charm in my applications, such as Texture Overview and AudioClip Explorer. If their cache is up-to-date, starting the plugin is so fast that no progressbar is necessary at all. However, if a few cache entries are outdated and updating them takes a while, the progressbar appears after 1 sec and gets updated periodically until it completes.

Unity: Reading assetTimestamp’s blazingly fast

UnityIn my previous posts (1 2), I was complaining reading the timestamp of an asset using the “AssetImporter.GetAtPath().assetTimestamp” API can be enormously slow.

In this post, I describe what I came up with to read thousands of timestamps in a few milliseconds only, rather than waiting an hour when using the official Unity API.

Upcoming versions of my Unity plugins feature a cache file that holds asset properties which are expensive to read. Once these properties have been read, they are stored in the cache file, so the next time they are requested, they can be served much faster.

The problem I encountered was to detect if an asset has been modified, to refresh the corresponding cache entry, in an acceptable period. Something like the following pseudo-code with 3000 textures stored on a 7 years old harddrive of mine took about 20 minutes to complete:

The issue, as explained in my previous post, is that “AssetImporter.GetAtPath” loads the asset into memory. Thus, the time the call requires to complete highly depends on the asset filesize itself.

While digging in various Unity related project folders to find a workaround, I came across the file¬†“Library/assetDatabase3”. This file stores timestamps, along other data, of all assets in the project.

The format of assetDatabase3 changed from Unity 3.x to Unity 4 and it’s very likely that it can change in a future release too. Thus, it’s important for the plugin not to break when reading assetDatabase3 fails.

While reading this file, Unity shouldn’t updating it either. Running the code from the main-thread will do the trick, since it blocks the application and Unity won’t start to import new assets during this time.

In Unity 4, assetDatabase3 holds at offset 0x0C the offset where the timestamp table is located. In the following image, it tells us it’s located at offset 00 00 6B 80:

assetDatabase3 in HEX-Editor

Seeking at offset 0x6b80 in the same file, gets us at the at the start of the timestamps table:

assetDatabase3 in HEX-Editor

The timetamp table starts with:

For every element it is:

Timestamps need a some extra bit-magic to shift them into the correct order. The necessary bit-magic is also different for Mac and Windows. The final assetTime is basically the greater value of the two timestamps.

Reading assetDatabase3 and extracting all the assetTimestamps takes only a few milliseconds to complete. Once read, the plugin compares each of the timestamps to the cached data entries. If they are different, the cache entry is assumed to be invalid and will be refreshed. If reading assetDatabase3 fails, the plugin handles it as all cache entries are invalid.

This change improves the startup time of my plugins dramatically. I tested it with several projects and different Unity 4.x versions and it doesn’t really matter how many assets they contain. When opening the plugin, such as Texture Overview, it’s ready in about 0.5-2 seconds always (assuming the cache file is uptodate and assets have not changed/reimported). Most of these projects contain about 3000 textures and 1000 audio clips. One of my artificial test project contains 20000 audio clips. The plugin opens and is ready-to-use in all projects almost instantly.

Unity: AssetImporter.GetAtPath causes alot of file system activity

UnityIn my previous post, I wrote I was optimizing my Texture Overview Unity plugin by caching texture properties (width, height, filesize, mipmap count, etc), that usually require expensive file I/O operations to collect. Once these properties have been collected, the plugin adds them to a persistent cache, so they can be served much faster the next time they are requested.

In order to detect if a cache-entry of a texture turned invalid, the plugin compares the AssetImporter.assetTimestamp to the timestamp of the cache-entry. If they don’t match, the cache-entry became invalid and the plugin has to read and collect the new texture properties, rather than just serving the cached data.

I was certain this solution will make the plugin blazingly fast, but to my suprise, it did not. It did improve the startup time of the plugin, but not as much as I thought it would be. The reason for that is AssetImporter.GetAtPath() can be horribly slow.

While the plugin starts, it calls AssetImporter.GetAtPath(“path”).assetTimestamp for every texture in the project, to detect if the cached data for a particular texture is invalid. During this time, the harddrive is extremely busy.

To try to understand what is happening there, I downloaded Process Monitor to monitor file system activity.

I created a little script that just calls AssetImporter.GetAtPath for “Assets/Textures/AngryBots.png” (inside the AngryBots project) and it turns out this¬†inconsiderable method opens three different files, as Process Monitor reveals:Process Monitor: AssetImporter.GetAtPath()

“AngryBots.png” is the source image file. “AngryBots.png.meta” is in Unity’s own words “a text file for every asset in the Assets directory containing the necessary bookkeeping information required by Unity” (see here) and “7b469925895d5466dbc74ebf68ae2a98” is the imported image file in Unity’s own texture asset format, the filename equals the asset guid you can get by calling AssetDatabase.AssetPathToGUID btw.

I’m wondering why Unity is actually opening all of these files. My understanding was the importer settings are stored in the .meta file, so why does it open the imported texture asset (two times) and why even the source .png file?!

I also noticed getting the importer for a huge texture file is slower than for a small one. I thought this makes no sense at all, but now, since I know Unity opens all of these files, this could actually be true.

Calling AssetImporter.GetAtPath a second time for¬†“AngryBots.png” during the same Unity session, only opens “AngryBots.png” and “AngryBots.png.meta”, but not “7b469925895d5466dbc74ebf68ae2a98” anymore, so it’s much faster this time. I guess Unity loads the imported texture into memory and then it doesn’t need to load it again on the seconds call and this would actually support my theory that AssetImporter.GetAtPath performs worse the bigger the imported texture asset is.

Anyway, I will probably never find out why it is reading all these files and whatnot.

Unfortunalety, this performance issue makes AssetImporter.GetAtPath, to get my hands on the assetTimestamp, rather useless again. There has to be a way to get the assetTimestamp of 10000 assets in less than several minutes.