Rodrigo Copetti

I was wondering what instruction set architecture the megadrive was using and came across this great article on the Motorolla 68000 and megadrive: https://www.copetti.org/writings/consoles/mega-drive-genesis/#cpu

If you want an architectural overview of the DS, this is a fantastic overview: https://www.copetti.org/writings/consoles/nintendo-ds/

If you want to appreciate his work today, consider reading these lovely articles about the systems he helped design: https://www.copetti.org/writings/consoles/master-system/ https://www.copetti.org/writings/consoles/mega-drive-genesis/ https://www.copetti.org/writings/consoles/sega-saturn/ https://www.copetti.org/writings/consoles/dreamcast/

Another deep dive is in https://www.copetti.org/writings/consoles/master-system/ I've got a mostly-written emulator (in Rust). It's very easy to emulate, possibly the best gameplay bang for the emulator coding effort buck aside from NES. My main intent in writing this emulator is getting it running on an RP2350 board, like Adafruit Fruit Jam or Olimex RP2350pc. It should also be possible to get the next generation (SNES, Genesis) on such hardware, but it's a much tighter fit and more effort.

If you're wondering about the overall architecture of the NES, I just found this page - it's pretty great and answered all my questions that came up reading the article: https://www.copetti.org/writings/consoles/nes/

What a great writeup! For anyone wanting to dive deeper on the PS1 hardware, I can't recommend this writeup enough: https://www.copetti.org/writings/consoles/playstation It's part of a great series on various retro and not-so-retro game console.

Among one of the excellent articles on game consoles is the on on the 3DS that references the 3dbrew articles, but provides an easier to higher level explanation of the flaws (along with how the rest of the machine works). https://www.copetti.org/writings/consoles/nintendo-3ds/

Have you checked out https://www.copetti.org/writings/consoles/, it's a great write up of various consoles and the author does go into some context/history behind each console he has covered. To support the author, there is also the ebook option: https://www.copetti.org/writings/consoles/materials/ebook/

Loved your article! I just wanted to expand a bit on your last section. The Game Boy Advance did offer somewhat support for integer division, but it's not hardware-accelerated [1]. I suspect the LUT model was for performance reasons (and rightfully so!). [1] https://www.copetti.org/writings/consoles/game-boy-advance/#operating-…

This is part of an excellent series https://www.copetti.org/writings/consoles/

The Saturn one is a great read, what a crazy design: https://www.copetti.org/writings/consoles/sega-saturn/

> Is that how the wii u ran wii games? More or less. The Wii U is architecturally very similar to the Wii, just with a higher clockspeed, a couple of extra cores, more RAM and a better GPU; the Wii in turn is just an overclocked overspecced GameCube. It's possible, through a homebrew application, to load and run GameCube games directly on the WiiU. If you're interested in this kind of thing, I'd highly recommend the architecture of consoles series of blog posts[1][2]. [1]: https://www.copetti.org/writings/consoles [2]: https://www.copetti.org/writings/consoles/wiiu/

> We also should not forget the Sega Genesis. Thank you - I forgot about the 68000-based consoles :) Ironic, given how many great articles about console architecture[0] have done the rounds recently! The Atari Jaguar and Sega Saturn also had 68000s among the many processors in their complex architecture, albeit explicitly as a sound coprocessor in the Saturn. Edit: I guess I didn't exactly forget - I was restricting my mental search to the 68030 specifically. But all the 680x0 systems were cool :) [0] e.g. https://www.copetti.org/writings/consoles/mega-drive-genesis/

PS2 was unique. EE was the CPU, but it had two programmable vector units as MIPS coprocessors or something like that. VU0 could talk to VU1, and VU1 could talk to the GS directly. I think their job was generating "display lists" for the GS to follow and draw per frame. GS might be more accurately called a rasterizer/TMU. https://www.copetti.org/writings/consoles/playstation-2/

Rodrigo Copetti has a great article detailing the Wii architecture and how similar it is to the GCN - https://www.copetti.org/writings/consoles/wii/ - Really looking forward to his Wii U article.

This is an awesome article! It covers a lot of ground in a way that makes sense for people that aren't game developers or system-level engineers. I love the tabbed sections and the model viewers too. It looks like the author, Rodrigo, has done similar articles for a bunch of other consoles which is incredible. https://www.copetti.org/writings/consoles/

Nice! I loved the Mega Drive one [0]. This series is so cool! Its full of details on sprites and architecture. I admire the work that was put on this. [0] https://www.copetti.org/writings/consoles/mega-drive-genesis/

Impressive because a lot of N64 devs at the time didn't do these now-common things Absolutely, but it's also worth noting that these techniques might not have been viable in the context of a game (or at least, most games) anyway. The author himself addressess this at the end of one of the videos and concludes that it might be a stretch unless a game was designed specifically around this rendering strategy. He skips the N64's hardware Z-buffer (to conserve bandwidth) and DIY's it, which works for the demo because the demo room has exceedingly simple geometry. I don't know that this approach would work once you involve player models with 500-700 polys as seen here: https://www.copetti.org/writings/consoles/nintendo-64/ The transition between texture detail levels is also a bit jarring: it's an amazing demo, but might be too jarring or frustrating for a game. On the positive side, the demo runs in the N64's hires mode, which could be avoided to free up some perf. Also the author admits that the highest detail level of the textures is not something that would necessarily be needed for a game. One also wonders if a hybrid approach would work: "megatextures" and DIY z-buffering for the scenery, trad rendering for the characters. I don't know if that is possible.

