/************************************************************************
  ＧｏＮｏＧｏテストプログラムをエージング検査用に変更したもの
  vi.cはかなり分かりにくいプログラムだったので全面改訂しました
  
  File          : vi.c
  Creater       : Masaki Wada
  E-Mail Address: wada@hamster.nintendo.co.jp
  
  **********************************************************************/


#include <ultra64.h>

#include "RGBA16brick.h"
#include "RGBA16brickMM.h"
#include "vi.h"
#include "DisplayList.h"
#include "poly.h"
#include "../gng_report/font_ext.h"
#include "../testDriver/gng.h"


/***********************************************************************
  エクスターン宣言領域
  **********************************************************************/

/* スタティックセグメントの再ロード用 */
extern char        _staticSegmentRomStart[], _staticSegmentRomEnd[];
extern char        _static1SegmentRomStart[], _static1SegmentRomEnd[];
extern char        _static2SegmentRomStart[], _static2SegmentRomEnd[];
extern char        _codeSegmentEnd[];
extern OSMesg	   dummyMessage;
extern OSIoMesg	   dmaIOMessageBuf;
extern char        *staticSegment;
extern char        *static1Segment;
extern char        *static2Segment;
extern OSMesgQueue dmaMessageQ;


/* その他 */
extern void          *cfb_ptrs[2];    /* フレームバッファの各先頭アドレス */
extern unsigned int  cfb_16_a[];
extern unsigned int  cfb_16_b[];

extern OSMesgQueue  rspMessageQ, rdpMessageQ, retraceMessageQ;

extern unsigned char CfbTestArea[];     /* ＣＦＢテスト用エリア */

extern void AudioTest( int testNum );   /* サウンド関数 */
/***********************************************************************
  関数プロトタイプ宣言領域
  **********************************************************************/
int         RunViTests( void );
int         AutoVideo( int NtscMode );
static void TwirlFunc( void );
static void PlaneFunc( void );
static void GammaFunc( void );
static void DivotFunc( void );
static void DitherFunc( void );
static void ChangeVideoModes( void );
static void InitDisplayLists( void );
static void InitTwirl( void );
static void DoCommonSetup( void );
static void DoTwirlPolys( float theta );
static void CleanupAndSendDisplayList(int MicrocodeType);
static void SwapViBuffer( void );
static void SetupVi(void);
static void ClearFrameBuffer( COLOR Color );
static void InitPlane( void );
static void DoScalePolys( void );
static void DoGammaPolys( void );
static void InitGamma( void );
static void DontSwapViBuffer(void);
static void DoDitherPolys( void );
static void InitDither( void );
static void InitDivot( void );
static void WriteToFrameBuffer( void );
static void ShowNumber( INDEX_INFO Info );
static void draw_floor( void );
static void draw_sasano( void );
static void SasanoFunc( void );
static void InitSasano( void );
static void DoSasanoPolys( float theta, DIMENSION3 look );
static void SelectCfbArea( enum RAM_AREA RamArea, int Width );
static void WhiteFunc( void ); 
static void BlackFunc( void ); 
static void RedFunc( void ); 
static void GreenFunc( void ); 
static void BlueFunc( void ); 
static void UniColorFunc( COLOR Color ); 
static void InitUniColor( void );
static int  GetTrigger( void );
static void ReloadStaticSegment( void );

/***********************************************************************
  グローバル変数宣言領域
  **********************************************************************/

/*
ＶＩの各機能を検査する順序を示した配列
これに沿って検査を進行していきます
*/
static TEST_STRUCT TestStruct[]={
    /* ビデオモード  色   縦   横  使用ＲＡＭ 番号  関数のアドレス */

    OS_VI_NTSC_LAN1, 16, 320, 240, STANDARD,   0xff, SasanoFunc,
    OS_VI_NTSC_LPN2, 32, 320, 240, EXTEND_1ST, 0xf0, TwirlFunc,
    OS_VI_NTSC_LPN2, 32, 320, 240, EXTEND_1ST, 0xf2, PlaneFunc,
    OS_VI_NTSC_HPF1, 16, 640, 480, STANDARD,   0xf3, GammaFunc,
    OS_VI_NTSC_HAF1, 16, 640, 480, STANDARD,   0xf5, DitherFunc,
    OS_VI_NTSC_LAF2, 32, 320, 240, EXTEND_2ND, 0xf9, DivotFunc,

    OS_VI_NTSC_LPN2, 32, 320, 240, STANDARD,   0xe0, WhiteFunc,
    OS_VI_NTSC_LPN2, 32, 320, 240, STANDARD,   0xe1, BlackFunc,
    OS_VI_NTSC_LPN2, 32, 320, 240, STANDARD,   0xe2, RedFunc,
    OS_VI_NTSC_LPN2, 32, 320, 240, STANDARD,   0xe3, GreenFunc,
    OS_VI_NTSC_LPN2, 32, 320, 240, STANDARD,   0xe4, BlueFunc,

    0,                0,   0,   0, STANDARD,  0x00, (void *)NULL   /*ＥＮＤ*/
};  


/* ＲＳＰのスタックエリア */
static u64 dram_stack[SP_DRAM_STACK_SIZE64];	
   
/* おえかき用のタスクリスト */   
static OSTask   *tlistp;  /*ＲＳＰタスクリスト*/
static OSTask	tlist =
{
    M_GFXTASK,			
    OS_TASK_DP_WAIT,		
    NULL,			
    0,				
    NULL,			
    SP_UCODE_SIZE,		
    NULL,			
    SP_UCODE_DATA_SIZE,		
    &(dram_stack[0]),		
    SP_DRAM_STACK_SIZE8,	
    NULL,
    NULL,
    NULL,			
    0,				
    NULL,			
    0				
};

static ViDynamic *dynamicp; /*動的領域の設定*/
static ViDynamic dynamic;

/*現在の画面の広さ*/
static int ScreenWidth;     /* 画面の横方向の広さ */
static int ScreenHeight;    /* 画面の縦方向の広さ */

static int TestIndex;       /* 現在の検査番号     */

static CONFIGRATION Config; /* ＶＩの画面機能項目 */

static Gfx *glistp;         /* ディスプレイリストポインタ */

static int draw_buffer=0;   /* 現在のフレームバッファインデックス */

static u16 *zbuffer;        /* Ｚバッファの先頭アドレス */


/***********************************************************************
  ＶＩ検査ドライブ関数
  上位関数がこの関数を呼び出します
  **********************************************************************/
int RunViTests( void ){
    /* おえかきの為の基本ポインタ設定 */
    tlistp   = &tlist;
    dynamicp = &dynamic;

    /* テストリストの順番にテストしてゆく */
    for( TestIndex=0 ; TestStruct[TestIndex].Function!=0 ; TestIndex++ ){
	/* テストの実行 */
	( *( TestStruct[TestIndex] ).Function )();
    }

    /* 検査中に破壊したオーバーラップセクションを元に戻す */
    ReloadStaticSegment();

    /* 常にＯＫを返す */
    return 0;
}

/**********************************************************************
***********************************************************************
  Ｔｗｉｒｌ検査専用ルーチン
***********************************************************************
**********************************************************************/

/***********************************************************************
  ４つの幾何学模様をぐるぐる回す
  **********************************************************************/
