The quest for N64 perfection

I’ve tried literally everything BUT I feel I’m really close this time.

This is what I have so far (I call it vifilter-3dfx.glslp)

shaders = "8" shader0 = "shaders/bilateral.glsl" filter_linear0 = "false" scale_type_x0 = "source" scale_x0 = "1.000000" scale_type_y0 = "source" scale_y0 = "1.000000" shader1 = "shaders/2xsal.glsl" filter_linear1 = "false" scale_type_x1 = "source" scale_x1 = "2.000000" scale_type_y1 = "source" scale_y1 = "1.000000" shader2 = "shaders/3dfx_pass_0.glsl" filter_linear2 = "true" scale_type_x2 = "source" scale_x2 = "1.000000" shader3 = "shaders/3dfx_pass_1.glsl" filter_linear3 = "true" scale_type_x3 = "source" scale_x3 = "1.000000" shader4 = "shaders/3dfx_pass_1.glsl" filter_linear4 = "true" shader5 = "shaders/3dfx_pass_1.glsl" filter_linear5 = "true" shader6 = "shaders/3dfx_pass_1.glsl" filter_linear6 = "true" shader7 = "shaders/3dfx_pass_2.glsl"

I have also set internal resolution to 320x240 and as you can see it looks somewhat good, but that text blurriness is driving me insane and I don’t know how to fix it.

What am I missing here?

That looks quite nice! I’m afraid there’s not really anything that can be done about that text insofar as post-processing doesn’t have any mechanism for selectively filtering only certain things. It just looks for pixels and applies a transformation. There are bound to be false-positives for things that you do/don’t want blurred.

Game text always forces me to make compromises when using shaders.

I haven’t experimented much with shaders in N64, but for SNES I’ve found scalefx gives an interesting result without messing up the text too much.

I think GTU is the best option for N64, myself, since you can adjust how blurry you want it.

Thanks for the input guys!

Seems like I have to compromise yet again then with something else, and I was so close because it feels so good with this setup (apart from the damn text which screw things up, just look at it as it tries to be sharp but can’t)

Changing resolution from 320x240 to 640x480 fixes the text for sure but then the image quality in general is to sharp for my taste.

You could also try reducing the parameter values on the bilateral shader, since that’s what’s doing the blurring. You likely won’t find any value that works for every game, but you might find one that blurs other stuff enough without affecting your text.

Looks like you’re using one of the OpenGL renderers. Try software or Vulkan. To use Vulkan, you have to enter RetroArch’s settings and change the driver. You’ll also have to use slang shaders instead of glsl.

Yes I’m actually using the GLupeN64 OpenGL 2.5 core, one of the last made earlier this year before the project was shut down.

I’m not so sure either Software or Vulkan will work on it.

With this setup there’s a mixed bag kind of experience, some games shows text “quite good” and some games like Super Mario 64 is a blurry mess regarding text.

I’m not giving up on having a genuine authentic N64 look and feel, someday it will come.

This entire topic seems fascinating to me.

So, if I understand right, the N64 system itself filtered the graphics in a particular way prior to sending it to a video source?

I’ve often thought (there’s no way Super Mario 64 looked like this on my TV) So I’m just really really intrigued.

The N64 had multiple layers of blurryness:

  • Low resolution textures stretched over huge areas
  • Bi/Tri-linear filtering to hide jaggies
  • Full screen filtering
  • The color bleed of the pixels on your CRT

there’s no way Super Mario 64 looked like this on my TV

I believe that’s thanks to the TV’s scanlines.

It is very fascinating indeed, but it can drive you mad for sure.

I have no problem getting other cores to look and feel like the real consoles do but N64 is insane and I have spent an insanely amount of hours trying to get it right but there’s always something off in the end.

There is definitely a love/hate relation to N64 emulation for me.

You wouldn’t happen to have a small list of sorts for what you used on the other cores would you? I’d love to do some comparisons.

Well I have tried all sorts of cores and combinations when it comes to N64 RetroArch emulation.

With ParaLLEl (former mupen64plus) I’ve tried Angrylion which is quite accurate to how the N64 looked and felt, only backside is performance.

