i dont know much about the parallel lua thing or actors but maybe that might be able to help, never used them but yeah just heard about them
1 Like
nice, also W acerola same thing i used
1 Like
(also quick plug here’s what my implementation looks like)
(these are the characters too " .∙⁚⁖⁘⁙⁜♼☗"
3 Likes
tried your gradient, and no character renders properly (ignore the red edges)
what font do you use? can’t seem to make it render ascii character properly; also how did you get it to 25 fps at 80x80 resolution? that seems fairly fast for 80x80
1 Like
the font I used was Inconsolata, and im pretty sure the only reason im getting 25fps for 80x80 is because i just have a good cpu lol (also no gaussian)
1 Like
no gaussian 
so it is pure edge gradients or another preprocessing alternative
seems like it i guess
it still shows up as <?> might just be on my end
1 Like
yeah its just pure edge gradients
it still shows up as <?> might just be on my end
weird
1 Like
skipped the difference of gaussians step and got 0.2 frame refresh rate + 17 fps;
definitely more noisier though
1 Like
i edited the source code of ComputeLua to poll faster with PreRender instead of task.wait (Heartbeat), which brings it from 0.2s DoG frame time to 0.06s DoG frame time, with 0.1~0.2 whole frame time, with the same FPS; while this might seem not so significant, it should help reserve more time for the raycast/sobel calculation
also hey you can try it out here: ascii shader - Roblox
let me know whats your fps
1 Like
yoooo, I somehow made it 250% faster!!! I was experimenting with parallelism techniques and got a library prototype working, with it, it stands at 75ms compute time which is 13 SHADER FPS (shader and native fps are different)
I decreased the number of actors and it got to a stable 20 shader fps
It seems like I need to dynamically find the right amount of actors, since the less actors there are, the less lag thereof
When Difference of Gaussians and Sobel runs serially instead of in parallel, it gains a big increase in Shader FPS and lower compute times, but with lower FPS, which leads to less smoother gameplay. So I guess the parallelism will guarantee smoother experience, but with more overhead than the serial counterpart
i noticed that playing it windowed is better, and is actually playable too (10 fps but still playable)
did you try to use Actors?
ofc i did or else you’re gonna see a lot of choppyness, you should be able to tell from the debug window
do you mean better performance wise or just more convenient windowed, the code expects the screen to be as square as possible so maybe thats why it looks better
This is very cool. I already got the ball rolling on making meaningful stuff with roblox and have been wanting to learn the absolute fundamentals of graphics programming so was wanting to try in roblox - this is really cool to see as it means fancy things are possible. Not a lot (no screen space for me 
) but still, very cool
Just out of curiosity - is this all done entirely with raycasts? Like, raycasting is used to gather “pixel” data in a grid and then processing is done on top? Or is there other data being pulled in? I was wondering what resolution a filter could be pushed to at max without actual pixel data access
yep
yep
not that im aware of, the data is just the raycast result which is then processed
not sure i quite understand, because filters (with kernels) do require pixel data access?
not sure i quite understand
reasonable; me neither. I guess I assumed whatever you were doing to get the | \ / - edge lines involved some data beyond just the raycasts - I guess I assumed you couldn’t do effective difference of gaussians with that little information? Idk. I forwent further high-level comp sci and calculus studies to focus on my art skills so in this context I’m kind of just hitting things beyond my comprehension with hammers and hoping it works.
Regardless, this is cool as hell; mad respect. Hopefully someday I can learn to use the same tech. This is awe-inspiring, so hats off to you, and sorry again for the necropost lol
The data taken is purely raycasts (color, transparency, position, etc). There’s really no outside factors.
In case you weren’t aware, this is the pipeline:
Raycast (including reflection and refraction) → Difference Of Gaussians → Sobel → Edge quantization based on the sobel gradient (in serial)
So they’re all just processing the raycast data. The DoG is just a preprocessing step for the sobel filter.
Pretty much, difference of gaussians with 80x80 is somewhat performance demanding for roblox. And that small of a resolution causes most of the edges to merge together.
Well thank you! I hope roblox would have their attention back to Parallel Luau since it’s pretty limited right now