You just casually made a spatially mapped datamodel lol

Hi! I wrote the "Binary greedy meshing" algorithm. Very cool to see this video on my youtube frontpage today, I love your video and explanations :)

Thanks for the video, I can advise you not to make a greedy mesh for each type of block, but to make for all complete solid blocks, and then transfer to the GPU data structure with the help of which you can calculate the block type and texture by pixel position, it will simplify the mesh many times as well as the algorithm itself.

Found a way to make it even faster: you are initializing the 2 initial vectors with chunk_size_p³, but it can also be done with chunk_size_p² because the 3rd dimension is in the bits. this way you can use arrays because there is no longer a stack overflow

I now fully understand the concepts used to achieve such high performance. I also fully understand that if I were to try to write it. Every line of code would have an off-by-one error.

When you explained the part in 14:40, where you explained how to find the faces looking right just by modify an interger, I was so surprise at how simple it is an yet amazingly complex

You can speed up the data setup part by using stack arrays instead of using "Vec"s

this is insane! i have my own culled and greedy meshing implementations and i know they're not the fastest, but i'd never have thought it could get THIS fast. you could literally remesh every chunk every frame with this and still get good fps, which is mind-boggling. good job with the explanations, too.

This video is honestly so well explained and even though I don't know anything about voxel engines or game development I was able to understand it. This is probably one of the best resources for making a voxel engine. If I ever make one, I'll probably take a look at this again, thanks for your amazing work!

This is incredible! I did something extremely close to this for counting strings within DNA sequences and got immense speedup. Binary manipulation is insanely speedy if you can comprehend it. Great job figuring this out and explaining it.

Use an array for the data instead of a vector (since you know exactly how many entries it will contain) and it should have essentially zero allocation time since it'll be allocated on the stack instead of the heap

Now do it with SIMD

If your friends CPU has significantly larger L2 or L3 cache, the performance difference could perhaps be cache misses? Aligning data for CPU cache optimization is another beast to tackle though 😅

Oh my god I wish i had this video like 2 months ago when i was trying to write a greedy mesher. Thank you so much for this resource! Will definetly save it for the future!!

I'm making a game that has voxels and I implemented this also using Rust and something very similar to the slow approach. This video came out with such a great timing. Thanks for sharing this. Maybe it can be even faster if SIMD or parallelization are included? 😁

Looking at this made me realise that I clearly need to lurn bitwise manipulation

Just want you to kmow that this video was so good that at 11:27 there was a solid 5 seconds where I actually scrambled to rewind the video to try to desperately see the code

Thank you Tantan for somehow releasing a video on the exact topic I was worried about for my next project, very cool.

i love everything about this your awkward presentation, the handdrawn sketches, the weird pronounciation, the focus on speed, your manbun, your long hair that makes you look like a metalhead, the jokes, the effort you made, everything, everything in this video is just *right* .

Man amazing video. You made it sound so hard but I feel like I grasp all of it pretty well. The visuals make it soo much easy to follow, hats off to your work.

I haven’t tried greedy meshing but I’ve seen some demos of greedy meshes where it doesn’t care about block type, it constructs the triangles while remembering where the different block types are, so it’s possible to make the greedy meshes not slow down when you increase the block type count

This is some Big Brain Calculation right here, great video Tantan!

Great video! I wrote a basic algorithm for doing this on culled meshes, but I'm glad to see it's possible with greedy meshes too!

Wow man, mad props. That was some heavy stuff and yiu actually explained it extremely well. Thanks, and keep up the good work!

Now i understood why this video take a while to be made! This was a really good video!

You succeeded very well in explaining something complex in a simple manner! Well done!

phenomenal video explaining this. you are very good at explaning these topics

I came from Dani's video, and I'm glad I did :) Great video!

What a coincidence, I currently need a good voxel algorithm for my project :D Will definitely look into it! thanks

