Looks extremely fake, compared to mine 
Last year, I came up with a much faster algorithm, that I haven’t turned into code yet. The idea is this:
You have a massive grid (both in volume and in memory size). Think of it like: byte[whd]
You image the light-source infinitely far, so all light-rays have the same vector, but different initial positions (as in: directional light).
Every cell in your 3D grid is filled with air/watervapor (determines translucency). Naturally, tracing through this grid for every cell is extremely slow, as you’ll find yourself doing ray-cube intersections. There is a shortcut however:
Take 1 ray, and make its directional vector length tiny (say 0.05, where the grid cellsize is 1.0). Now slowly advance your position and check in which cell you are (casting x,y,z to int). Once you determine you left the current cell, put that cell in a list. After tens of thousands of iterations, you end up with a path with a reasonable amount of integer 3d coordinates. Compare the adjacent coords in the path and you’ll (obviously) see the delta in each axis is either -1, 0 or +1. Put these delta’s into a list.
Now you have a list (or array, for performance reasons) of deltas that allows you to step through the grid at incredible speed, no geometry intersection-checks.
It would look like:
byte[] density3d = new byte[w*h*d];
int[] illumination3d= new int[w*h*d];
int x,y,z;
int[] stepper3d;
int rayLight = 10000;
for(int p=0; ??? && rayLight > 100; p++)
{
int index3d = (d*width*height) + (y*width) + x; // replace with bit-fiddling
int density = density3d[index3d] & 0xFF; // 0..255
int absorb = rayLight * (0xFF-density) / 0xFF;
rayLight -= absorb;
illumination3d[index3d] += absorb;
// follow your stepper, multiple times.
int step3d = stepper3d[p%stepper3d.length]; // obviously use bit-masking here, not modulo
x += (step3d / 1 % 3) -1;
y += (step3d / 3 % 3) -1;
z += (step3d / 9 % 3) -1; // 0..2 => -1..+1, also turn this into bit-magic
// faster code would look like:
// x += ((step3d>>0)&2)-1;
// y += ((step3d>>2)&2)-1;
// z += ((step3d>>4)&2)-1;
}
Naturally it’d suffer from jittering artifacts, so you create 4 (or more) paths, with adjusted initial position (say 0.5*cellsize).
| | TOP VIEW
--+-------+--
+ x x +
+ + x means where the 4 paths initiate
+ x x +
--+-------+--
| |
You can use these 4 paths to trace your entire volume (or part of it every frame), by starting at the edge-cells of your 3d grid. It won’t be 100% accurate, but it will be more than adequate.
If you’d wish, you can do a 3d blur as a last step. Now you have the luminance of each cell in your 3d grid. When you place your sprites, you can lookup these values to set the vertex-colors.
)
(if you propose to share your code).