static void TwirlFunc( void ){
    const int  Offset = OS_VI_NTSC_LAN2 - OS_VI_NTSC_LPN2;
                                     /* モード切り替え時のオフセット */ 

    float      theta = 0;                        /* 回転角 */
    INDEX_INFO ThisInfo  =   { 3, 10, 10, 1.0 }; /* インデックス表示 */ 
    int        PushCounter = 0;                  /* ボタンを押した回数 */
    int        ModifyFlag  = FALSE;              /* 画面変更するとTRUEになる */
    int        VideoMode;                        /* 変更後のビデオモード */
    InitTwirl();
    while( PushCounter != 2 ){  

	/* 回転角の増加 */
	theta += 0.12;
	if( theta > 360.0 ) theta -= 360;  /* 周回判定 */ 

	InitDisplayLists();        /* ディスプレイリストの初期化 */
	ClearFrameBuffer( BLACK ); /* フレームバッファの初期化  */
	DoCommonSetup();           /* 標準のディスプレイリストのセットアップ */
	DoTwirlPolys(theta);       /* 実際にテストパターンを描く */          
	ShowNumber( ThisInfo );    /* 検査番号の表示 */
	CleanupAndSendDisplayList(FAST3D);
                                   /* タスクを作って送る */  
	SwapViBuffer();            /* ダブルバッファの切り替え */

	/* ボタン判定 */
	if( GetTrigger() ) PushCounter++; 

	/* ボタンを一度押した時に識別番号とビデオモードを変更する */
	if( (PushCounter == 1)&&( !ModifyFlag ) ){

	    /* ビデオモードの変更 */
	    VideoMode = AutoVideo( TestStruct[TestIndex].VideoMode ) + Offset;
	    osViSetMode( &osViModeTable[ VideoMode ] );


	    /* 検査器に次の検査画面に移った事を通達 */
	    ZaruSetMemA( TestStruct[ TestIndex ].Index + 1 );
	    ThisInfo.Index ++;  /* 検査番号表示をインクリメント */
	    ModifyFlag = TRUE; 
	    
	}
    }
}

/***********************************************************************
  Ｔｗｉｒｌ検査の初期化パート
  **********************************************************************/

static void InitTwirl( void ){
    CONFIGRATION  ThisConfig = { 0.5, 0.5, 0, 0, 1, 0, 0, 0 };
    Config = ThisConfig;
    ChangeVideoModes();
    
    /* 使用するＣＦＢエリアの設定 */
    SelectCfbArea( TestStruct[TestIndex].RamArea,
		   TestStruct[TestIndex].ScreenWidth );

    /* 検査器との通信 */
    ZaruSetMemA( TestStruct[ TestIndex ].Index );
}

/***********************************************************************
  Ｔｗｉｒｌ検査の描画パート
  **********************************************************************/
static void DoTwirlPolys( float theta ){

    guTranslate(&dynamicp->modeling5, 37, 207, 0.0); 
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamic.modeling5)),
	      G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_PUSH);
    guRotate(&dynamicp->modeling6, theta, 0.0F, 0.0F, 1.0F); 
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamic.modeling6)),
	      G_MTX_MODELVIEW|G_MTX_MUL|G_MTX_NOPUSH);
    gSPDisplayList(glistp++, TwirlFigure1);
    gSPPopMatrix(glistp++, G_MTX_MODELVIEW);
    
    guTranslate(&dynamicp->modeling7, 108, 207, 0.0); 
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamic.modeling7)),
	      G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_PUSH);
    guRotate(&dynamicp->modeling8, theta, 0.0F, 0.0F, 1.0F); 
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamic.modeling8)),
	      G_MTX_MODELVIEW|G_MTX_MUL|G_MTX_NOPUSH);
    gSPDisplayList(glistp++, TwirlFigure2);
    gSPPopMatrix(glistp++, G_MTX_MODELVIEW);
    
    guTranslate(&dynamicp->modeling9, 37, 155, 0.0); 
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamic.modeling9)),
	      G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_PUSH);
    guRotate(&dynamicp->modeling10, theta, 0.0F, 0.0F, 1.0F); 
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamic.modeling10)),
	      G_MTX_MODELVIEW|G_MTX_MUL|G_MTX_NOPUSH);
    gSPDisplayList(glistp++, TwirlFigure3);
    gSPPopMatrix(glistp++, G_MTX_MODELVIEW);
    
    guTranslate(&dynamicp->modeling11, 108, 155, 0.0); 
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamic.modeling11)),
	      G_MTX_MODELVIEW|G_MTX_MUL|G_MTX_PUSH);
    guRotate(&dynamicp->modeling12, theta, 0.0F, 0.0F, 1.0F); 
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamic.modeling12)),
	      G_MTX_MODELVIEW|G_MTX_MUL|G_MTX_NOPUSH);
    gSPDisplayList(glistp++, TwirlFigure4);
    gSPPopMatrix(glistp++, G_MTX_MODELVIEW);
    
}

/**********************************************************************
***********************************************************************
Ｐｌａｎｅ検査専用ルーチン
***********************************************************************
**********************************************************************/


/***********************************************************************
ある図形を縮めたり伸ばしたり
**********************************************************************/
static void PlaneFunc( void ){

    const INDEX_INFO ThisInfo   = { 5, 30, 30, 1.0 }; 

    const DIMENSION2 ScaleDelta  = { 0.01, 0.02 }; /* 変化量         */
    const DIMENSION2 Max         = { 1.00, 1.00 }; /* 最大許容拡大値 */
    const DIMENSION2 Min         = { 0.25, 0.05 }; /* 最低許容拡大値 */
          DIMENSION2 IdentVector = { -1.0, -1.0 }; /* 変化方向       */

    COLOR       Color       = BLACK; 

    InitPlane();

    while ( !GetTrigger() ){
	/* 背景色変更判定 */
	if( Config.XScale > Max.x ) Color = GRAY;
	/* ＸＹ方向の増分を乗ずる */
	Config.XScale *= ( 1.0 + (ScaleDelta.x * IdentVector.x) )
	                *( 1.0 + (ScaleDelta.x * IdentVector.x) );
	Config.YScale *= ( 1.0 + (ScaleDelta.y * IdentVector.y) )
	                *( 1.0 + (ScaleDelta.y * IdentVector.y) );

	/* 拡大率の制限 */
	if( !( Min.x<Config.XScale&&Config.XScale<Max.x ) )IdentVector.x *= -1;
	if( !( Min.y<Config.YScale&&Config.YScale<Max.y ) )IdentVector.y *= -1;


	InitDisplayLists();        /* ディスプレイリストの初期化 */
	ClearFrameBuffer( Color ); /* フレームバッファの初期化  */
	DoCommonSetup();           /* 標準のディスプレイリストのセットアップ */
	DoScalePolys();            /* 実際にテストパターンを描く */          

	ShowNumber( ThisInfo );    /* 検査番号の表示 */

	CleanupAndSendDisplayList(FAST3D);
	                           /* タスクを作って送る */  
	SwapViBuffer();            /* ダブルバッファの切り替え */
	
    }

}


/***********************************************************************
  Ｐｌａｎｅ検査の初期化パート
  **********************************************************************/

static void InitPlane( void ){
    CONFIGRATION  ThisConfig = { 1.0, 1.0, 0, 0, 1, 0, -100, -100 };
    Config = ThisConfig;
    ChangeVideoModes();

    /* 使用するＣＦＢエリアの設定 */
    SelectCfbArea( TestStruct[TestIndex].RamArea,
		   TestStruct[TestIndex].ScreenWidth);

    /* 検査器との通信 */
    ZaruSetMemA( TestStruct[ TestIndex ].Index );
    
}

/***********************************************************************
  Ｐｌａｎｅ検査の描画パート
  **********************************************************************/