It's like a gift for me. It was a problem no matter how much I optimized it before but now I have no problem loading and rendering faster than before. thanks for your video

WOW you did a really phenomenal job at explaining your algorithm

You explained this really well! Thanks!

This is awesome! I'm looking forward to attempting to implement this myself. I'd love it if you would cover ambient occlusion in the future or at least provide some resources for where you learned about it

The brings back memories. I recognized some code I wrote about 15 years ago after being blown away by Minecraft. The & operation on the shifted bits specifically. The merging of the meshes was clever and much better than what I ever came up with. I put it all in a fancy octree though so I only rendered on-screen chunks. I hit a brick wall getting the lighting to work on merged meshes and it all fell apart once I had more than, say, 6 block types. Your code will do so too. But it's a great exercise and good job. A more modern way would no doubt be raycasting, there are many more triangles than pixels on the screen if you scale things up and it parallelizes better. Nice video, keep them coming!

I would love to see a full bevy tutorial on your channel

Less go. great video as always sensei

I like how you mostly pronounce "Chunk" as "Shunk", always made me smile :D

Love this. I remember building a 2048 AI and going from loop-type grid transformations to bitwise operations. Bitwise stuff is hard to grok but there are sooo many orders of magnitude of improvement and it's so satisfying :)

Excellent video. The animations are easy to follow along with. Thanks for sharing. I'm curious about the method you used to profile your code to determine the execution time of various sections. I didn't see any particular video in your catalog that seemed to cover this, so perhaps a "How Tantan profiles his Rust code" could be an idea for another video.

BLAZINGLY FAST

Woah, love the bit shift and negation. That's a great way to generate the culling indices instead of iterating through every single block.

You love to see it! I've also been optimizing the Rust code of my Chess engine, although this seems exponentially more complicated 😅

I dont watch your videos (but still subscribed (I want to learn rust&bevy some day)), but every time I see your videos it feels like a new scientific experiment.

Amazing to see the level of performance you can get out of using the binary representation and this has me wondering if I can use any in my own projects. I suspect I will need something similar to create an AI navmesh in the near future. Fantastic video once again TanTan!

Yes! He's back! Let's goooo!

This is so cool and such a good explanation.

Loved the Flight of the Conchords reference

That is cool revelation and use of bits.

Let's gooooooooooo...I love this series

damn i always had wanted to play around with bitwise manipulations, really cool video

You're using bitwise operations to calculate binary derivatives. That's dope :')

15:04 this was the point I verbally said “this guys psychotic” but in a good way. This is a crazy way to think about this data but it makes so much sense! Good work man!

Amazing video!

wow, this is actually inspiring

this videos singlehandedly makes me wanna try to make a 3D game from scratch

Nice technique. Possible considerations for the future: - With SIMD you can implement masking for each block type without having to split them into different array. Though it does mean a hard limit on the block types and chunk size. - I'm pretty sure SIMD could be used to "instantly" (

Thak You! That video and research are so usefull! After watching your video, my greedy mesher looks so sloooooow :c

Thanks from a godot developer (csharp) this is very useful there as well since bitwise operations work very similarly and especially with multimesh instancing! Cheers :)

Brilliant! how does splitting data by block type affect the memory footprint as more types are added tho? Is there an optimal sized chunk to limit the unique block types that can occur within each versus the number of iterations to cover every chunk?

So nice, a new vid!!!!

Lmao I wrote an algorithm yesterday for greedy meshing which does a bunch of neighbour checks for each block and then creates a bit mask from that. Definitely stealing the bitshifted comparison optimisation. This must be the most amazingly timed video I've ever seen.

Really cool. I wonder how this would relate to the optimizations that Vercidium uses to get voxel rendering running at a claimed 12000 fps.

This is... beautiful

I wonder if the data layout could be improved as it looked like you use sequences of array indices that are far apart from another. Depending on how large the data is, this could theoretically lead to cache misses as not the entire array is loaded into the cache at the same time. But it's only 0.8% of runtime and the Compiler probably already optimizes this. But if there was a slowdown caused by cache misses, improving the data layout could speed up the code a lot

