analytical-ish solution for grid visibility on the left, pathtracing at 32 samples per pixel on the right

I don't know basic linear algebra so the analytical solution is bugged and I've never been able to write an unbiased pathtracer so there are differences in the outputs, an unbugged version should be mostly identical.

The analytical solution should be equivalent to firing infinite rays while having much better scaling. It's O(N^2 * sqrt(2N^2)) where N is the side length of your grid instead of O(M * N^2 * sqrt(2N^2)) Where M is the number of rays per pixel

raytraced occlusion checks:            2002938325
analytical occlusion checks:           11812361

raytraced high resolution clock time:  5.911035111 seconds
analytical high resolution clock time: 0.027131559 seconds (~220x faster)

Shadows in my voxel raytracer. Bit hard to have a sense of scale since there's nothing in the scene, but each colored block is 1 cubic meter. :giggline:

Optimized this algorithm by iterating in a spiral pattern rather than linearly. This removes the data dependencies the reference implementation had on every iteration and brought the time it takes to solve a 201^2 grid from 0.13724713ms down to 0.02504632ms!

https://towardsdatascience.com/a-quick-and-clear-look-at-grid-based-visibility-bf63769fbc78
Ported the above visibility algorithm to C++, works really well! Really like how it captures the "penumbra"

nothing says "indie block game" like "unfiltered single octave simplex noise" :smugdance:

With the power of raytracing, I'm rendering 256 chunk(8192 x 1024 x 8192 world) render distance at 500+fps on my 7900xtx

redid my voxel pathtracer to serve as a reference to compare to realtime GI solutions. Neat image I got when I forgot to attenuate the light based on distance included as well :thumbeline:

:catpop:
voxel terrain is now generated on the cpu and uploaded to the gpu in a neat datastructure. There is no duplicate data here, every block takes up a unique region in memory. Takes about 2 seconds to generate 8196 x 8196 x 8 voxels, gotta get it much faster for it to be reasonable in real time

Added shadows to my multi-level 3dda voxel raytracing :catpog:
https://www.shadertoy.com/view/Mc3SRB

Put my multi-level voxel rendering stuff on shadertoy :catpog:
https://www.shadertoy.com/view/lfyGRW

Finally implemented brickmaps, 4096 block render distance running at a cinematic 1000-5000fps at 1440p on a 7900 xtx :oomfiePlane:

4096 block render distance running at a cinematic 60fps at 1440p on a 7900xtx :catting:

https://cdn.discordapp.com/attachments/985018469907038209/1221637785962676345/image.png?ex=66134dd9&is=6600d8d9&hm=03acfe6bffd63753468a710743e35ca2f154ddd738640f2e9d2fb8e7fe8b4c5f&
https://cdn.discordapp.com/attachments/985018469907038209/1221637534124347474/image.png?ex=66134d9d&is=6600d89d&hm=bb31ec02e9892db438d2ea7b2218b1e09914f0cf970d7b6807d12abbc2ec50cc&

https://www.shadertoy.com/view/X3SXDy
https://www.shadertoy.com/view/M3SXWV
Uploaded my DDA fixes to shadertoy and also made a fork with nice AO

Fixed the DDA voxel shadertoy so that it doesn't explode if you look at it in certain angles(Before vs After) :catpog:

Checkered rendering works quite well with the heuristic of "If all 4 neighboring texels are the same, assume this texel is the same. Otherwise do a raytrace". Offers a modest 20-50% performance gain

Because everything's an AABB, I can get pretty much perfect edge detection by hashing the block and face id, and then take more samples at the edges for some solid AA

:elmofire: rendering a bit over Minecraft's 32 chunk render distance (512 x 512 x 408) voxels at a cinematic 20fps on a 5800x