we integrate a brdf
#Fwog and co.
long robin
I guess my point is that sampling a hemisphere means you can make your samples not be wasted
but yeah
can't really do that
shell inlet
we can build a distribution that samples only emissive parts of the surface
now how practical that would be is a different question with an answer most likely very unpractical, aka are you crazy or what
long robin
I'm okay with keeping this purely diffuse for now
trying to figure out svgf alone is hard enough
I'll probably settle for a scuffed version of it anyways since increasing the sample count is relatively cheap
shell inlet
bro I can't
I now want to make specular rsm
help
the brainworm is brainworming my brain
long robin
just add phong brdf or something real quick to scratch your brainworm
shell inlet
tho I don't have time atm
literally moving out tomorrow
I will revisit it maybe in a month if lucky
long robin
ah, gl on the move
in your honor I'm going to calculate depth gradients and use it to fix the atrous filter
shell inlet
I think we could narrow down the area where we sample the specular on the rsm
by again marching to find intersection point first, and then generating a disk around it
marching for every sample is dumb but for reflected direction not as much
long robin
ye, not a bad idea
long robin
actually there is already a volumetric fog impl in fwog
shell inlet
but with indirect from rsm?
long robin
ah, not yet 
shell inlet
not yet 😈
long robin
tbh the way it's implemented, it wouldn't be too hard to add
and since the fog samples are big in screen space, I could use the dumb RSM sampling method and get free smoothing
speaking of samples
going from 1 to 2 samples literally doubles the execution time of the rsm shader
shell inlet
cache thrashing?
long robin
evidently
shell inlet
well at least you empirically evaluated that algorithm is O(N)
long robin
since I'm now doing temporal filtering, it seems like a larger blue noise texture has a positive overall effect, although it still performs worse with the spatial filter alone (as in these pics, 16x16 vs 256x256)
when temporal accumulation is enabled, instead of boiling artifacts I get splotches which are probably easier to clean up
long robin
yeah, I gotta work on that
shell inlet
and then also hysteresis when you store first pass of subsampled filter to be reused in the next frame
this effectively increases sample count
long robin
ye I sent a pic of that from the svgf paper
long robin
I also gotta figure out this variance stuff, but that can come later
also
- sample and denoise at quarter res, then upscale
- VRS to better allocate rsm samples (high variance regions get more samples, low variance regions get fewer)
I wonder how this disocclusion blur is implemented
https://youtu.be/3EdE38iRn2A?t=225
I have a history buffer, so it's easy to tell when a pixel was disoccluded
maybe it's just an extra atrous pass on discoccluded pixels
ah dammit, it was in the video all along
the disocclusion blur is like 80% of the algorithm 
shell inlet
disocclusion blur is just blur except for disocclused areas
real question is though whether this disocclusion blur is stored in history or is only a 1-frame-long step to mask lack of samples
long robin
I would guess it's not stored
long robin
@golden schooner do you have any ideas on include handling? Every time I link my code I see bits that could just be in a header 😩
I could just make the include path be the directory the file is in
golden schooner
i have something indeed
long robin
or I could allow the user to pass an array of include paths
golden schooner
not added to enginekit yet, but i prototyped something
when you do #include <Foobar.glsl> it will do 2 things
either find the file relative to the programdir + Data/Shaders (thats where all my shaders sit)
or when the include was named "EngineKit.Graphics.GpuMaterial.virtual.glsl"
the include handler for that one will generate a glsl equivalent of the GpuMaterial struct at that include spot
does it make any sense?
long robin
I'm confused about the GpuMaterial thing
are you just saying the contents of the include get pasted in like usual?
golden schooner
GpuMaterial is my cpu side struct describing the elements for the materialbuffer for instance
or GpuLight for the lights
or GpuBaseInformation
ye
in case of an actual file, i just include the contents of the file as is
in case of a "virtual" file (marked by .virtual. in the filename) i lookup the struct (via reflection) in the namespace provided by the filename
long robin
I'm thinking of doing something more "standard"
golden schooner
and then generate a glsl equivalent out of that type/struct, and insert it
i did that virtual thing in d3d11 a lot back when
then i dont need to write all the supporting structs in glsl myself
long robin
ye that'd be nice
golden schooner
just a little reflection majeek
long robin
it's a bit complicated to add in C++ though
golden schooner
ye
long robin
so I just want to stick to regular includes
golden schooner
fair
i have a regex for detecting includes
and named the capture for the include name
long robin
I'm just gonna use stb_include since it does manual parsing and probably handles all the edge cases
long robin
so now I'm wondering how to design the interface
long robin
recursive too? 🙂
ye
golden schooner
in my case, at the stage where you read in the shader source, before passing it to glShaderSource..., i would plug in stbinclude, and then hand over the processed string to opengl
long robin
I think the main problem is that stb_include only accepts a single include dir
but I can probably change that
shell inlet
what do you think on implementing software ray tracing and adding an unwrapping lib to create baked AO maps for RSM?
not very practical for dynamic scenes but will compensate for some lack of visibility
tho at this point may as well bake the whole indirect
shell inlet
I guess if I get the chance I'll start by making perfect speular via rsm
which I'll then extend to rough specular by sampling around the perfect reflection point
maybe I'll try tomorrow if no assignments
I hope my poor laptop could handle the rsm
long robin
if I make this run at quarter res then it might perform acceptably on these low-end devices
long robin
I just realized something cool
the denoising pass has a constant cost
which means you could have a bunch of RSMs and only sample each once
then it all gets denoised at once
golden schooner
--------
SamplerCache.cpp:46
--------
// TODO: determine whether int white values should be 1 or 255
i believe it stays int or uint, when you use the i or ui variants of glSamplerParameterXv
if i got page 183 of glspec46 right
golden schooner
hmm also you were mentioning something about border color and clamp_to_edge but i forgor what it was exactly, glspec also only has some vague stuff going, it was bordercolor needs to be set when address mode is clamp_to_edge, wasnt it?
long robin
Clamp to edge clamps to the last texel
Clamp to border is the one where you need to set the border color
golden schooner
ah
long robin
Also I think both 1 and 255 are wrong for integer formats
shell inlet
is it not dependent on format
golden schooner
that would also mean samplercache could omit setting the bordercolor when clamp to border is not set
shell inlet
I thought if the texture was float you'd write float bits there
long robin
Yes
That's why there are different ones
But my point is that integer textures can go above 255 if they have more than 8 bits
golden schooner
Data conversions are performed as specified in section 2.2.1, with these excep-
tions:
• If the values for TEXTURE_BORDER_COLOR are specified with TexParame-
terIiv or TexParameterIuiv, they are unmodified and stored with an internal
data type of integer. If specified with TexParameteriv, they are converted to
floating-point using equation 2.2. Otherwise, the values are unmodified and
stored as floating-point.
default: FWOG_UNREACHABLE; break;
no assert? megamind meme
golden schooner
its just breadcrumbs jaker left behind for us
shell inlet
honestly I'm not the one to point that out, which is why my project is not open source
not the one to point fingers rather
golden schooner
i dont mind being finger pointed at my code
most of the time there is good feedback
shell inlet
I mind being finger pointed because I speedrun implementations
shell inlet
it just ticks me off if someone says it's not optimal or clean when I know it's not
golden schooner
understandable
shell inlet
I actually put effort in my nickname
long robin
`default: FWOG_UNREACHABLE; break;`
no assert? *megamind meme*
Unreachable is an assert in debug mode
shell inlet
epic
daring surge
its what, can't start declaration with number, void with return, return mispelled, g isn't valid in hex, wrong brace, semicolon after brace?
viral haven
This is pretty cool
long robin
I wish there was something that explained how exactly the depth gradient is supposed to be used for the bilateral filter weight
I get that it's supposed to help with denoising surfaces viewed at an oblique angle
but just looking at some code is not great for learning
I think I'm going to just write unscientific jank and eyeball the results
mathematical rigor is too hard to achieve
hello scene-dependent constants my old friend
shell inlet
I wish there was something that explained how exactly the depth gradient is supp...
float depthThreshold = dot(1, abs(Ddxy));
translates to 1*|ddx| + 1*|ddy|
long robin
yeah that part is not hard to understand
shell inlet
you don't understand what gradients are?
long robin
idk it's just taking me some time to soak in all this code
shell inlet
gradient is a rate of change
long robin
I know what a gradient is
long robin
also there are different ways to get the depth gradient, and I can't find the shader where they compute that
shell inlet
if you view the surface straight on there is less tolerance because rate of change in depth is smaller
long robin
so I'm just gonna make a dumb one that does (f(x + 1) - f(x), f(y + 1) - f(y))
shell inlet
but for oblique there is more tolerance needed as nearby pixels will have more depth difference
shell inlet
there are built in gradients in glsl
long robin
only for fragment shaders
shell inlet
yes and you store it in gbuffers
long robin
and via some extension in vulkan glsl
shell inlet
when you rasterize
long robin
// Remap partial depth derivatives at z0 from [1,1] pixel offset to a new pixel offset.
float2 RemapDdxy(in float z0, in float2 ddxy, in float2 pixelOffset)
{
// Perspective correction for non-linear depth interpolation.
// Ref: https://www.scratchapixel.com/lessons/3d-basic-rendering/rasterization-practical-implementation/visibility-problem-depth-buffer-depth-interpolation
// Given a linear depth interpolation for finding z at offset q along z0 to z1
// z = 1 / (1 / z0 * (1 - q) + 1 / z1 * q)
// and z1 = z0 + ddxy, where z1 is at a unit pixel offset [1, 1]
// z can be calculated via ddxy as
//
// z = (z0 + ddxy) / (1 + (1-q) / z0 * ddxy)
float2 z = (z0 + ddxy) / (1 + ((1 - pixelOffset) / z0) * ddxy);
return sign(pixelOffset) * (z - z0);
}
I was specifically trying to avoid that
I could compute it in image space with acceptably few artifacts probably
shell inlet
I think you need a ratio of change over distance
long robin
and if it's bad I could use a more advanced method like this
https://atyuwen.github.io/posts/normal-reconstruction/
shell inlet
because it's the definition of a gradient
(change in value)/(change in argument)
y/x
derivative definition version lim(h->0){(f(x+h)-f(x))/h}
long robin
ye I'd just use the finite difference to get the gradient in image space
shell inlet
I don't rember the units of measure of argument change in builtin
need to look up glslspec
long robin
now, there will be artifacts at corners with a naive image space method, but who cares
long robin
I don't rember the units of measure of argument change in builtin
pretty sure it's implementation-dependent
but in practice it uses the neighboring pixel (since 2x2 pixels are shaded in lockstep)
and if you use the coarse variants then the same samples in a quad (2x2 pixels) might be reused
long robin
what I'm going to do is calculate the naive image-space gradient and store that in a texture for now
it should be enough to fix most of the ugliness™️
shell inlet
reading some articles seems like it only takes a difference between values
long robin
ye
long robin
it's finite difference but on the rasterized triangle instead of in the image
which means no edge artifacts where planes meet
shell inlet
you can branch at the edge
if say you take difference current and right pixel you can instead take difference with left pixel at the right edge
same result
long robin
I meant geometric edges
shell inlet
well not really but at least it will try to extrapolate instead of just taking difference with itself (if clamped) or with wrapped around pixel
long robin
but ye I'll take that into account for screen space
shell inlet
so opting out of storing gradients is to avoid being memory bound?
long robin
I meant geometric edges
e.g., finite difference in screen space will give incorrect results for a bunch of pixels here
https://i.imgur.com/t60gJBO.png
shell inlet
because it's assumed to be one big surface?
long robin
so opting out of storing gradients is to avoid being memory bound?
also to reduce the requirements from the renderer. I'd prefer to hide as much stuff in the file where I do all the RSM-specific things
shell inlet
can fight that with triangle indices
this is also one of the heuristics in weighting bilateral filters btw
long robin
I could imagine
I linked one technique that relies on the depth buffer only to identify the surface
tl;dr sample the neighboring pixels and use the depth of the two that are closest to this one to form the surface
shell inlet
@long robin what's the plan anyways?
to make a better filter?
also imagine pulling off temporal gradients later... for RSM
this is basically a rt pipeline denoiser so that you could swap RSM with path tracer and it'll work OK
given that it can work with 1spp that is
because rt is just that much more demanding when compared to sampling textures with whatever other math there is
can fwog bindless textures?
long robin
- create depth gradients
- add 3x3 bilateral blur (regardless of disocclusion)
- create moments
- upgrade atrous denoiser to use depth gradients and gamer moments
- sample and denoise at quarter res instead of screen res
- use VRS to further guide samples
long robin
can fwog bindless textures?
yes
shell inlet
ok then if you also add bindless buffers I could make a pt example for fun
long robin
it's kinda in beta though
but it is usable (I use bindless textures in GPU-driven example)
shell inlet
there is a NV only extension NV_shader_buffer_load/store which gives you bindless buffers via pointers
BDA for ogl basically
long robin
I'm mainly interested in ubiquitous extensions
shell inlet
amd is not as generous
long robin
you can pretend with bindless textures
shell inlet
nor intel but what do you expect from intel
I guess buffer textures may do but they're ugly in code
also for whateer reason slow as hell on nv
slower than BDA extension
shell inlet
yes bindless handles work
long robin
huh, interesting
shell inlet
they're a texture after all
shell inlet
I don't remember can you alias memory buffers with vbo and texture at the same time?
probably can because I would have rejected the idea otherwise back then
I hate dupes
long robin
you can do it, and probably legally even, provided you use the correct barriers
also this denoiser- idk if it's going to be ideal for path tracers since it's my first attempt at a spatiotemporal denoiser
RSM is kinda forgiving because you can take extra samples cheaply
shell inlet
I would argue it'll going to do better with pt due to importance sampling
RSM samples are distributed very suboptimally
surface integrals are very bad like that
long robin
mayhaps, but I predict 1SPP PT will be very expensive compared to 1SPP RSM
it's a bold prediction
long robin
indubitably
and very divergent
and so very not hw accelerated since this is 
either way, pretty much any good GI solution will involve path tracing packaged in various ways
long robin
except those two
shell inlet
what about lightcuts?
long robin
is that even a good GI solution
long robin
all the recent ones I've seen use PT somehow
long robin
- surfels is PT with a fancy world space cache
- DDGI is PT with a fancy world space cache
- GI-1.0 is PT with a fancy world and screen space cache
- RTXGI is PT with a fancy world space cache
shell inlet
everyone is keen to put them cores to use
long robin
I'll have to take a look at lightcuts though since I have no clue at all how it works
shell inlet
not worth the effort if you ask me
in modern day and age
it's basically rasterizing the scene from multiple angles and caching the results
long robin
hmm
the paper is only 10 pages long so I can give it a skim
after I sleep
but it sounds not ideal for real-time from your description
shell inlet
its underlying technique is instant radiosity so it's not
shell inlet
any updates?
long robin
The five most recent commits
https://github.com/JuanDiegoMontoya/Fwog/commits/examples-refactor
The only thing of significance is making example 5 use the example framework, which was the original purpose of this branch
shell inlet
I see, truly minor
on an unrelated note I think I won't be working on fwog due to being busy for months ahead
long robin
Np, go work on important stuff 
shell inlet
more like do things to prove I know what I know
college is so stupid
I came there already knowing beyond what they can offer
I picked a thesis that they will have trouble understanding
pure comedy
long robin
Lol
golden schooner
you could just drop out and do your own thing
long robin
Naw, you need that piece of paper to tell employers to give you a job
golden schooner
then, just finish skool summa cum laude, while focusing on your hobbies on the side
brisk narwhal
I came there already knowing beyond what they can offer
meanwhile I was struggling with "Math II" 3 years ago 🥲
must be nice to have talent
shell inlet
theres no such thing
long robin
when people attribute your success to talent 😩
shell inlet
heavy cipher
then, just finish skool summa cum laude, while focusing on your hobbies on the s...
i parsed skool summa as skooma, which uh, is an acceptable minor if you are having a too easy time
long robin
opengl programmers scare me
this is what teardown does before rendering a fullscreen quad whose sole purpose is to unnecessarily copy a texture to another texture
golden schooner
the scary part is also the amount of objects in this thing
heavy cipher
this is what teardown does before rendering a fullscreen quad whose sole purpose...
what you see there is a specially crafted binary signature in the command buffer designed for nv blob engineers and jakeronis to patch out in the driver
long robin
Ah, yes. I should have guessed
Teardown is such an interesting renderer, but it uses such a crusty old version of OpenGL and all the associated crusty practices involved
dire badge
enable blend?
heavy cipher
long robin
another Teardown classic (in the g-buffer pass)
I guess that explains why albedo in the g-buffer is stored in a RGB16_UNORM texture
my brother in christ stores the input albedo texture as RGBA8_UNORM
and storing normals in RGB8_SNORM without any special encoding 
minus half a sin because there are no curved surfaces, but still keeping half a sin because RGB8
also storing linear depth in R16_UNORM while also having nonlinear depth in D32_UNORM (and clearly not using a reverse z projection)
heavy cipher
tearing down teardown in teardown teardown
long robin
I'm writing a frame breakdown, but I don't want it to "accidentally" turn into a giant roast of the renderer
these people actually shipped a successful game
I also couldn't get Nsight to connect to the game, so I can't tell how much of an impact any of these problems actually have on the game's perf
well, I suppose there is always this option 😈
something doesn't add up here (first row = whole frame)
😶
shell inlet
bruh moment
modern saffron
something doesn't add up here (first row = whole frame)
😭
long robin
@heavy cipher just so I am 100% clear, one should use an sRGB render target instead of storing pow(color, 2.2) into a unorm target, correct?
because what Teardown is doing is sampling a RGBA8 color texture, then doing pow(color, 2.2) and storing it into an RGB16_UNORM target
heavy cipher
<@122845331934281729> just so I am 100% clear, one should use an sRGB render tar...
thats okay
depends on how you use it after
long robin
yeah I'm looking rn
heavy cipher
sympler, no sampling, as dora would say
long robin
looks like they are just sampling it and using it with no further transformation
it is confusing
they are doing color math with this ^2.2'd value
long robin
I feel like the whole reason they are using a RGB16_unorm target is to mitigate precision loss from the ^2.2
heavy cipher
weird
long robin
maybe I should refrain from passing judgement in my breakdown because I don't know wtf they are doing
long robin
I'll just mention it as something that is weird and I don't understand it
which one is more correcter though
spoilers
||the first image has the ^2.2 line commented out, while the second is unchanged||
long robin
I can't find if they are doing srgb encoding/"gamma correction" at the end of the pipeline like a normal person, so I can only assume that they're "doing it" here with the albedo???
sadly, modifying the shader they use to blit the texture to the screen affects a bunch of places, so I can't test my hypothesis
interesting to note that the swapchain is sRGB, but doesn't that mean it's doing linear->nonlinear to the color again
heavy cipher
ah i missed that albedo was unemcoded too
long robin
well idk what the encoding of albedo is in the material texture
but a normal person would put it in nonlinear srgb texture and have the sampler do the nonlinear->linear transform for lighting and shit
heavy cipher
but this is a gfx programmer
heavy cipher
well idk what the encoding of albedo is in the material texture
they do lin2nonlin
so if it is already nonlin, its just worse
long robin
isn't albedo normally stored in nonlinear sRGB?
then you put it in an sRGB texture so it's linear when you sample
but yeah when you write to one, it does linear2nonlinear
heavy cipher
ye but i am just repeating what you said in off topi
long robin
ok so to confirm, is that color pipeline weird to you too?
heavy cipher
Yeah but some of it can be explained with "but opengl!!! Buggy!!!!!"
not color meth tho
Well that can be an artistic choice
Its an NPR renderer anyway
long robin
kinda
they have some clearly PBR-inspired code in here
ok, maybe the real albedo g-buffer texture for lighting is obfuscated through a glBlit
heavy cipher
the real albedo is the friends we made along the way
long robin
lightColor *= texture2D(uScreen, b2).rgb;
that's the usage in the shader where it actually looks like it's going from albedo to shaded color
rugged notch
fwog
long robin
I need to just forget about this color stuff because it's melting my brain
rugged notch
it's just a color, but it burns
long robin
renderdoc should have an overlay that shows discarded fragments
it probably wouldn't be easy to implement though
my naive idea would be to patch shaders and add a write to a hidden SSBO before discarding
heavy cipher
how naive
long robin
huh, I imagine the overdraw overlays probably do something similar to what I described
looks like they are unaffected by discards, which I guess means they are implemented with an SSBO/image atomic add
golden schooner
would it be possible to contact the guy and ask?
long robin
golden schooner
ok
long robin
hehe
I did in fact ask him, in case you didn't click my link
well Baldur immediately thought of a better solution than what I thought would be possible
using the stencil buffer no less
downside is no heatmap
golden schooner
I did in fact ask him, in case you didn't click my link
i was referring to the author of teardown 😉 not baldur
long robin
Oh, you were referring to the previous conversation
That would basically be cheating
But it would be nice to be able to ask him any questions I have about it
shell inlet
"hey so I've been reverse engineering ur game mind helping me out?"
golden schooner
"for educational purposes, I am also asking for a friend"
daring surge
I need to just forget about this color stuff because it's melting my brain
retweet
long robin
another ism in teardown
the focal plane texture is generated and unused when DoF is disabled
it's a draw to a 1x1 texture though, so who cares
heavy cipher
you
long robin
soulja boy tell em
shell inlet
which one is more correcter though
this looks correcter
linear colorspace is known to look darker like that one below
when put on a srgb display
heavy cipher
this looks correcter
both images are in the same comment, which one did you mean 
shell inlet
don't you like seeing a man pull off complex voxel renderer with GI and fail on a basic task of handling srgb
also when you see the pow 2.2 in code it automatically looks sus
when there are hardware formats for doing every aspect of srgb correction for you
shell inlet
vertex colors?
aren't those vec4s so you don't need to store them in nonlinear format?
shell inlet
enough precision to get away with using linears
heavy cipher
but originally they are in some format, which is usually not f32
unless you like spending bw on that for some reason
heavy cipher
very much so
and i dunno if opengl lets you do ILS to srgb
it is possible in vk since 1.1 or some ext
shell inlet
ILS?
shell inlet
that'd be stupid not to
rendering to a srgb texture is same thing as storing to it or am I wrong?
heavy cipher
it is different
shell inlet
and when you do render to srgb it converts for you
heavy cipher
rendering is well supported
rendering goes through the "framebuffer" hw
ILS does not
heavy cipher
wdym?
shell inlet
you can imageStore and imageLoad in fragment shader
heavy cipher
yes
shell inlet
does it use different parts of hardware to store and to write to framebuffer in one shader invocation?
heavy cipher
you don't store to the FB with ILS
you store to some different image
and yes, different HW
ILS conceptually is just like SSBO stores/loads, but to images
shell inlet
I see
can't really imagine what hardware would do to allow both in fragment shader though, but it's cool because we can use that to voxelize the scene by rendering every triangle using raster pipeline and store each fragment to 3d texture
heavy cipher
yes, this something indeed done
heavy cipher
can't really imagine what hardware would do to allow both in fragment shader tho...
imagine it as a side-effect of the FS
the FS writes to some bit of global memory for your image / SSBO store, then passes the FB value to the special hardware magic
long robin
don't you like seeing a man pull off complex voxel renderer with GI and fail on ...
minor correction: there is no GI in this game (though it looks like there might be)
long robin
and i dunno if opengl lets you do ILS to srgb
no, you have to create a non-srgb view to use them
for writing data, teardown uses fragment shader output exclusively anyways
heavy cipher
no, you have to create a non-srgb view to use them
well ye
but i didn't know if that was allowed
long robin
ok, I thought you were wondering if you could get the automagic format conversion
shell inlet
minor correction: there is no GI in this game (though it looks like there might ...
only direct?
how does it have non-black shadows? (disregarding penumbra)
constant ambient?
long robin
yeah, I think it depends on the time of day
well no
it has IBL
so it's not constant ambient exactly
shell inlet
according to my experiments it should leak like crazy
and well if you think about it for more than 5 seconds
long robin
the IBL is just the skybox
like learnopengl IBL basically
it's used for ambient color
shell inlet
you cannot use skybox IBL as is for diffuse
you need to preconvolve it
preintegrate
long robin
yuh
long robin
the details will be in the breakdown
shell inlet
see there is a separate term for it
I guess the skybox as-is is the radiance map?
you can even do the integration with it in the shader by doing limited amount of samples
long robin
I haven't looked at the IBL yet but all I've seen is a single un-convoluted skybox cubemap
long robin
imagine being a sample 😳
shell inlet
what's up with my crazy ideas
long robin
you took your crazy pills today
shell inlet
I took a lot of ray tracing pills for a few years
heavy cipher
I haven't looked at the IBL yet but all I've seen is a single un-convoluted skyb...
convoluted rendering
long robin
very
also I found some more albedo textures being used (sampled) and they're all unorm
quite epic
shell inlet
if it's using radiance map without preintegrating then it would look silly as all pixels on the map will only influence those specific directions they lie at
heavy cipher
maybe it is using a low mip?
shell inlet
e.g. a star map would look silly because all surfaces would on average be black-ish and those that happen to coincide with a star would look bright
long robin
tfw convoluting using glGenerateMipmap (fake) (not real)
shell inlet
convoluting 
shell inlet
tfw convoluting using glGenerateMipmap <:nervous:836935166437883934> (fake) (not...
unironically a way to do it, but not exactly correct
for rough reflections
any reflections, including rough
by going down the lod
I would still convolve the thing and store at different mip levels to be at least somewhat more correct
fully correct thing would interpolate between fullres preconvolved cubemaps
why is it convolved exactly though
maybe someone managed to preintegrate an irradiance map with a blur kernel?
hmmm but a convolution is an integral iirc
maybe it is the same thing
heavy cipher
use convolved instead of convoluted when writing the article (not real advice)(truth)
long robin
volve these nuts
heavy cipher
thanks gaben
heavy cipher
I would still convolve the thing and store at different mip levels to be at leas...
that is generally what is done, yeah
is there spec at all tho?
or just diffoose
long robin
there are shiny materials
roughness, metallic, and reflectivity are written to the g-boofer
long robin
yeah, apparently this game is half PBR
the blend between diffuse and specular seems proportional to the reflectivity
heavy cipher
"based on physics from a different reality"
heavy cipher
why is it convolved exactly though
wdym?
shell inlet
so why are you smoking teardown rn?
long robin
so why are you smoking teardown rn?
I told some people in another server that I will make a frame breakdown of it
plus I was interested in seeing how its renderer worked
shell inlet
I have already answered my own question in that chain of messages
long robin
convolvulating
heavy cipher
the higher mips are just a convenient place to store them
shell inlet
I know, it becomes progressively more low frequency
heavy cipher
we are in violent agreement
shell inlet
that's what happens when two people try to argue over objective truth
long robin
objective truth in a discussion about Teardown
shell inlet
bikeshed is full of opinions
that is my opinion
so I though about the rsm specular some more
thought
and realized that it would only show the bright parts illuminated by the directional light source
and what's worse it would show them through every obstacle on the way
still might be worth trying out
does your deferred pipe have material info already?
specifically diffuse and specular parts
because it would be more handy to have those as opposed to metallic and calculate fresnel and friends for every light source
imo
maybe not so good on bandwidth
shell inlet
does it assume anything to make those specular highlights from point lights?
long robin
yeah
shell inlet
all materials dielectrics?
long robin
you could think of it like that
shell inlet
so that's why it looks decent
for metals there is no ambient term because ambient is pretty much diffuse
and there is no diffuse for metals
so pretty much all metals end up black
in a renderer without reflection probes
or without SSR
you can cheat and sample skybox but that looks weird with all the leaking
unity games used to look like that
shell inlet
there is still no diffuse
shell inlet
it will look like smudged highlight
unless you gradually, with roughness, add ambient to it which will look even weirder
if every material is 100% rough it will be alright maybe
I get you aren't serious
long robin
I'm half serious in that if all the metal materials have a roughness of 1, it probably wouldn't look too inaccurate
completely rough metals look like poopoo though
rugged notch
I told some people in another server that I will make a frame breakdown of it
didn't Gustafsson already do a breakdown of sorts on stream once
long robin
sounds somewhat familiar but I'd rather spend 20 hours figuring out how things work than 1 hour
long robin
@rugged notch also thinking about it more, it's way more useful IMO to have this sort of info in a textual format
but I suppose I can cheat and look at that stream
heavy cipher
just have a breakdown on stream
brings in the big views
also i bet he didn't go: "haha this is where i commit srgb warcrimes"
shell inlet
have a meltdown during a breakdown of a stream of a breakdown of teardown
long robin
"srgb war crimes" is a phrase that I shall appropriate
long robin
instead of frogment shader, we should say 🐸ment shader
am I tripping, or is this explanation of how depth buffers work completely wrong 🐸
https://youtu.be/0VzE8ROwC58?t=1221
I wonder if them catching flak for this is why they deleted the twitch vod
long robin
"the hardware gets confused" 
heavy cipher
i am not sure what he explain
isn't he talking about not having depth info inside the rasterized boxes
long robin
yeah but you can set the depth yourself or discard if you hit nothing
I don't see the poor interaction here that requires weird hacky workarounds like copying the depth buffer several times in the g-buffer pass
heavy cipher
let me watch 1x more
long robin
I'm also speaking from having looked at the frame, in which there are multiple of these
where they copy linear depth to another texture so it can be read in subsequent draws
this is how they use it
perhaps this is just an optimization?
but they could use conservative depth + early fragment tests
heavy cipher
i think he is talking about losing early depth
so depth is correct but you need to trace all fragments, all the time
heavy cipher
but they could use conservative depth + early fragment tests
not with discard
long robin
well on modern hardware you can do it
but these guys want to target old hardware that can't run this game for some reason
heavy cipher
the way of the worm
heavy cipher
are the boxes sorted?
heavy cipher
can nv do re-z?
long robin
idk but who cares
heavy cipher
even on amd its not always a win
anyways, they might have looked into this and this was better perf
long robin
my perception has been tainted ever since the 2022 srgb incident
heavy cipher
make the review into a diss track and release under the pseudonym jaker 1.5
long robin
what if instead of discarding, they just set the depth to a very large value
ah but they'd need to render front faces instead of back faces
heavy cipher
sending the fragment to the shadow realm
long robin
I wonder why they render back faces only
heavy cipher
what if instead of discarding, they just set the depth to a very large value
what would this accomplish?
long robin
the ability to use early-z on inferior hardware
heavy cipher
you can't have both early-z and increase the depth on that hw
assuming a non-reversed z
that would just be a discard with extra steps and slavery
heavy cipher
conservative depth is about decreasing depth
some hw can only do (atomic) depth test-and-set
i think
long robin
I thought it was just about assumptions, e.g., early discard is okay if you promise to only write depth values that wouldn't break it
heavy cipher
yeah, so writing a depth value that is larger than the original one breaks it
(again with a LEQ test)
long robin
I drew a diagram to explain my thoughts
this SO answer seems to agree, but it doesn't mention hardware specifics
https://stackoverflow.com/questions/31624437/understanding-gl-arb-conservative-depth-extension
heavy cipher
if you have already failed the early test, the shader will not run
what are you writing then?
heavy cipher
i have no idea what you are talking about then jaker
long robin
nor do I have any idea what you're talking about
heavy cipher
if you have a LEQ test, and (depth_greater), the only legal fragdepth you can write is the same depth you already have
heavy cipher
or rather in this case i imagine the implementation will just turn off early tests
with conservative depth you can't change the depth value in a way that would make the early test fail
thats the important bit
long robin
I concur
heavy cipher
so if the test is LEQ, increasing the depth might make it fail, where it originally passed
hence that is not compatible with conservative depth
long robin
okay, I think I see where our thoughts are diverging
I am looking at it from another angle
if the early-z test fails, you cannot write a depth that would make it pass
heavy cipher
if the early test fails the shader is not run bruh
long robin
yes I worded that poorly
what I mean is that it is illegal to write a depth that would make it pass when you enable conservative z, if it failed the early z test
long robin
is this SO answer wrong?
With the GL_LESS comparison function, fragments that fail the depth test will have depth values larger than the current value in the depth buffer. This means that the early depth test can be used without affecting the result with depth_greater:
If the early depth test is applied, it eliminates fragments with depth larger than the current value before the fragment shader.
If the early depth test is not applied, the fragment will be processed by the fragment shader. Since it's guaranteed that the fragment shader will only make the value larger, it will still be larger than the current depth value, and will be eliminated by the depth test after the fragment shader.
heavy cipher
ye
either you have it running in conservative depth or not
if it is not conservative depth, then your annotation means nothing
you just get a late test
long robin
okay now let's consider an entirely hypothetical scenario
if the hardware did do an early test there, would it be wrong?
so we have early test + late test (if the early test passed)
or is this precisely what re-z is
I can't see the case in which early z + depth_less would result in an optimization though (in a non-reverse-z renderer) (and by optimization I mean early z actually being used)
so the thought I have rn is that conservative z does nothing except maybe allow extra early-z tests on certain AMD hardware, but it feels wrong
however, the extension spec was written by AMD employees, so...
heavy cipher
my understanding is that amd has the following modes:
LATE_Z - depth test and set after fragment shader
EARLY_Z_THEN_LATE_Z - depth test and set after fragment shader (when certain conditions are met this becomes EARLY_Z)
RE_Z - depth test before the fragment shader, depth test and set after the fragment shader
EARLY_Z_THEN_RE_Z - depth test before the fragment shader, depth test and set after the fragment shader (when certain conditions are met this becomes EARLY_Z)
long robin
I wonder what those "certain conditions" are
that reads like sarcasm but I'm genuinely curious
are they explained in the doc you're reading?
when I search "re-z" in this server I see an ancient message from you
#vulkan message
heavy cipher
https://gitlab.freedesktop.org/mesa/mesa/-/blob/main/src/amd/vulkan/radv_pipeline.c#L5024
http://developer.amd.com/wordpress/media/2013/10/cayman_3D_registers_v2.pdf
https://www.yumpu.com/en/document/read/43374261/mantle-programming-guide-and-api-reference
https://gitlab.freedesktop.org/mesa/mesa/-/blob/main/src/gallium/drivers/radeonsi/si_state_shaders.cpp#L1890
enjoy my sources
if only one of us worked for amd
imagine how much more info we could have
long robin
indeed, but my coworkers are all sleeping rn
and I haven't looked at prop drivers very much because I'm not a driver dev
and unfortunately there is no way for me to plug into the company and absorb all of its knowledge instantly
heavy cipher
heavy cipher
I can't see the case in which early z + `depth_less` would result in an optimiza...
this is reZ really
but apparently reZ is just shit in perf usually
or rather, this is a weaker one because this could also be implemented via two depth test and sets
long robin
this is reZ really
Wouldn't depth_less prevent any sort of early test though
I mean conceptually
heavy cipher
no, i think you are misunderstanding what this is for
long robin
Mayhaps
heavy cipher
you have a conservative test first
ie you rast'ed the bbox backside
then you update the depth buffer with a closer value
but maybe it is I who misunderstand this stuff
long robin
Let's ignore the Teardown example
It seems to me like the point of conservative depth is to allow for more early z testing
I hope you agree
long robin
I drew a diagram to explain my thoughts
And it seems like the only scenario where it would ever enable more early z is this one
And the parallel discussion is what hardware is actually able to do that "optimization" (which apparently isn't always an optimization)
If that is wrong then I'm probably going to suffer from an aneurysm because I even drew a picture and everything
heavy cipher
ok i think you are right
i had it wrong
the other conclusion is is that apparently the hw does fuckall to accelerate this 😛
heavy cipher
thanks for the insight 🙏
long robin
No u
long robin
@shell inlet I learned something interesting
apparently you can approximate the depth gradient (not really the gradient, but the adaptive factor you use based on the surface slope) using the dot product of the surface normal and the camera forward vector
it seems like it would break down as you get farther from the center of the screen, but maybe it's hard to notice
long robin
yes
heavy cipher
👋 👋👋👋👋👋👋👋 👋 👋👋👋👋👋👋👋 👋 👋👋👋👋👋👋👋 👋 👋👋👋👋👋👋👋
long robin
is this u jaker
tl;dr ask an employee to give you encrypted registry keys to set or add a line in the driver
shell inlet
apparently you can approximate the depth gradient (not really the gradient, but ...
yeah lmao actually I've tried that but didn't push because it didn't help much
the problem was in something else however
in the kernel itself being too sparse, not the rejection heuristics
I didn't try to fix it because I knew you were working already on a better filter altogether
shell inlet
@long robin do you have magic code in your lib that makes drivers pick best GPUs instead of integrated ones
I accidentally opened a pr to your repo trying to merge your refactor branch with my main lol
how to use github
delete the pr later unless you want to meme about it
golden schooner
you can remove commits with rebase -i
golden schooner
desktop github client sucks
shell inlet
you dont say
golden schooner
: )
shell inlet
github also sucks in general
golden schooner
time to learn some git cli
shell inlet
no please I dont want to turn into a linux user
golden schooner
if you have clion or rider or any other jetbrains based product, they have very nice git clients as well built in
and should support rebase too
shell inlet
also fwog doesnt run on my lap top
golden schooner
their git gui is well integrated into the jetbrains products
shell inlet
because it probably doesnt have the magic code
golden schooner
shell inlet
i dont have jetbrains only visual studio by microsoft
stop pushing me to change my toolchains
it wont work
shell inlet
i dont even use cmake
golden schooner
thats ok
shell inlet
bro what happened to fwog
truly fighting to run the gltf example
wen building copy textures doesn't happen only copy models and copy shaders
and it causes runtime errors
but that's after I added magic code
before that it was picking integrated gpu
@long robin basically add this code somewhere
#ifdef _WIN32
extern "C" {
__declspec(dllexport) unsigned long NvOptimusEnablement = 0x00000001;
__declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
}
#endif
those exports tell drivers to pick gaming GPUs
in laptops
also had to tweak the cmake configuration haphazardly to find a working one because it defaults to non building project
idk who to blame here and if it's fixable
nice fps
when I minimized it it crashed
filtered runs 30 on average
but it's 1spp so expected
golden schooner
you could have applied the plum color scheme at least
that was my fav in win9x days 🙂
shell inlet
I like classic
it was aero by default and I changed to classic
and didn't touch colour because I like blue
anyways nah I don't think I'm going to attempt to work on fwog on this slow laptop
it was worth it to see how it performs though
and that I pointed out that it will not pick proper gpu on most laptops
the ones that have two of them
had to dig up my old opengl engine to look for the magic exports
golden schooner
had to dig up my old opengl engine to look for the magic exports
you could have asked as well, or just use the searchbox on this server 😉
shell inlet
im at a hotel away from home attending college
shell inlet
you could have asked as well, or just use the searchbox on this server 😉
digging up old projects is not a rare thing for me so it was faster than google search query
because i still remember how things are designed in them more or less
can recall where specific code is at
shell inlet
are you asking to segue into something else?
or specifically curious when I get back at home
shell inlet
well then it's just one more week and im moving back
shell inlet
but I will have a lot of homework to do
golden schooner
thought you were gone for half a year or so now, and no beingable to use your pc pc
shell inlet
it's distanced
I attend personally only for 3 weeks
the rest is self educayshun and homework/coursework/internships
and now next year thesis
golden schooner
i see
long robin
<@288411937962721305> basically add this code somewhere
```cpp
#ifdef _WIN32
ext...
I need to figure out if pasting the magic vars is the ideal thing or if I should expose this some other way
golden schooner
for opengl its the only way, unless you force it in the control panel
long robin
Well yeah
I guess those vars need to be set before creating the GL context
Plus that code only works on Windows
heavy cipher
use vk to do device sel and swapchain and do interop to do the rest in GL
shell inlet
expose like as a part of teh api?
is my internet bad or is discord bad
anyways you can only idfef it with some macro there's nothing more to do about it
long robin
I can just put it in Application.cpp actually
golden schooner
app.cpp is bae class of the others
long robin
Yeah all the examples use it
long robin
I did not
I wonder why
Maybe it's a bug in window resizing
Perhaps it's trying to make 0x0 render targets
golden schooner
maybe render() can be skipped when window is minimized
long robin
Let's see what's causing the crash first
golden schooner
hmm i found something earlier
and reminded me of your open issue at renderdoc
GL_INTEL_performance_queries
has metrics for the thing you are asking
...
31 FragmentsKillCount 0x940b uint64 Number of times Fragment Shader performed a fragment-discard operation for fragment or sample
...
Lol you called me jaker although my GitHub handle is different
golden schooner
Lol you called me jaker although my GitHub handle is different
lol
reflex, let me massage it
: D
baldur might know either way
long robin
Let's see what's causing the crash first
looks like the window is indeed becoming 0x0 and it trips an assert in glm::perspective
should be an easy fix. I just need to add the thing to Application.cpp as well
long robin
@shell inlet I pushed the high perf magic numbers and the window minimize crash fix
long robin
I'm also not sure
long robin
I was secretly seeking validation this whole time
🤰 anyways, time to work on the denoiser once more
heavy cipher
the real validation layer is the friends we made along the way
golden schooner
hmm @long robin i noticed you use GL_GOOGLE_include_directive
but isnt that only available in glslangvalidator and shaderc?
long robin
Yeah, I'm only enabling it though
Not requiring it
Basically I only use it so the linter doesn't complain about my includes
golden schooner
hmm but
will it include the files? or do you have a custom handler somewhere? (i didnt bother to check)
heavy cipher
will it include the files? or do you have a custom handler somewhere? (i didnt b...
correct behaviour is just enabled, not required 😛
long robin
will it include the files? or do you have a custom handler somewhere? (i didnt b...
I'm using stb_include
Therefore I don't care if the extension is actually implemented
golden schooner
ah i rember you mentioning that one now
long robin
Yes it's literally just so I can press ctrl+s and not have the linter complain
The extension I mean
I couldn't figure out a more convenient way to do it
heavy cipher
but isnt that only available in glslangvalidator and shaderc?
you said yourself here deccer
long robin
The best part is that Nvidia's driver actually implements it (the new line directives)
golden schooner
nvidia implements the ARB version, ye
long robin
No, I mean Nvidia will compile your #extension GL_GOOGLE_include_directive : require as well as the #line directives it adds
And it will actually use the line directives for error reporting
golden schooner
ah
astral nacelle
tfw you send jjj to a random text channel cause you were watching a youtube video and wanted to rewind a minute but didn't have youtube as the focused window
long robin
What does j in discord do
astral nacelle
j is a keyboard shortcut to 'go back 10 seconds' in youtube. l goes forward 10 seconds. k is play/pause
nothing. its called I had the wrong window open when I hit j on the keyboard
golden schooner
i use arrow keys 🙂
astral nacelle
arrow keys are good for finer scrubbing, cause its 5s intervals
long robin
5 second increment pleb
golden schooner
is it?
long robin
tfw you send jjj to a random text channel cause you were watching a youtube vide...
You should've pressed enter
astral nacelle
I should of. Wouldn't of been the first time!
golden schooner
of times is the charm
astral nacelle
shhhh of is my calling card
golden schooner
at least you dont work on work stuff right now 🙂
long robin
shhhh of is my calling card
You should of kept it a secret
astral nacelle
I would of but wheres the fun in that
golden schooner
heh
astral nacelle
I haven't figured out what we are doing for next week GP meetup. I half wanna do a 'lets play with fwog'
golden schooner
@daring narwhal spit it out
daring narwhal
what was i typing in here
golden schooner
np 🙂
long robin
I haven't figured out what we are doing for next week GP meetup. I half wanna do...
It might be interesting if you use a small framework (e.g., the application class in examples-refactor) to speed things up
golden schooner
jaker coerce them into implementing the volume clustered thing#
long robin
but it doesn't fundamentally change anything about designing a renderer, so it would pretty much just be that but with some convenient stuff from fwog
golden schooner
maybe peeps could see if fwog makes sense, architectural wise, if its easy to use to write advanced stuff, or if stuff is missing
golden schooner
sounds like a cool idea
long robin
What a spooky level of scrutiny to be subjected to
golden schooner
shut up and deal with it
long robin
I haven't even merged examples-refactor yet
golden schooner
ah speaking of
i was able to get my old business laptop working again, has a 960m in it and your volume renderer and rsm thing run way smoofer
astral nacelle
i'm just shooting ideas, we don't have to do it jaker 🙂
golden schooner
isnt it just the RSM part?
long robin
All of the examples got heavily refactored
golden schooner
ah
long robin
But also there are a bunch of RSM improvements and other random stuff tacked on
long robin
Yeah, I can probably merge it soon then open a branch for RSM stuff
astral nacelle
maybe not this week, but soon ™️
long robin
I wonder how reprojection error is handled for normal and depth rejection heuristics
perhaps a shrimple bilinear interpolation works for those
eh, there is still overzealous rejection on edges when turning the camera
mayhaps I shrimply select the pixel in the 2x2 that closest matches the original pixel in depth or normal
this seems to clear up some of the unnecessary rejection
vec4 depthPrevs = textureGather(s_gDepthPrev, reprojectedUV.xy, 0);
vec4 diffs = abs(depthPrevs - reprojectedUV.z);
float depthPrev;
if (diffs[0] < diffs[1] && diffs[0] < diffs[2] && diffs[0] < diffs[3])
depthPrev = depthPrevs[0];
else if (diffs[1] < diffs[2] && diffs[1] < diffs[3])
depthPrev = depthPrevs[1];
else if (diffs[2] < diffs[3])
depthPrev = depthPrevs[2];
else
depthPrev = depthPrevs[3];
but the #line is not part of that ext
long robin
well, nv can compile C-style #line directives, wherever they come from
heavy cipher
yes, but thats part of glsl, not the ext, afaik
heavy cipher
wait whats the c-style ones then
heavy cipher
okay, but the file you linked is the glsl spec
long robin
`#line 123 "foo.h"`
what I am saying is that NV can compile these
I assumed they came from the google include directive extension, but according to you that is false
heavy cipher
you are out of line kowalski
long robin
no u
golden schooner
jaker im going to center fwog's windows
did you change anything in Application in examples-refactor?
long robin
Since when?
golden schooner
since the branch was created
long robin
Yes, I have changed it
golden schooner
oki then ill base the branch off of this one then
oki of ill base of branch of of of of then // for thomas
long robin
Yeah, cuz I ain't done
golden schooner
its been 11hrs since i made this PR? feels like it was 2hrs ago
long robin
hmm what's the default font in VS 2022 called
golden schooner
Consolas?
long robin
my work PC has some old-looking font
it's really consolas by default?
on my home PC it looks different, more modern
long robin
golden schooner
ye looks washed out
shell inlet
why is it so big is my question
golden schooner
no thats just discord
long robin
4k monitor
golden schooner
looks sharp, its serif
golden schooner
looks like jaker increased fontsize
shell inlet
I changed the zoom in the text editor because of that
golden schooner
or ctrl+mousewheeled a little
shell inlet
I don't think monitor resolution plays the role in the font scale also
long robin
I have this tho
shell inlet
because the bigger it is the smaller every thing is by default unless you tweak it
good job internet made me feel like im using internet explorer
golden schooner
that will also change in the future 🙂
restarting because you installed an extension
shell inlet
promises promises
golden schooner
when they move addons out of process
shell inlet
it's not funny that even on my modern pc visual studio often lags
they are probably in a tremendous tech debt
golden schooner
yea