Amazing work, You can make this dramatically faster using SIMD now that its a bitwise op game

Impressive, very nice!

Thanks to practicing image manipulation in JS, this was surprisingly easy to understand and clicked right away for me. 1D data models and traversal is not simple, so I understand your pain.

God damn bitwise wizards, I really have to learn how to use that stuff, because in theory I understand it, but I don't know how to use it

Coincidentally I just implemented nearly the same thing a week ago, though I support octree blocks so it's a bit more involved, but cool to compare implementations. I made use of xor to detect my faces, never thought of just flipping the neighbor... My meshing ended up about 50% faster somehow after implementing it, even though it feels like more work is being done

Funny and fascinating! Thank you!

Mine is faster I dont use any meshes just face information and send that to the gpu Then with a shader you can procedurally make vertices and triangles

This voxel engine looks incredibly advanced and would make a brilliant base for games! For future videos I'd love to see you implement a scripting language into an existing Rust project like Lua or Angelscript.

1:03 missed opportunity for the vsauce intro ost

Several people have mentioned looking into SIMD optimization, but a few other ideas: 1) Using a fixed sized allocation instead of a Vec since the size is known. Not sure whether the entire arrays would fit on the stack but if so that may provide several speed improvements over a Vec on the heap. 2) It might be possible to combine both positive and negative edge detection into a single operation by using an XOR, but would require a slightly different method of iterating over them to pass into the greedy meshing. 3) Your structure for axis_cols has the data for each grid separated, a format similar as such: (y1, y2, y3, y4... x1, x2, x3, x4... z1, z2, z3, z4...) this means when setting the values you're writing into separate parts of the vec that might be far enough from each other to cause frequent cache misses. A layout where the three axis all are interwoven beside beside each others might be faster, such as (y1, x1, z1, y2, x2, z2, y3, x3, z3, y4, x4, z4...) 4) It would require a bit of rework but this seems very reasonably practical for a compute shader. 5) Would take a fair amount of work, but rethinking how you store the actual voxel data in general may make it faster to convert. 6) Again it would be a change in direction, but there are approaches people have taken where you can greedy mesh any flat surface, regardless of different types of blocks. The way that achieve this is usually to pack the color data for the chunk into a 3D texture and use it in the material/shader for the chunk mesh, then, rather than each triangle having a color, the fragment shader can use world coordinates to query from the color data as a 3D texture at the position of the face. Allowing a single triangle to have multiple colors on it. This makes the fragment shader slightly more complex, but in most examples of people using this technique it tends to improve performance in both rendering and construction because it can result in a massive reduction of polygons, especially as you add more and more materials.

Отличное видео !!!

Very cool. I bet you can double the performance with some tweaks to how you manage memory. I see a lot allocations happening in loops when you could make 1 allocation outside the loop and reuse the variable for each cycle of the loop.

Amazing!

Facinating this is nearly idendical to what I did for my voxel engine as well. I think mine is a little bit more complicated as I store my voxels in a (squashed octree) tree structure. I also use bitwise operations heavily and pointer manipulation and I found the same issue as you. Just to generate the bitmap takes more time than the algorithm itself. I wonder how long the FULL generation of the mesh takes not only the meshing part. Fine takes about 10ms in C# including data setup for a 64x64x64 bock chunk (64bit longs are better suited for most modern processors)

I tried out the mesher in my own project with a different chunk storage scheme. I ran benchmarks on my project and got around 500 µs (microseconds) per chunk. When I ran your benchmark I was getting around 32 µs. Initially I thought it was just inefficiencies in retrieving voxel data since I'm using palette based compression. After some more testing I found that if I use your chunk generation code the benchmark result was around 50 µs. Turns out there's only a few solid voxels in the benchmark chunk which is why it runs much faster. The first chunk I tested/benchmarked had solid voxels in a sphere shape. Still my voxel retrievel from the chunk is significantly slower then simply indexing into a Vec. Mainly because I use bitpacking for the indices.

