/*---------------------------------------------------------------------
	Copyright (C) 1997, Nintendo.
	
	File		main.c
	Coded    by	Yoshitaka Yasumoto.	Feb  6, 1997.
	Modified by	
	Comments	
	
	$Id: main.c,v 1.1.1.1 2002/05/02 03:27:17 blythe Exp $
  ---------------------------------------------------------------------*/
#include	<ultra64.h>
#include	<PR/gs2dex.h>
#include	"system.h"
#include	"texture.h"
#include	"action.h"
#include	"uc_assert.h"
#include	"sprite.h"

extern	Gfx	rdpInit_dl[];
extern	Gfx	clearCfb_dl[];
extern	Gfx	spriteInit_dl[];

void	setBg(void);
void	setObject(void);
void	loadSegment(u32, u32);

/*---------------------------------------------------------------------------*
 *	DL 処理ログを出力するときの設定
 *---------------------------------------------------------------------------*/
#if	defined(RSP_DEBUG)
# define	S2DEX_UCODE(x)	gspS2DEX_fifo_d##x##Start
# define	GFXLOGSIZE	1024
u64		GfxLog[GFXLOGSIZE];
#elif	defined(F3DEX_GBI_2)
# ifdef	XBUS
#  define	S2DEX_UCODE(x)	gspS2DEX2_xbus##x##Start
# else
#  define	S2DEX_UCODE(x)	gspS2DEX2_fifo##x##Start
# endif
# define	GfxLog		0
#else
# define	S2DEX_UCODE(x)	gspS2DEX_fifo##x##Start
# define	GfxLog		0
#endif

/*---------------------------------------------------------------------------*
 * タスクデータ定義
 *---------------------------------------------------------------------------*/
OSTask	tlist = {
  M_GFXTASK,					/* task type                */
  OS_TASK_DP_WAIT|OS_TASK_LOADABLE,		/* task flags               */
  (u64 *)&rspbootTextStart,			/* boot ucode ptr           */
  SP_BOOT_UCODE_SIZE,				/* boot ucode size          */
  (u64 *)&S2DEX_UCODE(Text),			/* ucode ptr                */
  SP_UCODE_SIZE,				/* ucode size               */
  (u64 *)&S2DEX_UCODE(Data),			/* ucode data ptr           */
  SP_UCODE_DATA_SIZE,				/* ucode data size          */
  NULL,						/* dram stack      (不使用) */
  0,						/* dram stack size (不使用) */
  (u64 *)system_rdpfifo,			/* fifo buffer top          */
  (u64 *)system_rdpfifo+RDPFIFO_SIZE,		/* fifo buffer bottom       */
  NULL,						/* data ptr      (後で設定) */
  (u32)GfxLog,	/* S2DEXでは dl log ptr を指定     data size     (設定不要) */
  (u64 *)system_rspyield,			/* yield data ptr           */
  OS_YIELD_DATA_SIZE,				/* yield data size          */
};

/*---------------------------------------------------------------------------*
 * グラフィクスリスト領域
 *---------------------------------------------------------------------------*/
Gfx	glist[2][GLIST_LEN];

/*---------------------------------------------------------------------------*
 * 描画モード パラメータテーブル
 *---------------------------------------------------------------------------*/
static	struct	{
  u32	antiAlias;
  u32	txtrFilter;
  u32	cycleType;
  u32	objRMode;
} RMmodeTable[] = {
{ 0,G_TF_POINT, G_CYC_1CYCLE,0 },                      /* NonAA+Point+1cycle */
{ 0,G_TF_POINT, G_CYC_COPY,  0 },                      /* NonAA+Point+Copy   */
{ 0,G_TF_BILERP,G_CYC_1CYCLE,G_OBJRM_BILERP},          /* NonAA+Bilerp       */
{ 1,G_TF_BILERP,G_CYC_1CYCLE,G_OBJRM_BILERP}	       /* AA+Bilerp          */
};

