Shading tests – Dirtmaps

With the production start of project Mango getting close it’s a good idea to test your own workflow a bit … because when instead you’re swamped with tons of work you can’t spend time thinking how to make things smarter and faster. So I tried to put together some questions and topics that always bothered me when I do environment models and shaders. Nothing amazing or innovative, but hopefully good for speeding up work, here’s what I came up with:

You got to love a carefully painted custom texture map, with all those subtle (or strong) weathering effects placed in the right spots just for that object.

Only issue: painting textures takes a lot of time! :)

Speaking of environments, that’s a real issue: your environment is often made of tons of different pieces, all quite detailed as models but not that important by themselves to afford the time for accurate custom painting. In my experience, in arch.viz. you only can afford tileable textures and no custom painting, in games you have to custom paint, and in movies you ‘simply’ need the best quality and realism…

Still, in any case it could be handy to have some kind of automation to get some weathering effects (based on the shape of the object) without custom painting, and keeping the unwrap phase reasonably fast. ‘Automation’ for this stuff won’t help quality much, but speeds things up. So it’s good for minor objects or as a base for important ‘hero’ pieces.

That’s the idea behind the tests below, dealing with: batch-bake of AO/dirtmaps, unwrapping multiple objects together, node shaders (cycles in particular)

Batch Bake – Dirtmap script 

First part of these tests is a small python script – just a proof of concept by now, if the idea works it will need quite some polishing (I’m an env. artist, my python is really basic…). In the image below you can see the UI, the process and results :

Using the script, what you get is a mix of different AO maps, which works well as a base map for weathering effects: then you can either paint manually over that (in Blender or Gimp). Or you can use that dirtmap directly in a node shader: mixing it with some tileable grunge splotches and patterns to give variation and realism, then using it to control and mix tileable maps and brdfs.

A sample result: a kit of sci-fi greeble pieces (note: all this is just a technical tests, not much to do with the style that will be in the actual project)

Cycles node shaders :

Using that dirtmap and with the help of some quick vertex color paint, you can then create some pretty complex shaders in cycles (or BI nodes as well). For organization, node-groups are just great: they work as instances, so you can reuse parts of your shaders in different materials.

So, in this case, the group can contain everything (brdfs, tileable textures ) except the dirtmap, then create various materials with that group (instanced!) and just replace the dirtmap. How this performs at render time (compared to custom painted textures) is still a question: it forces you to use many mix-nodes and complex node-trees, but on a full scene should save quite some memory on total texture size (dirtmaps don’t need to be that much high-res, the rest is tileable textures that can be reused for various materials).

Cycles renders of the kit :

Some parts use a metal shader, some use a plastic shader :

And the same kit, quickly scattered on a sphere, rendered on hdr background (from openfootage.net) :