common.h

ESS3890+SL原代码（1*16内存）

    /* Start of window in screen buffer */
    P=PP+X1;

    Z=ZBuf+(X1>>3)+1;  /* Start of window in Z-buffer        */

    Offset=WY;                         /* Actual line number */
    T=WndTab+((int)(Offset&0xF8)<<2);  /* Name Table address */
    Offset=(Offset&0x07)<<1;           /* Offset inside tile */

    /* Initialize Z-buffer */
    X2=X1&0x07;
    Z[0]|=0xFF>>X2;

    /* Drawing tiles... */
    for(X1>>=3;X1<(160>>3);X1++)
    {
      D0=*T;                          /* Tile number         */
      C=T[0x2000];                    /* Attributes          */
      if(!(LCDCONT&0x10)) D0=(D0+0x80)&0xff;   /* Correct tile number */

      /* Tile pattern address is... */
      R = ChrGen                            /* ChrGen addr-s */
        + ((int)D0<<4)                      /* Tile number   */
        + (C&BANK_ATTR?  0x2000:0)          /* Bank number   */
        + (C&VFLIP_ATTR? 14-Offset:Offset); /* Off-t in tile */

      /* Fetch pattern bytes */
      if(C&HFLIP_ATTR) { D0=HFlip[R[0]];D2=HFlip[R[1]]; }
      else             { D0=R[0];D2=R[1]; }

      /* Modify Z-buffer */
      if(C&PRIOR_ATTR) { Z[25]|=0xFF>>X2;Z[26]=~(0xFF>>X2); }
      else Z[26]=0x00;
      Z[1]=0xFF;

      /* Compute CGB palette offset  */
      C=((C&PAL_ATTR)<<2)&0xff;

      /* Modify screen buffer */
      D1=(int)D2<<1;
      D1=(D1&0xAAA)|((D1&0x555)<<7)|(D0&0x55)|((int)(D0&0xAA)<<7);
      P[0]=XPal[C|((D1&0xC000)>>14)];
      P[1]=XPal[C|((D1&0x00C0)>>6 )];
      P[2]=XPal[C|((D1&0x3000)>>12)];
      P[3]=XPal[C|((D1&0x0030)>>4 )];
      P[4]=XPal[C|((D1&0x0C00)>>10)];
      P[5]=XPal[C|((D1&0x000C)>>2 )];
      P[6]=XPal[C|((D1&0x0300)>>8 )];
      P[7]=XPal[C|( D1&0x003      )];

      /* Move pointers */
      P+=8;Z++;T++;
    }
  }

  /* Refresh sprites in this scanline */
  if((LCDCONT&0x82)==0x82) CGBRefreshSprites(Y,PP,ZBuf+1);
}

/** RefreshSprites() *****************************************/
/** Refresh sprites in line Y [0-143]. Called from          **/
/** RefreshLine().                                          **/
/*************************************************************/
void RefreshSprites(int Y,byte *PP,byte *ZBuf)
{
  register byte *Z,*T,*S, *XPal;
  register pixel *P;
  register int D2,D1,D0,J,K,H;
  pixel Pal[4];

  XPal = gmby->XPal;
  H=LCDCONT&0x04? 15:7;
  Y+=16;

  /* Scanning through all sprites... */
  for(S=IO+0x09C,J=40;J;S-=4,J--)
  {
    /* D2=X+8,D0=Y+16 */
    D0=S[0];D2=S[1];

    /* If showing sprite... */
    if((D2<168)&&(Y>=D0)&&(Y<=D0+H))
    {
      /* D2=X,D0=Y+16 */
      D2-=8;

      /* If V-flipped, count the offset from the end */
      D0=S[3]&0x40? D0+H-Y:Y-D0;

      /* Compute pattern address in RAM  */
      T = VRAM
        + ((int)(H>8? S[2]&0xFE:S[2])<<4)
        + (D0<<1);

      /* Read sprite pattern data H-flipping if needed */
      if(S[3]&0x20) { D0=HFlip[T[0]];D1=HFlip[T[1]]; }
      else          { D0=T[0];D1=T[1]; }

      /* Find opaque pixels */
      K=D0|D1;

      /* Clip if under background */
      if(S[3]&0x80)
      {
        Z=ZBuf+(D2>>3);
        K&=~((((int)Z[0]<<8)+Z[1])>>(8-(D2&0x07)));
      }

      /* If there is anything to draw... */
      if(K)
      {
        /* Compute drawing address in XBuf */
        P=PP+D2;

        /* Compute color palette */
        T=S[3]&0x10? SPal1:SPal0;
        Pal[0]=XPal[T[0]];
        Pal[1]=XPal[T[1]];
        Pal[2]=XPal[T[2]];
        Pal[3]=XPal[T[3]];

        /* Drawing a sprite... */     
        D1<<=1;
        D1=(D1&0xAAA)|((D1&0x555)<<7)|(D0&0x55)|((D0&0xAA)<<7);
        if(K&0x80) P[0]=Pal[(D1&0xC000)>>14];
        if(K&0x40) P[1]=Pal[(D1&0x00C0)>>6 ];
        if(K&0x20) P[2]=Pal[(D1&0x3000)>>12];
        if(K&0x10) P[3]=Pal[(D1&0x0030)>>4 ];
        if(K&0x08) P[4]=Pal[(D1&0x0C00)>>10];
        if(K&0x04) P[5]=Pal[(D1&0x000C)>>2 ];
        if(K&0x02) P[6]=Pal[(D1&0x0300)>>8 ];
        if(K&0x01) P[7]=Pal[ D1&0x0003     ];
      }
    }
  }
}

