/*---------------------------------------------------------------------*
	Copyright (C) 1998, Nintendo.
	
	File		us2dex_emu.c
	Coded    by	Yoshitaka Yasumoto.	Apr  9, 1998.
	
	$Id: us2dex_emu.c,v 1.1.1.2 2002/10/29 08:06:43 blythe Exp $
 *---------------------------------------------------------------------*/
#define		F3DEX_GBI
#include	<ultra64.h>
#include	<PR/gs2dex.h>

#define	RSP_DEBUG

static	u16	scissorX0 = 0;		/* (s13.2) */
static	u16	scissorY0 = 0;		/* (s13.2) */
static	u16	scissorX1 = 320<<2;	/* (s13.2) */
static	u16	scissorY1 = 240<<2;	/* (s13.2) */
static	u8	flagBilerp = 0;

static	u32	rdpSetTimg_w0, rdpSetTile_w0;
static  u16	tmemSliceWmax;
static  u16	imageSrcWsize;
static	s16	flagSplit;
static	u16	imagePtrX0;
static	u32	imageTop;
static  s16	tmemSrcLines;

/* Addition 99/05/31(Y) */
static s8 bgflg;

/*---------------------------------------------------------------------------*
 * シザリングパラメータ設定 
 * *---------------------------------------------------------------------------*/
void	guS2DEmuSetScissor(u32 ulx, u32 uly, u32 lrx, u32 lry, u8 flag)
{
  scissorX0 = (u16)ulx << 2;
  scissorY0 = (u16)uly << 2;
  scissorX1 = (u16)lrx << 2;
  scissorY1 = (u16)lry << 2;
  flagBilerp = (flag) ? 1 : 0;
}

/*---------------------------------------------------------------------------*
 * テクスチャロード用 RDP コマンド作成部
 *---------------------------------------------------------------------------*/
static	void	tmemLoad_B(Gfx **pkt, u32 imagePtr, s16 loadLines, s16 tmemSH)
{
  /*
   * tmem に imagePtr からの幅 tmemSH ワードの 16bit テクスチャを
   * loadLines 行ロードする
   */

  /* [SetTImg]  CMD=0x3d FMT=RGBA(0) SIZ=16b(2) */
  (*pkt)->words.w0 = rdpSetTimg_w0;
  (*pkt)->words.w1 = imagePtr;
  (*pkt) ++;

  /* [LoadSync] 先行するプリミティブの描画の終了を待つ */
  (*pkt)->words.w0 = (G_RDPLOADSYNC<<24);
  (*pkt) ++;

  /* [LoadTile] CMD=0x34 TILE=7 SH=TMEMW*16-1 TMEMH*4-1 */
  (*pkt)->words.w0 = (G_LOADTILE<<24)|0x000000;
/* addition 99/5/31(Y) */
  if(bgflg==3) (*pkt)->words.w1 = 0x07000000 | (tmemSH-1)<<16;
  else  (*pkt)->words.w1 = 0x07000000 | (tmemSH-1)<<16 | (loadLines<<2)-1;
  (*pkt) ++;
}

static	void	tmemLoad_A(Gfx **pkt, u32 imagePtr,
			   s16 loadLines, s16 tmemAdrs, s16 tmemSH)
{
  /*
   * tmem の tmemAdrs へに imagePtr からの幅 tmemSH ワードの 16bit テクスチャを
   * loadLines 行ロードする
   */

  /* [TileSync] 先行する命令の Tile アクセス終了を待つ */
  (*pkt)->words.w0 = 0xe8000000;
  (*pkt) ++;

  /* [SetTile] */
  (*pkt)->words.w0 = rdpSetTile_w0|tmemAdrs;
  (*pkt)->words.w1 = 0x07000000;
  (*pkt) ++;
  
  tmemLoad_B(pkt, imagePtr, loadLines, tmemSH);
}