static void DoScalePolys( void ){

    /* 頂点の基本的な宣言 */
    Vtx Vertex[3]={
	{ 0, 0, 0, 0, 0, 0, 0xff,    0,    0, 0xff },
	{ 0, 0, 0, 0, 0, 0,    0, 0xff,    0, 0xff },
	{ 0, 0, 0, 0, 0, 0,    0,    0,    0, 0xff }
    }; 

    /* 三角形の頂点座標を代入 */
    Vertex[0].v.ob[0] = (int) ( 50.0/320.0 * ScreenWidth );
    Vertex[0].v.ob[1] = (int) ( ScreenHeight - 50.0/240.0 * ScreenHeight );

    Vertex[1].v.ob[0] = (int) ( ScreenWidth - 50.0/320.0 * ScreenWidth );
    Vertex[1].v.ob[1] = (int) ( 50.0/240.0 * ScreenHeight );

    Vertex[2].v.ob[0] = (int) ( 50.0/320.0 * ScreenWidth );
    Vertex[2].v.ob[1] = (int) ( 50.0/240.0 * ScreenHeight );

 
    /* ダイナミック領域の頂点情報エリアに上記情報を書き込む */
    dynamic.Vertex[0] = Vertex[0];
    dynamic.Vertex[1] = Vertex[1];
    dynamic.Vertex[2] = Vertex[2];
   

    /* Setup display modes antialiased in 1 cycle */
    gDPPipeSync(  glistp++ );
    gSPVertex(    glistp++, dynamic.Vertex, 3, 0 );
    gSP1Triangle( glistp++, 0, 1, 2, 0 );
}


/**********************************************************************
***********************************************************************
Ｇａｍｍａ検査専用ルーチン
***********************************************************************
**********************************************************************/

/**********************************************************************
ガンマ補正していない画面とガンマ補正済みの画面を順に表示する
**********************************************************************/
static void GammaFunc( void ){

    int        Timer;                           /* 表示時間タイマ */
    const int  LimitTime=120;                   /* 表示制限時間   */

    INDEX_INFO ThisInfo   = { 6, 80, 80, 4.0 }; /* インデックス表示用 */ 
    int        PushCounter = 0;                 /* ボタンを押した回数 */
    int        ModifyFlag  = FALSE;             /* 画面変更するとTRUEになる */


    InitGamma();          /* 初期化 */

    while( PushCounter != 2 ){
	/* 最初にテストパターンを描く */
	InitDisplayLists();        /* ディスプレイリストの初期化 */
	ClearFrameBuffer( BLACK ); /* フレームバッファの初期化  */
	DoCommonSetup();           /* 標準のディスプレイリストのセットアップ */
	DoGammaPolys();            /* 実際にテストパターンを描く */          
	ShowNumber( ThisInfo );    /* 検査番号の表示 */

        CleanupAndSendDisplayList(FAST3D);
	SwapViBuffer();
	
	/* Ｇａｍｍａ補正ビット切り替え */
	if( ( PushCounter==1 )&&( !ModifyFlag )  ){
	    /* 検査器に次の検査画面に移った事を通達 */
	    ZaruSetMemA( TestStruct[ TestIndex ].Index + 1 );

	    Config.ViGammaEnable ^= 1;
	    SetupVi();
	    ThisInfo.Index++;          /* 検査番号のインクリメント */
	    ModifyFlag = TRUE;
	}

	/* ボタン判定 */
	if( GetTrigger() ) PushCounter++;
    }
}


/**********************************************************************
Ｇａｍｍａ検査の初期化パート
**********************************************************************/
static void InitGamma( void ){
    CONFIGRATION  ThisConfig = { 1.0, 1.0, 0, 0, 1, 0, 0, 0 };
    Config = ThisConfig;

    draw_buffer = 0;     /* 表示バッファの指定 */

    ChangeVideoModes();

    /* 使用するＣＦＢエリアの設定 */
    SelectCfbArea( TestStruct[TestIndex].RamArea,
		   TestStruct[TestIndex].ScreenWidth );

    /* 検査器との通信 */
    ZaruSetMemA( TestStruct[ TestIndex ].Index );
    
}
/**********************************************************************
Ｇａｍｍａ検査のガンマ補正検査用テストパターン描画パート
**********************************************************************/
static void DoGammaPolys( void ){
    /* 頂点の基本的な宣言 */
    Vtx Vertex[5] = {
	{ 0, 0, 0, 0, 0, 0,    0,    0,    0, 0xff },
	{ 0, 0, 0, 0, 0, 0,    0,    0,    0, 0xff },
	{ 0, 0, 0, 0, 0, 0,    0,    0,    0, 0xff },
	{ 0, 0, 0, 0, 0, 0,    0,    0,    0, 0xff },
	{ 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff }
    }; 

    /* 三角形の頂点座標を代入 */
    Vertex[0].v.ob[0] = (int) ( 5.0/320.0 * ScreenWidth );
    Vertex[0].v.ob[1] = (int) ( ScreenHeight - 5.0/240.0 * ScreenHeight );

    Vertex[1].v.ob[0] = (int) ( ScreenWidth  - 5.0/320.0 * ScreenWidth );
    Vertex[1].v.ob[1] = (int) ( ScreenHeight - 5.0/240.0 * ScreenHeight );

    Vertex[2].v.ob[0] = (int) ( ScreenWidth  - 0.0/320.0 * ScreenWidth );
    Vertex[2].v.ob[1] = (int) ( 5.0/240.0 * ScreenHeight );

    Vertex[3].v.ob[0] = (int) ( 0.0/320.0 * ScreenWidth );
    Vertex[3].v.ob[1] = (int) ( 5.0/240.0 * ScreenHeight );

    Vertex[4].v.ob[0] = (int) ( 160.0/320.0 * ScreenWidth );
    Vertex[4].v.ob[1] = (int) ( 120.0/240.0 * ScreenHeight );

    /* ダイナミック領域の頂点情報エリアに上記情報を書き込む */
    dynamic.Vertex[0] = Vertex[0];
    dynamic.Vertex[1] = Vertex[1];
    dynamic.Vertex[2] = Vertex[2];
    dynamic.Vertex[3] = Vertex[3];
    dynamic.Vertex[4] = Vertex[4];


    /* Setup display modes antialiased in 1 cycle */
    gDPPipeSync(glistp++);

    gSPVertex(glistp++, dynamic.Vertex, 5, 0);

    gSP1Triangle(glistp++, 0, 1, 4, 0);
    gSP1Triangle(glistp++, 1, 2, 4, 1);
    gSP1Triangle(glistp++, 4, 2, 3, 4);
    gSP1Triangle(glistp++, 0, 4, 3, 0);

}


/**********************************************************************
***********************************************************************
Ｄｉｔｈｅｒ検査専用ルーチン
***********************************************************************
**********************************************************************/

/**********************************************************************
各種のディザパターンで検査画面を表示する
**********************************************************************/
static void DitherFunc( void ){
    INDEX_INFO ThisInfo  = { 8, 10, 10, 1.0 };
                      /* 途中でインデックスが１ずつ３回増加します */ 
 
    InitDither();          /* 初期化 */

    while( Config.DitherEnable<4 ){
	while( !GetTrigger() ){
	    InitDisplayLists();    /* ディスプレイリストの初期化 */
	    ClearFrameBuffer( BLACK ); /* フレームバッファの初期化  */
	    DoCommonSetup();       /* 標準のディスプレイリストのセットアップ */
	    DoDitherPolys();       /* 実際にテストパターンを描く */          
	    ShowNumber( ThisInfo );/* 検査番号の表示 */
	    CleanupAndSendDisplayList(FAST3D);
	    SwapViBuffer();    /* リトレース割り込み待ち */
	}

	Config.DitherEnable ++;    /* ディザパターンの変更 */ 
	Config.ViDitherEnable ++;
	ThisInfo.Index++;          /* 検査パターンのインクリメント */

	/* 検査器との通信 */
	ZaruSetMemA( TestStruct[ TestIndex ].Index + Config.DitherEnable );
    }
}


