Neil Bickford @neilbickford@mastodon.gamedev.place

How it works:
* Phrase finding an approximation as minimizing a cost function;
* Cost function is a combination of 3 metrics;
* Landscape has many local minima, so:
* Maintain c instances of k candidates in different temperature and cost bands;
* Mutate each candidate; accept new candidate according to Metropolis criterion;
* Replace all candidates in cost band every few iterations.

High-Performance Image Filters via Sparse Approximations by Schuster, Trettner, and Kobbelt approximates convolutions by multiple passes of a few samples, which often uses fewer samples total even if the kernel is separable: https://www.graphics.rwth-aachen.de/publication/03312/

The supplemental data for the paper includes GLSL code for several kernels computed using this technique! Here's a port of some of these to Shadertoy, so you can see a few pre-optimized kernels running in your browser: https://www.shadertoy.com/view/WlSBzc

This indie game bundle is amazing - including multiple IGF award winners, A Short Hike, PtPatP, Overland, Astrologaster, Quadrilateral Cowboy, DragonRuby, The King's Bird, and 735 more. And all proceeds are donated to the NAACP Legal Defense and Educational Fund and the Community Bail Fund, split 50/50. Can it make it to 5 million? https://itch.io/b/520/bundle-for-racial-justice-and-equality

And if you're overwhelmed by all of these games, here are just a few recommendations from this list from itch.io: https://itch.io/c/891735/bundle-for-racial-justice-and-equality-selections

Massively Parallel Rendering of Complex Closed-Form Implicit Surfaces by Matt Keeter shows a new way to rasterize or voxelize implicit surfaces (regions where f(x,y,z)<0, where f can involve e.g. piecewise functions): https://mattkeeter.com/research/mpr/

How it works:
• Express f as sequence of operations
• Start at low-res then subdivide to high-res
• Use interval arithmetic to tell if a box is inside, outside, or needs subdivision
• Remove ops when subdividing that don't impact f in region for perf boost

Here's a new sampled version of the celesta recorded for the Celeste Celeste Collections fan videos last year! It includes:
🎧 3 stereo configurations
🎹 Every note sampled
💻 New algorithms with source code
And it's free — you can download it at https://gitlab.com/Nbickford/a-sampled-celesta !

Video: This sampled celesta playing Anitra's Dance by Edvard Grieg, using the denoised, tuned, mixed configuration and Soundtoys' Little Plate for reverb. Please see the project page for the full list of acknowledgements!

I'm releasing a new free sampled virtual instrument tomorrow, and have been working on putting together the finishing touches for it this weekend (including some new processing tricks)! Here are some images of the process along the way:

Did I mention that it reads more than 130 DXGI and ASTC formats and is ICC v4 compliant?

Some other neat things it has: Mipmapping uses correct filtering (linear space pre-alpha). Normal maps use slope-space CLEAN filtering! We brought in the effects system from the old plugin. You can drag sliders and see the compression preview update in real-time! And much more!

Here's our developer news blog post about it: https://news.developer.nvidia.com/texture-tools-exporter-2020-1/

