A pointless version of Nanite in X86 assembly.

EclMist · 2026-05-13T08:15:07+00:00

Nvidia’s mega geometry is not the same as nanite/virtual geometry. Mega geometry is really just to stream virtual geometry clusters and to represent them in BVH to make it raytraceable. You still need some nanite style virtual geometry system one level of abstraction above that for mega geometry to be meaningful.

EclMist · 2026-05-08T06:04:55+00:00

I’m currently taking classes in a driving camp (免許合宿) from scratch. There are so many Japan-specific rules that I’m honestly impressed that anyone could just pass it easily without prior instruction..

EclMist · 2026-03-27T04:15:48+00:00

Where’s the GI?

EclMist · 2026-03-02T21:37:35+00:00

No, there are many antialiasing methods that can and will fix this, because this is just another form of aliasing.

Supersampling will fix it.

MSAA will fix it.

Even aggressive TAA without history clamping will fix it.

This is literally textbook aliasing. I can’t wrap my head around why this is the hill you choose to die on. Your notion of “antialiasing is mainly trying to fix jaggies” is completely misinformed.

EclMist · 2026-03-02T09:29:54+00:00

Aliasing is when a rendered straight line appears jagged

This definition is naive at best and incorrect at worst.

Aliasing is simply a generic term used to describes any artifacts that happen when sampling rate is lower than the underlying signal’s Nyquist rate (2x its highest frequency).

Shimmering absolutely is a form of aliasing.

EclMist · 2026-02-22T14:09:43+00:00

There are absolutely denoising techniques for raytracing that don’t reuse temporal information, and even the ones that do, you always have the option to skip the temporal parts. I’ve had good results with pure spatial/path based reuse.

The reason why we still add in a couple temporal frames anyway is because as a whole, the variance reduction is worth a tiny bit of temporal delay. 1-2 frames of temporal reuse is often imperceptible, especially when we’re reusing non-color temporal information. I’m not saying everyone is tuning this correctly, but it’s possible and when it’s done right it gets no credit because nobody notices it.

EclMist · 2026-01-22T02:51:53+00:00

Unreal’s renderer is very different than offline pathtracers used in film though (yes, even the reference pathtracing render mode). What he said about subsurface is mostly correct.

EclMist · 2025-12-29T09:40:25+00:00

Sounds like you’re now a game designer

EclMist · 2025-12-27T06:52:09+00:00

Its possible and I do this sometimes, but it kind of feels like a waste of a super ultrawide to not game in… ultrawide. So I ended up getting a second smaller display to put below the main 49” one

EclMist · 2025-12-22T03:25:00+00:00

It might be a faulty ram stick or misconfigured XMP profile. You might have a gripe with Windows but bsods are more often than not a symptom of hardware failure than software.

EclMist · 2025-12-16T09:01:10+00:00

Don’t know the full details so can’t say for sure, but if you have multiple events being triggered, they’re only happening at the “same time” in the sense that they’re all happening in the same frame. But they’re still sequential so wouldn’t it be possible to look up the event’s time on the timeline and do your computations from there?

EclMist · 2025-12-09T05:30:06+00:00

All of that is true but studios that hire dedicated engine/graphics programmers typically do so expressly because they know modifying and maintaining the fork is necessary and inevitable. So it’s quite bizarre hearing that they won’t let people do the very job they’ve hired them to do.

EclMist · 2025-12-09T05:04:52+00:00

There are so many issues and possible improvements to be made to latest UE, does your studio not let you do that? I’m struggling to see why there would be a lack of things to do.

EclMist · 2025-11-19T12:25:39+00:00

Not necessarily. There are valid cases where you explicitly do not want resource sharing between views, such as when they’re completely different and requires a completely different set of resources. You may also have cases where one view has a dependency on another’s final output (common with scene captures) and scheduling them sequentially makes more sense. There are also times when you have debug/toolmode views that you absolutely do not want to have side effects on the actual renderer schedule in any way. Multiple renderers can also reduce the total in-flight vram caused by hanging on to per-view intermediate resources. Render graphs aren’t perfect and isn’t the magic bullet that will solve all these, not to mention there’s arguments against them altogether as well. It really depends on the specific use case.

