a couple 3D aabb tricks: gpfault.net/posts/aabb-t...

Ecstatica II (1997) Developed by Andrew Spencer Studios.

I've been reading up on k-means clustering again. I learned that scikit-learn's default "k-means++" init is actually "greedy": it does multiple attempts when randomly picking the next center to add. And the default value for the number of tries is based on an offhand remark in the original paper.

I tried to use premultiplied alpha on the Nintendo 64 but I don't think it's actually possible. The hw blending equation does an unfortunate rounding when mixing colors, adding some black even in fully transparent pixels. Left: Straight alpha, Right: My attempt at premultiplied alpha.

I was looking for how to make deleting files a tiny bit safer in shell scripts and found this subtly terrible StackOverflow answer. Consider the case where $SOMEPATH is empty and what does `cd` do then 🤠

I've been reading about color science for my book and I wanted to verify the claim that Oklab gives better linear gradients than the otherwise excellent "CAM16-UCS" color space. And yes, its gradient obviously too desaturated in this test. Oklab's ancestor "IPT" also works fine.

It's lovely when I see dedication to an experiment: keeping a CRT on for a month to avoid affecting its color reproduction. From Fritz Ebner's 1998 dissertation: repository.rit.edu/theses/2858/ The same hue matching experiment data was used by Björn Ottosson when creating the Oklab color space.

Here's an unexpectedly brilliant introduction to perceptual color spaces www.youtube.com/watch?v=nJlZ...

I recently translated my book manuscript (it's about palettes) to Typst and been pretty happy so far. Today instead of writing I procrastinated by moving code snippets' line numbers over the left margin to salvage three extra characters of horizontal space😃

The Wikipedia page on Color appearance models at en.wikipedia.org/wiki/Color_a... surprisingly good: to the point but still feels comprehensive. Includes a quick comparison of different perceptual color spaces.

via the magic of laion_clap embeddings and umap, my live coding thingy has a sample browser at last!

What if Doom's "colormap" was computed in Oklab instead of RGB? A short article about it on my site: 30fps.net/pages/doom-o...

Silent Hill 4 uses interesting volumetric light / light glare approximation. Instead of drawing sprites at each light source, full-screen subdivided plane with procedural vertex colors is rendered and blended with game frame. #gamedev

Relatable😑 From: doomwiki.org/wiki/Carmack... The line in question: github.com/linguica/dmu...

A new article: Why CIELAB doesn’t improve median cut It's a common misconception that CIELAB will instantly improve palettes produced by the median cut algorithm. Unfortunately it's not that simple. 📜 30fps.net/pages/median... It gets pretty technical but I added some context to the intro.

Wow I didn't know Python has cute chained comparisons: "e.g., x < y <= z is equivalent to x < y and y <= z, except that y is evaluated only once (but in both cases z is not evaluated at all when x < y is found to be false)." docs.python.org/3/reference/...

A fun look into Source 2's precomputed visibility from a mapper's perspective: www.youtube.com/watch?v=XLT2... It's not a BSP anymore but an octree whose nodes get grouped into clusters. Spoiler: Visleaks can still happen😀

A cool collection of monitor and sensor filter subpixel patterns geometrian.com/resources/su...

New article on my site: Better sRGB to greyscale conversion The commonly used greyscale formula is slightly off when computed in gamma space but can it be fixed? 📜 30fps.net/pages/better...

My new visualization for color quantization algorithm execution, though still unfinished. Attached is the result for a simple 12-color median cut. Each box contains a subset of image colors with the X-axis as a chosen sort axis; Y is PCA for plotting. See how e.g. box 3 has unwanted greens in it.

New blog post! In "Billions of triangles in minutes" we'll walk through hierarchical cluster level of detail generation of, well, billions of triangles in minutes. Reposts welcome! zeux.io/2025/09/30/b...

I wrote a simple box collision resolution code today and made the classic mistake of not checking if box_a != box_b before testing for overlap. This was the bug that made me post my first programming question online 20 years ago or so! I was unaware of the <> Basic "not equals" operator at the time.

Tried to be clever with some NumPy array partitioning code and exchange two values with the "x[i], x[j] = x[j], x[i]" idiom. Nope: got to use "x[[i,j]] = x[[j, i]]" instead, see stackoverflow.com/a/47951813

A neat little paper from 2006 "A Median Cut Algorithm for Light Probe Sampling" where an environment map is compressed to a set of point lights using the median cut algorithm. Seems like a precursor to another 2007 paper where others cast the task as density estimation.

Got my flight sim taking keyboard input and using that to drive the aerodynamic control surfaces. One step closer to take-off! #gamedev #flightsim #physics 🛩️

N64brew user @boxingbruin.bsky.social continues to showcase more work that they've done for their Pickle64 project, their action-RPG platformer hybrid with dark souls-like boss fights.

There's a classic color transfer technique from 2001: convert source and target image to a decorrelated color space (Oklab works fine), make target's mean and stddev match the source, convert back to RGB. Using a palette image as a target is no problem :) Paper: home.cis.rit.edu/~cnspci/refe...