static	void	tmemLoad(Gfx **pkt, u32 *imagePtr,
		 s16 *imageRemain, s16 drawLines, s16 flagBilerp)
{
  s16	loadLines = drawLines + flagBilerp;
  s16	iLoadable = (*imageRemain) - flagSplit;
  
  if (iLoadable >= loadLines){		/* 一気にロードが出来る場合 */
    tmemLoad_B(pkt, *imagePtr, loadLines, tmemSliceWmax);    
    (*imagePtr)    += imageSrcWsize * drawLines;
    (*imageRemain) -= drawLines;
    
  } else {				/* 分割してロードする場合 */
    s16  SubSliceL2, SubSliceD2, SubSliceY2;
    u32	 imageTopSeg = imageTop & 0xff000000; 
    
    SubSliceY2 = *imageRemain;
    SubSliceL2 = loadLines - SubSliceY2;
    SubSliceD2 = drawLines - SubSliceY2;
    
    if (SubSliceL2 > 0){
      u32  imagePtr2;
      
      imagePtr2 = imageTop + imagePtrX0;
      if (SubSliceY2 & 1){
	imagePtr2 -= imageSrcWsize;
	imagePtr2  = imageTopSeg | (imagePtr2 & 0x00ffffff); /*Segment対策 */
	SubSliceY2 --;
	SubSliceL2 ++;
      }
      tmemLoad_A(pkt, imagePtr2,
		 SubSliceL2, SubSliceY2 * tmemSliceWmax, tmemSliceWmax);
    }
    if (flagSplit){
      u32    imagePtr1A, imagePtr1B;
      s16    SubSliceY1, SubSliceL1;
      s16    tmemSH_A, tmemSH_B;
      
      imagePtr1A = (*imagePtr) + iLoadable * imageSrcWsize;
      imagePtr1B = imageTop;
      SubSliceY1 = iLoadable;
      if (SubSliceL1 = iLoadable & 1){
	imagePtr1A -= imageSrcWsize;
	imagePtr1B -= imageSrcWsize;
	imagePtr1B  = imageTopSeg | (imagePtr1B & 0x00ffffff); /*Segment対策 */
	SubSliceY1 --;
      }
      SubSliceL1 ++;
      tmemSH_A = (imageSrcWsize - imagePtrX0) >> 3;
      tmemSH_B =  tmemSliceWmax - tmemSH_A;
      tmemLoad_A(pkt, imagePtr1B,
		 SubSliceL1, SubSliceY1 * tmemSliceWmax + tmemSH_A, tmemSH_B);
      tmemLoad_A(pkt, imagePtr1A,
		 SubSliceL1, SubSliceY1 * tmemSliceWmax, tmemSH_A);      
    }
    if (iLoadable > 0){

      tmemLoad_A(pkt, *imagePtr, iLoadable, 0, tmemSliceWmax);
            
    } else {
      
      /* [SetTile] */
      (*pkt)->words.w0 = rdpSetTile_w0;
      (*pkt)->words.w1 = 0x07000000;
      (*pkt) ++;
    }
    
    (*imageRemain) -= drawLines;
    if ((*imageRemain) > 0){
      (*imagePtr) += imageSrcWsize * drawLines;
    } else {
      (*imageRemain) = tmemSrcLines - SubSliceD2;
      (*imagePtr) = imageTop + SubSliceD2 * imageSrcWsize + imagePtrX0;
    }
    
  }
}

/*---------------------------------------------------------------------------*
 * Scalable BG 面描画処理
 *---------------------------------------------------------------------------*/
