Hmm yeah I see
#Fwog and co.
oak garden
So the compiled backend should have them just fine I guess, even when calling from rust
long robin
yeah
the shader tool bakes the shader permutations and reflection data into a bunch of headers
oh btw my epic glUniform calls don't work on AMD 
glGetUniformLocation returns -1 for those
oak garden
long robin
time to make vendor-specific paths
oak garden
wouldnt the workaround also work on nvidia
long robin
the workaround I was thinking of would be to simply use the high bindings on AMD, which doesn't work on NV
long robin
orrrrrrr I can figure something else out
dapper gorge
I love how Intel is completely out of the equation
I have a laptop with a 12th gen intel chip because the ryzen models were all sold out 😭
I guess I'll just be running my app on my main machine
oak garden
I love how Intel is completely out of the equation <:bleakekw:108259835030353924...
not a real vendor
long robin
GL_MAX_IMAGE_UNITS on arc is 8, which means I have to do whatever I do for NV and pray that it works
I'd rather not have to make a hack though
I really just want glslang to automap bindings but not be dumb by starting at a uselessly high index
long robin
I finally figured out how to manipulate glslang into doing what I want
I just needed these flags
--amb --stb comp 8 --ssb comp 8 --suavb comp 0 --sib comp 0
long robin
the idea is to force textures and samplers to start at index 8, then auto-mapped bindings for images will start at index 0
oak garden
right i see
dapper gorge
Very nice
long robin
guess it means I can remove le hacks now
dapper gorge
Let us know if it works fine
if it does execute le push
So that I can execute le pull
long robin
the current thing works on nvidia atm
so you can le pull whenever
you have an nv gpu, right?
dapper gorge
Yes
long robin
then it should Just Work™️ as the uploaded version has the glUniform hack
dapper gorge
Inshallah pull I must
"The current GL state uses a sampler (6) that has depth comparisons disabled, with a texture object (56) with a depth format, by a shader that samples it with a shadow sampler. This will result in undefined behavior." 
long robin
ignore it
long robin
it's annoying because these things are reported before the actual draw
long robin
long robin
uh
these are the samplers that the gl backend creates
the only shadow sampler that I made is in the gltf viewer sample in fwog, which you are apparently not building
long robin
glBindSampler(theUnitYouWantToUnbind, 0);
dapper gorge
Which units do you bind
dapper gorge
Interesting
long robin
all my homies love using sampler objects
dapper gorge
I will now do something that for sure does NOT involve a for (i = 0 to GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS)
oak garden
dapper gorge
Would you look at that, it worked NOT doing that thing I very explicitly said I wasn't going to do!
oak garden
incredible
long robin
now would be a good time to start using shrimpler objects yourself
dapper gorge
I suppose so
oak garden
so afaik fsr2 is an upscaling thing but would you also do aa with it by downscaling again or something like that?
dapper gorge
I think render resolution and present resolution being equal should be TAA
dapper gorge
Or well, the best TAA AMD could come up with
long robin
it's also TAA even when it's upscaling
oak garden
very cool
yeh ill definitely replace my crappy MSAA with it once i get the bindings sorted out
long robin
but you could get even more AA by combining FSR 2 with supersampling, I suppose
probably not huge gains I'd imagine
long robin
yeh ill definitely replace my crappy MSAA with it once i get the bindings sorted...
ye MSAA and FSR 2 don't mix anyways
oak garden
dapper gorge
Holy shit
Now this is some good TAA
Compared to that garbage I did this is incredible
Big blurry mess when moving though (my fault) 
How does FSR2 want its motion vectors again?
long robin
I rendered mine as rg16f, then passed {renderWidth, renderHeight} to the motion vector scale param
||it still artifacts, but not too badly I guess ||
oak garden
long robin
no motion vs me shaking the camera violently
oak garden
honestly not that bad
long robin
yeah it's better than I expected
maybe I did integrate it properly
well, I'm still missing proper motion vectors on the skybox
but idk, it still seems more aliased under motion compared to the vulkan sample
oak garden
opengl issue
dapper gorge
It's a bit too sharp maybe?
dapper gorge
Ah, yeah I did 😛
It do be kinda iffy when shaking your mouse violently
But under normal human being conditions it's great
oak garden
i mean this is zoomed in
dapper gorge
Yeah we're pixel picking, it's great, thank you Jaker
I will make sure to pay you in pretty pictures
Like this frog, for example
oak garden
long robin
Might be worth taking a look at the fsr2 cauldron samples btw
oak garden
did you delete the media submodule in your 🍴
long robin
It seemed like the image was cleaner than my own
shell inlet
I don't remember fsr2 being this bad when shaking camera
long robin
did you delete the media submodule in your 🍴
I didn't explicitly delete it
oak garden
i fought git submodules for a while to get rid of it because downloading a couple gb of assets isnt exactly great
long robin
I don't remember fsr2 being this bad when shaking camera
I'm guessing my motion vectors are still slightly wack
shell inlet
how calculate?
dapper gorge
ndc_prev - ndc_curr
long robin
Variables are poorly named
I tried calculating motion vectors by doing the world->ndc transform in the fs, then subtracting, but somehow that made my motion vectors huge
shell inlet
format for mv image?
long robin
rg16f
shell inlet
both seem fine
shell inlet
I tried calculating motion vectors by doing the world->ndc transform in the fs, ...
?
passed fragment world to fs?
long robin
yeah
long robin
I feel like I made a mistake, but it was like 2 lines of code so idk lmao
shell inlet
did you set proper motion vector scale?
If your application computes motion vectors in another space - for example normalized device coordinate space - then you may use the motionVectorScale field of the FfxFsr2DispatchDescription structure to instruct FSR2 to adjust them to match the expected range for FSR2. The code examples below illustrate how motion vectors may be scaled to screen space. The example HLSL and C++ code below illustrates how NDC-space motion vectors can be scaled using the FSR2 host API.
dispatchParameters.motionVectorScale.x = (float)renderWidth;
dispatchParameters.motionVectorScale.y = (float)renderHeight;
also lol that formatting
I also tried different permutations of negating the jitter Y, but the current config seems to be the most stable
dapper gorge
Damn, FSR2 is taking 2ms
long robin
what gpu
dapper gorge
3070 currently
long robin
what resolution?
dapper gorge
A little under 1080p
long robin
oh and what upscaling factor
dapper gorge
None, render and present resolutions are equal
long robin
ah
fsr2 isn't optimized for pure TAA, but your perf shouldn't be that bad still
perf should be closer to 1ms according to this chart (looking at the 6800 column)
https://github.com/JuanDiegoMontoya/FidelityFX-FSR2#performance
dapper gorge
Here's the breakdown btw
long robin
I'm doing a lot of suboptimal things in the backend
- excess memory barriers
- excess gl calls (glGetUniformLocation and glUniform1i)
- no fp16
- no subgroups
also, the persistently mapped buffers may not be offering the best performance
I think no subgroups hurts perf a lot in the SPD pass
not sure about no fp16 though
dapper gorge
Completely unrelated, but do you know why my second and third cascade take so much longer to render?
long robin
yeah, they're rendering more stuff
dapper gorge
The second, third and fourth cascade have the same amounts of (indirect) drawcalls
dapper gorge
Only frustum
long robin
the later cascades should have larger frustums, no?
dapper gorge
Yeah but I'm using a very low lambda so 2nd 3rd and 4th enclose the whole bistro
shell inlet
@long robin check this out https://github.com/GPUOpen-Effects/FidelityFX-FSR2/issues/22
long robin
Yeah but I'm using a very low lambda so 2nd 3rd and 4th enclose the whole bistro
it's not a surprise to me that it would take longer than the first cascade then
dapper gorge
Of course, but the problem is the second cascade
it takes 0.66ms while the third takes 1.5ms
dapper gorge
Yes
You can see compute warps skyrocket in the third cascade too
But there's no in here dispatch...
long robin
and unit throughput goes wack on the third cascade
dapper gorge
Ah well I'll figure it out, I'll stop leaking my thread into this lol
shell inlet
trying to find fsr2 code that does sampling with motion vectors
why is it so hard
it had to be the most convoluted code ever
so they say
For example, a motion vector for a pixel in the upper-left corner of the screen with a value of <width, height> would represent a motion that traversed the full width and height of the input surfaces, originating from the bottom-right corner.
doesn't that mean that the scale is actually width/2 and height/2? If ndc is [-1; 1], such that from say (-1, -1), you travel to (1, 1) the distance is 2 on each axis, then you want to scale such that
(1 - (-1))x = width
2x = width
x = width/2
@long robin plz respond
don't tell me ur already asleep
golden schooner
long robin
I was afk
long robin
doesn't that mean that the scale is actually width/2 and height/2? If ndc is [-1...
Yeah that's what it would seem like
I'll test when I'm no longer on the john ||producing my best code||
oak garden
it had to be the most convoluted code ever
its extremely well documented 
long robin
the empty line after all the enum names annoys me 😩
oak garden
me too lol
long robin
however, it is consistent 😃
long robin
well, you see, um
oak garden
golden schooner
at least the * is left at the type
oak garden
As it should
golden schooner
i have a huge respect for you jaker
for dinglefarting all that together within a few days 🙂
oak garden
Yeah thats honestly quite impressive
golden schooner
working as intended or not
long robin
shell inlet
I'll test when I'm no longer on the john ||producing my best code||
john amd?
long robin
the other john
dapper gorge
Competitor John
long robin
hmm it seems like simply dividing the motion vector scale by 2 fixed things
oak garden
that seems so random
long robin
oak garden
that looks quite nice
long robin
there is still a little flickering under no motion, but I think that's caused by the high frequency detail in the scene
normally there would be indirect lighting to reduce the contrast
oak garden
do you happen to know if ffxFsr2ContextDispatch is thread safe?
long robin
wdym
oak garden
or just access to the context in general
tbh not that i would ever call it from different threads
just curious if i should wrap it for safety
oak garden
right for opengl it wouldnt be very safe ofc
long robin
you cannot call it from multiple threads simultaneously
long robin
not sure why you'd want to do that anyways
oak garden
yeah true
ill just put a little disclaimer
the bindings are done i think so i can start integrating
long robin
you can call it from a different thread than the one that initialized it
oak garden
thats good enough
long robin
but not multiple threads at once
oak garden
long robin
the context and backend each store a bunch of state that gets modified when you dispatch
and the state is modified in a non-atomic way, so overlapping dispatches would fook everything up
oak garden
yeah makes sense
i havent really looked at the impl
just mindlessly copied headers to rust 
long robin
take a look at these files to see what kind of state there is
https://github.com/JuanDiegoMontoya/FidelityFX-FSR2/blob/master/src/ffx-fsr2-api/gl/ffx_fsr2_gl.cpp
https://github.com/JuanDiegoMontoya/FidelityFX-FSR2/blob/master/src/ffx-fsr2-api/ffx_fsr2.cpp
here's a vid of me adding indirect lighting to remove the flickering and own the libs
lol the flickering is still there
long robin
prolly not
dapper gorge
I don't observe flickering btw
long robin
what do you do for motion vectors and scale
dapper gorge
vec2 calculate_velocity() {
vec4 clip_pos = i_clip_pos;
vec4 prev_clip_pos = i_prev_clip_pos;
clip_pos /= clip_pos.w;
prev_clip_pos /= prev_clip_pos.w;
return prev_clip_pos.xy - clip_pos.xy;
}```In FS
scale is just render resolution
dapper gorge
I just use ffxFsr2GetJitterPhaseCount and ffxFsr2GetJitterOffset
In VS I construct a shrimple mat4 with the jitter offsets
long robin
I do this
float jitterX{};
float jitterY{};
ffxFsr2GetJitterOffset(&jitterX, &jitterY, frameIndex, ffxFsr2GetJitterPhaseCount(renderWidth, windowWidth));
const float jitterOffsetX = 2.0f * jitterX / (float)renderWidth;
const float jitterOffsetY = 2.0f * jitterY / (float)renderHeight;
const auto jitterMatrix = glm::translate(glm::mat4(1), glm::vec3(jitterOffsetX, jitterOffsetY, 0));
const auto projUnjittered = glm::perspectiveZO(cameraFovY, renderWidth / (float)renderHeight, cameraNear, cameraFar);
const auto projJittered = jitterMatrix * projUnjittered;
...
dispatchDesc.jitterOffset = {jitterX, jitterY},
I think my motion vectors are okay actually
dapper gorge
gl_Position = clip_pos + vec4(u_jitter * clip_pos.w, 0.0, 0.0);```Here's what I actually do
long robin
spooky
dapper gorge
Indeed
long robin
I just pass this frame's and last frame's unjittered viewproj
dapper gorge
Yeah, same
long robin
what's the deal with u_jitter in your math then
dapper gorge
Right now I don't jitter the projection at all
u_jitter is a vec2 of the offsets fsr2 gives me
long robin
oh, this is for gl_Position
what do you pass for the jitter offset in the dispatch description?
the output of ffxFsr2GetJitterOffset?
dapper gorge
Output of that yes
long robin
what about for u_jitter?
dapper gorge
jitter_offset * 2.0f / glm::vec2(window.width, window.height)
Where jitter_offset is the output of ffxFsr2GetJitterOffset
long robin
oh you're using window size and I'm using render size
dapper gorge
Ah well remember my render size and present size are one and the same
long robin
ah
dapper gorge
I think it should be render size though?
long robin
yeah the guide says so
const float jitterX = 2.0f * jitterX / (float)renderWidth;
const float jitterY = -2.0f * jitterY / (float)renderHeight;
except we don't negate the Y because opengl
dapper gorge
Best API
dapper gorge
Turns out math works (huge discovery)
long robin
I'm gonna try rendering with 1x upscaling
shell inlet
also someone should make a PR or poke someone at AMD to update the motion vector section to include correct info
long robin
yeah, someone
long robin
joker
shell inlet
joker works at amd? Well that's why hes so mentally unstable
final cove
idk I wouldn't ask the first guy, maybe the 2nd
dapper gorge
That's true, what happened to Jaker 1?
long robin
yeah, this is 1x upscale (TAA basically)
dapper gorge
I can only see 4 blocks
dapper gorge
H264 still the king btw
final cove
seems pretty poopy if its supposed to flicker ngl
final cove
you can see it in every game with fsr2 on any fence
production games use fsr?
shell inlet
yes some spoodermoon
long robin
tons of games use fsr2 
shell inlet
ok I was a bout to list some but ok a lot of games use fsr2
final cove
I basically don't play any modern games so I legit wouldn't know
final cove
the crysis crisis
long robin
bababooey
dapper gorge
Spooky
long robin
this is the official shrimple
dapper gorge
How the hell do I not see any flickering?
long robin
you aren't looking hard enough
final cove
what's going on with the yellow balls inside
long robin
also it's harder for you to observe because you aren't doing any upscaling
dapper gorge
oak garden
lvstri built different
long robin
what's going on with the yellow balls inside
long robin
yeah, it's to show how it interacts with particlezzzz
oak garden
do you need to recreate the fsr2 context if the display size changes?
long robin
yeah
dapper gorge
Yes
long robin
you should already be creating all window-size-related resources anyways
oak garden
Yeah I do that somewhat implicitly
dapper gorge
destroy_the_world()
oak garden
eh ill think about it later
long robin
it's very easy in opengl
dapper gorge
I literally just do a reassignment
oak garden
dapper gorge
Checkmate Vulkaners
long robin
oak garden
FfxFsr2Message fpMessage can this be null btw
dapper gorge
Ah btw did you remove the asserts for commandList and device
.commandList = (void*)0x1,``` Might look like I was on crack while codingI have not touched those yet
oak garden
seems useful to have so ill implement it anyway
long robin
I forgor about the giant magnifier that comes with the samples
long robin
don't turn the sharpening > 1
shell inlet
this is not sharpening, this is coarse sanding at this point
long robin
how important is it to actually use the samplers from a gltf
because atm mine don't have a lod bias since I load the scene before creating the fsr2 context, so all the textures are blurry
long robin
I'm wondering if there are gltf files that actually use a "non standard" sampler, if that makes sense
because I would like to just use one hardcoded sampler of my choice
daring surge
in prop engines, it's dictated by the integration with external editors and how much the artists care (which usually comes down to style)
general purpose engines obviously have to care
and bespoke engines i would imagine almost always hardcode samplers or expose it in-editor
if you want to be able to arbitrarily take a gltf file off sketchfab
there is going to be stuff that doesn't work due to samplers, i'd imagine mostly due to the address difference though, not the sampling
daring surge
is there an LOD setting with samplers?
long robin
I imagine some pixel-style models want point filtering too
long robin
is there an LOD setting with samplers?
yeah, you can set a lod bias
daring surge
i see
daring surge
having 100% coverage of gltf is a relatively dumb goal imo though
unless your name is godot, UE, or unity
long robin
just normie stuff like address and filter mode seem exposed by gltf
long robin
having 100% coverage of gltf is a relatively dumb goal imo though
ye, I just want to support a "reasonable" number of models for testing
daring surge
artists are really good at finding weird ways to use things that exist, and working around things that don't exist
long robin
I have an idea w.r.t. samplers anyways
I can just construct them on the fly
rather than baking them into the loaded model
daring surge
hehe this is definitely what UVs were intended for right
shell inlet
artists are really good at finding weird ways to use things that exist, and work...
yeah like generate normal map from albedo, fiddle with the generated normal map such that it doesn't contain unit vectors anymore
change output color space in the engine to some obscure one because it "looks better"
daring surge
level designers are more unhinged
most of them start out modding games, a lot of the time without documentation
shell inlet
completely ignore requests to make models to scale cause "you can scale in-engine by eyeballing anyways"
daring surge
2m tall chair
but yeah, if your goal is just to import random gltf models, you're probably gonna find edge cases that don't work because people do really weird things
samplers are probably pretty low on the graph of cost vs reward
long robin
I fixed the issue already; my question was dumm
shell inlet
soon anticipating artists to use ai to generate illustrations and then it turns out ai autocompleted a chunk of it to be identical to some reference they trained it on
shell inlet
goner froger
long robin
an absolutely wild lad
anyways, textures don't turn to blob when I lower the render res now
daring surge
crazy how much better quality looks than balanced imo
shell inlet
I think quality is the fullres TAA via upscaling and downsampling
daring surge
yeah
its not surprising given what it is
but often quality/balanced shows little actual quality change
vs balanced to performance
e.g. video encoding
or graphics settings in general tbh
long robin
I think quality is the fullres TAA via upscaling and downsampling
Quality is 1.5x upscale
i.e., they're all upscaling, just to different degrees
balanced is 1.7x area upscaling and performance is 2.0x
and ultra perf is 3x
shell inlet
Quality is 1.5x upscale
damn that's unexpected
daring surge
i would not expect 1.5x and 1.7x to look perceivably different
would i be cruel for asking for a no FSR comparison?
long robin
@oak garden you could make multiple fsr2 contexts if you wanted to multithread
then you could provide different command lists and get parallel fsr2s
not sure why you'd want that though lmao
oak garden
That’s a bit weird yeah lmao
long robin
fsr looks barely different when I use the wrong depth convention
I wonder if it even matters
thank you resharper
oak garden
long robin
@dapper gorge latest fsr2 stuff has goodies like not relying on extreme UB and FFX_FSR2_ALLOW_NULL_DEVICE_AND_COMMAND_LIST
also it should use fp16 now, if supported
oak garden
does fsr2 even build on linux
long robin
nop
long robin
oak garden
very cool
long robin
it probably wouldn't be too hard to take that person's efforts and make it work with the gl backend
eh but you're a vulkan guzzler, so the pr already has what you want
oak garden
true
i could probably integrate it in my fork eventually
i think i messed up the build and i cant get it to generate cmake manually
long robin
btw don't use my fork if you're targeting non-gl
I probably screwed up the cmake somehow
oak garden
ah i can generate it from the cmd line outside vs
long robin
yeah
long robin
same
I think it's the shader tool generating hundreds of permutations with every thread on your pc
long robin
renderdoc doesn't seem to like something I added recently
ah, it's this
if (!subgroupSupported)
{
return FFX_ERROR_BACKEND_API_ERROR; // GL_KHR_shader_subgroup is required
}
renderdoc does not report support for the subgroup ext (or most other exts for that matter)
long robin
yet the ext works
digital lion
how do you set subgroupSupported?
long robin
er
long robin
how do you set `subgroupSupported`?
bool subgroupSupported = false;
GLint numExtensions{};
glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions);
for (GLint i = 0; i < numExtensions; i++)
{
const auto* extensionString = reinterpret_cast<const char*>(backendContext->glFunctionTable.glGetStringi(GL_EXTENSIONS, i));
if (strcmp(extensionString, "GL_KHR_shader_subgroup") == 0)
{
GLint supportedStages{};
backendContext->glFunctionTable.glGetIntegerv(GL_SUBGROUP_SUPPORTED_STAGES_KHR, &supportedStages);
if (supportedStages & GL_COMPUTE_SHADER_BIT)
{
subgroupSupported = true;
}
}
if (strcmp(extensionString, "GL_NV_gpu_shader5") == 0 || strcmp(extensionString, "GL_AMD_gpu_shader_half_float") == 0)
{
deviceCapabilities->fp16Supported = true;
}
}
if (!subgroupSupported)
{
return FFX_ERROR_BACKEND_API_ERROR; // GL_KHR_shader_subgroup is required
}
ok. I now on the latest and greatest amd opengl drivers querying it like that doesnt actually contain GL_KHR_shader_subgroup even though you can use it in glsl
long robin
man, the new nsight (gpu traces in particular) is way better
no more horrendous lag when a capture is open, interface looks a lot more like RGP
there is even an analysis view that shows estimated gain by fixing various things
too bad the handy little tips don't appear on compute passes, which is where I spend about 90% of my frame 😄
dapper gorge
<@320895822394818561> latest fsr2 stuff has goodies like not relying on extreme ...
Superb
viral haven
man, the new nsight (gpu traces in particular) is way better
I read somewhere that gpu trace supports async compute (pretty nice), I think the normal frame capture doesnt. I guess it means this (https://developer.nvidia.com/blog/the-peak-performance-analysis-method-for-optimizing-any-gpu-workload/) is outdated now 😦
long robin
yeah :'(, fortunately there is a blog post telling us how to migrate
viral haven
yeah :'(, fortunately there is a blog post telling us how to migrate
do you have any links for it 👀
long robin
Yeah, one sec
viral haven
long robin
it's this @viral haven
https://developer.nvidia.com/blog/migrating-from-range-profiler-to-gpu-trace-in-nsight-graphics/
viral haven
Thanks
golden schooner
if its not in #graphics-resources perhaps its a good item for there
final cove
while you're posting articles I've been looking at this particularly good set of resources on morton curves
http://johnsietsma.com/2019/12/05/morton-order-introduction/
long robin
@digital lion have you already reported the bug with the AMD driver not reporting support for the subgroup ext
I am experiencing it right now
it's not even reporting support for GL_AMD_gpu_shader_half_float
golden schooner
they really want gl to die 😦
long robin
wait nvm it is reporting the half float ext
golden schooner
they really only try to kill gl
long robin
well there was the gl/dx11 driver overhaul somewhat recently
that was pretty nice, but a lot of the changes were undocumented
oak garden
they really only try to kill gl
good 
dapper gorge
good <a:ElmoFire:924630975147823124>
I am still wrapping my head around Vulkan about one week after starting studying it, I was up and running with GL within the first few days 😦
oak garden
it does take some time
dapper gorge
GL must remain
long robin
byeah
const auto* vendor = reinterpret_cast<const char*>(backendContext->glFunctionTable.glGetString(GL_VENDOR));
if (strstr(vendor, "ATI") || strstr(vendor, "AMD"))
{
subgroupSupported = true;
}
Incredible
long robin
the last thing I want to add to the backend (frontend technically) is support for gl crusty z convention, but my question in #mathematics hasn't gotten any attention yet (I'm praying that criver sees it)
long robin
also praying for driver engineers to resolve my ticket for the subgroup thing
oak garden
could go do some angry yelling in their office
dapper gorge
Just update the driver yourself and release a sneaky update not even the engineers know about
golden schooner
subgroupSupported = strstr(vendor, "ATI") || strstr(vendor, "AMD");
that would set it to false if it was reported as supported on nv
golden schooner
sheesh
brazen glacier
then simply
subgroupSupported |= strstr(vendor, "ATI") || strstr(vendor, "AMD");
isSubgroupSupported 😉
oak garden
imo that doesnt make it much cleaner
golden schooner
perhaps ATI doesnt make so much sense, since you probably wont be able to run anything involving Fwog on an actual ATI
long robin
long robin
perhaps ATI doesnt make so much sense, since you probably wont be able to run an...
and yet
so really the test against the "AMD" string is unnecessary afaik, I just have it to hedge my bets
dapper gorge
ATI's ghost will forever haunt us
long robin
on the bright side, the new driver reports GL_EXT_nonuniform_qualifier 
long robin
on the bright side, the new driver reports `GL_EXT_nonuniform_qualifier` <:froge...
@digital lion you may enjoy this information
golden schooner
he knows 😉
long robin
how
golden schooner
i believe we talked about that like a month ago or so already
when AMD released their new gl driver
long robin
I know he knows that the driver supports the ext, but it finally reports that when you enumerate exts
instead of being secretly supported
long robin
np 😄
dapper gorge
oh, ah, uh
monke_sounds.ogg
Speaking of monke, I almost forgot to watch Oliver eating an apple today
long robin
hwat
dapper gorge
digital lion
is the ticket you've created public, I'd like to follow it
long robin
It's not public
heavy cipher
you can just give us your credentials to look at the ticket even if it is not public
daring surge
you could also install a remote access tool like parsec or horizon for us to take a peek
digital lion
you could also send us hourly screenshots of the tickets progress
daring surge
it's the least you could do, really
long robin
shell inlet
does fsr2 blur your dithered transparency and shadows?
long robin
I don't have transparency atm, but it sorta blurs shadows
however, the shadows don't have per-frame rng, so it's noisy no matter what
shell inlet
so it just reconstructs the dither pattern?
long robin
I guess yeah
shell inlet
lol
long robin
the worst part is that it reconstructs the low-res dither pattern
so you get extra big chunky bits
debug build btw
long robin
the worst part is that it reconstructs the low-res dither pattern
rsm settings no longer reset whenever you change the resolution 🙏
fsr2 actually resolves some amount of noise pretty well
it breaks when the noise is super high frequency (1spp)
hmm I guess this is #wip-worthy
long robin
no, I think it's good how it is
oak garden
you did clip space and then pass (width,height) / 2 to fsr2 right
long robin
I did ndc space, then resolution/2 to fsr2
oak garden
right
long robin
ah, I think I know why my renderer is so slow in renderdoc
I'm doing this for roughly 5k draws
I need to
- sort mah draws
- put all the uniforms in a buffer so I don't call glBufferData a billion times
long robin
apparently this math for reprojection is wrong (I'm plugging motion vectors into the denoiser instead of using matrix math)
vec2 reprojectedUV = uv + textureLod(s_gMotion, uv, 0.0).xy;
shell inlet
what?
long robin
something else is wrong methinks
shell inlet
reprojected uv is kinda odd name
long robin
my motion vectors should be in uv space now
o_motion = ((v_oldPos.xy / v_oldPos.w) - (v_curPos.xy / v_curPos.w)) * 0.5;
long robin
I thought you were talking about projecting from last frame onto the current frame, but I guess not
I'm going from current frame to last
shell inlet
but why what do you mean
motion vectors do tell the displacement needed to arrive at the position of the current fragment on the previous frame
so you treat the current one as the origin for motion vectors
and get the difference (target - origin)
long robin
yeah I get how they work
there was just a bit of a terminology mishap
I think my motion vectors are fine actually
shell inlet
my motion vectors should be in uv space now
`o_motion = ((v_oldPos.xy / v_oldPos...
I don't think this is in uv
o_motion = ((v_oldPos.xy / v_oldPos.w) - (v_curPos.xy / v_curPos.w)) * 0.5;
NDC to UV
[-1; 1] -> [0; 1] : (x+1)/2
start from NDC
(prev+1)/2 - (curr+1)/2
simplify
(prev+1 - curr+1)/2
(prev - curr + 2)/2
something's odd, you have
(prev - curr)/2
did I do the maths wrong
long robin
no, I think this is another terminology moment tho
maybe
"uv" means they are suitable for math in uv space
"ndc" motion vectors are suitable for math in ndc space [-1, 1], but "uv" motion vectors are halved because the space is half as large
shell inlet
if you want to pass width and height to motion vector scale in FSR2 I think you should use what I derived
full screen step from corner to corner
prev = (-1, -1)
cur = (1, 1)
get the UV space motion vector
(prev - curr + 2)/2
((-1, -1) - (1, 1) + 2)/2
((1, 1) - (3, 3))/2
(-2, -2)/2
(-1, -1)
full step in UV [0; 1] achieved
I am basing it on their claim that motion vectors are done such that each tells amount of pixels displaced together with the scale factor
For example, a motion vector for a pixel in the upper-left corner of the screen with a value of <width, height> would represent a motion that traversed the full width and height of the input surfaces, originating from the bottom-right corner.
I can only interpret this as (0, 0) + (width, height) travels entire screen, meaning that you want [0; 1] UV and [width, height] remapping scale factor
long robin
here is my maf
motion_ndc = ndc_old - ndc_cur
motion_uv = uv_old - uv_cur
motion_uv = (ndc_old*.5+.5) - (ndc_cur*.5+.5)
motion_uv = 0.5 * (ndc_old - ndc_cur)
anyways, my current motion vectors work fine for fsr2
the docs are also wrong about the motion vectors, they expect "uv" motion vectors rather than "ndc" ones (assuming the motion scale passed to the API is equal to the screen resolution)
there are two issues about this
https://github.com/GPUOpen-Effects/FidelityFX-FSR2/issues/22
https://github.com/GPUOpen-Effects/FidelityFX-FSR2/issues/78
shell inlet
is uv you're talking about zero to one?
long robin
it's the difference between coordinates in uv space
shell inlet
actually doesn't matter anyways because motion vectors only denote displacement, doesn't matter which space it is because of that and that you can scale them
what's clear is that in the end your space must be [0, width]*[0; height]
long robin
yeah
shell inlet
late reply but displacement renders offset term obsolete because
b - a = c
make a relationship such that c is constant displacement between a and b, by expressing b as dependent on a and displacement c
b = a + c
substitute
(a + c) - a = c
now add arbitrary offset x
((a + x) + c) - (a + x) = c
(a + x) + c - (a + x) = c
cancel out terms
c = c
still holds
so (prev - curr + 2)/2 and (prev - curr)/2 are equivalent
dapper gorge
Jaker did you fix FSR2 perf
long robin
No
My investigation yielded that I'm severely VRAM bottlenecked in gl for some reason
There was a comment in the Vulkan backend indicating that fp16 should be disabled for a certain pass on Nvidia due to high VRAM use
I already did that though
dapper gorge
Time to boop your colleagues
long robin
I wonder if maybe it's the resources I pass to fsr2 being too thicc
long robin
Time to boop your colleagues
Lol I'm not gonna have them waste time looking at this
Hmm cache hit rates are fine for me in the slow passes
long robin
hmm that's not the worst
but also not the best lol
do you have the latest version of the backend?
dapper gorge
Subchannel switches
dapper gorge
I donut know
long robin
(they imply the workload is switching between graphics/compute/copy)
dapper gorge
I think there's some kind of bug within my app tbh
I just don't know what it is
There are more subchannel switches in completely random positions
long robin
Are you using persistently mapped buffers
snow sun
why are these in the middle of fsr2 <:listenyoupieceofshit:1023657474148012142>
i would also like to know
long robin
I have them in the fsr backend and I wonder if they're causing issues
dapper gorge
Are you using persistently mapped buffers
None
snow sun
i believe nv just randomly shits in some commands into your command stream
i saw these randomly in many captures
long robin
Interesting
oak garden
why does it do that
long robin
Keeps ya on yer toes
dapper gorge
With the advanced trace dwm.exe appears for some reason
Right in the middle of fsr lol
long robin
I also need to check the shaders again to see if the extensions are actually being used
Especially subgroup
dapper gorge
(Ignore the many subchannel switches in shadow map rendering, those are my fault )
golden schooner
re dwm, schwapping vram resources perchance?
oak garden
you never know with gl
golden schooner
you hung the bar too high
long robin
These also might simply be regular wfis due to memory barriers
I think it's more likely that nsight is just being dumb though
golden schooner
long robin
Can I get a caption on this one
heavy cipher
https://tenor.com/view/waving-hand-alphakep-xset-like-a-wave-moving-my-hand-gif-...
me giving virtual headpat to Jaker for his opengl heroisms
golden schooner
that much better 🙂
dapper gorge
Same, your hard work is appreciated Jaker 🫡
golden schooner
jaker the wallpaper man, getting fsr2 to work in greenland
digital lion
yes it is🫡
long robin
golden schooner
compared to how much without fsr2?
long robin
that's how long fsr2 takes, sorry I wasn't clear
golden schooner
no i am just an idiot
long robin
here is what I'm comparing it against
https://github.com/GPUOpen-Effects/FidelityFX-FSR2#performance
golden schooner
what you said earlier makes absolute sense
ah
can i just run it after checking out the fxr2-test branch?
golden schooner
oki
golden schooner
i could give it a try here if you want
long robin
lemme write the fat commit msg
golden schooner
lunix + gtx1060
long robin
it won't run on loonix
golden schooner
oh, right, you also mentioned that yestergestern
long robin
I'm also using windows.hisms to detect renderdoc
final cove
what makes it windows exclusive
golden schooner
#include <windows.h>
long robin
what makes it windows exclusive
- shader tool being an exe
- some code relying on windows.h and msvc C extensions
- cmake being hardcoded to reject non-windows builds
all of which are fixable, and in fact someone has made a PR on the fsr2 github to make it build on linux
I'm still open to someone porting the stuff to make it work on linux to my branch
golden schooner
but that one needs massaging
shell inlet
bro why would they do all of the above
golden schooner
i suppose because people more likely live on windows
oak garden
🤷
long robin
bro why would they do all of the above
idk, especially the shader tool one is baffling
golden schooner
ja 😦
oak garden
yeah the shader tool i dont understand
shell inlet
someone needs to get the stick out
oak garden
the entire shader compiler folder is like 30 Mb
long robin
the equivalent python script is like 300 loc
oak garden
their shader compiler, glslangvalidator, dxcompiler.dll and dxir.dll
long robin
well you kinda have to ship dxc/fxc binaries
golden schooner
kinda feels like hastily hacked together somehow
long robin
probably some choices made in the beginning that ended up in the final thing since they didn't affect the target
golden schooner
yeah
which is fine
its more like a POC anyway i guess, and AAA studios have the wo:manpower/$$$ to implement it properly
oak garden
i do have to say i was pleasantly surprised by how shrimple it is to integrate
long robin
@golden schooner try pulling the latest from the fsr2-test branch and running 03_gltf_viewer
02_deferred is broken because I haven't added motion vectors to it yet, and rsm now requires them
long robin
examples are not built by default btw
golden schooner
oh
long robin
you need to enable a thingy
golden schooner
is that new?
long robin
it's relatively new (I changed it probably a month or two ago)
around the time I was adding docs I think
long robin
don't worry, I've already confused myself with that change
golden schooner
oki what do i enable where? 🙂
golden schooner
ah
found it
option(FWOG_BUILD_EXAMPLES "Build the example projects for Fwog." FALSE)
ye 🙂 i dont use cmake-gui
long robin
I don't even use cmake-gui anymore except to build other projects
just VS's integration
golden schooner
i just let cmake addon in vscode do all the things
long robin
there is probably a nice button for you to check too
golden schooner
and cashually switch a FALSE to TRUE in one's cmakelist
nah, i have to edit the .txts
golden schooner
but bulding/selecting targets works
its all good
[cmake] CMake Error at build/_deps/fsr2-src/CMakeLists.txt:69 (message):
[cmake] Cannot find MSVC toolset version 142 or greater. Please make sure Visual
[cmake] Studio 2019 or newer installed
I dont understand why americans put 2 spaces after . irritates the shit out of me
long robin
fsr2 isn't very friendly to devs who don't conform
golden schooner
hehe
long robin
I dont understand why americans put 2 spaces after . irritates the shit out of m...
only old people do that here
golden schooner
dragonslayer does that too
long robin
he's old
imo it isn't as bad as when people put a space before punctuation (ahem gob)
golden schooner
hes en baguette beljeeque, they do be plenking, but ye
long robin
when I'm done with this branch, I'll probably turn this into its own example that is quarantined behind a flag
or maybe its own repo
long robin
I was thinkin about it
oak garden
hes en baguette beljeeque, they do be plenking, but ye
i think thats a french thing
i dont do that
long robin
as if I need more evidence that frenchies are crazed
golden schooner
well you didnt ask for it, but zer you go
pengu you are not from the bagette part of beljeek, you are from the cheese corner of beljeekistan
golden schooner
hehe
oak garden
how do i say that
hmm
he's kinda used to the comfy "mom provides everything for me"
long robin
l'estench d'echeese
golden schooner
ah
oak garden
bit stuck up
kind of a pain in the backdoor
but i move out in a month so ill tolerate it
golden schooner
eggcellent
oak garden
for a bit longer
my new place is much nicer
private kitchen and bathroom is a huge plus
golden schooner
+1
long robin
actually doesn't matter anyways because motion vectors only denote displacement,...
btw my issue was that I wasn't applying the jitter to my uv before reprojecting
it was working before because I was accidentally passing a jittered invViewProj without realizing
long robin
because it affects the location of the reprojected uv
the subpixel location matters since I filter
the only thing that confuses me is that the frame I'm reprojecting onto was jittered in a different way, so I feel like that should matter too
shell inlet
wait I get it, the jitter makes up for the displacement in the target resolution
say you have 1/4 render resolution, then full resolution would have 4x4 tile + 4x4 jitter offset as the pixel
or more than just the 4x4 grid if you account for TAA
long robin
this rsm denoising stuff is all happening at the render resolution too though 
hmm, I think I see what you mean
but I'm also pretty sure it's not exclusive to upscaling, but rather any TAA with per-frame jittering
shell inlet
TAA at least makes sense in motion, with upscaling I still have no idea what happens when you just move around and low resolution geometry changes shape
long robin
I think a big part of it is that internal upscaled depth and color are maintained between frames (in the TAAU impl)
so you can compare the low-res input with the reconstructed image from last frame and do some magic heuristics to reconstruct the current frame
shell inlet
I don't think upscaling depth helps anything in motion
motion invalidates any reconstruction
just rotating camera is not motion, what I'm talking about is real moving and deforming geometry, especially the edges
and even worse stuff like moving blades of grass
or hair
long robin
it's still possible to get high quality motion vectors from things like that
I think getting good motion vectors from literally everything is one of the painful parts of TAA(U) integration in a real engine
shell inlet
this isn't about motion vectors anymore though I just segued into something different at this point
long robin
at least FSR 2 lets you provide masks for things like transparent stuff and scrolling textures
long robin
this isn't about motion vectors anymore though I just segued into something diff...
where're we at now
golden schooner
ltt's sponsor segment
shell inlet
my point is that if all you have is 1 pixel per tile when geometry moves you gotta drop it to pure blurry low res quality
upscaling only makes sense for somewhat still geometry to me
long robin
have you read this
https://github.com/GPUOpen-Effects/FidelityFX-FSR2#the-technique
shell inlet
yeah it doesn't have any insights
long robin
just outsights
long robin
my point is that if all you have is 1 pixel per tile when geometry moves you got...
what does "when geometry moves" mean exactly?
are you referring to e.g., objects having different transforms between frames
shell inlet
imagine a bending leaf which is also over some distant background
there is a hard edge between those which you need to reconstruct with just 1 pixel per some tile
this leaf moves such that you only get 1 pixel per tile each frame, all different tiles
what do you reconstruct?
does that sound like it's possible to get meaningful info?
at least with just TAA you have a proper 1:1 geometry outline every frame and extra info is subpixel
long robin
there is a hard edge between those which you need to reconstruct with just 1 pix...
what is a tile
pixel in input resolution?
shell inlet
render resolution is 1 pixel in a tile of the target resolution
each frame you render 1 pixel in a tile as a consequence
from that you'd reconstruct the full image
given that it's all static of course, it'd converge to ground truth
but in motion naah
long robin
how does it work when there are 1.5 pixels per tile
shell inlet
simple, you don't actually treat pixels as discrete with reconstruction
long robin
shrimple as that
shell inlet
it's just easier to think of it as tile
in reality it's continuous
you can splat samples onto the target image and eventually it converges to the full resolution
that's what wavelet upscalers do iirc
the problem is still a problem, when stuff moves it's hard to make sense of it
when the scene is static and you only rotate the view you still get pretty small error because motion vectors compensate for the change
and only rotating the camera is not deforming anything
long robin
what is deforming
shell inlet
my enthusiasm to explain it all over again
imagine a cubemap
you put it on the skybox
rotating a camera does not alter anything
but now if clouds move that's deforming geometry
does that make it clearer
long robin
I see
what I don't get is how that's fundamentally different from transforming the camera
shell inlet
because maths
long robin
you can still get disocclusions and such when the camera moves
shell inlet
moves yes rotates no
long robin
that was the missing part for me
shell inlet
moving camera is really same as moving object relative to it
mathematically speaking
long robin
I still don't get how info is irrecoverable except when disocclusions occur
unless that was the point you were making
shell inlet
because we also have changing shading especially if motion is fast
specular is nasty adds lots of high frequency details
add a bump map it's a nightmare
shell inlet
so you either have bad ghosting or bad quality from dropping history
long robin
I guess you could somewhat "compensate" by not using the negative sampler lod offset lmao
so now everything looks awful, but at least it's not blocky under movement
shell inlet
ok I need to sleep now
long robin
gn
heavy cipher
mfw when opengl
long robin
it's like the driver delays the dma until the perfect moment to troll you
heavy cipher
the driver senses profiling so it randomises behavior
long robin
yeah btw I can't even reproduce the fucked up graph
oh wait
now, with glBufferSubData, I get the epic dma at the beginning of the pass
guess I won't worry about it then
digital lion
persistently mapped UBOs vs glBufferSubData
the one with longer frametime and empty space is persistently mapped?
long robin
yeah
but it's probably random chance that caused it
now I need to figure out why I'm being horribly bottlenecked by vram throughput
even the vk one gets screwed by random dmas in the middle of the pass, but at least it's not uber vram bottlenecked (instead, it's L1 + SM throughtput)
btw @digital lion, the subgroup bug should be fixed in the next driver release
digital lion
amazing
long robin
even the vk one gets screwed by random dmas in the middle of the pass, but at le...
the difference between the gl shaders and the vk shaders is almost nil, so I guess it's either an epic GL moment, NV moment (since it doesn't happen on AMD), or just the inputs I'm providing being too thicc
meh, reduced my color input & output to R11_G11_B10F (from RGBA16F) and almost 0 difference in perf
I blame nv for making bad hw
fiery sorrel
I have been lurkin here for the past few days and have still been confused if this is still fwog thread
long robin
this is the "& co." part of it
fiery sorrel
Oooh!
long robin
there are some fwog example updates interspersed throughout
dapper gorge
Fwog now has a FSR2 sample that has random performance on NV
dapper gorge
How does NV hardware take 300 microseconds to switch to DMA mode smh
long robin
fsr2 performs pretty consistently poorly on this (3-4x worse than the equivalent AMD card)
long robin
How does NV hardware take 300 microseconds to switch to DMA mode smh
it's doing a copy and waiting for it I think
long robin
(seriously though, my problem is also high vram and occupancy in the accumulate pass on NV)
Except when I toggle fp16, there is no epic perf difference 😢
long robin
should I
long robin
documenting my fsr2 journey, starting somewhere around here: #1019779751600205955 message
long robin
it gon be lit
dapper gorge
hype
oak garden
Epic
shell inlet
type
golden schooner
it gon be lit
finally it pays off to pester you to write 🙂
long robin
can confirm that this works btw
you can target multiple envs with glslang like so: --target-env opengl --target-env spirv1.3
golden schooner
you need to run them separately then neh?
long robin
no, you can combine multiple envs at once
I literally invoke the shader compiler with these args:
-compiler=glslang -e main --target-env opengl --target-env spirv1.3 --amb --stb comp 8 --ssb comp 8 --sib comp 0 --suavb comp 0 -Os -S comp -DFFX_GLSL=1
long robin
cant arget
long robin
it gon be lit
I'm accepting ideas for memes (funny or not) to put in this
I'm thinking about putting the stick-in-spokes meme for when I dared to try using glUniform to set image bindings in a spirv shader
long robin
I already have 1000 words wtf
why can't I pump out actually useful stuff this quickly
long robin
I'm just mildly frustrated that I haven't worked on the other article that much lately
golden schooner
ill just leave that here https://developer.download.nvidia.com/opengl/tutorials/bindless_graphics.pdf
long robin
I recently noticed that my fix for my temporal reprojection (incorporating jitter) adds a small bias which makes it look like the pixels are moving up and right 😩
it's weird because the jitter is distributed around 0, so no single direction should be favored over time
long robin
vec2 uv = (vec2(gid) + 0.5) / uniforms.targetDim;
it also only happens when I add the jitter
long robin
I think I'm not accounting for last frame's jitter but that sounds like a problem for tomorrow me
shell inlet
truly mental
if I were to write opengl-like softraster app today I would name shader interpreter source file jaker.cpp
long robin
to make it accurate you need to leave any bugs you find in it
golden schooner
golden schooner
yep, a minute or so, thats fine
oak garden
yeah
ill try "large canyon with rocks scattered around the place. a dense fog covers the bottom"
golden schooner
its not as "accurate" you would think it is/or have played with on the stable diffusion/openai discord
oak garden
golden schooner
oi nice
golden schooner
can you share the image nonetheless?
oak garden
sure
golden schooner
perhaps DM? then we dont pollute jaker's living room
oak garden
long robin
hmm https://skybox.blockadelabs.com/
are these HDR
daring surge
no, they are jpegs
long robin
agx (copied from jasper) vs aces
the toe on aces deletes so many details
anyways, I guess tony mcmapface looks similar to the left pic
shell inlet
we need to see the path to white
golden schooner
are your monitors calibrated?
shell inlet
also slight shift to purple in blues in agx
shell inlet
mine is not calibrated because it burns in srgb mode
but the difference is in luma calibration only
so it's either no srgb or buying a new monitor for me
long robin
my brother had his monitors at 250 nits and saturation cranked up 💀
it was like staring into those pits of glowing green goo in half life
shell inlet
what's with the colorimeter thing?
are you colorimetring the colors of your surroundings as a hobby?
long robin
I used it to calibrate my monitors lol
and everyone else's monitors that I come across
shell inlet
but there's like
dedicated sRGB mode in each monitor's internal config
just choosing it should be enough
like built-in hardware
long robin
sRGB as opposed to HDR of some sort?
shell inlet
I have no clue how hdr is supposed to work
long robin
most monitors do not come from the factory well-calibrated anyways
plus you need to account for suboptimal viewing conditions
shell inlet
I know there are color spaces with wider gamut
in that case hardware should come with settings for those as well
what is a suboptimal viewing condition
long robin
ambient light > 0
shell inlet
displays are black and absorb most ambient radiation though