/**********************************************************************
Ｄｉｔｈｅｒ検査の初期化パート
**********************************************************************/
static void InitDither( void ){
    CONFIGRATION  ThisConfig = { 0.25, 0.25, 0, 0, 1, 0, -121, -88 };
    Config = ThisConfig;

    draw_buffer = 0;     /* 表示バッファの指定 */

    ChangeVideoModes();

    /* 使用するＣＦＢエリアの設定 */
    SelectCfbArea( TestStruct[TestIndex].RamArea,
		   TestStruct[TestIndex].ScreenWidth );

    /* 検査器との通信 */
    ZaruSetMemA( TestStruct[ TestIndex ].Index );
    
}
/**********************************************************************
Ｄｉｔｈｅｒ検査のテストパターン描画パート
**********************************************************************/
static void DoDitherPolys( void ){

    const float WindowStart = 120.0;  /* 頂点決定に関与する変な定数式多達 */
    const float YDivisor    = 320.0;

    int i;

    /* 頂点の基本的な宣言 */
    Vtx Vertex[16] = {
	{ 0, 0, 0, 0, 0, 0, 0x5f,    0,    0,    0 },  /*  0 */
	{ 0, 0, 0, 0, 0, 0,    0, 0x5f,    0, 0xff },  /*  1 */
	{ 0, 0, 0, 0, 0, 0,    0,    0, 0x5f, 0xff },  /*  2 */
	{ 0, 0, 0, 0, 0, 0, 0x5f, 0x5f, 0x5f, 0xff },  /*  3 */
	{ 0, 0, 0, 0, 0, 0, 0x2f,    0,    0,    0 },  /*  4 */
	{ 0, 0, 0, 0, 0, 0,    0, 0x2f,    0,    0 },  /*  5 */
	{ 0, 0, 0, 0, 0, 0,    0, 0x2f,    0,    0 },  /*  6 */
	{ 0, 0, 0, 0, 0, 0,    0,    0, 0x2f,    0 },  /*  7 */
	{ 0, 0, 0, 0, 0, 0,    0,    0, 0x2f,    0 },  /*  8 */
	{ 0, 0, 0, 0, 0, 0, 0x2f, 0x2f, 0x2f,    0 },  /*  9 */
	{ 0, 0, 0, 0, 0, 0, 0x2f, 0x2f, 0x2f,    0 },  /* 10 */
	{ 0, 0, 0, 0, 0, 0, 0x2f,    0,    0,    0 },  /* 11 */
	{ 0, 0, 0, 0, 0, 0,    0,    0,    0,    0 },  /* 12 */
	{ 0, 0, 0, 0, 0, 0,    0,    0,    0,    0 },  /* 13 */
	{ 0, 0, 0, 0, 0, 0,    0,    0,    0,    0 },  /* 14 */
	{ 0, 0, 0, 0, 0, 0,    0,    0,    0,    0 }   /* 15 */
    }; 

    COORDINATES coord[2]; /* 基準頂点座標 */

    /* 三角形の頂点座標を代入 */
    coord[0].x = (int)( WindowStart/YDivisor * ScreenWidth  );
    coord[0].y = (int)( WindowStart/YDivisor * ScreenHeight );
    coord[1].x = (int)( ScreenWidth  - WindowStart/YDivisor * ScreenWidth  );
    coord[1].y = (int)( ScreenHeight - WindowStart/YDivisor * ScreenHeight ); 

    /* 基準座標を元に頂点座標を決定する */
    Vertex[ 0].v.ob[0] = 
    Vertex[ 3].v.ob[0] = 
    Vertex[10].v.ob[0] = 
    Vertex[11].v.ob[0] = coord[0].x;

    Vertex[ 2].v.ob[1] = 
    Vertex[ 3].v.ob[1] = 
    Vertex[ 8].v.ob[1] =
    Vertex[ 9].v.ob[1] = coord[0].y;

    Vertex[ 1].v.ob[0] = 
    Vertex[ 2].v.ob[0] = 
    Vertex[ 6].v.ob[0] = 
    Vertex[ 7].v.ob[0] = coord[1].x;

    Vertex[ 0].v.ob[1] = 
    Vertex[ 1].v.ob[1] =
    Vertex[ 4].v.ob[1] = 
    Vertex[ 5].v.ob[1] = coord[1].y;

    Vertex[ 4].v.ob[0] = 
    Vertex[ 5].v.ob[0] = 
    Vertex[ 8].v.ob[0] = 
    Vertex[ 9].v.ob[0] = 
    Vertex[12].v.ob[0] = 
    Vertex[13].v.ob[0] = 
    Vertex[14].v.ob[0] = 
    Vertex[15].v.ob[0] = ( coord[0].x + coord[1].x ) >>1;

    Vertex[ 6].v.ob[1] = 
    Vertex[ 7].v.ob[1] = 
    Vertex[10].v.ob[1] = 
    Vertex[11].v.ob[1] =
    Vertex[12].v.ob[1] = 
    Vertex[13].v.ob[1] = 
    Vertex[14].v.ob[1] = 
    Vertex[15].v.ob[1] = ( coord[0].y + coord[1].y ) >>1;

    /* ダイナミック領域の頂点情報エリアに上記情報を書き込む */
    
    for( i=0 ; i<16 ; i++ ) dynamic.Vertex[i] = Vertex[i];

    /* Setup display modes antialiased in 1 cycle */
    gDPPipeSync(glistp++);

    gSPVertex(glistp++, dynamic.Vertex, 16, 0);

    gSP1Triangle(glistp++,  0,  4, 12, 0);  
    gSP1Triangle(glistp++,  0, 12, 11, 0);  
    
    gSP1Triangle(glistp++,  5,  1,  6, 0);  
    gSP1Triangle(glistp++,  5,  6, 13, 0);  
    
    gSP1Triangle(glistp++, 14,  7,  2, 0);  
    gSP1Triangle(glistp++, 14,  2,  8, 0);  
    
    gSP1Triangle(glistp++, 10, 15,  9, 0);  
    gSP1Triangle(glistp++, 10,  9,  3, 0);  
    
}

/**********************************************************************
***********************************************************************
Ｄｉｖｏｔ検査専用ルーチン
***********************************************************************
**********************************************************************/

/**********************************************************************
Ｄｉｖｏｔ補正していない画面とＤｉｖｏｔ補正済みの画面を順に表示する
**********************************************************************/
static void DivotFunc( void ){

    int       Timer;               /* 表示時間タイマ */
    const int LimitTime=120;       /* 表示制限時間   */

    INDEX_INFO ThisInfo  = { 12, 10, 14, 1.0 };
                                   /* インデックス表示用構造体 */

    InitDivot();                   /* 初期化 */

    /* 最初の画面クリア */
    InitDisplayLists();            /* ディスプレイリストの初期化 */
    ClearFrameBuffer( BLACK );     /* フレームバッファの初期化  */
    DoCommonSetup();               /* 標準のディスプレイリストのセットアップ */
    CleanupAndSendDisplayList(FAST3D);

    /* 検査パターンの書き込み */
    WriteToFrameBuffer();          /* Ｄｉｖｏｔ検査パターンをＣＰＵで描く */
 
    InitDisplayLists();            /* ディスプレイリストの初期化 */
    DoCommonSetup();               /* 標準のディスプレイリストのセットアップ */
    ShowNumber( ThisInfo );        /* 検査番号の表示 */
    ThisInfo.Index++;              /* 検査番号のインクリメント */
    CleanupAndSendDisplayList(FAST3D);
                                   /* タスクを作って送る */  
    SetupVi();
    DontSwapViBuffer();            /* リトレース割り込み待ち */

    /* ボタン待ち */
    while( !GetTrigger() );
 
    /* 検査器との通信 */
    ZaruSetMemA( TestStruct[ TestIndex ].Index+1 );

    /* 最初の画面クリア */
    InitDisplayLists();            /* ディスプレイリストの初期化 */
    ClearFrameBuffer( BLACK );     /* フレームバッファの初期化  */
    DoCommonSetup();               /* 標準のディスプレイリストのセットアップ */
    CleanupAndSendDisplayList(FAST3D);

    /* 検査パターンの書き込み */
    WriteToFrameBuffer();          /* Ｄｉｖｏｔ検査パターンをＣＰＵで描く */
 
    InitDisplayLists();            /* ディスプレイリストの初期化 */
    DoCommonSetup();               /* 標準のディスプレイリストのセットアップ */
    ShowNumber( ThisInfo );        /* 検査番号の表示 */
    CleanupAndSendDisplayList(FAST3D);
                                   /* タスクを作って送る */  

    Config.ViDivotEnable ^= 1;
    SetupVi();

    /* ボタン待ち */
    while( !GetTrigger() );
    DontSwapViBuffer();            /* リトレース割り込み待ち */

}