You can go farther. In my greedy mesher I store both block and ambient-occlusion lighting in textures, as bytes, using a bin-packing algorithm. One 2kx2k texture has always been enough, but I also added the ability to track which is needed by each chunk in case I needed many. This is particularly useful in city-like terrain where the geometry has a lot of flat faces made up of different types of blocks.

I can't find it anywhere but I remember an attempt at moving meshing onto the GPU with mesh shaders. On a more similar scale to yours, I believe the mod Nvidium for Minecraft does that too

there are some weird similarities with your binary greedy mesher and my implementation of 2048 in the desmos graphing calculator. I love things like that

One final thought, if you use 30x30 chunks you can fit the left/right neighbors into a 32bit int rather than expanding to 64. It'd halve your memory bandwidth requirements at minimum and if you use SIMD it will let you double the number of calculations performed per cycle.

16:30 🤯whooooa, kudos on visualizing that! That really clicked well! 👏 Also this is a bit of a loop-unrolling idea, not sure if the unexplained ambient occlusion part defeats it, but instead of iterating over the 6 axis separately could you iterate over just the 3 (X, Y, Z, no reverse) and do the reverse calculations in the same portion handling the same axis? So grouping X and XReverse into the same iteration. Honestly it's a shot in the dark, and it's also not even a major fraction of the computation time anymore even if it did somehow manage to shave any time, but figured I'd contribute something while I'm here 😅

Babe wake up another tantan video has dropped

Would it be possible to bitmask the x, y and z coords somewhere? So as you can calculate the face-5ets in one pass, without having to triple loop and storing the bite set for it somewhere external to the loop? Whether it's worth it or not is down to testing performance but is it even possible? Could it be possible to use the remaining space in the byte to store block type data too? (IE: air/dirt/grass etc.) it would grow as you add more block types, but if you're taking up 3, for xyz, perhaps possible to find a way for the remaining 5 to be useful for each parse?

Now write it in SIMD using WIDE bit registers. imagine what you could do with 4x256 bits :P

neat. since you already have the faces separated from each other you can cull based on chunk location vs player location with dot product on the cpu. also i've been wondering for a while why people don't just generate the mesh on the gpu since it's way better at this sort of multithreadable processing. i'm pretty sure the data ammount transferred to gpu could also go down?

Nice 🔥

Is it possible to make write this threaded? each axis having it's own thread? or somehow execute this on a gpu? Thx for the deep dive, I learned a lot!

this is great

I love when you get examples of these hyper-specific x86 ops in the wild. Everyone's knee-jerk reaction the first time is always "WHO COULD **POSSIBLY** NEED THAT!?" and then there's always something like this algorithm that's ridiculously faster. So is the 64 bit version faster on 64x64x64 chunks?

please would you turn the in-game render distance up as far as you can and show us how fast it runs?!

Wow! 🚀✨ This video is not just training, it's inspiration. Inspiration for all of us to keep striving to do better, faster and more efficiently. Inspiration to keep exploring, learning and growing. 🌟🚀 Thank you for this amazing experience! 💖🌐

when i see "blazingly" i know it's rust already.

This is the same algorithm as bitmap edge detection. Shift-not-and-ing is really common in other applications 🤙

3:00 as I always say "paint is the most important software for software developers"

Epic games had a wonderful talk about nanite, and the part that blowed my mind is: Gpu’s are very slow at rendering extremely small triangles. So what they did? They just wrote a SOFTWARE RASTERIZER, that is faster than the hardware one I think when the size of a triangle is less then 40*40 pixels. The difference is really impactfull, and they showed the code and implementation for everybody to use it!

how do you count the bits in the binary data? do you just use a bitscanforward / reverse?

Blazingly fast 🔥🚀