(and you can download it free at https://developer.nvidia.com/nvidia-texture-tools-exporter!)

They even stay compressed on the GPU, so you save VRAM.

BC7's 1/4th the size of RGBA8, and supports transparency, and BC6H supports HDR. If you're already using compressed textures, this speeds up compression on CUDA-capable GPUs! It uses NVTT 3.0, which has been used to ship tons of games over decades (including some you might know!)

But the core of this is usability - you can use it as a Photoshop plugin, or as a standalone, using the GUI, a command-line interface, or with batch scripting!

And now to reveal the app I've been building for the last few months - the NVIDIA Texture Tools Exporter! Compress to BC7, ASTC (+more!), create normal maps, mipmaps, cube maps, and so much more in this new version of the classic tool! Available now at https://developer.nvidia.com/nvidia-texture-tools-exporter!

If your app uses textures, try using compressed textures - you can fit more on the GPU or use higher-quality textures! They'll even load faster than PNG or JPG files - copy the data to your GPU, and that's it! (Thread)

I've just started my new blog, Page Fault, with the release of a tutorial for making your own audio denoiser in REAPER's scripting language! https://www.neilbickford.com/blog/2020/02/02/a-real-time-jsfx-audio-denoiser-for-reaper/

This is also the denoiser that was used in GME for the Celeste Celeste Collections videos, as well as several Powell Library tracks. It's now free and open-source, and you can get it at https://github.com/nbickford/REAPERDenoiser!

(Why post this today? It's Groundhog Day, and a palindrome day in US/UK/ISO 8601 date formats—02/02/2020 and 2020-02-02!)

We’ve released the new version of our Vulkan ray tracing tutorial! https://nvpro-samples.github.io/vk_raytracing_tutorial/

This shows you how to modify a rasterizer to use ray tracing, and has eight sub-tutorials about antialiasing, transparency, reflection, animation, procedural shapes, SBTs, and more!

These are by Martin-Karl Lefrancois and Pascal Gautron, and I had the privilege of getting to edit these!

Here's one side effect of a JSFX audio denoiser I'm working on I didn't expect - if you set the noise scale to a really high value (i.e. removing all but the most prominent frequencies in each tile), it generates some nice bell-like artifacts!

I wrote an article for PROCJAM's SEEDS, the generative systems zine, out today!

It's about one of my favorite methods of terrain generation; or, how to generate virtual terrain using a piece of paper and some open-source photogrammetry software.

You can read it here! (Runs from page 39 to page 41.) http://www.procjam.com/seeds/issues/4/issue4.pdf

You can also find other issues of SEEDS here: http://www.procjam.com/seeds/

You can also draw the Petersen graph with 3-way symmetry. Here's what the same animation looks like if you draw the graph that way:

Why S5? Suppose you take 10 vertices and label each node with 2 distinct integers from 1 to 5 and join vertices with no common number. You get the Petersen graph! Can then label each edge with the number that its two vertices lack. Elements of S5 map to automorphisms by permuting numbers; map from automorphisms to S5 by edges. Then have to show this is a bijection.

(More math than gamedev, posting here for completeness)

The Petersen graph has 120 automorphisms (ways to rearrange the nodes of the graph to get an identical graph shape). Here's a looping GIF of all 120 of them!

The group of automorphisms turns out to be S5, the group of permutations of a 5-element set.

I did post audio mixing for 10 concerts at MAGWest this year! Here are the ones I mixed:
Mega Ran and Super Soul Bros.: https://youtu.be/2H11LruWgxo
8-Bit Jazz Heroes: https://youtu.be/SN4MJlQSCsk
NyteXing et al.: https://youtu.be/LGBf3_IaDQg
Nikola Whallon: https://youtu.be/cS6-Lvb8K2Q
Petriform: https://youtu.be/d6L4tILEWP0
chibi-tech: https://youtu.be/ZREflAiikr4
Infinite Combo: https://youtu.be/oxMpIuwljp4
Sergio and the Holograms: https://youtu.be/vYI7j-y_OGg
minibosses: https://youtu.be/ZjH6MMq3BCM
SkyBlew: https://youtu.be/iN-0uyREDI4

SPIR-mint

It looks like last year's Gathering for Gardner exchange book is now online, so I can finally release the paper I wrote for it!

It's about how unit quaternions work, and why any rotation is represented by two quaternions (spoiler: the space of rotations isn't simply connected, so you can't blend paths of rotations without this duplication!): https://www.dropbox.com/s/mxwfrgw6pv9vihj/G4G13%20-%20Why%20do%20the%20Unit%20Quaternions%20Double-Cover%20the%20Space%20of%20Rotations.pdf?dl=0

Also includes 9 quaternion recipes, including why qxq^-1 rotates a vector, Frisvad-style tangent space generation, and more.

The team also released Korgi today, which allows you to modify Q2 console variables (like sun direction!) using a MIDI controller (somewhat like PANORAMICAL's MIDI interface)!

You can find the code for Korgi at https://github.com/NVIDIA/korgi.