
Tutorial series for simulating NES Graphics (2018) - ericdanielski
https://nesrocks.com/blog/nes-graphics/
======
gdubs
This is nicely done. As an aside, there was something posted a while back
regarding some of the custom workstations that were used to produce art for
NES games. One thing I never really considered, but learned from that article,
is how artists back then utilized the imperfections of 'pixels' on a TV set to
give sprites more richness. In many ways viewing pixel art on a perfect modern
display loses something – a kind of 'warmth' or complexity that becomes too
'perfect' on a high-def display.

~~~
T-R
This came up indirectly in the thread on color emulation earlier[1] - there
was some discussion of the need to emulate phosphor glow[2]

[1]
[https://news.ycombinator.com/item?id=20959831](https://news.ycombinator.com/item?id=20959831)

[2]
[https://sites.google.com/site/psigamp3/PhosphorSimTest1.jpg](https://sites.google.com/site/psigamp3/PhosphorSimTest1.jpg)

------
mrob
Note that some of these features require special hardware support in the
cartridge. The NES cartridge connector exposes CPU and PPU (picture processing
unit) pins, and the simplest games ("NROM") connect ROM chips directly to
them. More advanced designs add an additional memory management controller
(commonly called a "mapper"):

[https://wiki.nesdev.com/w/index.php/MMC](https://wiki.nesdev.com/w/index.php/MMC)

The animated backgrounds are accomplished by the mapper bank switching the
character (tile) memory. The parallax scrolling is accomplished by the mapper
counting scanlines and generating an interrupt when the correct scanline is
reached, so the CPU can change the PPU scroll registers mid-frame with the
correct timing. Later mappers like the the MMC5 could precisely time mid-frame
bank changes to support more than 256 tiles on screen at once, and to support
8x8 attribute blocks instead of 16x16.

The ultimate mapper feeds arbitrary data to the PPU to simulate having a
bitmapped display with 8x1 attribute blocks (the PPU only reads attribute
memory once every 8 pixels, so that's a hard limit). Tom Murphy implemented
this with a Raspberry Pi (which isn't ideally suited to the task, so there are
timing imperfections causing graphical glitches, but theoretically it could be
done without them):

[https://www.youtube.com/watch?v=ar9WRwCiSr0](https://www.youtube.com/watch?v=ar9WRwCiSr0)

------
trykondev
Thank you for sharing -- these are great. I'm always impressed with this style
of tutorial which distills a useful lesson into a single image or GIF. These
are very clear, interesting, and informative!

There is another game studio that I've been following which does a good job
with this tutorial technique as well (Couch Game Crafters). One great example
of their work demonstrates creating a shader for animating the visual effect
of a toaster moving through a cartoonish pipe [1]

[1]
[https://twitter.com/CouchGameCraft/status/100797028441722470...](https://twitter.com/CouchGameCraft/status/1007970284417224704)

~~~
jmiskovic
I love this tutorial format. Below is my favorite series, which concentrates
on pixel art but is also useful for animation, composition, color composition.
Each GIF is a tiny work of art.

[https://www.patreon.com/saint11](https://www.patreon.com/saint11)

------
dannypgh
This is a nice companion to
[https://youtu.be/Tfh0ytz8S0k](https://youtu.be/Tfh0ytz8S0k) which deals with
more technical details of the implementation of NES and C64 graphics. This
document reads like requirements to that video's design.

------
mnky9800n
Can tiles be rotated or mirrored?