/** CGBRefreshSprites() **************************************/
/** Refresh sprites in line Y [0-143] on a ColorGB. Called  **/
/** from CGBRefreshLine().                                  **/
/*************************************************************/
void CGBRefreshSprites(int Y,byte *PP,byte *ZBuf)
{
  register byte *Z,*T,*S, *XPal;
  register pixel *P;
  register int D2,D1,D0, J, K, H;
  pixel Pal[4];

  XPal = gmby->XPal;
  H=LCDCONT&0x04? 15:7;
  Y+=16;

  /* Scanning through all sprites... */
  for(S=IO+0x09C,J=40;J;S-=4,J--)
  {
    /* D2=X+8,D0=Y+16 */
    D0=S[0];D2=S[1];

    /* If showing sprite... */
    if((D2<168)&&(Y>=D0)&&(Y<=D0+H))
    {
      /* D2=X,D0=Y+16 */
      D2-=8;

      /* If V-flipped, count the offset from the end */
      D0=S[3]&0x40? D0+H-Y:Y-D0;

      /* Compute pattern address in RAM  */
      T = VRAM
        + (S[3]&0x08? 0x2000:0)
        + ((int)(H>8? S[2]&0xFE:S[2])<<4)
        + (D0<<1);

      /* Read sprite pattern data H-flipping if needed */
      if(S[3]&0x20) { D0=HFlip[T[0]];D1=HFlip[T[1]]; }
      else          { D0=T[0];D1=T[1]; }

      /* Find opaque pixels */
      K=D0|D1;

      /* Clip with high priority background */
      Z=ZBuf+(D2>>3);
      K&=~((((int)Z[25]<<8)+Z[26])>>(8-(D2&0x07)));
      
      /* Clip if under background */
      if(K&&(S[3]&0x80)) K&=~((((int)Z[0]<<8)+Z[1])>>(8-(D2&0x07)));

      /* If there is anything to draw... */
      if(K)
      {
        /* Compute drawing address in XBuf */
        P=PP+D2;

        /* Compute color palette for ColorGB */ 
        D2=((S[3]&0x07)<<2)+32;
        Pal[0]=XPal[D2];
        Pal[1]=XPal[D2+1];
        Pal[2]=XPal[D2+2];
        Pal[3]=XPal[D2+3];

        /* Drawing a sprite... */     
        D1<<=1;
        D1=(D1&0xAAA)|((D1&0x555)<<7)|(D0&0x55)|((D0&0xAA)<<7);
        if(K&0x80) P[0]=Pal[(D1&0xC000)>>14];
        if(K&0x40) P[1]=Pal[(D1&0x00C0)>>6 ];
        if(K&0x20) P[2]=Pal[(D1&0x3000)>>12];
        if(K&0x10) P[3]=Pal[(D1&0x0030)>>4 ];
        if(K&0x08) P[4]=Pal[(D1&0x0C00)>>10];
        if(K&0x04) P[5]=Pal[(D1&0x000C)>>2 ];
        if(K&0x02) P[6]=Pal[(D1&0x0300)>>8 ];
        if(K&0x01) P[7]=Pal[ D1&0x0003     ];
      }
    }
  }
}

/** SGBBackdrop() ********************************************/
/** Show SuperGB backdrop. Called by SuperGB extension.     **/
/*************************************************************/
void SGBBackdrop(void)
{
  register byte *T,*R, *XPal, *HFlip;
  register unsigned int L;
  register pixel *P,*C;
  register int DY;
  int X, Y, J, I, M;

  HFlip = PHFlip;
  XPal = gmby->XPal;
  P=XBuf;
  T=SGBChrTab;

  for(Y=0;Y<28;Y++,P+=1792)
    for(X=0;X<32;X++)
    {
      I=T[1];
      R=SGBChrGen+((int)T[0]<<5);
      if(I&0x80) { R+=14;DY=-2; } else DY=2;
      C=XPal+((I&0x0C)<<2)+64;
      I&=0x40;

      for(J=0;J<8;J++)
      {
        M=I? HFlip[R[0]]:R[0];
        L=((M&0x88)<<21)|((M&0x44)<<14)|((M&0x22)<<7)|(M&0x11);
        M=I? HFlip[R[1]]:R[1];
        L|=((M&0x88)<<22)|((M&0x44)<<15)|((M&0x22)<<8)|((M&0x11)<<1);
        M=I? HFlip[R[16]]:R[16];
        L|=((M&0x88)<<23)|((M&0x44)<<16)|((M&0x22)<<9)|((M&0x11)<<2);
        M=I? HFlip[R[17]]:R[17];
        L|=((M&0x88)<<24)|((M&0x44)<<17)|((M&0x22)<<10)|((M&0x11)<<3);

        P[0]=C[(L>>28)&0x0F];
        P[1]=C[(L>>20)&0x0F];
        P[2]=C[(L>>12)&0x0F];
        P[3]=C[(L>>4)&0x0F];
        P[4]=C[(L>>24)&0x0F];
        P[5]=C[(L>>16)&0x0F];
        P[6]=C[(L>>8)&0x0F];
        P[7]=C[L&0x0F];
        P+=WIDTH;R+=DY;
      }
      P-=2040;T+=2;
    }

  VGAPutImage(&Img,0,0,256,224);
}

#endif
/*VGB*/