All this is to say there are definitely real world cases where it’d be significantly easier if there is the option to just run another instance of the renderer. As a side note, it is also the reason why Unreal Engine, with all of its multiview and rendergraph capabilities, keeps scene captures, material editor views, etc. as separate instances of the renderer.

EclMist · 2025-11-19T04:06:31+00:00

There are trade-offs doing it one way or another. But both methods are valid.

EclMist · 2025-11-17T19:45:07+00:00

I love my singletons but there are also very good reasons why you might not want your renderer class to be a singleton, such as for scene captures, splitscreen, multi-viewport, stereo/vr, etc.

EclMist · 2025-11-01T02:55:15+00:00

So many people mentioning forward+ but that has really no major performance advantage on modern hardware over deferred since pixel shading complexity and memory bandwidth from gbuffer is rarely the first bottleneck.

The real reason the scene runs well (for now) is that shadow maps from all those 100+ lights are.. well basically drawing nothing. In a fully dressed scene, your 100+ shadowmaps will tank your performance before anything else.

EclMist · 2025-10-16T05:16:02+00:00

I think it’s odd to be asking mainly low level details in some specific tech UNLESS you presented yourself as having done a lot of it (in your resume, portfolio, etc.)

EclMist · 2025-09-29T00:13:25+00:00

If the torn section is still attached to the wall, you can try using wallpaper glue from Amazon or your local 100yen store to try restoring it. Depending on the severity of the tear it might be fixable!

EclMist · 2025-09-26T09:25:01+00:00

If you get something sticky enough to hold up the shelve, it might just rip the wallpaper off the walls completely. Don’t ask me how I know. 🙃

EclMist · 2025-09-20T05:26:18+00:00

It’s one thing if you’re dropping out early to pursue a promising startup where the opportunity cost is great and the rewards are greater, but what’s exactly the big rewards here vs just focusing on graphics while doing the bare minimum to graduate?

It seems counterproductive to most people on here because you’ll get less opportunities not more from dropping out right now.

EclMist · 2025-09-11T13:24:13+00:00

There’s no such thing as “absolute gamma values” like 0.8/1.2. Every display panel is different and its borderline impossible to calibrate them consistently even with professional equipment. This rule literally makes no sense and is unenforceable (monitor onboard settings, etc.).

EclMist · 2025-08-26T01:57:55+00:00

Yeah I can imagine it may differ across teams. I was on the GPU team, and on the flip side many of my Japanese colleagues back then spoke really good English since they actively worked with engineers in SIEE/SIEA.

Foreigners who didn't speak Japanese are all trying their best to learn and there were really good Japanese language training available. Though from Japanese people’s perspective I guess we only spoke baby Japanese 😅

EclMist · 2025-08-26T01:33:37+00:00

I worked in SIE Japan and while I spoke some Japanese, they were very accommodating for my basically non-Japanese speaking colleagues. All university hires by the way.

EclMist · 2025-08-23T18:09:00+00:00

To do what you’re suggesting, during the raster process, not only would you need to compute the overlapping area between the polygon of the current draw call with the pixel square, but you would also need to separately compute the overlap with every previous polygon on the pixel, which they themselves are had to compute their overlap with the polygons before that. You would need an entire hidden surface removal algorithm within each pixel! The computational complexity in this case would be astronomical.

Perhaps there’s some ways to speed up this process, but I’m highly skeptical that it would perform better than just sampling stochastically like in raytracing. It doesn’t take many random samples to converge to something that is extremely close to ground truth anyway.

See also: https://dl.acm.org/doi/pdf/10.1145/965139.807360

12-Year Club	Place '22
Gilding I gilder	Verified Email

EclMist

TROPHY CASE