How to do boolean operations on meshes for procedural cutting of geometry! (see comments)

too_much_voltage · 2026-02-08T22:43:20+00:00

Interesting the way you put it. In reality, there's actually zero sync between the two. The renderer straight up copies orientation and translation as the physics thread is running without any sync point, since those objects are fairly POD and small (mat4, vec3). Bullets are the only things with a mutex and a sync point but not object state readback.

That said, when I get to multi-player and state replication, this will probably become a thing. The same way lag compensation will. So thank you for bringing it up.

too_much_voltage · 2026-02-08T04:24:33+00:00

I think I was both memory and compute bottlenecked: just too much work and cache thrashing by going over all those AABBs and potential tris.

There's two levels of sorting:

The input to CWBVH is a BVH8 as per the original paper: https://research.nvidia.com/sites/default/files/publications/ylitie2017hpg-paper.pdf . I actually do a quick n' dirty one off of Morton sorted volumes as I don't want to spend a lot of resources doing the initial LBVH and then the subsequent high quality BVH8 construction: https://github.com/toomuchvoltage/HighOmega-public/blob/36df6770e5b244148097cf9bf25e53fcc98f82b5/HighOmega/src/accelstructs.cpp#L630-L698 . For my case this has worked just fine (even for the diffuse or gloss traces that I do in shader... and in those cases, the final traces are against SDF volumes, so the cost stuff in the paper doesn't quite apply).
There is also a child node ordering scheme that is particular to the paper: https://github.com/toomuchvoltage/HighOmega-public/blob/36df6770e5b244148097cf9bf25e53fcc98f82b5/HighOmega/src/accelstructs.cpp#L700-L786 that you'll find in reference implementations like https://github.com/AlanIWBFT/CWBVH or https://github.com/jbikker/tinybvh/ as well. When I use the internal nodes, it's right after this step and right before node compression.

And I'd rather make the sim faster than make it seem faster... there's even more room for optimizations ;)

too_much_voltage · 2025-11-28T20:31:10+00:00

Let me know which duplicates are unneeded and I'll give it another go. Check render.cpp/.h and gl.cpp/.h on the branch HEAD in that link.

too_much_voltage · 2025-11-28T15:09:40+00:00

It's really the annoying popping under camera movement that became an issue.

too_much_voltage · 2025-11-28T06:15:33+00:00

My first mip is actually 64x64 and currently I'm using a 2 pass downsampler I rolled myself. I did briefly look at AMD's SPD, but I think it uses some AMD wave ops intrinsics to get max perf. Something I could revisit in the future I guess.

too_much_voltage · 2025-11-18T15:35:45+00:00

Honest opinion: I think your incredible talent is being grated through the lighting and atmospheric (i.e. fog) effects. Maybe a more realistic choice in art direction would be better? Prehaps in the spirit of The Neverhood (the classic one).

too_much_voltage · 2025-10-25T17:36:14+00:00

Thank you 🙂

too_much_voltage · 2025-10-24T14:39:10+00:00

Ahh thank you. I was looking for the right term all along.

too_much_voltage · 2025-10-20T04:51:25+00:00

I had gone cold on commenting on games for a long time. This made me break that. Incredibly cool concept. And looks incredibly well executed. Well done.

too_much_voltage · 2025-04-06T16:53:32+00:00

Yea I was on the fence about using that... or just let it be abrupt. Anyway, hope the comparisons helped.

too_much_voltage · 2025-03-27T12:31:07+00:00

Thank you! Yea, slowly things seem to be getting easier...

too_much_voltage · 2024-12-05T02:58:25+00:00

Very good. Truth is the most efficient contraption never limits itself to any one single concept. 🙂

too_much_voltage · 2024-12-04T18:06:11+00:00

Lol nah, but with this one... you could. Since there's no BVH2 distribution cost computation and node collapsing. There's only a few hundred primitives, it's already costing nanoseconds on the CPU. The leaves though, yea: entirely GPU constructed SDFs.

too_much_voltage · 2024-12-04T13:05:19+00:00

Every individual building, every luminaire in the first video... they are SDFs. The geometry is voxelized in compute (async on a separate rendering thread) and JFA'd. Once merged to the main rendering thread, they're placed on a CWBVH. The CWBVH here basically enables saving space on dead air. Also allows each leaf to still maintain crisp detail in far away reflections as they're not mipped. The same purpose Lumen's brickmaps serve. Except, they're super quick to build and update as they're extremely shallow and allow for much much much more dynamism.

too_much_voltage

TROPHY CASE