 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 DriveNintendo® Confidential |
|
 |
|
gspFast3D Microcode
gspF3DNoN Microcode
This microcode comprises the following six object files:
- gspFast3D.o
- gspFast3D.dram.o
- gspFast3D.fifo.o
- gspF3DNoN.o
- gspF3DNoN.dram.o
- gspF3DNoN.fifo.o
gspFast3D
The gspFast3D microcode is the most full-featured of the microcode types. It is also the microcode used in the majority of the demo applications. gspFast3D supports 3D triangles, 3D clipping, Z-Buffering, near and far clipping, lighting, MIP-mapped textures, perspective textures, fog, and matrix stack operations. It does not support the GBI macro, gSPLine3D.
gspF3DNoN
The gspF3DNoN microcode is similar to gspFast3D microcode except it does not handle near plane clipping in the same manner. When using gspFast3D microcode, objects between the eye and the near plane are clipped. When using gspF3DNoN microcode, objects between the eye and the near plane are not clipped. However, the area between the eye and the near clipping plane does not implement Z-Buffering. This means that objects that fall into this area must be rendered in order from far to near.
DRAM Version
The DRAM version of the microcode directs the output (RDP display list) to the RDP through a memory buffer (DRAM) that is larger than the buffer used in gspFast3D microcode.
The gspFast3D, gspFast3D.dram, and gspFast3D.fifo versions of the microcode are equivalent to the gspF3DNoN, gspF3DNoN.dram, and gspF3DNoN.fifo versions (respectively), with the difference that near clipping is performed at the Near Clipping plane in the former 3 versions, and performed at the eyepoint in the latter 3 versions.
All computations are performed with as much precision as is practical, in order to create the highest quality images.
Unsupported GBI Macros
All gSPLine3D macros are complied as no-ops, so they have no effect.
Performance
In order from the fastest to the slowest, the following types of triangles can be generated by this microcode:
- Filled Flat Shaded (must set primitive color in DP appropriately)
- Gouraud Shaded
- Gouraud Shaded, Z-buffered
- Gouraud Shaded, Textured
- Gouraud Shaded, Textured, Z-buffered
Vertex transformations and lighting calculations are heavily vectorized, so it is best to operate on as many vertices as possible. Even number-sized loads are more efficient because vertices are processed in groups of two.
When doing lighting, and any vertices are clipped, clipping and lighting are implemented as ucode overlays, using a most recently used algorithm. Lighting happens at vertex load time and clipping happens at triangle draw time, so this division of microcode is acceptable. However, a display list that loads only a few vertices at a time and then draws a small number of triangles, would not amortize the microcode swapping overhead very effectively.
The RCP is designed to draw high quality textured primitives. Where possible, use texture-mapping to achieve visual complexity rather than additional geometry.
Notes on Different Versions
There are some differences when calling the DRAM and fifo versions of this microcode.
gspFast3D: The flags field of any task followed by this task should have OS_TASK_DP_WAIT set. If more than one task using this microcode is called in the same frame, then only the last task should contain a gSPFullSync in its display list. This microcode takes care of sending all output to the RDP. When using this microcode, it is not necessary to specify output_buff or an output_buff_size. (These fields of task header can be set to 0.)
gspFast3D.dram: Tasks using this microcode need to set the OS_TASK_DP_WAIT flag only if they follow a task using gspFast3D or gspFast3D.fifo. This microcode sends its data to a buffer in DRAM and not to the RDP. The CPU must then cause the buffer to be sent to the RDP. The buffer is pointed to by output_buff in the task header. This must point to a buffer which is at least as big as the maximum RDP display list that can be generated by the task. Remember that when geometry gets clipped RDP lists will expand, so leave extra room. If the buffer is not large enough to store the entire RDP display list, other memory areas will be overwritten. After the RSP finishes its process, the buffer can be sent to the RSP using the osDpSetNextBuffer command. The length of data in the buffer, which is needed for osDpSetNextBuffer, is written at an address specified by rdp_output_len in the task header. While the display list is being sent to the RDP, the RSP can execute other DRAM microcode, whose output_buff is different, or audio tasks. When gDPFullSync is not included in the display list to be sent to the RDP, other RDP display lists can be sent (from the RSP task to other buffers) using other osDpSetNextBuffer commands. However, when gDPFullSync is included in the display list, neither send other RDP display lists using osDpSetNextBuffer nor start gspFast3D or gspFast3D.fifo tasks until completing the display list.
gspFast3D.fifo: A task that uses this microcode and is followed by a gspFast3D task or a osDpSetNextBuffer command needs to set the OS_TASK_DP_WAIT flag. This microcode watches transmission of the display list to the RDP. A buffer specified by output_buf in the task header is used. The buffer must be cache aligned. Output_buff_size must be the pointer for byte followed by last byte of the buffer. The larger the buffer is, the more practical the interface between the RSP and the RDP. When there are multiple tasks in parallel which use fifo microcode, only the last task in a frame must include gDPFullSync. There are multiple tasks continuously which use fifo microcode, all tasks must use the output_buff buffer. (Each task can use a different buffer, however, it is more efficient to use one large buffer for all tasks.)
Note for Near Clipping
Near Clipping removes geometry either behind the viewer or between the viewer and the Near Clipping plane. In actual circumstances, an object never disappears when getting closer to the viewpoint, so it should not happen in a N64 program. One way to achieve this is to locate the near plane very close to the viewpoint. (By calling guPerspective, make the near value small.) However, it does not always work because the smaller ratio of near/far makes the accuracy of Z and texture mapping worse. Another way to accomplish this is to use a gspF3DNoN microcode (or its DRAM or fifo version) which does Near Clipping. An object behind the viewer is clipped and an object far from the near plane is visible. However, an object between the near plane and the viewer is also visible. In this way, the near value can be increased without geometry disappearing between the viewpoint and the near plane.
Z buffering never functions in the area between the viewpoint and the near plane. As a result, objects between the near plane and viewer never hide each other. For example, in an asteroid type game, when an asteroid approaches the view point closer than the near plane, the asteroid is drawn correctly. (objects far from the near plane are hidden.) However, when two asteroids approach closer than the near plane, they cannot be hidden correctly.
Default RDP State
Whenever a graphic task is first started, some of the RDP states are initialized to their default states. The rest of the states keep their previous values. After restarting from yield, RDP states are restored with states set at yield. The following are RDP default settings:
- gsDPSetAlphaCompare(G_AC_NONE)
- gsDPSetDepthSource(G_ZS_PIXEL)
- gsDPSetRenderMode(RM_NOOP, RM_NOOP2)
- gsDPSetAlphaDither(G_AD_DISABLE)
- gsDPSetColorDither(G_CD_DISABLE)
- gsDPSetCombineKey(G_CK_NONE)
- gsDPSetTextureConvert(G_TC_FILT)
- gsDPSetTextureFilter(G_TF_POINT)
- gsDPSetTextureLUT(G_TT_NONE)
- gsDPSetTextureLOD(G_TL_NONE)
- gsDPSetTextureDetail(G_TD_CLAMP)
- gsDPSetTexturePersp(G_TP_PERSP)
- gsDPSetCycleType(G_CYC_1CYCLE)
- gsDPPipelineMode(G_PM_NPRIMITIVE)
gspLine3D
gspTurbo3D
osSpTaskStart
|
|
|
|
|
|
|
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
|
|
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 |