Yes my clouds can move, in lower resolution, after any move is done, the high resolution bakes itself into an half cube (upper sky dome) using tiled rendering.

its too slow for pure real time, it would lower the system to around 1 or 2 FPS in full res full real time.

The biggest issue is the number of times the fractal needs to get evaulated per pixel. knowing the fractal is made by iterating reading a noise texture with UV coords that multiply exponentially (octaves). I calculated that at max quality one pixel = 1800 texture reads. Of course it only works so great because the texture is so small it can get in the cache. But I even suggest using registers (constant buffers) to pass an even smaller noise base, that could help I guess.

Though, in my technique the shader was so complex, on DX9 it was difficult to compile because I would exceed the max number of registers very often.

Because of the presence of loops, and dependence on variables outside the loops, creating arrays with size that multiplies with the nested loops...

Anyways, the night, sunset and dawn are handled with a mix of empirical tunings and the effects from the aerial perspective (rayleigh). The empirical stuff is mainly the intensity of the sun light, and the sky light that I use as a second source from the top. Normally you should evaluate the irradiance of the sky as a 3D function (encoded into spherical harmonics or as an lookupable envmap) but a single scalar is more than enough in the sky case because of its uniformity across the hemisphere.

The quality of the technique is that the light direction change really change the volume impression we get of the clouds. Though it is not using scattering formulas, its already slow enough :) instead it uses empirical formulas.

About the parameters, there are literally tens of them (~50), but I reduced it to 10 "master" parameters that drives the other ones with empirical ramps that I adjusted to be "cute". So the user can move the sun, time of day, or change the quantity of coverage, and it any combination it remains controlled and the best consensus. It took days to adjust.

In 2006 I wrote a little weather engine with a little state machine, and it was capable of interpolating between sets of uniforms that the artists could save as presets and presented as "weather condition" in the interface, then a randomizer would make a sequence with a probability function that was evaluated using a special "distance" function between the weather state. (that made that some condition were far from other and thus rarely chosen as following each other. like snowy would rarely come after bright clear)

It was an internship at Etranges Libellules. the 6 years non disclosure is expired so I can say all I want :)

here a picture:

In terms of rendering it is super primitive, it has a perlin noise for the clouds applied on a single flat layer, and a smoothstep (hermite) would apply a contrast curve on the alpha of the cloud to vary the density. All that driven by the weather engine. but like I said, a very small and unimpressive one.

But at the time I was super happy of my sky dome technique, it worked without any shader, just a few layers of dome layers rendered with additive blending, and the correct color gradient adjustments with help of reference photos at different moments of the day, and yay ! no cost of scattering to pay. but of course, no fog/aerial perspective on objects...

For the aforementioned, and also much more recent technique and better looking, the man hour would be around 50 days * 8 hours. (so ~400 man hours.)

The dobashi technique responds to humidity. i've implemented a prototype of it in ~10/15 hours, with cubic rendering (one cube per voxel), very slow and ugly. But the technique is good to generate interesting evolutions and shapes. and its totally controllable. Local humidities, pressures, temperatures... can all be fed from your weather engine.

There is a journal from Issanaya (flavien brebion) on this technique on gamedev in an old log entry. This was also showed off at GDC 2008 and there is a demo here:

http://www.simul.co.uk/truesky/multicore

It is totally using dobashi (13 years old paper), and frankly it is barely impressive when you know the technique. But the rendering is innovative and there are some ideas to be taken.

The time I took to make the fractal technique was a lot of fine tuning, polishing, optimizing and robustification towards large use cases. This may not come into account depending on the professionalism of the project. In any case, the man hour can totally be drastically reduced using a development spirit focused on time rather than quality.

yes you are correct :)