I've adopted this method for use in our 2D game. Since we are using a 3D api I hypothosize this will be a far more performant way to draw our terrain, instead of emmulating how it would be done in a 2D api (draw diamond shaped graphical tiles).
here is a picture to illustrate =)
one thing to keep in mind, a 'tile' in morning's wrath, was dimensionally, about the foot-space of one person.
however in this case a tile will be able to fit about 4x4 (16) people on a single tile.
on each tile a base texture is used, in some cases an entire map will use this same texture on all tiles, but in most cases it will vary, regionally.
in this case, all color textures are 256x256 @ 24bits (no alpha channel) since they dont need it and this helps to reduce memory overhead.
these textures are also Atlased, depending on hardware an atlast can hold 1 to 16 color textures, this is done by packing them together onto a single surface and address them through UV coords. Atlasing is important because it can improve batching, if you must render 16 tiles, each with different base textures, you can render them all with a single SetTexture call; if they were all sepreate textures, you would need to call SetTexture for each of them. Atlasing with a known texture size is rather easy, and atlases can manage their dimensions by examing card capabilities and desired maximums.
so once you have your base textures down, your terrain likely looks very good already.
what it lacks is the ability to carve out paths, put down feilds of grass, pools of water, you name it; traditionally this was done via tile-sets and overlay sets, and unless done properly it can look really bad, plus it requires large amounts of image data; AND it doesn't lend itself all that well to the way 3D likes to do things.
So, if we wanted to put a path on this tile, we would add a 'splat' you can think of a splat as a layer (like in photoshop for instance) that is on top of your base texture.
Each splat has a reference to a texture [256x256x24] and a custom alpha map [32x32x8].
You may note the alpha map is very small compared to the texture, this is okay, since it is stretched over the entire tile, and via interpolation turns out to look very smooth, which is what you want in an alpha blend.
Keep in mind, alpha maps are also atlased, since they are small you can fit 16 to 1024 of them in a single atlas. This will help to speed things up.
So, each splat uses a color texture and a small alpha map, and it draws the texture using the alpha map's translucency, and voila you get your highly detailed terrain texture, clipped with the low resolution (but smooth) alpha map, a perfect system to draw paths with.
So if we had a 50x50 tile map, and we used custom images for all of them, we would be looking at
50*50*256*256*3 = ~468MB (holy cow!)
But if we use splating, we only use memory for a bunch of color textures, lets say 20
20*256*256*3 = 3.75MB (Pretty good!)
And then the cost of alpha maps, let us assume that each tile uses a single splat (unlikely, but it will account for tiles that use multiple ones)
then that is
50*50*32*32*1 = 2.44MB (Not bad at all!)
So, splatting would gives us a nice system, with a bit less flexibility, but at a much lighter memory cost.
I've yet to implement it, but it sounds like the method for me! =)