/**********************************************************************
Ｄｉｖｏｔ検査の初期化パート
**********************************************************************/
static void InitDivot( void ){
    CONFIGRATION  ThisConfig = { 0.25, 1.0, 0, 0, 1, 0, 0, 0 };
    Config = ThisConfig;

    draw_buffer = 0;     /* 表示バッファの指定 */

    ChangeVideoModes();

    /* 使用するＣＦＢエリアの設定 */
    SelectCfbArea( TestStruct[TestIndex].RamArea,
		   TestStruct[TestIndex].ScreenWidth );

    /* 検査器との通信 */
    ZaruSetMemA( TestStruct[ TestIndex ].Index );
    
}

/**********************************************************************
Ｄｉｖｏｔ検査のテストパターン描画パート
**********************************************************************/
static void WriteToFrameBuffer( void ){
    int  i, j;
    u32 *Pointer32; /* フレームバッファのカレントアドレス */
    u16 *Pointer16;

    /* 画面表示のビット組み合わせ */
    const u32 Matrix32[2][2] = { { 0x000000ff, 0x000000ff },
				 { 0xffff00ff, 0xffff00df }
    };

    const u16 Matrix16[2][2] = { { 0x0001, 0x0001 },
				 { 0xffc1, 0xffc0 }
    };

    if( TestStruct[TestIndex].NumColorBits == 32 ){
	/* ３２ビットカラーの場合 */
	Pointer32 = (u32 *)cfb_ptrs[0]; /*フレームバッファの先頭アドレス代入*/

	for( i=0 ; i<TestStruct[TestIndex].ScreenHeight ; i++ ){
	    for( j=0 ; j<TestStruct[TestIndex].ScreenWidth ; j++ ){
		*Pointer32++ = Matrix32[ (j%3)==2 ? 1:0 ][ i/32%2 ? 1:0 ];
	    }
	}
    }else{
	/* １６ビットカラーの場合 */
	Pointer16 = (u16 *)cfb_ptrs[0]; /*フレームバッファの先頭アドレス代入*/

	for( i=0 ; i<TestStruct[TestIndex].ScreenHeight ; i++ ){
	    for( j=0 ; j<TestStruct[TestIndex].ScreenWidth ; j++ ){
		*Pointer16++ = Matrix16[ (j%3)==2 ? 1:0 ][ i/32%2 ? 1:0 ];
	    }
	}
    }
    osWritebackDCacheAll();    /* データキャッシュのデータを戻す */
}		

/**********************************************************************
***********************************************************************
  笹野さんの検査専用ルーチン

  この検査ではTestStructに設定しているRamAreaメンバは使用せずに独自
  の設定で動作しています。

***********************************************************************
**********************************************************************/

/***********************************************************************
  フレームバッファアドレスを変更しながら煉瓦床をぐるぐる回す
  **********************************************************************/
static void SasanoFunc( void ){
    float      theta     = 0;                  /* 回転角 */
    u32        FrameSize;                      /* フレームバッファのサイズ */
    void       *LastAddress;                   /* フレームバッファの最終番地 */
    int        EndFlag   = FALSE;              /* 検査終了フラグ */ 
    DIMENSION3 look      = { 660, 660, 660 };  /* ビュー座標 */
    INDEX_INFO ThisInfo  = { 1, 20, 20, 2.0 }; /* 検査画面のインデックス */ 
    u64        Counter   = 0;                  /* フレームバッファ変更用 */
    u64        MultiBuf  = 0;                  /* フレームの位置決め用   */

    COLOR      Color     = BLACK;              /* 背景色 */

    InitSasano();                              /* 画面の初期化 */

    /* フレームバッファを設定する。 */
    /*
      この設定でＲＤＰテスト用スタティックエリアが破壊されるので
      以降にＲＤＰテストを実行する場合はスタティックエリアを再ロード
      する事
      */

    /* １画面のサイズ（８Ｂｉｔ長）計算 */
    FrameSize = ScreenWidth * ScreenHeight * sizeof(u16) ;

    /* フレームバッファの初期設定 */
    zbuffer     = ( u16 *)( CfbTestArea               ); 
    cfb_ptrs[0] = ( u16 *)( CfbTestArea + FrameSize   );
    cfb_ptrs[1] = ( u16 *)( CfbTestArea + FrameSize*2 );
    
    /* フレームバッファの最終アドレス計算 */
    LastAddress = (void *)( osMemSize + 0x80000000 - FrameSize );

    /* 実際にオブジェクトを回転させるパート */
    while( !EndFlag && !GetTrigger() ){

	/* 回転させる */
	theta += 1.0;
	if( theta > 360.0 ) theta -= 360;  /* 周回判定 */ 

	/* フレームバッファをずらす */
	if( (Counter++)%10 == 0 ){
	    cfb_ptrs[1] = ( u16 *)( CfbTestArea+FrameSize*((MultiBuf++)+2) ) ;

	    /* フレームバッファがメモリの最終まで到着した場合の処理 */
	    if( cfb_ptrs[1] > LastAddress ){

		cfb_ptrs[1] = ( u16 *)( CfbTestArea + FrameSize*2 );
		Color       = GRAY;

		/* 検査器に検査範囲終了を通知 */
		ZaruWriteReg2( REG_LOOKEND, ZARU_LOOKEND );

	    }
	}
	
	InitDisplayLists();        /* ディスプレイリストの初期化 */
	ClearFrameBuffer( Color ); /* フレームバッファの初期化  */
	DoSasanoPolys( theta, look );
                                   /* 実際にテストパターンを描く */          
	ShowNumber( ThisInfo );    /* 検査番号の表示 */
	CleanupAndSendDisplayList(FAST3D);
                                   /* タスクを作って送る */  
	SwapViBuffer();            /* ダブルバッファの切り替え */
    }

    /* サウンド検査へ向けて画面を回転 */
    ThisInfo.Index++;

    while( (int)theta%90 != 0 ){
	InitDisplayLists();        /* ディスプレイリストの初期化 */
	ClearFrameBuffer( Color ); /* フレームバッファの初期化  */
	DoSasanoPolys( theta, look );
	                           /* 実際にテストパターンを描く */          
	ShowNumber( ThisInfo );    /* 検査番号の表示 */
	CleanupAndSendDisplayList(FAST3D);
                                   /* タスクを作って送る */  
	SwapViBuffer();            /* ダブルバッファの切り替え */

	theta  += 1.0;
	look.x *= 0.9;

    }

    while( look.x > 0.0 ){
	InitDisplayLists();        /* ディスプレイリストの初期化 */
	ClearFrameBuffer( Color ); /* フレームバッファの初期化  */
	DoSasanoPolys( theta, look );
	                           /* 実際にテストパターンを描く */          
	ShowNumber( ThisInfo );    /* 検査番号の表示 */
	CleanupAndSendDisplayList(FAST3D);
                                   /* タスクを作って送る */  
	SwapViBuffer();            /* ダブルバッファの切り替え */

	look.x  = (look.x*0.9) -1.0;
	look.y -= 1.0;
	look.z -= 1.0;
    }

    /* 画面を表示したままサウンドを鳴らす */
    AudioTest( 3 );
}


/***********************************************************************
  笹野検査の初期化パート
  **********************************************************************/

