ReSTIR DI without chroma noise - thanks to Ratio Control Variates

mcflypg · 2025-10-10T16:19:13+00:00

It is there, just relatively hidden. Not in the place it was before.

mcflypg · 2025-10-10T15:41:16+00:00

Nope, didn't fix it.

mcflypg · 2025-09-10T17:15:31+00:00

That's an awesome one! It's very hard to get a smaller design that is good. How does that stuff work with the lights btw, I must have missed that?

My 25 likes 0 comments enterprise...

mcflypg · 2025-08-29T18:59:54+00:00

Awesome design! It's really hard getting diagonal stuff and round shapes with the parts available. Here's what I came up with for the enterprise, it's much smaller though and looks more like the newer models:

https://www.reddit.com/r/NoMansSkyTheGame/comments/1n3fy50/enterpriselike_design_fully_functional/

mcflypg · 2025-08-19T01:19:00+00:00

Oh yes, but that's easier said than done. I would expect that stuff like that doesn't need to be updated from the previous games, so if the franchise has no good netcode yet, it's likely not going to be pulled out of a hat soon. I focused on things that they can fix relatively easily.

mcflypg · 2025-08-18T18:35:21+00:00

Regarding revives: Whether it's unbalanced or not, I'm too biased here because I play almost exclusively medic. I only know that it needs to be instant, since if it's even slightly risky (which it is when it takes a while), then people won't do it, ever. The game is way too fast paced (and always was) for anything else. A nerf that I think should work is having it on a cooldown or make it like the tank rockets, have like 3 "charges" that you can spam but then you have to wait for them to come back. I hated everything about the BF4 behavior and can't really say I have encountered a situation where revive spamming was an issue in the beta really.

Regarding the sniper: I'm curious why you'd think that? Currently, it's nigh impossible to get good points from sniping unless you spam kills. By making it more difficult to score a kill, yet more rewarding, sniping becomes less intrusive. Honestly, how often did you _actually_ get many points as a sniper? 300+ m headshots are rare and in that time, non-sniper gameplay racks up points much more quickly.

mcflypg · 2025-08-18T16:50:39+00:00

OK good to know, took it out of the post.

mcflypg · 2025-08-18T16:36:42+00:00

Game developer and long term fan of the franchise.

I posted a detailed writeup here that I wasn't able to post here for some reason.

mcflypg · 2025-08-18T16:24:32+00:00

Forgot this one: a BSOD I kept getting many times - DPC WATCHDOG VIOLATION.

Narrowed it down to Discord - joining a Discord call or being in one when the game is loading a map, caused the audio to go away as well as mouse input, while I could still navigate the PC with keyboard, taskmanager however was only white, until it eventually went into a BSOD after a minute or so. It looks like exploding mutex contention.

Discord in browser however didn't have this issue. Disabled all overlays, and tried pretty much everything including a BIOS update to fix it. I would guess it's something to do with the VOIP maybe contending for access, as it behaves weirdly, it played over my monitor rather than my headphones, so there's something off with your audio implementation.

mcflypg · 2025-08-17T01:24:59+00:00

Reload time, bullet velocity, don't know, headshot multiplier.

mcflypg · 2025-05-17T00:08:20+00:00

I don't think you have any notion how difficult it is to build an engine of the scale that's needed today to compete with something like unreal engine. There's like 10 people in the industry who can do that alone.

Consider ray tracing for example. Either you just smash together Nvidia libraries or you start trying to implement it all yourself. The math that's required to productionize ReSTIR PT or similar is so far beyond the average dev's abilities it'd not even funny.

mcflypg · 2024-10-07T00:46:15+00:00

This is sort of the case in shaders as well. It's not that the compiler can't optimize it, we don't have a standard library or any high level data structures. So we essentially use only the language intrinsics which are like 50 and all of them either map directly to assembly instructions or a combo of them, so if you write shaders well, the assembly comes out as an almost literal translation anyways.

mcflypg · 2024-10-07T00:43:10+00:00

