THE CPU (Central Processing Unit): The CPU is a MIPS 4300 processor, which was designed by MIPS (a division of Silicon Graphics) specifically for the Nintendo 64 (although a variant of the 4300 CPU is now available for other applications). The CPU controls most aspects of the game. It figures out what the player wants to do based on the input from the controller. It figures out what all the creatures and objects in the game are going to do based on the program that the game designer wrote. Finally, every frame (somewhere between about 15 times per second up to 60 times per second depending on the game) the CPU decides what objects to draw in the scene and from what viewing angle and position to view the scene. It also describes what lights will be shining on the objects, how much fog is around, and various other aspects of the scene. This information is then sent to the RSP. THE RSP (Rendering Signal Processor): The RSP takes the information about the scene (the shape of all the objects, the colors and attributes of the objects, the lights shining, the viewing position, etc) and figures out where to draw them on the screen. The objects are all described in terms of triangles. Each object which appears on the Nintendo 64 is made up of many small triangles. The RSP figures out where on the screen to place each triangle, as well as how big to make it and what color to draw it. This information is all calculated based on the scene description sent from the CPU. Some specific things the RSP does is transform the vertices, perform a perspective divide (to give the appearance of perspective, where things that are farther from the viewer appear smaller), do lighting (figure out what color to draw the triangle based on the triangle's intrinsic color and the lights that are shining on it), do clipping (clip away triangles and pieces of triangles which are off of the screen or behind the viewer), and setup the triangle data in the format that the RDP expects. THE RDP (Rendering Display Processor: The RDP takes the description of each triangle from the RSP and figures out how to draw it on the screen. It gets a description of the 3 corners of each triangle and figures out which pixels (the dots that make up the screen) are contained within the triangle. Then it puts the correct color in each of those pixels. The result is a triangle on the screen. The RDP also performs Z-buffering (to ensure that parts of the scene (triangles) which are farther away from the viewer are obscured behind parts of the scene (triangles) which are in front of them), texture mapping (attaching a flat picture to the triangles such that the picture appears wrapped around, or pasted to, the 3 dimensional object), and anti-aliasing (making the edges of triangles smooth so they don't appear bumpy, or "stairsteppy"). If you look at the circuit board inside the Nintendo 64 you will see 2 large square computer chips, 2 large rectangular chips, a smaller rectangular chip, and several other components (little boxes and cylinders). The large rectangular chip in the center is the RCP (Rendering Co Processor). The RCP contains the RSP and the RDP (described above) as well as several other important parts of the Nintendo 64. The square chip to the left is the 4300 CPU. The 2 large rectangular chips are the RDRAM memory chips (4 megabytes of RAM total). The smaller chip was designed by Nintendo and communicates with the game controllers as well as performing some other tasks. The rest of the components are used for outputting video and amplifying audio. This description is a great simplification of what goes on inside the Nintendo 64. There are many other things going on that I have not mentioned. For example the CPU and the RSP also process all the sound (music and sound effects) which come out of the Nintendo 64. The part which Silicon Graphics designed (in addition to the 4300 CPU) is the RCP (which contains the RSP, the RDP, and many other important parts of the Nintendo 64). I personally worked on the program which runs in the RSP. Specifically I wrote the lighting, clipping, and matrix code among other things. I also worked on verifying the RDP to make sure it was designed correctly before spending lots of money to build it. Specifically I verified the blender unit which is responsible for z buffering, anti-aliasing, and fogging. |