Sample Program Readme

The following is an explanation of the functions and features of each sample program:

The following sample programs depend on demos/Texture/ directory, so compile Texture/ directory before compiling them.

autofill:
This is a simple sample program that measures the performance of painting out the screen. It paints out the screen using a polygon with different aspect ratio for size, and measures the speed automatically. It is possible to see the measurement data using gnuplot. For details, refer to README in the autofill sample program.

blockmonkey:
This is an application that measures a simple performance. The user can change the size of a display list or parameters, and confirm the effect when rendering. Operation instructions for the Controller are displayed on the host screen when the application is executed.

The graph of performance measurement on the lower screen shows the time needed to render a polygon. The processing time of CPU needed to create a display list is not calculated. This is not to slow down the animation even when it cannot catch up with the next frame.

bumpmap:
This is a sample program of bump mapping. For details, refer to the README in the bump map sample program.

chrome:
This is a sample program for the reflection mapping function.

ci8fb:
This sample program is similar to autofill. Rendering is processed using 8bit color index. For details, refer to the README for the ci8fb sample program.

cptest:
This sample program is simple and uses C++. Please refer to README of the cptest sample program for details.

detail:
This is a sample program which explains how to use the multi tiling texture. This demonstrates the detail texture and MIP map texture as well.

eeptest:
A simple program to test EEPROM (4k or 16k).

fault:
A sample program which processes CPU exceptions without using rmon debug thread.

fogworld:
This is a sample program which shows how to use the fog process and the volume culling process.

ginv:
A simple sample program to output information such as the version of the emulator board which is equipped to INDY or clock speed of RCP or CPU and total available DRAM capacity.

greset:
A simple sample program to simulate the operation of pushing the Reset button on the Nintendo 64 Control Deck.

ground:
This is a sample program which performs the clipping of a large ground plane accurately.

gs2dex:
This is a sample program which explains how to use the sprite micro code S2DEX.

perl is needed to compile this program. Please install the following package from the IRIX CD.
gtdemo:
This is a complicated sample program in which characters run or punch someone. It performs a demo of the multiple graphics task and uses turbo3D microcodes a lot. Animation is realized by a complicated matrix calculation by the host.

hostio:
This sample program exchanges data between Indy (host) and the game application using the Host-U64 API (Application programmer's interface). For detailed information, please refer to hostio/Readme.

lights:
This expresses specular highlight effect, which uses RSP texture and shadows (shades) falsely. Using inputs from the Controller, it controls the location and size. The background is processed with MIP map.

mipmap:
This demonstrates MIP mapping. It is possible to verify by comparing with other texture processing or changing MIP map parameters.

morphcube:
The CPU calculates each vertex for morphing. The CPU and the graphics pipeline execute 2 frames consecutively in parallel. Tiling of a large MIP map texture is processed with a capacity that is stored in a texture memory.

morphfaces:
Morphing of two dimensional images. The CPU processes the morphing of vertex, and blending is performed using 2 cycle mode. For details, refer to NOTES in the morphfaces sample program.

motortest:
A sample Rumble Pak program.

nnsample1:
A sample scheduler program created by the NINTENDO 64 Technical Support Center.

nnsample2:
A sample program that uses the graphic microcode F3DEXVer1.21.

nosPak:
A sample program for the Controller Pak menu using the N64 font data.

onetri:
A simple sample program for rendering 1 polygon without Z buffer. By executing using "gload -a -t", simple texture mapping is possible.

overlay:
A sample program that overlays onetri code (2 different segments containing code or data share the same memory area).

pfs:
A sample program for the Controller Pak. You can experiment with checking, creating and deleting game notes. The control operations are explained below: C Up...Check the file system C Down...Delete game note C Left...Create game note C Right...Format the Controller Pak A...Game note read test B...Game note write test START...Reread & display This sample program differs from the Controller Pak menu provided with the application. For a sample Controller Pak menu, see the provided nosPak sample program.

playseq:
A sample program using the sequence player.

polyline:
This renders by switching microcodes of polygon and line.

print:
This test program measures the effect the use (or disuse) of osInitRdb() has on the performance of the osSyncPrintf() function.

simple:
This demonstrates the compatibility of the audio process and the graphics process. In this sample, the audio process is supposed to stop the graphics process when the graphics process cannot be done in time.

soundmonkey:
A sample program using both the sequence player and the sound player.

spgame:
A sample program which renders objects in the foreground and the background using a sprite function.

spin:
A tool to experiment with the function of the RDP. Please refer to README of the spin sample for details. Execute the script file "spinit" to execute the spin. When the execution has failed, stop the execution once with CTRL+C and execute "spinit" again.

spritemonkey:
A sample program which demonstrates the use of sprite microcode Sprite2D.

sramtest:
Tests for the operation of 256K SRAM. The execution result is displayed with osSyncPrintf(). The 256K SRAM board is required for execution of this sample program.

terrain:
This is a sample program for the creation of geographical features. This renders the geometry using N64 hardware, and operates the interface using the Controller. Data can be created and save the disk of INDY by using this tool. Demonstration of many advanced function including the communications between the host(HOST I/O) is conducted. Please refer to README of the terrain sample program for details.

texlight:
A sample program which expresses a diffuse lighting process, a specular highlight process, and objects which are texture mapped at the same time.

tile_rect2d:
This demonstrates in a simple way to divide a large texture into small texture tiles so the large texture can be stored in texture memory. It creates two dimensional texture rectangle primitives.

tile_rect3d:
This explains how to divide a large texture into tiles so it can be stored in texture memory. As filtering is processed properly, there will be no joints. A triangle will be created.

topgun:
The fighter plane that appears in this sample program is data in .flt format modeled by MultiGen. The display list is created by the geometry converter flt2c, which is included as a sample program.

tron:
A wall is a transparent object which is not sort processed. It demonstrates how to use the BOWTIE_VAL parameter, which avoids RDP hanging.

turbomonkey:
This is the same as blockmonkey except that is uses turbo3D micro code. This is a sample program that verifies the difference between turbo3D micro code and Fast3D micro code on the actual screen. A trade-off of image quality or processing speed can be compared using this program and blockmonkey.