Worn Edges

Worn Edges

WORN EDGES is a tool I created in 2013 that allows the user to generate a worn look (amongst other things) for their props. It is written as a Unity3D editor extension (as such it only works within unity).
I wrote a small post on it when it was early in development, you can see it here.

Tori, before and after using the WORN EDGES tool

It works by generating a lot of different maps, which get combined into a single “combined map”, which details the level of wornness for each pixel of the texture. This combined map is in turn used to alter the original, clean, texture.

a simple example of the principle
a simple example of the principle

The tool can create a lot of different maps:

  • 3d, 2d and 1d noise map
  • sharpness map
  • ambient occlusion map
  • directional occlusion map
  • angle falloff map
  • distance map
  • wood map
  • mask map

How these maps are created and combined is fully customizable, to create the effect the user desires.
As such, it can create more than just a worn edges look (see screenshot below).
tikis with different maps

In general, for just a worn edges look, only the 3d noise, ambient occlusion and sharpness maps are used. The other maps are generally for more specific effects (see screenshot above).

The models this tool is used on should have a clean UV layout, without overlapping triangles (although symmetrical or otherwise identical geometry can often share uv-space without a problem). But it can also bake everything to a 2nd set of UVs, for example the auto-generated lightmap UVs (that is often used in Unity3D). As such you can actually also use this to bake multiple textures with overlapping UVs into a single texture that uses these 2nd UVs.

wooden - worn edges
ball_variations 2_ballDevelopment
worn (edges) (worn) edges

It’s available on the Unity Asset Store.

Here’s a relatively recent (at the time of writing) demonstration movie:

and here’s an older demonstration (a bit outdated, but still relevant):
(Unfortunately though, it is kind of slow)




SNOWIFY is a tool I created early 2013 that allows the user to generate thick packs of snow on any prop.
For when a simple snow shader isn’t enough.

It started of as a hobby project; I had just had to make a snow level for work (more precisely, a snowed version of an existing level), for which I had created a couple of simple snow shaders (using the angle of the surface normal to determine snowiness).
But when making that level, I found that in some cases it would have looked better if the snow had a volume, rather than being flat.
So afterwards I came up with an idea to create snow meshes based on the mesh of the object it was resting on, and started working on a tool to do that in my spare time.

Since I nowadays work primarily in the Unity3D engine, I made this tool for use in Unity.

houses with snow

The tool allows for complete control over the snow’s thickness, angle, direction, material, smoothness, and various other settings.
The snow meshes are also automatically unwrapped and textured.

jeep with snow

It’s available on the Unity Asset Store.



Snowify was used by Hinterland Studios for the creation of their game “The Long Dark”:
(it’s being listed as one of their favorite packages from the Unity Asset Store)

Procedural “Worn Edge”-effect

When texturing some sort of metallic object (a machine, weapon, robot,…),
it’s often a good idea to make the edges a bit worn off, otherwise it looks to clean, and it just makes the object more interesting.

worn-edges example (not made by me)

The way I was taught to do this, was by painting it manually on the texture.
But I always felt this to be kind of a hassle, as these worn edges are often on UV-seams, making it more difficult to paint correctly than anywhere else on the textures.
And it just always seemed to me that this could perfectly be generated procedurally,
as the location and look of a worn edge is more of a technical thing, rather than a design chose.
Like ambient occlusion, you can paint that aswell, but most often you’re better of baking procedural ambient occlusion.

A couple of weeks ago I finally started making something to do this.

I created an editor extension in Unity3D, that allows you to generate worn edges and bake it into a texture.

Here’s an example:

Both the rust/dirt and the worn edges (middle and right) where created by my tool.

My first idea was to make this a tool in Blender, but I’m not familiar with Python, and so I wanted to test some things in Unity first. But before I knew it, I had already created the whole outline of how to make it in Unity in my head.
So I started making it in Unity instead, and to my suprise, the development of it went extremely smooth, everything worked as expected, even the things I had to invent on the spot.

The editor extension and a test object in Unity.

Now the tool does have it’s restrictions (for example: it currently only works on hard/sharp edges), but if you keep these in mind it works great IMO.

I’m planning on putting it on the Unity Asset Store,
I still have to make some documentation and screenshots and stuff, those things tend to take way more time than intended. 😦
But other than that, it’s as good as finished. 🙂


Now available on the Asset Store:

More info: