So far I have not seen anyone make a denoiser for a Roblox path tracing rendering engine. All realtime path tracers have to use some kind of denoiser, because the amount of samples to get a clear image is in the thousands (the gpu can’t do that 60 times a second). My rendering engine can’t use the gpu, but it allows a good image to render with 10 or more samples which the cpu can do in about 30 seconds. It takes about another 30 seconds to denoise and brighten the image.
(Text above is a bit outdated. I have seen some cool stuff recently)
I might make a showcase game for this in the future. Right now I am still experimenting and fixing stuff. Also the resolution is 5th the size of 1920 - 1080, or 384 - 216.
Features:
-Sunlight
-Ambient light
-Glowing objects
-Glowing terrain
-Water - kind of
-Transparent objects - kind of
-Denoiser
-Image brighten thingy
-Transparent objects coloring Sunlight
-Fresnel Reflections
-Smooth transition between full diffuse to specular reflections using the object’s reflection property
-Fake samples – samples color pixels randomly around the sample with edge detection to prevent color bleeding. This compensates for dark scenes without doing more samples and more calculations
And I think that’s it
What I will work on:
-Keeping Sunlight sharp after denoise - Fixed
-Keep objects behind transparent objects sharp before and after denoise - FIXED
-Keeping specular reflections sharp before and after denoise - FIXED
-Have water color sunlight
-Refraction I hope - Completed
-Make it a public showcase game/ make a version for the client
I forgot to mention, I used parts in a viewport frame instead of GUI instances, because I figured out that Roblox I think limits the amount of GUI instances a client can have. That’s a problem for larger resolutions. I think I should use editable images instead but I will have to learn how those work first.
During my first attempt I thought about it and tried to make that work, but it was kind of turning into a nightmare to try and do, and how I don’t know how I would hold the data of the image for edge detection without it turning into a mess. I think editable images might work better, but I would love to see if anyone could do that.
I believe it could work the same way as a conventional screen. Essentially, you save colours into a normal table on your however by however many screen size, then chop it up into rows. e.g row 1 = pixel 1 = 256,256,256,pixel 2 = 128,128,128… and so on then you repack them into a coloursequence with the same indexing you used in the square pixel packing, (I cant remember how to index coloursequences right now) but it would be something like colorsequence(1,256,256,256) and coloursequence:(2,128,128,128) and the frame that contains the colorsequence would be the same size as the amount of pixels in one row, so your rendering would be done line by line
I have to id verify which sucks. I heard there are ways to avoid that, but it’s not worth it right now. Besides, I do like to help others with their implementation by explaining my methods of denoising, and I think my project has good denoising. Might have been the whole goal at some point in making this.
Just a cool bonus of doing parts in a viewport frame. I can change how the image looks in post by the material the parts are. For example, the material neon makes the whole image look vibrant, but with dark shadows.
