[BACK]Return to gdc_sub.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / io

Diff for /np2/io/gdc_sub.c between versions 1.10 and 1.12

version 1.10, 2004/02/11 17:39:59 version 1.12, 2004/02/18 03:56:57
Line 34  static const VECTDIR vectdir[16] = { Line 34  static const VECTDIR vectdir[16] = {
                                         {-1, 0,-1, 1}, {-1, 1, 0, 1}};                                          {-1, 0,-1, 1}, {-1, 1, 0, 1}};
   
   
   #if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
   const UINT8 gdcbitreverse[0x100] = {
                                   0x00, 0x01, 0x01, 0x03, 0x01, 0x05, 0x03, 0x07,
                                   0x01, 0x09, 0x05, 0x0d, 0x03, 0x0b, 0x07, 0x0f,
                                   0x01, 0x11, 0x09, 0x19, 0x05, 0x15, 0x0d, 0x1d,
                                   0x03, 0x13, 0x0b, 0x1b, 0x07, 0x17, 0x0f, 0x1f,
                                   0x01, 0x21, 0x11, 0x31, 0x09, 0x29, 0x19, 0x39,
                                   0x05, 0x25, 0x15, 0x35, 0x0d, 0x2d, 0x1d, 0x3d,
                                   0x03, 0x23, 0x13, 0x33, 0x0b, 0x2b, 0x1b, 0x3b,
                                   0x07, 0x27, 0x17, 0x37, 0x0f, 0x2f, 0x1f, 0x3f,
                                   0x01, 0x41, 0x21, 0x61, 0x11, 0x51, 0x31, 0x71,
                                   0x09, 0x49, 0x29, 0x69, 0x19, 0x59, 0x39, 0x79,
                                   0x05, 0x45, 0x25, 0x65, 0x15, 0x55, 0x35, 0x75,
                                   0x0d, 0x4d, 0x2d, 0x6d, 0x1d, 0x5d, 0x3d, 0x7d,
                                   0x03, 0x43, 0x23, 0x63, 0x13, 0x53, 0x33, 0x73,
                                   0x0b, 0x4b, 0x2b, 0x6b, 0x1b, 0x5b, 0x3b, 0x7b,
                                   0x07, 0x47, 0x27, 0x67, 0x17, 0x57, 0x37, 0x77,
                                   0x0f, 0x4f, 0x2f, 0x6f, 0x1f, 0x5f, 0x3f, 0x7f,
                                   0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
                                   0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
                                   0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
                                   0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
                                   0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
                                   0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
                                   0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
                                   0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
                                   0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
                                   0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
                                   0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
                                   0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
                                   0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
                                   0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
                                   0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
                                   0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff};
   #else
   REG8 gdcbitreverse(REG8 data) {
   
           REG8    ret;
           UINT    cnt;
   
           ret = 0;
           cnt = 8;
           do {
                   ret = (ret * 2) + (data & 1);
                   data >>= 1;
           } while(--cnt);
           return(ret);
   }
   #endif
   
   
 void gdcsub_init(void) {  void gdcsub_init(void) {
   
         int             i;          int             i;
Line 69  static void calc_gdcslavewait(UINT dots) Line 120  static void calc_gdcslavewait(UINT dots)
         nevent_set(NEVENT_GDCSLAVE, clk, gdcslavewait, NEVENT_ABSOLUTE);          nevent_set(NEVENT_GDCSLAVE, clk, gdcslavewait, NEVENT_ABSOLUTE);
 }  }
   
 void gdcsub_null(UINT32 csrw, const GDCVECT *vect, REG16 pat, REG8 ope) {  void gdcsub_vect0(UINT32 csrw, const GDCVECT *vect, REG16 pat, REG8 ope) {
   
         (void)csrw;          (void)csrw;
         (void)vect;          (void)vect;
Line 77  void gdcsub_null(UINT32 csrw, const GDCV Line 128  void gdcsub_null(UINT32 csrw, const GDCV
         (void)ope;          (void)ope;
 }  }
   
 void gdcsub_line(UINT32 csrw, const GDCVECT *vect, REG16 pat, REG8 ope) {  void gdcsub_vectl(UINT32 csrw, const GDCVECT *vect, REG16 pat, REG8 ope) {
   
         _GDCPSET        pset;          _GDCPSET        pset;
         UINT            dc;          UINT            dc;
Line 157  void gdcsub_line(UINT32 csrw, const GDCV Line 208  void gdcsub_line(UINT32 csrw, const GDCV
         calc_gdcslavewait(pset.dots);          calc_gdcslavewait(pset.dots);
 }  }
   
 void gdcsub_box(UINT32 csrw, const GDCVECT *vect, REG16 pat, REG8 ope) {  void gdcsub_vectt(UINT32 csrw, const GDCVECT *vect, REG16 pat, REG8 ope) {
   
         _GDCPSET        pset;          _GDCPSET        pset;
         UINT            d;          BYTE            multiple;
         UINT            d2;          UINT            sx;
         REG16           x;  
         REG16           y;  
         UINT            i;  
 const VECTDIR   *dir;  const VECTDIR   *dir;
           BYTE            muly;
           REG16           cx;
           REG16           cy;
           UINT            xrem;
           BYTE            mulx;
   
         gdcpset_prepare(&pset, csrw, pat, ope);          if (vect->ope & 0x80) {         // SL
         d = (LOADINTELWORD(vect->D)) & 0x3fff;                  pat = (REG16)((GDCPATREVERSE(pat) << 8) + GDCPATREVERSE(pat >> 8));
         d2 = (LOADINTELWORD(vect->D2)) & 0x3fff;  
         x = pset.x;  
         y = pset.y;  
         // 回転はなしよ(手抜き)  
         dir = vectdir + ((vect->ope) & 7);  
         for (i=0; i<d; i++) {  
                 gdcpset(&pset, x, y);  
                 x += dir->x;  
                 y += dir->y;  
         }          }
         for (i=0; i<d2; i++) {          gdcpset_prepare(&pset, csrw, 0xffff, ope);
                 gdcpset(&pset, x, y);          multiple = (gdc.s.para[GDC_ZOOM] & 15) + 1;
                 x += dir->x2;  
                 y += dir->y2;          sx = LOADINTELWORD(vect->D);
         }          sx = ((sx - 1) & 0x3fff) + 1;
         for (i=0; i<d; i++) {          if (sx >= 768) {
                 gdcpset(&pset, x, y);                  sx = 768;
                 x -= dir->x;  
                 y -= dir->y;  
         }          }
         for (i=0; i<d2; i++) {          dir = vectdir + ((vect->ope) & 7);
                 gdcpset(&pset, x, y);  
                 x -= dir->x2;          muly = multiple;
                 y -= dir->y2;          while(muly--) {
                   cx = pset.x;
                   cy = pset.y;
                   xrem = sx;
                   while(xrem--) {
                           mulx = multiple;
                           if (pat & 1) {
                                   pat >>= 1;
                                   pat |= 0x8000;
                                   while(mulx--) {
                                           gdcpset(&pset, cx, cy);
                                           cx += dir->x;
                                           cy += dir->y;
                                   }
                           }
                           else {
                                   pat >>= 1;
                                   while(mulx--) {
                                           cx += dir->x;
                                           cy += dir->y;
                                   }
                           }
                   }
                   pset.x += dir->x2;
                   pset.y += dir->y2;
         }          }
         calc_gdcslavewait(pset.dots);          calc_gdcslavewait(pset.dots);
 }  }
   
 void gdcsub_circle(UINT32 csrw, const GDCVECT *vect, REG16 pat, REG8 ope) {  void gdcsub_vectc(UINT32 csrw, const GDCVECT *vect, REG16 pat, REG8 ope) {
   
         _GDCPSET        pset;          _GDCPSET        pset;
         UINT            r;          UINT            r;
Line 291  void gdcsub_circle(UINT32 csrw, const GD Line 357  void gdcsub_circle(UINT32 csrw, const GD
         calc_gdcslavewait(pset.dots);          calc_gdcslavewait(pset.dots);
 }  }
   
 void gdcsub_txt(UINT32 csrw, const GDCVECT *vect, REG16 pat, REG8 ope) {  void gdcsub_vectr(UINT32 csrw, const GDCVECT *vect, REG16 pat, REG8 ope) {
   
         _GDCPSET        pset;          _GDCPSET        pset;
         BYTE            multiple;          UINT            d;
         UINT            sx;          UINT            d2;
           REG16           x;
           REG16           y;
           UINT            i;
 const VECTDIR   *dir;  const VECTDIR   *dir;
         BYTE            muly;  
         REG16           cx;  
         REG16           cy;  
         UINT            xrem;  
         BYTE            mulx;  
   
         gdcpset_prepare(&pset, csrw, 0xffff, ope);          gdcpset_prepare(&pset, csrw, pat, ope);
         multiple = (gdc.s.para[GDC_ZOOM] & 15) + 1;          d = (LOADINTELWORD(vect->D)) & 0x3fff;
           d2 = (LOADINTELWORD(vect->D2)) & 0x3fff;
         sx = LOADINTELWORD(vect->D);          x = pset.x;
         sx = ((sx - 1) & 0x3fff) + 1;          y = pset.y;
         if (sx >= 768) {  
                 sx = 768;  
         }  
         dir = vectdir + ((vect->ope) & 7);          dir = vectdir + ((vect->ope) & 7);
           for (i=0; i<d; i++) {
         muly = multiple;                  gdcpset(&pset, x, y);
         while(muly--) {                  x += dir->x;
                 cx = pset.x;                  y += dir->y;
                 cy = pset.y;          }
                 xrem = sx;          for (i=0; i<d2; i++) {
                 while(xrem--) {                  gdcpset(&pset, x, y);
                         mulx = multiple;                  x += dir->x2;
                         if (pat & 1) {                  y += dir->y2;
                                 pat >>= 1;          }
                                 pat |= 0x8000;          for (i=0; i<d; i++) {
                                 while(mulx--) {                  gdcpset(&pset, x, y);
                                         gdcpset(&pset, cx, cy);                  x -= dir->x;
                                         cx += dir->x;                  y -= dir->y;
                                         cy += dir->y;          }
                                 }          for (i=0; i<d2; i++) {
                         }                  gdcpset(&pset, x, y);
                         else {                  x -= dir->x2;
                                 pat >>= 1;                  y -= dir->y2;
                                 while(mulx--) {  
                                         cx += dir->x;  
                                         cy += dir->y;  
                                 }  
                         }  
                 }  
                 pset.x += dir->x2;  
                 pset.y += dir->y2;  
         }          }
         calc_gdcslavewait(pset.dots);          calc_gdcslavewait(pset.dots);
 }  }
Removed from v.1.10  
changed lines
  Added in v.1.12

RetroPC.NET-CVS <cvs@retropc.net>