However due to a recent discovery of a conservative fork of the Angrylion plugin for Project64 there might be hope for multi-threaded rendering support instead of single-threaded which the original Angrylion have (here’s to hoping!)

For GLupeN64 (now mupen64plus) I have used various combinations of shaders. NTSC S-Video, 3dfx, 3dfx with the other shaders from the .glslp I mentioned above.

All I can say is, experiment as much as you can. The vifilter-3dfx.glslp is an experiment which turned out to be quite good apart from the text blurriness.

I’m not really a fan of high resolution when it comes to emulation and have always striven for accurate replication of any given system I wanted to emulate and that means native resolution and if possible shaders, filters and palettes to recreate authentic experience.

So does mupen64plus now have resolution set of what the game outputs instead of fixed resolution? I remember Glupen64 had choices of resolution and they don’t have an option to use game’s native resolution like what Mednafen PSX does. That way, it seems easier to put shaders without having the screen blurry, and gliden64’s native resolution option seems to scale to a desired resolution with bilinear. The VI Filter seems to scale horizontal resolution to 640 by interpolating pixels rather than bilinear.

I don’t think so because not much work have been done to the mupen64plus-libretro core since loganmc10 dropped and left GLupeN64 and they renamed the cores.

As I understand it they’re focusing on working on ParaLLEl instead and it makes sense because in the end ParaLLEl will be the best choice for N64 RetroArch emulation once it’s polished enough.

I’ve spent the last couple of hours playing with the angrylion-rdp-plus plugin for Project64 and the performance (since it’s multi-threaded) is absolutely astonishing.

The Unfiltered Video Output looks sexy and it feels great being able to play games with Angrylion fullspeed.

Until ParaLLEl has matured this is the second best option as of today, right now for N64 emulation in general.

Be advised that you’re gonna need the cxd4 RSP for it to work correctly, other than that I highly recommend up to date builds of Project64, Azimer’s AziAudio plugin and the NRage input plugin.

ParaLLEl seems to always have its resolutions fixed to the game’s resolution like Mednafen PSX. I tested Angrylion Plus with the latest plugins that you linked, and it is a lot faster, and even 480i parts on 2D seems to run better than original. Though, switching from 480i to 240p seems to increase performance a bit slightly. The bottleneck for the most part seems to be cxd4 for me, but not huge. The Plus fork seems to run a lot of games on fullspeed with very few sound stutter and it made Battle for Naboo much more playable, despite not always going full. Only think right now for the fork is it has poor noise emulation seen in Starfox 64 and Pichu scene in Pokemon Stadium 2 compared to the regular plugin. I had to use Shunyhan’s audio since I couldn’t find a build for Aziaudio and the first seems to handle crackled audio a bit better. Tested it from FX 8350 4.0 Ghz

Yeah, this is typically the case for ParaLLEl’s vulkan renderer, too. Even with my crappy Radeon 240 machine at work, it’s still CPU-bound.

This plugin is pretty great, i can play some games at full speed, unlike the older Angrylion. Only problem is that it is missing the VI filters in some games like F-Zero. Even if i choose “filtered” in the options.

I kinda wish this version to be implemented in ParaLLEl instead since the old angrylion is pretty much unusable for 99% of games.

There have been WIP mupen64plus api support implemented now for the angrylion-rdp-plus plugin.

You can download it here and use it with loganmc10’s m64p project downloaded from here

I think i found a good solution for N64 after many attempts.

I’m using Mupen 64 on a 1080p display for this. First you need to increase resolution to 640 x 480 in Mupen options.

Then the first shader you load is the “blur9x9.glsl” inside blurs folder, at 2x scale. Then use crt-Geom as your scanlines, also at 2x, since this one has more even scanlines at non-integer scales. I would also disable the “dot-mask” option and reduce the curvature but that’s a matter of taste.

This way i managed a soft enough screen (close to the real N64) with CRT scanlines and the 2D elements and text seem fine, at least compared to other solutions. You still don’t get sharp text in Mario 64 but it looks good enough for me. You also get a nice, antialiased image, without jaggies around Mario’s hat, just like the N64 on a CRT.

Click on the images to see them full size:

1 Like