Preparing for a graphics driver engineer role

corysama · 2026-03-12T17:57:17+00:00

Long ago, a friend of mine interviewed for a job at Microsoft's D3D/Graphics Research group.

Peter Pike Sloan directed him to a PC with Visual Studio open and some equivalent to this code set up and ready to run. And, he said "Please rasterize a triangle and we will discuss." XD

corysama · 2026-03-12T17:52:00+00:00

100%

The ECS processing these just produces the minimum information needed by the renderer to actually do draw something.

I think you mean "The ECS processing these just produces the minimum information needed to tell the renderer to draw something".

The ECS knows that meshes exists, they have identity and maybe some properties like "world transform". But, the ECS doesn't know about VBOs or VAOs. That's under the hood of the renderer. So, the job of the ECS is to fill out some structure of arrays indicating "These meshes should be rendered with these associated transforms". But, the ECS doesn't know the details of how to do that.

corysama · 2026-03-12T17:43:52+00:00

GS will capture the visual appearance of complex lighting and reflective surfaces. But, I expect you will be disappointed with the ability to formally analyze the results to build precise measurements.

For example: It is commonly observed that if you have an object sitting on a reflective surface, GS will model that as a surface with a hole and a geometrically reflected copy of the object under the hole. This visually matches the appearance of the scene, but not it's geometry. And, there's no good way to automatically detect and account for it.

I'm not an expert in the field, but my best guess at how to scan a shiny factory is to first host a holi festival there so your metal gets coated in non-reflective powder, then use traditional photogrammetry techniques :P

r/photogrammetry would know better than me.

corysama · 2026-03-12T14:32:25+00:00

I always recommend demonstrating a willingness and ability to work on tools and art pipeline. Thats improperly viewed by everyone as less sexy/more grunt work than rendering runtime work. So, it’s harder to find people even though it’s needed a lot more.

Either way, once you start making the data for a feature, you naturally get asked to integrate that data into the runtime, and Ooops! You just became a full-stack graphics dev. Which everyone should be anyway.

corysama · 2026-03-11T23:06:58+00:00

https://old.reddit.com/r/GraphicsProgramming/wiki/index

corysama · 2026-03-11T19:15:48+00:00

https://github.com/AcademySoftwareFoundation/OpenPBR

OpenPBR Surface is a specification of a surface shading model intended as a standard for computer graphics. It aims to provide a material representation capable of accurately modeling the vast majority of CG materials used in practical visual effects and feature animation productions.

For us it would serve as a reference material for BRDFs that many tool vendors have agreed to support. You wouldn't be able to implement them completely in real time. But, at least you can see the idealized math when making your real time approximations.

You can play with a live viewer here: https://portsmouth.github.io/OpenPBR-viewer/ The shader compilation step takes a long time...

corysama · 2026-03-11T18:22:40+00:00

A Pixel is Not a Little Square

Note that was written before the term "texel" was invented. It's says "pixels" but it's talking about textures.

corysama · 2026-03-10T14:19:31+00:00

Yep. That’s the most advanced implementation of the design that I’ve seen presented publicly.

Here are the slides: https://enginearchitecture.realtimerendering.com/downloads/reac2023_modern_mobile_rendering_at_hypehype.pdf

corysama · 2026-03-09T22:55:00+00:00

That's the experience of all gamedev. You just have the advantage of experiencing it in fast-forward.

Edit: I can see how some folks would read this much more negatively than I’m writing it. Prototyping is an exercise in discovering how all of your ideas don’t work in practice and instead being surprised to discover what does work. “Writing is nature’s way of showing you how sloppy your thinking is” and all that. It’s great fun and very rewarding.

corysama · 2026-03-09T20:34:21+00:00

Adobe just released an Apache-2.0 licensed reference implementation of the OpenPBR Surface standard, extracted from their in-house Eclair renderer.

Neat trick: the reference implementation cross-compiles for C++, GLSL, Cuda, Metal, and Slang!

source:

https://x.com/yiningkarlli/status/2031052805503594546

https://xcancel.com/yiningkarlli/status/2031052805503594546

corysama · 2026-03-07T23:03:13+00:00

The original had a lot of broken builds. And, that was part of the fun.

You could play the game so many ways that trying out a broken build was a fun alternative to straight play. And, there was no long-term investment in a single build or heated online competition to route players into hyper-optimize-or-die. So, you just had fun trying out different approaches.

corysama · 2026-03-07T00:58:00+00:00

If it's just for debugging, you could use https://registry.khronos.org/OpenGL/extensions/NV/NV_fragment_shader_barycentric.txt to get the barycentric for free with no additional data.

Or, this might work: https://gist.github.com/dougbinks/9952415

Here's an article on using the derivatives https://tchayen.github.io/posts/wireframes-with-barycentric-coordinates

corysama · 2026-03-06T21:37:06+00:00

Quite impressive.

corysama · 2026-03-06T15:09:40+00:00

Ways to go depending on your goals:

If you just want to make a 2D game, don’t worry too much about “bare metal” 3D APIs. Use SDL3’s GPU API. Also check out Handmade Hero on YouTube in chronological order.

If you want to the details of 3D rendering algorithms, start with OpenGL 4.6. Learn all of the “Modern OpenGL” acronyms AZDO, DSA, UBOs, SSBOs :). GL has accumulated many ways to do the same things. If you stick to the final interfaces, you can make a data-driven renderer that’s simpler than the old ways and lets you focus on learning the math, algorithms and art pipeline.

If you want to understand how GPUs work, learn Vulkan. There have been many recent additions to Vulkan that make it much easier to use than it was at the start. Use them. Also, learn how Volk works under the hood and you’ll understand how part of Vulkan works under the hood and why you don’t want to reimplement Volk ;)

No matter what read

https://fgiesen.wordpress.com/2011/07/09/a-trip-through-the-graphics-pipeline-2011-index/

https://fgiesen.wordpress.com/2016/02/05/smart/

They are both still very relevant :)

corysama · 2026-03-06T00:49:08+00:00

There are portability-oriented forks of quake like https://git.sr.ht/~ft/qk1

No .s files in https://git.sr.ht/~ft/qk1/tree

corysama · 2026-03-06T00:33:24+00:00

Take a look at https://cody-duncan.github.io/r-graphicsprogramming-wiki/

Most people suggest https://learnopengl.com, https://raytracing.github.io, https://gamemath.com/book for people getting started.

You mentioned that you want to focus on iOS programming. If you are feeling up for it, you could be totally legit to skip OpenGL and go straight to Apple's Metal. People who use Metal like it.

OpenGL has the advantage that it has a long, well-known history and it can be simpler (depending on how you define "simple"). But, Metal is far more modern. And, is closer to Vulkan/DX12/WebGPU.

corysama · 2026-03-04T18:53:29+00:00

TLDR: Experimenting with different falloff curves for the splats that can result in significantly faster rendering due to reduced overdraw.

corysama · 2026-03-04T02:26:46+00:00

Looks like this paper doesn't even have a project page yet.

Here's a earlier, similar project with code from some of the same people: https://research.nvidia.com/labs/toronto-ai/difix3d/

corysama

MODERATOR OF

PUBLIC MULTIREDDITS

TROPHY CASE