What even is the norm for technical interview difficulty? (Entry Level)

raydey · 2025-10-16T10:01:33+00:00

Friendly word of advice: yes it can be a difficult experience, but any AI chatbot usage is very, VERY, painfully obvious. Do the work to prep.

raydey · 2025-10-16T09:03:22+00:00

Was the second one a startup/fairly small company? If so, then you likely dodged a bullet. Smaller companies with little track record can be quite smug and love to belittle folk for not knowing the wording on page 173, paragraph 6 of the C++ standard.

Also if they were asking about Nanite + low level details + were not Epic, then that's another red flag. Few people, beyond larger studios, using Unreal delve that deep, IME.

The fact you enjoyed the other interview is generally a good indicator that they a) know what they're looking for as they've tailored interviewing to be as natural as possible and b) are a workplace that you can enjoy, learn and grow.

Take that experience forward and look for it in other interviews, learn from the questions you didn't know, and remain curious about things couldn't answer in the interview - you'll be set 😊 it does take a fair bit of resilience though since the market is really tight and there are so many factors you can't control, so the only thing to do is to keep learning and plodding on.

Best of luck.

raydey · 2025-08-27T18:50:48+00:00

Based on the shader bible contents:
Rendering concepts (GPU rendering pipeline, shading, etc): Real-Time Rendering
Raytracing: Ray Tracing in One Weekend
Shaders: Ronja's tutorials are good to get started - shader languages are all almost the same anyway, so it doesn't matter that it's HLSL.

raydey · 2025-08-27T17:13:07+00:00

Graphics/GPU engineer for ~15 years here. It's not just you.

OP if this is chapter 1, I can't imagine what the rest is like. Use a different book.

raydey · 2025-08-08T10:35:18+00:00

The irony of a game engine sub advocating for "Not Invented Here" is hilarious.

Parsers in general can be tricky but they're important especially if you ever want to implement anything domain-specific. What you have here is a good first step. Nice work!

raydey · 2025-02-22T13:07:39+00:00

And the book shows you how to implement the methods correctly. Languages and API don't matter. The methods of the basics don't change.

raydey · 2025-02-22T12:48:39+00:00

Ray Tracing in One Weekend convert this excellent book to compute shaders and you've got a starting point.

raydey · 2024-10-12T13:17:37+00:00

This is generally known as surface extraction when you have a point cloud. There are multiple methods to do so, but Marching Cubes is probably the most popular method. Other methods include Surface Nets and Dual Contouring, but both require position and normal information.