You're very welcome. Computer graphics has a very interesting history, and like many things, there's a lot to learn from studying it. Surprisingly, many techniques and principles are still relevant to this day. Thankfully, the Internet is full of documentation, post-mortem accounts and reference implementations to learn more about all this. Here's a bunch of random noteworthy things and references I forgot to link (sorry for potentially digging rabbit holes): The best information tends to come from official documentation detailing almost everything you want to know about the inner workings of systems. Additionally, unofficial community documentation can also be of great quality and complement official sources. The architecture overview posts from Rodrigo Copetti (https://www.copetti.org/writings/consoles/) pack a lot of accurate information at a glance, and are a great starting point if a specific topic piques your interest. The Resident Evil 2 microcode post-mortem: https://ultra64.ca/files/other/Game-Developer-Magazine/GDM_September_2… Improved lighting, reverberation, Dolby surround and MP3 microcodes from Rare: https://youtu.be/jcIupBUAy98?t=41 H.264 decoding microcode: https://www.reddit.com/r/n64/comments/gpwxx0/my_dragons_lair_port_now_… The Reality Signal Processor's programming guide:…

That post introduced me to both WebGL and reverse engineering back in the day. I remember reading it years ago and asking myself "seriously, is it that easy to do 3D in a browser???". The web as an app platform is not without its issues, sure, but for quick prototyping being able to just write some JS and have instant access to plenty of APIs is awesome. Last year I decided to finally break out of the browser and get into actual PS1 homebrew. Unfortunately the state of the scene wasn't, and to some extent still isn't, that great: most homebrew games are still made using what's basically a modded version of the original Psy-Q SDK, which is rather limited in many ways. I started contributing to an open-source PS1 SDK instead [1] by first adding a dynamic linker, then revamping the build system entirely and now building a custom high efficiency FMV playback library (totally not inspired by pl_mpeg of course) that combines the hardware accelerated MJPEG-like decoder with the GPU's alpha blending capabilities. I'm also working with a few other people on reverse engineering one of the most famous PS1-based arcade systems, the Konami System 573. It's a shame the PS1 isn't receiving the attention other consoles are getting in the homebrew scene. The hardware is architecturally simple yet powerful [2], but I guess nobody wants to fiddle with 120mm polycarbonate circles anymore. [1] https://github.com/Lameguy64/PSn00bSDK [2] https://www.copetti.org/writings/consoles/playstation

A little more than just a multiplication instruction (the 68000, used in, say, the Sega Mega Drive, had one of those too). Have a look at https://www.copetti.org/writings/consoles/playstation/, and in particular, read about the GTE - it offered quite a bit of hardware support for 3D math. Also, even though it didn't handle truly 3D transformations, the rasterizer was built for pumping out texture mapped, Gouraud shaded triangles at an impressive clip for the time. That's not nothing for 3D, compared to an unaccelerated frame buffer or the sprite/tile approach of consoles past.

Discussed in the article, should you want a refresher. https://www.copetti.org/writings/consoles/playstation-3#architecture-o…

It's very impressive to see "realistic" graphics on the N64. The demo reminds me of "ICO" for the PS2. I've always wondered if it would be possible to create an SDK to abstract the N64 graphics hardware and expose some modern primitives, lighting, shading, tools to bake lighting as this demo does, etc. The N64 has some pretty unique hardware for its generation, more details on the hardware are here on Copetti.org: https://www.copetti.org/writings/consoles/nintendo-64/

I dunno, this write-up both seems a lot more detailed than Wikipedia re: the hypervisor & kernel and agrees with my recollection as foolishly confirmed by an LLM: https://www.copetti.org/writings/consoles/xbox-360/#operating-system Appreciatively discussed on hn! https://news.ycombinator.com/item?id=31678045 Doesn’t sound at all like the NT/2000 kernel/HAL/Executive.

> Old Nintendo consoles like the N64 or the GameCube/Wii didn't have programmable shaders. The N64 did in fact have a fully programmable pipeline. [1] At boot, the game initialized the RSP (the N64’s GPU) with “microcode”, which was a program that implemented the RSP’s graphics pipeline. During gameplay, the game uploaded “display lists” of opcodes to the GPU which the microcode interpreted. (I misspoke earlier by referring to these opcodes as “microcode”.) For most of the console’s lifespan, game developers chose between two families of vendor-authored microcode: Fast3D and Turbo3D. Toward the end, some developers (notably Factor5) wrote their own microcode. [1]: https://www.copetti.org/writings/consoles/nintendo-64/

Also check out Rodrigo Copetti's article about SNES architecture. https://www.copetti.org/writings/consoles/super-nintendo/

in case you don't know, some Gameboy games required to have Nintendo logo in the game data as part of copy protection. allegedly that was legal protection against bootlegs. https://www.copetti.org/writings/consoles/game-boy/#anti-piracy Playstation2 used something similar. ( https://github.com/mlafeldt/ps2logo ) I suppose it gave companies in question additional legal leverage - they could not distribute copies of games without violating the trademark laws.

You can do subpixel rendering with fixed-point math https://www.copetti.org/writings/consoles/playstation/#tab-5-2-contrad… I thought the problem was that it only had 12 or 16-bit precision for vertex coords, which is not enough no matter whether you encode it as fixed-point or floating-point. Floats aren't magic.

If you check the other articles about the PlayStation [1] and the Nintendo 64 [2], you'll see that the design of a 3D-capable console in the 90s was a significant challenge for every company. Thus, each one proposed a different solution (with different pros and cons), yet all very interesting to analyse and compare. That's the reason this article was written. [1] https://www.copetti.org/writings/consoles/playstation/ [2] https://www.copetti.org/writings/consoles/nintendo-64/

"it's misleading to call them sprites" "Sega calls them ‘distorted sprites’" [0] [0] https://www.copetti.org/writings/consoles/sega-saturn/#graphics