static void InitSasano( void ){
    u32 FrameSize;    /* フレームバッファのサイズ */
    CONFIGRATION  ThisConfig = { 1.0, 1.0, 0, 0, 0, 0, 0, 0 };
    Config = ThisConfig;
    ChangeVideoModes();
    SetupVi();

    /* 検査器との通信 */
    ZaruSetMemA( TestStruct[ TestIndex ].Index );
}

/***********************************************************************
  笹野検査の描画パート
  **********************************************************************/
static void DoSasanoPolys( float theta, DIMENSION3 look ){
    u16 perspNorm;    /* パースペクティブコレクション用変数 */

    /* 初期設定をする */
    gDPSetBlendMask(   glistp++, 0xff );
    gDPSetColorDither( glistp++,G_CD_ENABLE );
    gDPSetDepthImage(  glistp++, OS_K0_TO_PHYSICAL( zbuffer ) );

    /* Ｚバッファのくりあ */
    gDPSetCycleType(  glistp++, G_CYC_FILL );
    gDPSetColorImage( glistp++, G_IM_FMT_RGBA, G_IM_SIZ_16b, 320,
		      OS_K0_TO_PHYSICAL( zbuffer )               );
    gDPSetFillColor(  glistp++, GPACK_ZDZ( G_MAXFBZ, 0 )<<16 | 
                                GPACK_ZDZ( G_MAXFBZ, 0 )       );      
    gDPFillRectangle( glistp++, 0, 0, ScreenWidth-1, ScreenHeight-1 );
    gDPPipeSync(glistp++);
    gDPSetCycleType(  glistp++, G_CYC_1CYCLE );

    /* カラーイメージの設定しなおし */
    gDPSetColorImage(glistp++, G_IM_FMT_RGBA, G_IM_SIZ_16b, 320, 
                     OS_K0_TO_PHYSICAL(cfb_ptrs[draw_buffer]));

    /* パースペクティブ ＆ 視点 ＆ オブジェクト回転 の設定 */
    guPerspective( &dynamicp->projection, &perspNorm,
                   33, 320.0/240.0, 100, 2000, 1.0 );

    guLookAt( &dynamicp->viewing, look.x, look.y, look.z,
	                               0,      0,      0,
	                               0,      1,      0 );

    guRotate( &dynamicp->floor_rotatex, theta, 1.0, 0.0, 0.0 );
    guRotate( &dynamicp->floor_rotatey, theta, 0.0, 1.0, 0.0 );
    guRotate( &dynamicp->floor_rotatez, theta, 0.0, 0.0, 1.0 );
    
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->projection)),
	      G_MTX_PROJECTION|G_MTX_LOAD|G_MTX_NOPUSH);
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->viewing)),
	      G_MTX_PROJECTION|G_MTX_MUL|G_MTX_NOPUSH);
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->floor_rotatex)),
	      G_MTX_PROJECTION|G_MTX_MUL|G_MTX_NOPUSH);
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->floor_rotatey)),
	      G_MTX_PROJECTION|G_MTX_MUL|G_MTX_NOPUSH);
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->floor_rotatez)),
	      G_MTX_PROJECTION|G_MTX_MUL|G_MTX_NOPUSH);

    /* パースぺクティブコレクション */
    gSPPerspNormalize(glistp++, perspNorm);

    /* おえかき部分 */
    draw_floor();       /* 床部分の描画 */ 
    draw_sasano();      /* 六角大王部分の描画 */
}

/***********************************************************************
  床部分の描画
  **********************************************************************/
static void draw_floor( void ){
    gSPDisplayList(glistp++, floor_setup_dl);

    guTranslate(&dynamicp->floor_model0, -128.0, 0.0, -128.0);
    guTranslate(&dynamicp->floor_model1, 0.0, 0.0, -128.0);
    guTranslate(&dynamicp->floor_model2, 128.0, 0.0, -128.0);
    guTranslate(&dynamicp->floor_model3, -128.0, 0.0, 0.0);
    guTranslate(&dynamicp->floor_model4, 0.0, 0.0, 0.0);
    guTranslate(&dynamicp->floor_model5, 128.0, 0.0, 0.0);
    guTranslate(&dynamicp->floor_model6, -128.0, 0.0, 128.0);
    guTranslate(&dynamicp->floor_model7, 0.0, 0.0, 128.0);
    guTranslate(&dynamicp->floor_model8, 128.0, 0.0, 128.0);

    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->floor_model0)),
        G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH);
    gSPDisplayList(glistp++, floor_geom_dl);

    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->floor_model1)),
        G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH);
    gSPDisplayList(glistp++, floor_geom_dl);

    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->floor_model2)),
        G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH);
    gSPDisplayList(glistp++, floor_geom_dl);

    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->floor_model3)),
        G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH);
    gSPDisplayList(glistp++, floor_geom_dl);

    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->floor_model4)),
        G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH);
    gSPDisplayList(glistp++, floor_geom_dl);

    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->floor_model5)),
        G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH);
    gSPDisplayList(glistp++, floor_geom_dl);

    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->floor_model6)),
        G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH);
    gSPDisplayList(glistp++, floor_geom_dl);

    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->floor_model7)),
        G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH);
    gSPDisplayList(glistp++, floor_geom_dl);

    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->floor_model8)),
        G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH);
    gSPDisplayList(glistp++, floor_geom_dl);

    gSPTexture(glistp++, 0, 0, 0, G_TX_RENDERTILE, G_OFF);

}

/***********************************************************************
  六角大王部分の描画
  **********************************************************************/
static void draw_sasano( void ){

    gSPDisplayList( glistp++, rspinit_dl );
    gSPDisplayList( glistp++, rdpinit_dl );
    /* シェーディングでレンダリングする為の設定 */
    gDPSetRenderMode( glistp++, G_RM_ZB_OPA_SURF, G_RM_ZB_OPA_SURF2 );
    gSPSetGeometryMode( glistp++, G_SHADE | G_SHADING_SMOOTH | G_ZBUFFER );

    /* フロアの位置と六角大王の位置がずれているので位置あわせをする */
    guTranslate( &dynamicp->floor_translate, 0, 0, 0 );
    gSPMatrix( glistp++, OS_K0_TO_PHYSICAL( &(dynamicp->floor_translate) ),
	       G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH );


    /* 六角大王を実際に描く */
    gSPDisplayList( glistp++, poly_dl );
}

/**********************************************************************
***********************************************************************
  各ベタ色検査ルーチン
***********************************************************************
**********************************************************************/

/***********************************************************************
  各検査色のドライバルーチンからやってくるつなぎの関数
  **********************************************************************/
static void WhiteFunc( void ){
    UniColorFunc( WHITE );
}
static void BlackFunc( void ){
    UniColorFunc( BLACK );
}
static void RedFunc( void ){
    UniColorFunc( RED );
}
static void GreenFunc( void ){
    UniColorFunc( GREEN );
}
static void BlueFunc( void ){
    UniColorFunc( BLUE );
}

/***********************************************************************
  ベタ色を一定時間表示する
  **********************************************************************/
static void UniColorFunc( COLOR Color ){
    InitUniColor();

    while( !GetTrigger() ){
	InitDisplayLists();        /* ディスプレイリストの初期化 */
	ClearFrameBuffer( Color ); /* フレームバッファの初期化  */
	DoCommonSetup();           /* 標準のディスプレイリストのセットアップ */
	CleanupAndSendDisplayList(FAST3D);
                                   /* タスクを作って送る */  
	SwapViBuffer();            /* ダブルバッファの切り替え */
    }
}


/***********************************************************************
  ベタ色検査の初期化パート
  **********************************************************************/

