Facepunch has quarterly hack weeks, where people can fuck around with something they've wanted to try out.
This could be anything from a new game idea, unique gameplay mechanics, editor tools or anything they want.

We end up with a bunch of weird and interesting things usually, sometimes an idea pans out well and becomes part of the game / engine. Here's what we got up to in s&box for this hack week.

This hackweek I implemented Gaussian Splat rendering and collision generation in s&box.

Gaussian Splats are 3D models constructed via a metric fuck ton of photos taken from various angles, placing coloured 3D splats in the world to build the geometry instead of being constructed with triangles and textures:

Since splats take parallax/perspective from every photo in the dataset, you can see they handle things like reflective surfaces and mirrors with great detail. But once you get up-close to a small object you can see the individual splats

Splats can optionally be re-lit using the lighting from your Scene, and can even receive shadows in real-time:

Here's a short animation I made in about an hour using Movie Maker and a re-lit Gaussian Splat for the environment. The splat I used isn't the highest quality but it came out surprisingly well :)

Gaussian Splats has been made available as a Library so you can start playing with this for yourself right now.
If you don't have a splat of your own, check out superspl.at for various .ply/.sog files with commercial licenses.

Check it out: https://sbox.game/facepunch/gaussian_splats

I've been wanting to work on a str& type game to see how far I can push our current landscape tools. I love hiking and climbing mountains, so I ended up adding gameplay as well. This is a collection of multiple different systems working together.

The player has a center of gravity that he has to keep balanced. The more cargo and weight you have, the harder it is to stay stable. The higher the cargo is, the stronger it's pull force is.

Very basic spline based river system. No gameplay element yet with the water. But I'd love to explore this more.

The elements in the scene blend smoothly with the landscape using vertex displacement and triplanar texture blending.

Using the player's IK functionality with the lean variables, the player leans against the slope to keep its balance. The feet always place themselves according to the terrain displacement.

The terrain and elements of the world gets darker as the cloud move, enhancing the sense of scale.

As the rain intensity increases, water puddles form on the terrain. Grass that is wet shrinks. As the rain clears up, the puddles slowly dries back and disappears. The colors, sun and fog adapts with the rain intensity as well.

Couldn't find the time to polish it up fully so it was a bit janky.

My libsdf library from years ago was in dire need of a rewrite, so I had a go this week. Everything is from scratch, with the main goal being to do the heavy lifting in compute shaders. First I got the basic idea working with cubey voxels.

Next I got a chunk system working, with multiple chunks being generated / meshed in parallel.

Now it was time for marching cubes. The first version I got working would just append to a vertex buffer in one pass.

Eventually I got a two-pass system working: generating vertices first, then the indices for each triangle so vertices are re-used. This made smooth normals a lot easier.

I only had until Wednesday so I finished off with a basic LoD system, and a simple infinite world demo.

When I get time I'll generate collision geometry so you can run around the surface, and eventually publish this as a library.

Giant Jigsaw is a game mode where players work together to assemble a giant jigsaw puzzle. The catch is that all the pieces are scattered across a hazardous map, but as more of the puzzle is put together, the more tools players unlock to deal with said hazards.

This has been a project I've been working on for several hackweeks and off and on in my spare time. The first version was made for the old entity system and focused more purely on the assembling mechanics. For the revival, I wanted to try something a little more in-depth and make better use of the third-person controller, so I made acquiring the pieces a larger part of the challenge.

Should be out by the time this goes live, hope you guys enjoy!
https://sbox.game/fphowie/giantjigsaw

I wanted to try and recreate one of my favourite game - A tool and a game, you can build your levels then play them straight away, then once finished you can upload them to the workshop!

It's all pretty modable and easy to expand.

Our text rendering is currently uses a CPU generated texture for all systems, makes it fast to composite and updates fast but could be improved.

It works fine for 2D text, UI elements, etc. Looks bad in 3D world panels and when you transform the UI since it's a texture.

Eric Lengyel has recently made his excellent text rendering algorithm public domain, thank you very much kind sir. It's considered the best that there is and can generate pixel-perfect font curves on the GPU very fast, so I've decided to overhaul our text rendering inspired by it.

Previous gold standard to do scalable text rendering in games was with MSDF, but could cause some issues with edges being blurry or rounded weirdly, would've been our choice if not for this.

GPU Text Rendering makes text super sharp with perfect antialiasing everywhere now:

Even though it's early it composites pretty well with existing stuff, if we have it on "master" a normal player wouldn't even notice a difference at a glance.

We can already lock axis in 3d physics to fake 2d physics but nothing beats a true 2d physics engine. Using box2d (like box3d but one less d)

From the start we absolutely wanted to avoid having an awful 3d/2d physics API split like some other engines do.  Instead, everything goes through our existing API, the backend makes it all work depending on your project settings.

I'm one of the few at Facepunch that own an eye tracker, it's pretty niché, but it's such fun to use. It's almost like VR without the massive screen strapped to your face.

Here's s&box parsing data from freetrack, an open source piece of software that supports most sources of head tracking.  The upside of freetrack is that it uses shared/named memory, which means no external dlls.

My tracker supports gaze (eye) tracking, so I moved onto that next using Tobii's own API. This is sadly an external dependency so it probably will never see the light of day.

Another thing I've wanted to do for the longest time, is let games support joysticks, or steering wheels, or any device with buttons. The tricky part is our input system doesn't really support arbitrary analog inputs, so I had to refactor a bunch of stuff to make that happen. The upside is, it works really well. You can define analogs from keys, so Forward (W +1, S -1), etc..

Then I added support for trapping any input received from any source, which lets you do stuff like this!

Until now, s&box's environmental audio has been pretty bare-bones. The two existing features are:

However, real acoustic environments are way more complex: sound reflects, transmits, absorbs, diffracts around corners, and more.
SImulating all of them accurately would be complex and expensive, so for now I am focusing on the three that have the most impact  and can be approximated well with a few raycasts:

Occlusion & Transmission

I experimented with replacing the binary occlusion switch with something more physical. Rays are cast through the scene and the materials they pass through are accumulated.
Each material has per-frequency transmission values. Concrete blocks much more than wood, and high frequencies get cut more aggressively than lows. The result is that sounds behind walls actually sound muffled rather than just quieter.

(Use Headphones and turn up volume of the video, these effects are subtle.)

Dynamic DSP/Reverb

The DSP volume system still works, but I experimented with adding a fully dynamic layer on top. Rays are cast from each sound source at runtime to estimate the room it's in: size, shape, and surface materials.

From that, reverb parameters (decay time, pre-delay, frequency coloring) are calculated and applied automatically. No manual volume placement needed.
 
 

This is far from done and needs a lot more fine tuning and performance optimizations before we can put it into the engine, but it's very promising.