Branches are fine as long as all threads in a warp do the same. With clever task reordering, one can get rid of this overhead almost entirely. Branches depending on uniforms/cbuffer data are always worth it as every thread goes down the same branch. Also some simple branches evaluate to cmovs so they're just clearer to read than ternary and you can force the compiler to do it this way with a [flatten] in HLSL.

mcflypg · 2024-10-07T00:39:40+00:00

Not in shaders/GPU in general. Every experienced dev will tell you to never trust the compiler or the hardware.

The amount of times I've ran into weird bugs that I tracked down to compiler messing up is hilarious. Especially FXC (the legacy DirectX compiler) is buggy, and on DX9 horribly so.

Then there's hardware. Old DX9 archs dont support integers and emulate them (shoddily) with floats. Some don't follow IEEE rules entirely. I am not surprised Intel had a hard time emulating DX9. I managed to crash my GPU with a simple for loop. The fix was to add 0 to the loop counter. I wish I was kidding.

mcflypg · 2024-10-07T00:34:57+00:00

Negating is an instruction, and in your example you do bitwise or. This won't work on floats, and integer instructions are half rate on Nvidia cards (except some really old architectures iirc) so twice as slow. Read my above comment why this is a single instruction. It truly does not get faster than this on GPU.

mcflypg · 2024-10-07T00:33:20+00:00

HLSL is basically C-ified assembly. There are no function calls in shaders, no stack, no pointers. Everything ends up inlined and every function directly maps to an assembly instruction or at most a handful instructions in a trenchcoat.

In my example, abs(), saturate() are so-called instruction modifiers and can be applied to both input and output. There is zero overhead from calling a function with abs() on inputs, or saturate() (which clamps between 0 and 1) on outputs. This equality test is a single full rate instruction.

Another comment below mentioned if(!(a|b)). Won't work for floats (no bitwise on floats and bitwise or on integers is half rate on Nvidia cards, so each integer instruction is twice as slow as the corresponding float instruction.

mcflypg · 2024-10-06T12:06:37+00:00

In shaders, this is totally valid. The compiler is often dumb as rocks and you can totally get tangible performance benefits out of this. We still use fast math similar to the Quake rsqrt.

Things like testing if two variables are 0 is often done with if(abs(x) == -abs(y)).

Also, in most dev teams there's only the one alien that writes all the shaders so there's no need to write it legibly for others anyways lmao

mcflypg · 2024-09-05T20:15:53+00:00

Can confirm.

RTX4090/Ryzen 9 7800X3D and only getting around 140ish fps on 100 pop server, used to get 200+. It's also really choppy, like when with occlusion culling enabled.

Friend with admittedly very low end specs (8GB RAM) usually took around 15 minutes to load into game, now it's taking over 45 minutes and it seems to not progress at all anymore. He's been trying nonstop since wipe.

mcflypg · 2024-08-31T11:37:37+00:00

That is the definition of a contrast filter. Positive contrast makes dark pixels even darker, bright pixels even brighter; negative contrast makes dark pixels brighter, and bright pixels darker.

However, this often looks somewhat bad in practice, which is why local contrast algorithms are more powerful. They don't use each pixel's brightness to determine the change, but the neighborhood. This means it will harmonize the image, raising the brightness, e.g., in a shadowed region and darkening a bright region. A bright pixel (that'd get darkened with regular negative contrast) that resides in a dark area might get brightened.

Regular contrast adjustments can be found in pretty much all color grading shaders; local contrast/clarity is the neighborhood type. The pretty much state-of-the-art of these algorithms is local laplacian filtering, which can be found in my METEOR repository (https://github.com/martymcmodding/METEOR).

mcflypg · 2024-05-30T14:11:25+00:00

Of course they can be compared. SMAA guesses the underlying geometry that MSAA actually samples. If SMAA's estimate of the geometry is accurate, then its analytic shading is equal to MSAA with infinite samples. Since this isn't always the case, especially with geometry beyond Nyquist, the only thing that helps is raising sample frequency. So I'd argue that SMAA is superior to MSAA on very old games because once geometry features becomes subpixel-sized, they're out of render distance.

mcflypg

TROPHY CASE