static void InitUniColor( void ){
    CONFIGRATION  ThisConfig = { 1.0, 1.0, 0, 0, 1, 0, 0, 0 };
    Config = ThisConfig;
    ChangeVideoModes();
    
    /* 使用するＣＦＢエリアの設定 */
    SelectCfbArea( TestStruct[TestIndex].RamArea,
		   TestStruct[TestIndex].ScreenWidth );

    /* 検査器との通信 */
    ZaruSetMemA( TestStruct[ TestIndex ].Index );
}

/**********************************************************************
***********************************************************************
  各検査画面共通の汎用ルーチン
***********************************************************************
**********************************************************************/


/**********************************************************************
ビデオモードの変更
**********************************************************************/
static void ChangeVideoModes( void ){
    /* 検査画面の縦横の大きさをグローバル変数に入力 */
    ScreenHeight = TestStruct[TestIndex].ScreenHeight;
    ScreenWidth  = TestStruct[TestIndex].ScreenWidth;

    /* ビデオモードの変更 */
    osViSetMode( &osViModeTable[AutoVideo(TestStruct[TestIndex].VideoMode)] );
}
/**********************************************************************
  映像出力方式の自動判定
  ＮＴＳＣ出力用のビデオモードを入力すると被検査物の映像出力方式に適した
  ビデオモード値を戻します。
  **********************************************************************/
int AutoVideo( int NtscMode ){
    int Offset;      /* 映像出力方式によってオフセットを決定する */

    const int UnitSize = OS_VI_PAL_LPN1 - OS_VI_NTSC_LPN1;
                    /* １つの映像出力方式に存在するビデオモード数 */ 

    /*
     * 検査画面のモード設定 
     * 被検査物によって映像出力方式を変更する
     * ＰＡＬの場合,ビデオモードにオフセット値を加えたものとする 
     *   OS_VI_PAL_LPN1 = OS_VI_NTSC_LPN1 + Offset 
     */
    switch( osTvType ){
      case NTSC:
	Offset = 0;
	break;

      case PAL: 
	Offset = UnitSize;
	break;

      case MPAL:
	Offset = UnitSize * 2;
	break;

      default:
	break;
    }

    return NtscMode + Offset ;
}

/**********************************************************************
ディスプレイリストの初期化
**********************************************************************/
static void InitDisplayLists( void ){
    
    Vp mvp;   /* 暫定的なビューポートマトリクス */

    /* pointers to build the display list */
    glistp = dynamicp->glist;

    /* Tell RCP where each segment is */
    gSPSegment(glistp++, 0, 0x0);
   
    /* Setup scissor values */
    gDPSetScissor(glistp++, G_SC_NON_INTERLACE, 0, 0,
		  ScreenWidth, ScreenHeight);

    /* Initialize RDP state */
    gSPDisplayList(glistp++, rdpinit_dl);

    /* Setup the Viewport */
    mvp.vp.vscale[0] = ScreenWidth*2;
    mvp.vp.vscale[1] = ScreenHeight*2;
    mvp.vp.vscale[2] = G_MAXZ/2;
    mvp.vp.vscale[3] = 0;
    
    mvp.vp.vtrans[0] = ScreenWidth*2;
    mvp.vp.vtrans[1] = ScreenHeight*2;
    mvp.vp.vtrans[2] = G_MAXZ/2;
    mvp.vp.vtrans[3] = 0;


    /* ダイナミック領域のビューポートマトリクスにマトリクスデータ転送 */
    dynamic.mvp = mvp;
  
    gSPViewport(glistp++, &(dynamic.mvp) );
  
    /* Initialize RSP state */
    gSPDisplayList(glistp++, rspinit_dl);  
}

/**********************************************************************
フレームバッファの初期化
**********************************************************************/
static void ClearFrameBuffer( COLOR Color ){
    const int BackgroundColor = 0;     /* フレームクリア時のクリアカラー */


    /* Clear color framebuffer */

    gDPSetCycleType(glistp++, G_CYC_FILL);
    
    if (TestStruct[TestIndex].NumColorBits == 32){
	gDPSetColorImage(glistp++, G_IM_FMT_RGBA, G_IM_SIZ_32b, ScreenWidth, 
			 OS_K0_TO_PHYSICAL(cfb_ptrs[draw_buffer]));
	    
	gDPSetFillColor( glistp++, Color.Color32 ); 
    }else{
	gDPSetColorImage(glistp++, G_IM_FMT_RGBA, G_IM_SIZ_16b, ScreenWidth, 
			 OS_K0_TO_PHYSICAL(cfb_ptrs[draw_buffer]));

	gDPSetFillColor( glistp++, Color.Color16 );
    }
    
    
    gDPFillRectangle(glistp++, 0, 0, ScreenWidth-1, ScreenWidth-1);
    gDPPipeSync(glistp++);
    
    gDPSetCycleType(glistp++, G_CYC_1CYCLE);  
}

/**********************************************************************
標準のディスプレイリストセットアップ
**********************************************************************/
static void DoCommonSetup(void){
  /* Setup display modes antialiased in 1 cycle */

  gDPSetRenderMode(glistp++, G_RM_AA_OPA_SURF, G_RM_AA_OPA_SURF2);

  /* Setup Viewing Matrix */
  guOrtho(&dynamicp->projection,
	  0.00, ScreenWidth -1,
	  0.00, ScreenHeight-1, 
	  -200, 200, 
	  1.0);

  gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamic.projection)),
		G_MTX_PROJECTION|G_MTX_LOAD|G_MTX_NOPUSH);        

  /* Setup IdentMarix */
  guRotate(&dynamicp->modeling1, 0, 0.0F, 0.0F, 1.0F); 

  gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamic.modeling1)),
	    G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH);

  /* Setup Poly Matrices */
  guTranslate(&dynamicp->modeling2,  
	      ScreenWidth /2.0 + Config.TranslateHorizontal/320.0*ScreenWidth, 
	      ScreenHeight/2.0 - Config.TranslateVertical  /240.0*ScreenHeight,
	      0.0);

  gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamic.modeling2)),
	    G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH);

  guRotate(&dynamicp->modeling3, 0, 1.0, 1.0, 0.0);  
  gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamic.modeling3)),
	    G_MTX_MODELVIEW|G_MTX_MUL|G_MTX_NOPUSH);

  guTranslate(&dynamicp->modeling4, 
	      -ScreenWidth /2.0,
	      -ScreenHeight/2.0,
	      0.0); 

  gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamic.modeling4)),
	    G_MTX_MODELVIEW|G_MTX_MUL|G_MTX_NOPUSH);


  /* Setup DitherMode */

  gDPSetColorDither(glistp++, DitherTypes[Config.DitherEnable] );

  SetupVi();
}
	
/**********************************************************************
ＶＩ特殊機能の設定 
**********************************************************************/
static void SetupVi(void){
    osViSetXScale(Config.XScale);
    osViSetYScale(Config.YScale);
    
    if (Config.ViDitherEnable){
	osViSetSpecialFeatures(OS_VI_DITHER_FILTER_ON);
    }else{
	osViSetSpecialFeatures(OS_VI_DITHER_FILTER_OFF);
    }

    if (Config.ViGammaEnable){
	osViSetSpecialFeatures(OS_VI_GAMMA_ON);
    }else{
	osViSetSpecialFeatures(OS_VI_GAMMA_OFF);
    }
    
    if (Config.ViDivotEnable){
	osViSetSpecialFeatures(OS_VI_DIVOT_ON);
    }else{
	osViSetSpecialFeatures(OS_VI_DIVOT_OFF);
    }
}