u32	ShrinkTable[] = { 0, G_OBJRM_SHRINKSIZE_1, G_OBJRM_SHRINKSIZE_2 };
u32	bg16seg, bg8seg;
OSPiHandle      *handler;

/*---------------------------------------------------------------------------*
 * M A I N 
 *---------------------------------------------------------------------------*/
void	Main(void *arg)
{
  u8	draw_frame = 0;
  u32	objRM;
  Gfx	*gp, *gtop;
  OSTime rspstart;
  u32	 rsptime, rdptime;
  
  bg16seg = (u32)_codeSegmentEnd 
          + (u32)_staticSegmentEnd - (u32)_staticSegmentStart;
  bg8seg  = bg16seg + 
          + (u32)_bg_rgbaSegmentRomEnd - (u32)_bg_rgbaSegmentRomStart;

  handler = osCartRomInit();
  loadSegment(bg16seg, bg8seg);
  menuInit();
  actionInit();
  rsptime = rdptime = 0;
  
  while(1){

    /*------ コントローラの読み込み開始 ------*/
    osContStartReadData(&siMessageQ);
    
    /*------ リトレース待ち ------*/
    osRecvMesg(&retraceMessageQ, NULL, OS_MESG_NOBLOCK);
    osRecvMesg(&retraceMessageQ, NULL, OS_MESG_BLOCK);

    /*------ Bg 構造体の設定 ------*/
    setBg();
    
    /*------ Object 構造体の設定 ------*/
    setObject();
    
    /*------ Gfx リスト作成 ------*/
    gtop = gp = glist[draw_frame];

    /*------ RSP 初期設定 ------*/
    gSPSegment(gp ++, 0, 0x0);
    gSPSegment(gp ++, STATIC_SEGMENT, _codeSegmentEnd);
    if (aMenu[MENU_BG_TX_FORMAT]){
      gSPSegment(gp ++, BG_SEGMENT, bg8seg);
    }
    gDPSetColorImage(gp ++, G_IM_FMT_RGBA,
		     G_IM_SIZ_16b, SCREEN_WD, system_cfb[draw_frame]);
    gSPDisplayList(gp ++, rdpInit_dl);
    gSPDisplayList(gp ++, clearCfb_dl);
    gSPDisplayList(gp ++, spriteInit_dl);

    /*------ Bg の出力 ------*/
    if (aMenu[MENU_BG_TX_FORMAT]){
      gDPSetTextureLUT(gp ++, G_TT_RGBA16);
      gSPObjLoadTxtr(gp ++, &objBgTLUT);
    }
    if (aMenu[MENU_BG_SCALABLE] == 0){

      /* Unscalable BG plane */
      gDPSetRenderMode(gp ++, G_RM_NOOP, G_RM_NOOP2);
      gDPSetCycleType(gp ++, G_CYC_COPY);
      gSPBgRectCopy(gp ++, &objBg);

    } else {
      /* Scalable BG plane */
      gDPSetRenderMode(gp ++, G_RM_SPRITE, G_RM_SPRITE2);
      gDPSetCycleType(gp ++, G_CYC_1CYCLE);
      gDPSetTextureFilter(gp ++,
			  RMmodeTable[aMenu[MENU_RENDERMODE]].txtrFilter);
      if (aMenu[MENU_BG_SCALABLE] == 1){
	/* Emulated by CPU */
	guS2DEmuSetScissor(0, 0, SCREEN_WD, SCREEN_HT, 
			   (RMmodeTable[aMenu[MENU_RENDERMODE]].txtrFilter
			    == G_TF_BILERP));
	guS2DEmuBgRect1Cyc(&gp, &objBg);
      } else {
	/* GBI command */
	gSPObjRenderMode(gp ++, RMmodeTable[aMenu[MENU_RENDERMODE]].objRMode);
	gSPBgRect1Cyc(gp ++, &objBg);
      }
    }
    gDPPipeSync(gp ++);

    /*------ Render Mode の設定 ------*/
    objRM = RMmodeTable[aMenu[MENU_RENDERMODE]].objRMode;
    if (RMmodeTable[aMenu[MENU_RENDERMODE]].cycleType != G_CYC_COPY){
      if (!aMenu[MENU_RENDERMODE_2]){
	/* Opaque */
	if (RMmodeTable[aMenu[MENU_RENDERMODE]].antiAlias){
	  gDPSetRenderMode(gp ++, G_RM_AA_SPRITE, G_RM_AA_SPRITE2);
	} else {
	  gDPSetRenderMode(gp ++, G_RM_SPRITE, G_RM_SPRITE2);
	}
      } else {
	/* Translucent */
	if (RMmodeTable[aMenu[MENU_RENDERMODE]].antiAlias){
	  gDPSetRenderMode(gp ++, G_RM_AA_XLU_SPRITE, G_RM_AA_XLU_SPRITE2);
	} else {
	  gDPSetRenderMode(gp ++, G_RM_XLU_SPRITE, G_RM_XLU_SPRITE2);
	}
	gDPSetCombineMode(gp ++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
	gDPSetPrimColor(gp ++, 0,0,255,255,255,128);
      }
    }
    
    /*------ Texture Filter, CycleType の設定 ------*/
    gDPSetTextureFilter(gp ++, RMmodeTable[aMenu[MENU_RENDERMODE]].txtrFilter);
    gDPSetCycleType    (gp ++, RMmodeTable[aMenu[MENU_RENDERMODE]].cycleType );
    
    /*------ Texture Window の設定 ------*/
    if (aMenu[MENU_OBJ_TX_WINDOW]) objRM |= G_OBJRM_NOTXCLAMP;

    /*------ Shrink の設定 ------*/
    objRM |= ShrinkTable[aMenu[MENU_OBJ_SHRINK]];
    
    /*------ Object Render Mode の設定 ------*/    
    gSPObjRenderMode(gp ++, objRM);
    
    /*------ Texture のロード設定 ------*/
    if (!aMenu[MENU_OBJ_TX_TYPE]){
      gDPSetTextureLUT(gp ++, G_TT_NONE);
      gSPObjLoadTxtr(gp ++, (aMenu[MENU_OBJ_TX_LOAD_BY]
			     ? &objTxtrTile_RGBA16 : &objTxtrBlock_RGBA16));
    } else {
      gDPSetTextureLUT(gp ++, G_TT_RGBA16);
      gSPObjLoadTxtr(gp ++, (aMenu[MENU_OBJ_TX_LOAD_BY]
			     ? &objTxtrTile_CI4 : &objTxtrBlock_CI4));
      gSPObjLoadTxtr(gp ++, &objTLUT_CI4);
    }
    
    /*------ Object:Rectangle1 の出力 ------*/
    gSPObjRectangle(gp ++, &(objRect[0]));

    if (RMmodeTable[aMenu[MENU_RENDERMODE]].cycleType != G_CYC_COPY){

      /*------ Object:Rectangle2 の出力 ------*/
      gSPObjMatrix(gp ++, &(objMtx[0]));
      gSPObjSprite(gp ++, &(objRect[1]));

      /*------ Object:Ball の出力 ------*/      
      /* 
	 Ball は 2 枚のスプライトを組み合わせて表示しています. 
	 このため Texture Filter の設定により処理方法を変える必要があります.

	 Texture Filter が PointSample の場合は SHRINKSIZE な指定する
	 必要はないですが, Bilerp のときは SHRINKSIZE_1 でなければなり
	 ません.  SHRINKSIZE_1 を指定すると, Sprite の周囲 0.5 Texel 
	 分がクランプされます. このクランプにより除外された領域は,
	 Bilerp 処理が効いていない部分となります.

	 Bilerp では Sprite の接している部分を 2 度ロードする必要があ
	 るため, Ball では 64x63 Texel 分しか描画しません.
	 objBall[1] と objBall[2] の違いをよく理解することが重要です.
      */
      if (!aMenu[MENU_RENDERMODE_2]){
	/* 接合部を隠すために一回り大きく描画する. (不透明時のみ)
	   S2DEX 1.05 以降では不要となった */
	/* objRM |= G_OBJRM_WIDEN; */
      }
      gDPPipeSync(gp ++);
      gDPSetTextureLUT(gp ++, G_TT_RGBA16);
      gSPObjLoadTxtr(gp ++, &objBallTLUT);
      if (RMmodeTable[aMenu[MENU_RENDERMODE]].txtrFilter == G_TF_POINT){
	gSPObjRenderMode(gp ++, objRM);
	gSPObjMatrix(gp ++, &(objMtx[2]));
	gSPObjLoadTxRectR(gp ++, &(objBall[0]));
	gSPObjLoadTxRectR(gp ++, &(objBall[1]));
	gSPObjMatrix(gp ++, &(objMtx[1]));
	gSPObjLoadTxSprite(gp ++, &(objBall[0]));
	gSPObjLoadTxSprite(gp ++, &(objBall[1]));
      } else {
	gSPObjRenderMode(gp ++, objRM|G_OBJRM_SHRINKSIZE_1);
	gSPObjMatrix(gp ++, &(objMtx[2]));
	gSPObjLoadTxRectR(gp ++, &(objBall[0]));
	gSPObjLoadTxRectR(gp ++, &(objBall[2]));
	gSPObjMatrix(gp ++, &(objMtx[1]));
	gSPObjLoadTxSprite(gp ++, &(objBall[0]));
	gSPObjLoadTxSprite(gp ++, &(objBall[2]));
      }
    }
    
    /*------ 処理メータ出力 ------*/
    if (rsptime){
      gDPPipeSync(gp ++);
      gDPSetCycleType(gp ++, G_CYC_FILL);
      gDPSetRenderMode(gp ++, G_RM_OPA_SURF, G_RM_OPA_SURF2);
      gDPSetFillColor(gp ++, (GPACK_RGBA5551(128,128,255,1) << 16 | 
			      GPACK_RGBA5551(128,128,255,1)));
      gDPFillRectangle(gp ++, 30, 201, 30+rsptime/100, 202);
      gDPFillRectangle(gp ++, 30, 205, 30+rdptime/100, 206);
      gDPSetFillColor(gp ++, (GPACK_RGBA5551(255,255,255,1) << 16 | 
			      GPACK_RGBA5551(255,255,255,1)));
      gDPFillRectangle(gp ++, 30,     200, 30,     207);
      gDPFillRectangle(gp ++, 30+166, 200, 30+166, 207);
    }

    gDPFullSync(gp ++);
    gSPEndDisplayList(gp ++);
    
    /*------ Gfx タスク実行 ------*/
    tlist.t.data_ptr = (u64 *)gtop;
    osWritebackDCache(gtop, ((u32)gp)-((u32)gtop));
    rspstart = osGetTime();
    osSpTaskStart(&tlist);
    
    /*------ 終了待ち ------*/
    osRecvMesg(&rspMessageQ, NULL, OS_MESG_BLOCK);
    rsptime = OS_CYCLES_TO_NSEC(osGetTime() - rspstart) / 1000;
    osRecvMesg(&rdpMessageQ, NULL, OS_MESG_BLOCK);
    rdptime = OS_CYCLES_TO_NSEC(osGetTime() - rspstart) / 1000;

#ifdef	RSP_DEBUG
    /*------ マイクロコードの ASSERT の処理 ------*/
    if (ucCheckAssert()){
      ucDebugGfxLogPrint(&tlist);  	/* RSP Gfx DL の処理ログの出力   */
//	ucDebugRdpFifoPrint(&tlist); 	/* RDP fifo バッファの出力       */
//	ucDebugIMEMPrint(); 		/* IMEM の出力                   */
//      ucDebugDMEMPrint(); 		/* DMEM の出力                   */
      ucDebugAssertPrint();		/* Assert 停止位置等の情報の出力 */
      ucDebugInfoPrint();		/* Debug  用ワークエリアの出力   */
      while(1);
    }
#endif

#if 1
    /*------ DEBUG 情報の出力 ------*/
    if ((Ac.pad[0].push   & (B_BUTTON|Z_TRIG)) &&
	(Ac.pad[0].button & (B_BUTTON|Z_TRIG)) == (B_BUTTON|Z_TRIG)){
      ucDebugRdpFifoPrint(&tlist); 	/* RDP fifo バッファの出力       */
      ucDebugInfoPrint();		/* Debug  用ワークエリアの出力   */
//    ucDebugIMEMPrint(); 		/* IMEM の出力                   */
//    ucDebugDMEMPrint(); 		/* DMEM の出力                   */
    }
#endif
    
    /* Frame 切り替え */
    osViSwapBuffer(system_cfb[draw_frame]);
    draw_frame ^= 1;

    /* コントローラデータ受け取り */
    osRecvMesg(&siMessageQ, NULL, OS_MESG_BLOCK);
    osContGetReadData(contPad);
    
    /* 入力処理 */
    actionUpdate();
  }
}

/*---------------------------------------------------------------------------*
 * BG 構造体の設定
 *---------------------------------------------------------------------------*/
void	setBg(void)
{
  /* BG 構造体の設定 */
  objBg.b.imageX = Ac.imageX;
  objBg.b.imageY = Ac.imageY;
  objBg.b.frameX = Ac.frameX;
  objBg.b.frameY = Ac.frameY;
  objBg.b.frameW = Ac.frameW;
  objBg.b.frameH = Ac.frameH; 
  objBg.b.imageFlip = (aMenu[MENU_BG_FLIPS] ? G_BG_FLAG_FLIPS : 0);
  objBg.b.imageLoad =
    (aMenu[MENU_BG_TX_LOAD_BY] ? G_BGLT_LOADTILE : G_BGLT_LOADBLOCK);
  if (aMenu[MENU_BG_TX_FORMAT]){
    objBg.b.imagePtr = (u64 *)L2_TV;
    objBg.b.imageFmt = G_IM_FMT_CI;
    objBg.b.imageSiz = G_IM_SIZ_8b;
  } else {
    objBg.b.imagePtr = (u64 *)bg16seg;
    objBg.b.imageFmt = G_IM_FMT_RGBA;
    objBg.b.imageSiz = G_IM_SIZ_16b;
  }

  if (!aMenu[MENU_BG_SCALABLE]){
    /*
     *	guS2DInitBg は, 初期化時に一度呼び出したら, あとは imageFmt,
     *	imageSiz, imageLoad, imageW, frameW のどれかを変更したときの
     *	み再度呼び出せば充分である.
     *	ここでは, imageLoad が変更される可能性があるので毎回呼び出す.
     */
    guS2DInitBg(&objBg);
  } else {
    objBg.s.imageYorig = Ac.imageYorig;
    objBg.s.scaleW     = Ac.frameScaleW;
    objBg.s.scaleH     = Ac.frameScaleH; 
  }
  osWritebackDCache(&objBg, sizeof(uObjBg));

  return;
}


/*---------------------------------------------------------------------------*
 * Object 構造体の設定
 *---------------------------------------------------------------------------*/
void	setObject(void)
{
  s32	Sin, Cos;
  u8	flags = ((aMenu[MENU_OBJ_FLIPS] ? G_OBJ_FLAG_FLIPS : 0)|
		 (aMenu[MENU_OBJ_FLIPT] ? G_OBJ_FLAG_FLIPT : 0));

  objRect[0].s.objX   = Ac.objX;
  objRect[0].s.objY   = Ac.objY;
  objRect[0].s.scaleW = Ac.scaleW;
  objRect[0].s.scaleH = Ac.scaleH;
  objRect[0].s.imageFlags = flags;
  
  objMtx[0].m.X = objMtx[1].m.X = Ac.objX + (64<<2);
  objMtx[0].m.Y = objMtx[1].m.Y = Ac.objY;
  objRect[1].s.scaleW = Ac.scaleW;
  objRect[1].s.scaleH = Ac.scaleH;
  objRect[1].s.imageFlags = flags;
  
  Cos = (s32)coss(Ac.theta)*2;
  Sin = (s32)sins(Ac.theta)*2;
  if (Cos == 0xfffe) Cos = 0x10000;
  if (Sin == 0xfffe) Sin = 0x10000;
  if (Cos ==-0xfffe) Cos =-0x10000;
  if (Sin ==-0xfffe) Sin =-0x10000;
  objMtx[0].m.A =    objMtx[0].m.D = Cos;
  objMtx[0].m.B = - (objMtx[0].m.C = Sin);
  
  objMtx[1].m.A =  Cos * 1024 / Ac.scaleW;
  objMtx[1].m.B = -Sin * 1024 / Ac.scaleH;
  objMtx[1].m.C =  Sin * 1024 / Ac.scaleW;
  objMtx[1].m.D =  Cos * 1024 / Ac.scaleH;  
  
  objMtx[2].m.X = Ac.objX;
  objMtx[2].m.Y = Ac.objY;
  objMtx[2].m.BaseScaleX = Ac.scaleW;
  objMtx[2].m.BaseScaleY = Ac.scaleH;

  if (!aMenu[MENU_OBJ_TX_TYPE]){
    objRect[0].s.imageFmt = objRect[1].s.imageFmt = G_IM_FMT_RGBA;
    objRect[0].s.imageSiz = objRect[1].s.imageSiz = G_IM_SIZ_16b;
    objRect[0].s.imageStride =
      objRect[1].s.imageStride = GS_PIX2TMEM(32, G_IM_SIZ_16b);
  } else {
    objRect[0].s.imageFmt = objRect[1].s.imageFmt = G_IM_FMT_CI;
    objRect[0].s.imageSiz = objRect[1].s.imageSiz = G_IM_SIZ_4b;
    objRect[0].s.imageStride =
      objRect[1].s.imageStride = GS_PIX2TMEM(32, G_IM_SIZ_4b);
  }
  
  osWritebackDCache(objRect, sizeof(uObjSprite)*2);
  osWritebackDCache(objMtx,  sizeof(uObjMtx)*3);
  
  return;
}

/*---------------------------------------------------------------------------*
 * セグメントの DMA ロード
 *---------------------------------------------------------------------------*/
void	loadSegment(u32 bg16seg, u32 bg8seg)
{
  /* Static segment のロード */
  dmaIOMessageBuf.hdr.pri      = OS_MESG_PRI_NORMAL;
  dmaIOMessageBuf.hdr.retQueue = &dmaMessageQ;
  dmaIOMessageBuf.dramAddr     = _codeSegmentEnd;
  dmaIOMessageBuf.devAddr      = (u32)_staticSegmentRomStart;
  dmaIOMessageBuf.size         = (u32)_staticSegmentRomEnd-(u32)_staticSegmentRomStart;
  osEPiStartDma(handler, &dmaIOMessageBuf, OS_READ);
  osRecvMesg(&dmaMessageQ, NULL, OS_MESG_BLOCK);  
  
  /* Bg RGBA segment のロード */
  dmaIOMessageBuf.dramAddr     = (char *)bg16seg;
  dmaIOMessageBuf.devAddr      = (u32)_bg_rgbaSegmentRomStart;
  dmaIOMessageBuf.size         = (u32)_bg_rgbaSegmentRomEnd - (u32)_bg_rgbaSegmentRomStart;
  osEPiStartDma(handler, &dmaIOMessageBuf, OS_READ);
  osRecvMesg(&dmaMessageQ, NULL, OS_MESG_BLOCK);  
  
  /* Bg CI segment のロード */
  dmaIOMessageBuf.dramAddr     = (char *)bg8seg;
  dmaIOMessageBuf.devAddr      = (u32)_bg_ciSegmentRomStart;
  dmaIOMessageBuf.size         = (u32)_bg_ciSegmentRomEnd-(u32)_bg_ciSegmentRomStart;
  osEPiStartDma(handler, &dmaIOMessageBuf, OS_READ);
  osRecvMesg(&dmaMessageQ, NULL, OS_MESG_BLOCK);  
}

/*======== End of main.c ========*/