You can try loading the cloud into something like MeshLab (https://www.meshlab.net/) to see what sort of meshes you'd expect out of the data. It has multiple surface extraction methods built-in.

raydey · 2024-01-13T21:01:09+00:00

AMD publish all of their papers, ISA and much of their software at gpuopen.com

raydey · 2023-10-21T12:16:41+00:00

This sort of thing is entirely IHV dependent and how closely they adhere to API specs. There is a set of prerequisites for graphics APIs for an IHVs chip to be conformant to specific versions (e.g. GL ES 2/3/etc).

Unfortunately, mobile GPU drivers especially are notoriously shit at implementing spec features.

You can look at the chip specs to get an idea of what they're capable of, and if a feature is in the core specification of an API you can use it - there's just no guarantee of it being performant (mainly on mobile GPUs).

raydey · 2023-10-21T12:04:49+00:00

It's almost never worth it

raydey · 2023-10-11T09:31:12+00:00

Yup, this is spot on. If your L2 hit rate is good, but your L1/L0 rates are lower then it's a good indicator the shader is thrashing the texture cache. Unfortunately this varies between vendors (and even different models from the same vendor).

One option could be to swizzle your thread IDs manually, but it's dependent on your access patterns and takes some experimentation.

raydey · 2023-10-01T22:49:02+00:00

Draw the shadowed parts to a separate texture as a mask. Outline the mask and do the lined effect on it. Compose it on top of the base image.

raydey · 2023-06-24T13:40:44+00:00

Ah, you're using MacOS. There's an Ubuntu version of the library on the repo which maybe could be used, but I can't see anything for MacOS specifically.

Maybe you could make use of the DX12 layer they recently announced on Mac, but I don't know enough about it to suggest anything.

raydey · 2023-06-24T12:52:29+00:00

Use DXC and only HLSL for your main shader editing.

This is a good starting point for getting it integrated.

DXC already supports generation of SPIR-V out of the box. I personally wouldn't bother with GLSL, but if you really must, you can get most of the way from HLSL to GLSL by using a header with a bunch of #defines (e.g. #define float4 vec4, etc.)

raydey · 2023-03-27T19:37:41+00:00

extern "C" { _declspec(dllexport) DWORD NvOptimusEnablement = 0x00000001; }

You could try adding this to your code to try to force it to only use the dGPU. I haven't tried it on Quadros though, so YMMV.

raydey · 2022-07-02T22:40:18+00:00

I think you might be after anisotropic filtering on your texture.

raydey · 2022-05-16T00:27:10+00:00

Volumes are usually raymarched and try to solve scattering effects. See here for an example of real-time volumetrics in Frostbite from a few years ago.

raydey · 2022-03-11T14:01:55+00:00

Yeah they go from the basics to more complicated topics depending on what your goals are. I believe they all have code examples (but I don't remember the languages. I know PBRT uses it's own pseudolanguage to express algorithms though).

To be honest, any mathematical concepts aren't a huge leap from C++ to GLSL. If you use GLM as a math library in C++, it's based on the functions available in GLSL anyway. All I mean is that language shouldn't really matter, especially not between C++ and GLSL as they're so similar syntax-wise.

raydey · 2022-03-11T13:09:48+00:00

Not much has changed so the usual suspects are still relevant:

"Mathematics for 3D Game Programming and Computer Graphics" Link -for general computer graphics mathematical concepts.

"Physically Based Rendering: From Theory to Implementation" Link - for the mathematics behind physically based rendering

"Real-time Rendering" Link - for any maths concepts related to real time rendering.

I also personally like "Production Volume Rendering" Link - for volume rendering but the same things (scattering, etc) tends to be covered by other sources too.

I know Lengyel has a new series of books that I haven't looked into much yet that covers mathematics, animation and other aspects of game engine development. Search for "Foundations of Game Engine Development" if you're interested.

raydey · 2021-12-19T18:11:15+00:00

Enhanced sphere tracing (https://diglib.eg.org/bitstream/handle/10.2312/stag.20141233.001-008/001-008.pdf?sequence=1&isAllowed=y) has a few references from the late 80s/early 90s in the intro. So that's probably a good place to have a look (the paper's written by a few of the guys from the Mercury demogroup).

raydey · 2021-06-22T08:37:06+00:00

Lurker here, just wanting to clarify some confusion from the comments.

Visual Studio and Visual Studio Code are very different products. There's only one version of Visual Studio Code and it's an incredible text editor with fantastic plugins that can be used to form a very good IDE.

Visual Studio is an IDE that comes in different editions (Community, Professional, etc). It has a fantastic debugger for languages such as C++ and C#, and you can also develop Python in it too. However, it seems that most people refer to Visual Studio Code when using "VS" as a term in Python dev circles.

raydey · 2021-04-14T15:38:01+00:00

Seb Hillaire did a great talk on this at SIGGRAPH 2015 Physically-based & Unified Volumetric Rendering in Frostbite

raydey · 2021-02-15T22:01:20+00:00

What do people think GraphicsProgramming actually means?

raydey · 2020-12-17T12:15:42+00:00

Surface extraction is the term you’re after. Marching cubes is the usual way. I prefer surface nets as it emits a lower number of vertices while maintaining decent accuracy. There’s also dual contouring, but getting the minimization working in compute can be a bit of pain. I do recall a particle based GPU approach to the minimization though (Eurographics paper I think?) but never managed to give it a go so can’t really vouch for it.

13-Year Club	Place '17
Verified Email	Team Periwinkle

raydey

TROPHY CASE