/**********************************************************************
ディスプレイリストをタスクの形式にしてＲＳＰに転送する 
**********************************************************************/
static void CleanupAndSendDisplayList(int MicrocodeType){
    gDPFullSync(glistp++);
    gSPEndDisplayList(glistp++);
    
    tlistp->t.data_size = (u32)((glistp - dynamicp->glist) * sizeof(Gfx));
    
    /* Write back dirty cache lines that need to be read by the RCP */
    osWritebackDCache(&dynamic, sizeof(dynamic));
    
    /* start up the RSP task */
    tlistp->t.ucode_boot      = (u64 *)rspbootTextStart;
    tlistp->t.ucode_boot_size = (u32)rspbootTextEnd - (u32)rspbootTextStart;
    tlistp->t.data_ptr        = (u64 *)dynamicp->glist;

    if( MicrocodeType == FAST3D ){
	tlistp->t.ucode      = (u64 *)gspFast3DTextStart;
	tlistp->t.ucode_data = (u64 *)gspFast3DDataStart;
    }else{
	tlistp->t.ucode      = (u64 *)gspLine3DTextStart;
	tlistp->t.ucode_data = (u64 *)gspLine3DDataStart;
    }

    osSpTaskStart(tlistp);
    
    /* wait for SP completion */
    (void)osRecvMesg(&rspMessageQ, NULL, OS_MESG_BLOCK);
    
    (void)osRecvMesg(&rdpMessageQ, NULL, OS_MESG_BLOCK);
}

/**********************************************************************
表示バッファのスワッピング 
**********************************************************************/
static void SwapViBuffer(void){
    /* setup to swap buffers */
    osViSwapBuffer(cfb_ptrs[draw_buffer]);

    /* Make sure there isn't an old retrace in queue */
    if (MQ_IS_FULL(&retraceMessageQ))
	(void)osRecvMesg(&retraceMessageQ, NULL, OS_MESG_BLOCK);
    
    /* Wait for Vertical retrace to finish swap buffers */
    (void)osRecvMesg(&retraceMessageQ, NULL, OS_MESG_BLOCK);
    
    draw_buffer ^= 1;
}

/**********************************************************************
リトレース割り込み待ち 
**********************************************************************/
static void DontSwapViBuffer(void){
    /* setup to swap buffers */
    osViSwapBuffer( cfb_ptrs[ draw_buffer] );

    /* Make sure there isn't an old retrace in queue */
    if (MQ_IS_FULL(&retraceMessageQ))
	(void)osRecvMesg(&retraceMessageQ, NULL, OS_MESG_BLOCK);
    
    /* Wait for Vertical retrace to finish swap buffers */
    (void)osRecvMesg(&retraceMessageQ, NULL, OS_MESG_BLOCK);
}
    
/**********************************************************************
テストパターンに検査番号をいれる 
**********************************************************************/
static void ShowNumber( INDEX_INFO Info ){
    char String[255];
    font_init( &glistp );			/* Initialize fonts */
    font_set_pos( Info.x, Info.y );   /* Setup where and how to draw text */
    font_set_color( 255, 255, 255, 255 );
    font_set_scale( Info.Magnification, Info.Magnification );
    font_set_win( 27, 7 );
    sprintf( String, "%d", Info.Index );
    font_show_string( &glistp, String  );
    font_finish( &glistp );		
}

/**********************************************************************
検査時に使用するＲＡＭの選択  

注意:ここで使用するFrameBufferPointer[]変数の配列値はRAM_AREA型の引数
     STANDARD, EXTEND_1ST, EXTEND_2NDを使用する事にし,各々の固有値は
     0, 1, 2 となる。

**********************************************************************/
static void SelectCfbArea( enum RAM_AREA RamArea , int Width ){
    unsigned int *FrameBufferPointer[3]; /* エリア制限用ポインタ */

    /* ステップ１  メモリサイズより使用するエリアを制限する */
    FrameBufferPointer[ STANDARD ] = cfb_16_a;

    switch( osMemSize ){
      case 0x400000:
	/* 増設メモリなしの場合 */
	FrameBufferPointer[ EXTEND_1ST ] =
	FrameBufferPointer[ EXTEND_2ND ] = cfb_16_a;
	break;

      case 0x600000:
	/* 増設２Ｍの場合 */
	FrameBufferPointer[ EXTEND_1ST ] =
	FrameBufferPointer[ EXTEND_2ND ] = (unsigned int *)L26V;
	break;
	
      case 0x800000:
	/* 創設４Ｍの場合 */
	FrameBufferPointer[ EXTEND_1ST ] = (unsigned int *)L26V;
	FrameBufferPointer[ EXTEND_2ND ] = (unsigned int *)L28V;
	break;

      default:
	break;
    }

    /* ステップ２ 引数によって使用するエリアを変更する */
    cfb_ptrs[0] = FrameBufferPointer[ RamArea ];

    if( Width == 640 ){
	/* 高解像度設定 */
	cfb_ptrs[1] = (unsigned int *)( cfb_16_b );
    }else{
	/* 低解像度設定 */
	cfb_ptrs[1] = (unsigned int *)( (unsigned int *)cfb_ptrs[0]+320*240 );
    }
}

/**********************************************************************
  検査器のボタンレジスタのトリガを返す（押した瞬間のみTRUE/その他FALSE）
  **********************************************************************/
static int GetTrigger( void ){
    static int PastStatus = FALSE;    /* 以前のステータス */
    int        Status;                /* 今回のステータス */
    int        ReturnValue;           /* 戻値             */
    
    /* 今回のボタンの状態を取得 */
    Status = ZaruGetNextTestButton();
    
    /* トリガ判定 */
    ReturnValue = Status & !PastStatus;
    

    /* 今回のトリガ状態を保存 */
    PastStatus = Status;

    return ReturnValue;
}
/**********************************************************************
  検査中に破壊したスタティックセグメント（ブート時にＲＯＭからＲＡＭに
  転送されるもの）を再ロードしなおす。
  **********************************************************************/
static void ReloadStaticSegment( void ){
    
    /*
     * Can just flush 16KB and forget about each individual pieces
     * of data to flush.  We flush the cache so that when the PI 
     * updates rdram (as a consequence of executing the dma task), the 
     * R4300 cpu won't ignore the newly updated data in favor of its
     * privately held data cache contents.
     */
    osWritebackDCacheAll();
    
    /*
     * Stick the static segment right after the code/data segment
     */
    staticSegment = _codeSegmentEnd;
    osPiStartDma(&dmaIOMessageBuf, OS_MESG_PRI_NORMAL, OS_READ,
                 (u32)_staticSegmentRomStart, staticSegment,
                 _staticSegmentRomEnd - _staticSegmentRomStart, &dmaMessageQ);
    
    /*
     * Wait for DMA to finish
     */
    (void)osRecvMesg(&dmaMessageQ, &dummyMessage, OS_MESG_BLOCK);
    
    /*
     * Dma in static segment1 at base of expansion memory
     *
     */
    if ((osMemSize == 0x600000) || (osMemSize == 0x800000)) {
        static1Segment = (char *)STATIC_SEGMENT1_DRAM_6M;
	
        osPiStartDma(&dmaIOMessageBuf, OS_MESG_PRI_NORMAL, OS_READ,
               (u32)_static1SegmentRomStart, static1Segment,
               _static1SegmentRomEnd - _static1SegmentRomStart, &dmaMessageQ);
	/*
        * Wait for DMA to finish
        */
        (void)osRecvMesg(&dmaMessageQ, &dummyMessage, OS_MESG_BLOCK);
    }

    /*
     * Dma in static segment2 3M into the expansion memory (7M)
     *
     */
    if (osMemSize == 0x800000) {
        static2Segment = (char *)STATIC_SEGMENT2_DRAM_8M;

        osPiStartDma(&dmaIOMessageBuf, OS_MESG_PRI_NORMAL, OS_READ,
               (u32)_static2SegmentRomStart, static2Segment,
               _static2SegmentRomEnd - _static2SegmentRomStart, &dmaMessageQ);
       /*
        * Wait for DMA to finish
        */
        (void)osRecvMesg(&dmaMessageQ, &dummyMessage, OS_MESG_BLOCK);
    }
}