
Nintendo 64 Vulkan Low-Level emulator – paraLLel – pre-alpha release - libretro
http://www.libretro.com/index.php/nintendo-64-vulkan-low-level-emulator-parallel-pre-alpha-release/
======
Jasper_
Should probably make an effortpost on this to explain what "low-level
emulation" is. That said, I don't support the libretro effort.

The Nintendo 64 is an architecture composed of a 64-bit MIPS CPU, 4MB of
memory, and, two chips for the GPU: the Reality Signal Processor (RSP), and
the Reality Display Processor (RDP). The codename for the N64 was "Reality",
and the system was co-developed by Nintendo and a small team at SGI.

The RSP is a programmable unit, while the RDP is a fixed-function unit that
does rasterization, perspective texture mapping, and basic glTexEnv-style
multitexturing.

When N64 emulators talk about "high-level" vs. "low-level", they're pretty
exclusively talking about how the RSP is implemented. The RSP is programmable
in that you can upload your own microcodes and provide your own instruction
set in return. When an RSP emulator interprets these microcodes directly, it's
"low-level". When an emulator author studies these microcodes, and then
reimplements them in C/C++, this is "high-level".

There are around 15 microcodes in existence, the most common one being F3DEX2,
which was the standard Nintendo-provided microcode which appeared a year after
the system was released. You can see the instruction set of F3DEX2 here:
[http://wiki.cloudmodding.com/oot/F3DZEX](http://wiki.cloudmodding.com/oot/F3DZEX)

Very few developers wrote their own microcodes -- pretty much only Rareware
and Factor 5 did their own thing. This is one reason why Rareware and Factor 5
games are harder to emulate.

Most emulators only implement low-level mode for compatibility and testing
purposes, since it tends to be pretty slow. paraLLel uses Vulkan and Compute
Shaders to run the RSP microcode on the GPU. I'm not convinced that's a good
approach, but good on them for trying.

~~~
anonbanker
why don't you support it?

~~~
Jasper_
The technical reason is that the microcode isn't designed to be run in
parallel -- it does DMA transfers between main memory and texture memory, and
such. I don't understand why running it on the GPU would help anybody.

For personal / drama reasons, the main author of libretro (squarepusher /
twinaphex) has a bad track record in the emulation community, but this isn't
the time or place to talk about it. Just know that not a lot of people in the
scene hold a very high opinion of him.

