Looking really nice and soft. Forgive me if you've explained already, but does the light bounce like traditional lighting methods, and if so what's the bounce cap?
The light reflection/bounce is a plain simple Lambertian BRDF for the diffuse
reflection used for each non-light object in the scene, currently, but with
some additional terms to account for the geometry of the area light.
To compute the reflected light I've broken my head down cracking up
this equation;
L(p,wo) = integral{BRDF(p,wi,wo)*L(q,-wi)*V*G}dA
(integrating over the area of the light source, V and G are geometry factors)
which would give the perfect solution for the reflected radiance from an area
light source at surface point p. For Lambertian the wo direction has no effect,
but anyways this equation is quite expensive to solve (yet a good hardware
implementation may help a lot), but for my alternative software renderer I
needed something more efficient. So I've broken down this integral much
further having developed a very rude screen-space approximation. Each pixel
computes just a fraction of this integral. It's sort of a piece-wise constant
approximation. And up to my understanding it can't get any easier solving this
equation nor can you make it more efficient (one order lower and everything
would be a constant). And since you can approximate "any" function with
piece-wise constant functions, the lighting/shades gets better the higher the
resolutions becomes. So at 4K, and seen from a distance, I'm pretty sure you
can't tell the difference between a full integration (Monte Carlo or any
quadrature formula) and my (perceptual/human-vision adapted) solution. Sure,
such integration methods would give smoother results even at lower resolutions
but they use hundreds of sample points resp. quadrature points taking ages to
compute. So it's my hope that if I'm going to implement this algorithm on
graphics hardware that I get a fast rendering algorithm to render cool GI
lighting for the fraction of the cost.
But unfortunately, there is no one ideal rendering technique which delivers
best results for every BRDF and every light source, you really have to split
up and combine depending on the situation. I've only done Lambertian here,
need to do specular/glossy BRDF which comes with their own issues. I even use
a slightly different form of the above integral for the environment light for
example. However, my current solution looks promising at least. There are
a couple of fallacies here and there, but I'm looking forward to it. What I've
implemented thus far runs in pure software at the moment, and I haven't seen
any area lighting implementation in software running in realtime out of the
box (unless you throw quad-cores on it). If you implement area lighting (or
soft shadows) in software the usual way, you are stopped dead all of a sudden,
yet my solution still runs! :-O xD
one way could be only show a "health" bar when a member is at critical. So lets say at 100%, nothing is shown. At 50% a voxel Heart/bar/whatever appears above their head as a warning. This starts to slowly get chipped away from top to bottom until it reaches 0%. Its basically remapping the bar from 0-100 to 0-50 but it might help clean up most of the party if they're relatively healthy (above 50%) which hopefully is most of the time.
