N64® Functions Menu

al - Audio Library Functions
gDP - DP GBI Macros
gdSP - General GBI Macros
gSP - SP GBI Macros
gt - Turbo Microcode RDP
gu - Graphics Utilities
Math - Math Functions
nuSys - NuSystem
os - N64 Operating System
sp - Sprite Library Functions
uh - Host to Target IO
64DD - N64 Disk Drive

Nintendo® Confidential

## Introduction to N64 Microcode

Graphics are rendered in Nintendo 64 games by creating a graphics display list and passing this display list to the RSP. In order for the RSP to process this display list, the application, using system calls, loads graphics microcode.
The pages in this section of the online Nintendo 64 Function Reference Manual introduce the different microcode object files available to applications.
The Seven Basic Microcodes
There are six basic versions of the graphics microcode:

- gspFast3D
- gspF3DNoN
- gspLine3D
- gspTurbo3D
- gspSprite2D
- gspS2DEX Each basic version has a different set of graphics rendering features and up to three subtypes. Each subtype has the same set of graphics features, but varies according to how the RSP passes commands to the RDP. The three possible subtypes are:
  - regular
  - .dram
  - .fifo
  The object files for the microcode are labeled as follows:
  - <basicType>.o
  - <basicType>.dram.o
  - <basicType>.fifo.o
  RSP to RDP command passing
  All types of RSP microcode generate commands for the RDP. The method used to pass the commands from the RSP to the RDP determines the suffix used to name the microcode object. In the regular method, the commands are written to a buffer in dmem, which can hold up to six RDP commands. If the buffer fills, the next time the RSP tries to write a command it will stall until there is space in the buffer. Microcode versions that use this type of command passing have no special suffix, just a .o appended to their name.
  Alternatively, the RSP can write all the commands to a larger fifo buffer in RDRAM. This helps to prevent the RSP from stalling when the RDP gets bound by processing large triangles. Microcode that uses this method has the .fifo.o suffix appended to its name. When using the fifo version of a microcode, the application must pass a pointer to a buffer to be used as the fifo buffer, in the task output_buff field. The size of the fifo buffer is put in the output_buff_size field. In order for fifo to have a positive effect on performance, the size of the buffer should be greater than 1K.
  The microcode also provides third option. The RSP can write all of the RSP commands to an RDRAM buffer. In this case, the application must start the RDP task separately by calling osDpSetNextBuffer. (This form of command passing is very useful for debugging in conjunction with the tool dlprint which can print display lists in a human readable form.) Microcode designed to use this method has the .dram.o suffix appended to its name. Tasks using the .dram.o microcode need a pointer to a buffer in the output_buff field of the task structure, and a size in the output_buff_size. Because RSP commands usually expand when converted into RDP commands, this buffer needs to be larger than the size of the RSP display list.
  The F3DEX Microcode Series
  In addition to the seven basic microcodes, there are seven additional modified versions of gspFast3D, gspF3DNoN, and gspLine3D that have been specially modified to .fifo subtypes to improve performance. These modified versions are:
  - gspF3DEX
  - gspF3DEX.NoN
  - gspF3DLX
  - gspF3DLX.NoN
  - gspF3DLX.Rej
  - gspF3DLP.Rej
  - gspL3DEX
  Together these seven modified microcode versions are known as the "F3DEX microcode series" or the "F3DEX package."

  Nintendo® Confidential Warning: all information in this document is confidential and covered by a non-disclosure agreement. You are responsible for keeping this information confidential and protected. Nintendo will vigorously enforce this responsibility.
  Copyright © 1998
  Nintendo of America Inc. All rights reserved
  Nintendo and N64 are registered trademarks of Nintendo
  Last updated March 1998