void	guS2DEmuBgRect1Cyc(Gfx **pkt, uObjBg *bg)
{
  s16	frameX0, frameX1, framePtrY0, frameRemain;
  s16	imageX0, imageY0, imageSliceW, imageW;
  s32	imageYorig;
  s16	scaleW,  scaleH;

  s16	imageSrcW, imageSrcH;
  s16	tmemSliceLines, imageSliceLines;
  s32	frameSliceLines, frameSliceCount;
  u16	imageS, imageT;
  u32	imagePtr;

  s16	imageISliceL0, imageIY0;
  s32	frameLSliceL0;
  
  scaleW = bg->s.scaleW;
  scaleH = bg->s.scaleH;  

/* addition 99/05/31(Y) */
  bgflg=bg->s.imageSiz;
  if(scaleW==0) scaleW=1;
  if(scaleH==0) scaleH=1;

    
{
  /*-------------------------------------------------*
    シザリング処理
   *-------------------------------------------------*/  
  /*
  /  frameX0, frameX1, framePtrY0, frameRemain
  /  imageX0, imageY0, tmemSliceW
  /  imageSrcW, imageSrcH
  */
  s16	pixX0, pixY0, pixX1, pixY1;			/* (s13.2) */
  s16	frameY0, frameW, frameH;
  s32	frameWmax, frameHmax;
  
  /* イメージと拡大率からフレームの最大サイズを求める */
  frameWmax = ((((s32)bg->s.imageW << 10) / scaleW)-1) & ~3;
  frameHmax = ((((s32)bg->s.imageH << 10) / scaleH)-1) & ~3;
  
  /* フレームサイズをクランプする */
  frameW  = bg->s.frameW;
  frameH  = bg->s.frameH;
  frameX0 = bg->s.frameX;
  frameY0 = bg->s.frameY;
  if ((frameWmax = bg->s.frameW - frameWmax) < 0) frameWmax = 0;
  if ((frameHmax = bg->s.frameH - frameHmax) < 0) frameHmax = 0;
  frameW -= frameWmax;
  frameH -= frameHmax;
  if (bg->s.imageFlip & G_BG_FLAG_FLIPS){
    frameX0 += frameWmax;
  }
  
  /* 画面からのはみ出し量の計算 */
  pixX0 = scissorX0 - frameX0;				/* (s13.2) */
  pixY0 = scissorY0 - frameY0;				/* (s13.2) */
  pixX1 = frameW - scissorX1 + frameX0;			/* (s13.2) */
  pixY1 = frameH - scissorY1 + frameY0;			/* (s13.2) */
  
  /* はみ出していないならクランプする */
  if (pixX0 < 0) pixX0 = 0;
  if (pixY0 < 0) pixY0 = 0;
  if (pixX1 < 0) pixX1 = 0;
  if (pixY1 < 0) pixY1 = 0;
  
  /* はみ出し分をカットする */
  frameW  = frameW - (pixX0 + pixX1);			/* (s13.2) */
  frameH  = frameH - (pixY0 + pixY1);			/* (s13.2) */
  frameX0 = frameX0 + pixX0;				/* (s13.2) */
  frameY0 = frameY0 + pixY0;				/* (s13.2) */

  /* 描画範囲が残っていないなら終了 */
  if (frameW <= 0 || frameH <= 0) return;

  /* フレームの計算 */
  frameX1     = frameX0 + frameW;			/* (s13.2) */
  framePtrY0  = frameY0 >> 2;				/* (s15.0) */
  frameRemain = frameH  >> 2; 				/* (s15.0) */
  
  /* イメージの桁あわせ */
  imageSrcW = bg->s.imageW << 3;		/* (u11.5) */
  imageSrcH = bg->s.imageH << 3;		/* (u11.5) */
  
  /* イメージの範囲の取得 (u14.2)*(u6.10)=(u20.12)->(u11.5) */
  imageSliceW = (imageW = frameW * scaleW >> 7) + flagBilerp * 32;
  if (bg->s.imageFlip & G_BG_FLAG_FLIPS){
    imageX0 = bg->s.imageX + (pixX1 * scaleW >> 7);		  /* (s10.5) */
  } else {
    imageX0 = bg->s.imageX + (pixX0 * scaleW >> 7);		  /* (s10.5) */
  }
  imageY0     = bg->s.imageY + (pixY0 * scaleH >> 7);		  /* (s10.5) */
  imageYorig  = bg->s.imageYorig;
  
  /* 描画領域の左端がイメージソースの右端を超えた場合はループさせ 1 段下へ */
  while (imageX0 >= imageSrcW){
    imageX0     -= imageSrcW;
    imageY0     += 32;
    imageYorig  += 32;			/* キャリーを 1 加算する */
  }
  
  /* 描画領域の上端がイメージソースの下端を超えた場合はループさせる */
  while (imageY0 >= imageSrcH){
    imageY0     -= imageSrcH;
    imageYorig  -= imageSrcH;
  }
}

{
  /*-------------------------------------------------*
    イメージの下端と上端の接続処理のチェック
   *-------------------------------------------------*/
  /*
  // flagSplit
  // tmemSrcLines
  // imageSrcLines
  */  
  /* 描画領域が右端をまたがると上下の接続処理をする必要がある */
  flagSplit = (imageX0 + imageSliceW >= imageSrcW);
  
  /* 一括ロードの可能なイメージライン数 */
  tmemSrcLines = imageSrcH >> 5;
}

{
  /*-------------------------------------------------*
    TMEM へのロードデータ取得
   *-------------------------------------------------*/
  /*
  //
  // TMEM 内にロードできるライン数の計算	
  //	シザリングによってスライスの幅が変るのに連動させてロードライ
  //	ン数を変化させた場合, フレームの分割線が変化するので不自然な
  //	シワが生じてしまう. これを防ぐためにシザリングされない状態を
  //	基準にして分割領域を固定にする.
  */
  s16	tmemSize, tmemMask, tmemShift;
  s32	imageNumSlice;
  s32	imageSliceWmax;
  s32	imageLYoffset, frameLYoffset;
  s32	imageLHidden,  frameLHidden;
  s32	frameLYslice;
  
  static s16	TMEMSIZE[]  = {   512,   512,   256,   512,  512 };
  static s16	TMEMMASK[]  = { 0x1ff,  0xff,  0x7f,  0x3f };
  static s16	TMEMSHIFT[] = { 0x200, 0x100,  0x80,  0x40 };   
  tmemSize  = TMEMSIZE[bg->s.imageFmt];		/* (s15.0) */
  tmemMask  = TMEMMASK[bg->s.imageSiz];		/* (s10.5) */
  tmemShift = TMEMSHIFT[bg->s.imageSiz];	/* (s10.5)->(s15.0) */

  /* スライスの image 幅に対応する tmem 幅の計算 */
  /* 	o Bilerp 時は補間のために余分が必要
  //	o スライスの image 幅の image のソース幅によるクランプ
  //	o image 幅の端数を TMEM Word 境界に切り上げる.
  //	o 開始位置が Word 境界と一致していない場合のために tmem 幅 +1 */

/* addition 99/05/31(Y) */
  if(bgflg==3){
     tmemSize=480;
     imageSliceWmax = 0x2800;
  }
  else{
     imageSliceWmax = (((s32)bg->s.frameW * (s32)scaleW)>>7) + (flagBilerp<<5);
     if (imageSliceWmax > imageSrcW) imageSliceWmax = imageSrcW;  
  }
  tmemSliceWmax  = (imageSliceWmax + tmemMask) / tmemShift + 1;
  
  /* 一度にロードできる TMEM/image/frame ライン数の取得 */
   tmemSliceLines = tmemSize / tmemSliceWmax;		/* (s15.0) */
  imageSliceLines = tmemSliceLines - flagBilerp;	/* (s15.0) */
  frameSliceLines = (imageSliceLines << 20) / scaleH;	/* (s21.10) */

  /* image Y 座標のオフセット値をフレームラインへ整列させる */
  imageLYoffset = ((s32)imageY0 - imageYorig) << 5;
  if (imageLYoffset < 0) imageLYoffset -= (scaleH - 1);
  frameLYoffset = imageLYoffset / scaleH;
  frameLYoffset <<= 10;
  
  /* image Y に対応するスライス番号の取得 */
  if (frameLYoffset >= 0){
    imageNumSlice = frameLYoffset / frameSliceLines;
  } else {
    imageNumSlice = (frameLYoffset - frameSliceLines + 1) / frameSliceLines;
  }
  
  /* 描画開始スライスがフレーム上部にどれだけ隠れているかを計算 */
  frameLYslice = (frameLSliceL0 = frameSliceLines * imageNumSlice) & ~1023;
  frameLHidden = frameLYoffset - frameLYslice;
  imageLHidden = (frameLHidden >> 10) * scaleH;
  
  /* 描画開始スライスのフレームサイズの計算 */
  frameLSliceL0 = (frameLSliceL0 & 1023) + frameSliceLines - frameLHidden;  
  
  /* スライスを途中から描画するためのイメージパラメータの計算 */
  imageT        = (imageLHidden >> 5) & 31;
  imageLHidden  >>= 10;
  imageISliceL0 = imageSliceLines - imageLHidden;
  imageIY0      =
    imageSliceLines * imageNumSlice + (imageYorig & ~31) / 32 + imageLHidden;
  if (imageIY0 < 0)                    imageIY0 += (bg->s.imageH >> 2);
  if (imageIY0 >= (bg->s.imageH >> 2)) imageIY0 -= (bg->s.imageH >> 2);
  imageTop      = (u32)bg->s.imagePtr;			/* (u32.0) */
  imageSrcWsize = (imageSrcW / tmemShift) << 3;		/* (u16.0) */
  imagePtrX0    = (imageX0   / tmemShift) << 3;		/* (u16.0) */
  imagePtr      = imageTop + imageSrcWsize * imageIY0 + imagePtrX0;

  /* S 反転時の処理 */
  imageS = imageX0 & tmemMask;		/* (u10.5) */
  if (bg->s.imageFlip & G_BG_FLAG_FLIPS){
    imageS = - (imageS + imageW);
  }
}

{
  /*-------------------------------------------------*
    RDP コマンドの定数値の作成
   *-------------------------------------------------*/
  /*	u32	rdpSetTimg_w0; 
  	u32	rdpSetTile_w0; */
/* Addition 99/05/31(Y) */
  if(bgflg==3){
    rdpSetTimg_w0 = (G_SETTIMG<<24)+0x180000+(imageSrcWsize>>1)-1;
    rdpSetTile_w0 = (G_SETTILE<<24)+0x180000+(tmemSliceWmax<<9);
  }
  else{
    rdpSetTimg_w0 = (G_SETTIMG<<24)+0x100000+(imageSrcWsize>>1)-1;
    rdpSetTile_w0 = (G_SETTILE<<24)+0x100000+(tmemSliceWmax<<9);
  }
  /* [SetTile:7] */
  (*pkt)->words.w0 = rdpSetTile_w0;
  (*pkt)->words.w1 = 0x07000000;
  (*pkt)++;
  /* [SetTile:0] */
  (*pkt)->words.w0 = rdpSetTile_w0;
  ((u8 *)&((*pkt)->words.w0))[1] = (bg->s.imageFmt<<5)|(bg->s.imageSiz<<3);
  (*pkt)->words.w1 = 0x0007c1f0 | (bg->s.imagePal<<20);
  (*pkt)++;
  /* [SetTileSize:7] */
  (*pkt)->words.w0 = (G_SETTILESIZE<<24)|0x000000;
  (*pkt)->words.w1 = 0x00000000;
  (*pkt)++;
}
  
{
  s16	imageRemain;
  s16	imageSliceH, frameSliceH;
  
  imageRemain     = tmemSrcLines - imageIY0;  
  imageSliceH     = imageISliceL0;
  frameSliceCount = frameLSliceL0;

  while(1){

    /* 描画ライン数の計算をし, 描画を行なうかどうか判定する */
    frameSliceH = frameSliceCount >> 10;
    if (frameSliceH <= 0){
      /* 描画をしない場合 */
      imageRemain -= imageSliceH;
      if (imageRemain > 0){
	imagePtr += imageSrcWsize * imageSliceH;
      } else {
	imagePtr = imageTop - (imageRemain * imageSrcWsize) + imagePtrX0;
	imageRemain += tmemSrcLines;
      }
      
    } else {
      /* 描画をする場合 */
      s16	framePtrY1;
      
      frameSliceCount &= 1023;
      if ((frameRemain -= frameSliceH) < 0){
	/* 最終スライスかの判定 */
	frameSliceH += frameRemain;
	imageSliceH += ((frameRemain * scaleH) >> 10) + 1;
	if (imageSliceH > imageSliceLines) imageSliceH = imageSliceLines;
      }
      tmemLoad(pkt, &imagePtr, &imageRemain, imageSliceH, flagBilerp);
      
      /* 描画フレーム範囲の取得 */
      framePtrY1 = framePtrY0 + frameSliceH;		/* (s15.0) */
      
      /* [PipeSync] 先行する LOADTILE 命令の終了を待つ */
      (*pkt)->words.w0 = (G_RDPPIPESYNC<<24);
      (*pkt) ++;

      /* Rectangle 描画 */
      /* ここでは RSP コマンドを作成するが, ucode では RDPコマンドを作成する */
#if 1
      {
	/* [TextureRectangle] */
	(*pkt)->words.w0 = (G_TEXRECT<<24)|(frameX1<<12)|(framePtrY1<<2);
	(*pkt)->words.w1 =                 (frameX0<<12)|(framePtrY0<<2);
	(*pkt) ++;
#else
      /* スライス分割ラインをチェックする場合のコード */
      if (frameSliceH > 1){
	(*pkt)->words.w0 = (G_TEXRECT<<24)|(frameX1<<12)|(framePtrY1<<2)-4;
	(*pkt)->words.w1 =                 (frameX0<<12)|(framePtrY0<<2);
	(*pkt) ++;
#endif
	
#if 0	/* RDP コマンド作成時 */
	(*pkt)->words.w0 = (imageS<<16) | imageT;
	(*pkt)->words.w1 = (scaleW<<16) | scaleH;
#else	/* RSP コマンド作成時 */
	(*pkt)->words.w0 = (G_RDPHALF_1<<24);
	(*pkt)->words.w1 = (imageS<<16) | imageT;
	(*pkt) ++;      
	(*pkt)->words.w0 = (G_RDPHALF_2<<24);
	(*pkt)->words.w1 = (scaleW<<16) | scaleH;
#endif
	(*pkt) ++;
      }

      /* 領域更新 */
      framePtrY0 = framePtrY1;

      /* フレームの未描画ライン数が無くなったら終わる */
      if (frameRemain <= 0){
	return;
      }
    }
    frameSliceCount += frameSliceLines;
    imageSliceH      = imageSliceLines;
    imageT           = 0;
  }
}
}

/*======== End of us2dex_emu.c ========*/