In general, I'm looking for a new, more sophisticated, solution to replace projective shadowmap.

Goals

• scaling with resolution (faster on low-res rendering)
• single solution for any GPU (unlike ray-tracing)
• high (pixel-perfect) quality

Progress

• DirectLighting (sun)
  • Planetary occlusion, for sun
• Fog
  • Optimized fog
• Point lights
• Refactor/cleanup: rename *cluster_task into something readale
• Overall optimization
  • small-core (512 threadgroup) support

interesting to experiment:

• software-rt (with meshelets binned by pages)
• software pre-trace, to complement culling. Similar to RT, but without ray-triangle test.

Known solutions

Not a lot actually...
nanite (page 119): https://advances.realtimerendering.com/s2021/Karis_Nanite_SIGGRAPH_Advances_2021_final.pdf
assassins creed (page 55): https://advances.realtimerendering.com/s2015/aaltonenhaar_siggraph2015_combined_final_footer_220dpi.pdf
https://ktstephano.github.io/rendering/stratusgfx/svsm
https://www.cse.chalmers.se/~uffe/ClusteredWithShadows.pdf
https://www.gamedevs.org/uploads/efficient-shadows-from-many-lights.pdf

not vsm, but close enough in concept:
http://lukaskalbertodt.github.io/2023/11/18/tiled-soft-shadow-volumes.html

Very first WIP

Some page-data to illustrate

Initial implementation

Decide to start with common parameters for now:

• only sun-light for now
• 4k*4k page atlas
• 128x128 page size: up to 1024 pages
• Clipmaps + page table 64x64x32
• Meshlets are duplicated, as many time as many pages they overlap

Current considerations:

1. Cluster culling: cull all clusters versus all pages is expensive
   1.1 Coarse culling not possible - need to output exact pageId, for visible meshlets
   1.2 Output size is not deterministic and no good way to react to out-of-memory
2. Cull versus clip-map (HiZ like) is easier, than versus each page individually
   2.1 Won't be able to use hw-rasterizer to output data (need to use image-atomics + image-less rendering)
   2.2 Image-less rendering limited by maxViewportDimensions = 4k
3. Software renderer?!
   3.1 Immediate one still requires atomics, and wont be better than render-pass based one
   3.2 Tile-base can be an interesting take, but not valid without bindless
4. Requires some complementary solution to work with volumetrics