A short article on mapping pixel colors to the PICO-8 palette in the CAM16-UCS color space. Surprisingly, it didn't do much better than Oklab, which is derived from CAM16. 📜 30fps.net/pages/percep...

Got familiar with NumPy's structured arrays today. It's basically an Array Of Structs, where fields can of course be different types. Could be useful with binary files, but I used it to organize code. Adding a "record array" allows a nice `colors.r` access syntax. numpy.org/doc/stable/u...

Some fun with shader-based debug drawing: here I'm drawing an arrow for each path taken in the path tracer, starting with the pixel under the mouse cursor.

I finally added alpha support to VariQuant. It took a lot of head-scratching to make it work with both RGB and L*a*b*😅 I premultiply the alpha and handle it like the other color channels. For RGBA color distance I'm using Kornel Lesiński's clever formula: stackoverflow.com/a/8796867

Gamma correction seems to be one of those things where the more you read the less you know. Is it really true that the NTSC standard assumes a CRT gamma of 2.5 but encoding is done with 1/2.2 instead to add a little contrast boost? From Charles Poynton's 2002 article at poynton.ca/notes/colour...

I've been improving my "VariQuant" color quantization tool. It now supports more color spaces, locally optimal cuts that guarantee the next color cluster split is the one that gives greatest decrease in error, luminance weight scaling, HyAB distance, A/B toggle, and palettes can be saved as PNGs :)

meshoptimizer v0.25 is out! Featuring new simplification function that optimizes positions and attributes for appearance, experimental permissive mode to simplify faceted regions with selective seam preservation, regularization option for improved tessellation quality and deformation, multiple ...

I was studying the "XYB" color space today. It uses a cube root for gamma correction but instead of a linear "toe" like in sRGB, there's a bias in the inputs that gets subtracted afterwards. Should be simpler to compute. I was surprised how the curve doesn't reach 1.0 at the end!

Godot may get approximate specular light from baked directional lightmaps, which is huge github.com/godotengine/...

It's pretty cool how if you have a small number of samples and know their type of distribution, the standard deviation is better estimated using their range rather than via population standard deviation.

I've been improving my experimental color quantization tool. It now supports separate palette design and pixel mapping color spaces with their own lightness weights. I added that palette visualization today and it's fun to play around the parameters and see it evolve.

I wrote earlier of a PCA approximation which worked surprisingly well. After some discussions, I now finally have a clear counter example where it fails. If the channels are uncorrelated, the result is an average that's clearly wrong. Updated the article: 30fps.net/pages/approx...

Apparently in Python's dataclasses any member not set via the constructor gets ignored in equality checks. Both asserts pass in the code included code snippet. I put this example to a gist of it so I can reference it in the future: gist.github.com/pekkavaa/4a1...

I'm trying to keep compile times under control in my N64 renderer, so I opted for writing a couple simple STL types (e.g. vector) myself. Since in C++17 the STL headers have gotten quite big, I had extracted only the necessary parts, such as std::forward, to make it work. But GLIBC is of course GPL!

I open sourced a little C library for GDB file access. It's meant for N64 homebrew running in an emulator: github.com/pekkavaa/gdb... The main contribution here is perhaps the hooking Python script that works in old and partially-installed versions of GDB without its bundled Python helper modules.

Interesting to see how in the original "The Irradiance Volume" paper from 1998 they stored irradiance per discrete direction instead of smooth spherical harmonics. Makes sense of course, it's basically a cubemap.

A neat 3D example of fitting an oriented bounding box using the approximate first principal component method I wrote about. Note that in the bottom left corner there's a toggle button for comparing between the exact PCA (red) its approximation (green).

A new article on my site: Approximate first principal component It describes simple trick to estimate the direction of most spread of a bunch of points without running a full PCA. Includes my Python re-implementation and plots of some quick tests. 30fps.net/pages/approx...

I wanted to try using some experimental color quantization algorithms for a real project (on the N64) so I started working on a little GUI tool. Interactive parameter editing is already fun with that single color count slider😀 And tk's "Professional Motif Look" keeps expectations at the right level.

Oklab seems to work well for mapping pixels to palette colors. To make the task more fun (and difficult), I picked the PICO-8 color palette. "CAM16-UCS" is the very accurate, baseline perceptual color space, Oklab is an optimized version of it, and HyAB is L*a*b* with 2x absolute difference in L.

"Hallucinations on the future of real-time rendering", High Performance Graphics 2025 keynote: c0de517e.com/023_hpg.htm

I read that Xiolin Wu's 1991 (Wu91) color quantization works as a k-means initializer. It's box splitting but with a split plane that minimizes predicted total squared error after the split. I compared it to Variance Cut (VC) that always splits at mean. They are close but there's a clear difference.

I love how the PICO-8 has a separate 16-color "hidden palette" you can access by poking some simulated memory location and setting the highest bit of 8-bit color index to 1😃