[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.8 and 1.19

version 1.8, 2004/02/09 20:39:39 version 1.19, 2004/06/28 12:31:32
Line 3 Line 3
 #include        "cpucore.h"  #include        "cpucore.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
   #include        "gdc_sub.h"
 #include        "gdc_pset.h"  #include        "gdc_pset.h"
 #include        "vram.h"  #include        "vram.h"
   
Line 13  enum { Line 14  enum {
         RT_TABLEMAX             = (1 << RT_TABLEBIT)          RT_TABLEMAX             = (1 << RT_TABLEBIT)
 };  };
   
   static  UINT16  gdc_rt[RT_TABLEMAX+1];
   
 typedef struct {  typedef struct {
         SINT16  x;          SINT16  x;
         SINT16  y;          SINT16  y;
         SINT16  sx;          SINT16  x2;
         SINT16  sy;          SINT16  y2;
 } TEXTDIR;  } VECTDIR;
   
 static  UINT16  gdc_rt[RT_TABLEMAX+1];  const UINT32 gdcplaneseg[4] = {VRAM_E, VRAM_B, VRAM_R, VRAM_G};
   
 static const TEXTDIR textdir[8] = {  static const VECTDIR vectdir[16] = {
                                         { 0, 1, 1, 0}, { 1, 1, 1,-1},                                          { 0, 1, 1, 0}, { 1, 1, 1,-1},
                                         { 1, 0, 0,-1}, { 1,-1,-1,-1},                                          { 1, 0, 0,-1}, { 1,-1,-1,-1},
                                         { 0,-1,-1, 0}, {-1,-1,-1, 1},                                          { 0,-1,-1, 0}, {-1,-1,-1, 1},
                                         {-1, 0, 0, 1}, {-1, 1, 1, 1}};                                          {-1, 0, 0, 1}, {-1, 1, 1, 1},
   
                                           { 0, 1, 1, 1}, { 1, 1, 1, 0},           // SL
                                           { 1, 0, 1,-1}, { 1,-1, 0,-1},
                                           { 0,-1,-1,-1}, {-1,-1,-1, 0},
                                           {-1, 0,-1, 1}, {-1, 1, 0, 1}};
   
   
   #if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
   const UINT8 gdcbitreverse[0x100] = {
                                   0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
                                   0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
                                   0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
                                   0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
                                   0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
                                   0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
                                   0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
                                   0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
                                   0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
                                   0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
                                   0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
                                   0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
                                   0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
                                   0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
                                   0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
                                   0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
                                   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) {
   
 void gdcsub_init(void) {          REG8    ret;
           UINT    cnt;
   
           ret = 0;
           cnt = 8;
           do {
                   ret = (ret * 2) + (data & 1);
                   data >>= 1;
           } while(--cnt);
           return(ret);
   }
   #endif
   
   
   void gdcsub_initialize(void) {
   
         int             i;          int             i;
   
Line 46  void gdcslavewait(NEVENTITEM item) { Line 105  void gdcslavewait(NEVENTITEM item) {
         }          }
 }  }
   
   void gdcsub_setslavewait(UINT32 wait) {
   
           SINT32  clk;
   
           clk = nevent_getremain(NEVENT_GDCSLAVE);
           if (clk < 0) {
                   clk = 0;
           }
           gdc.s_drawing = 8;                                                      // GDC DRAWING!
           nevent_set(NEVENT_GDCSLAVE, clk + wait, gdcslavewait, NEVENT_ABSOLUTE);
   }
   
 static void calc_gdcslavewait(UINT dots) {  static void calc_gdcslavewait(UINT dots) {
   
         SINT32  clk;          SINT32  clk;
   
         clk = dots;          clk = dots;
         if (pccore.baseclock != PCBASECLOCK20) {          if (pccore.cpumode & CPUMODE_8MHZ) {
                 clk *= 27648;                  clk *= 22464;
         }          }
         else {          else {
                 clk *= 22464;                  clk *= 27648;
         }          }
         clk *= pccore.multiple;          clk *= pccore.multiple;
         clk /= 15625;          clk /= 15625;
         clk += 30 * pccore.multiple;          clk += 30 * pccore.multiple;
         gdc.s_drawing = 8;                                                      // GDC DRAWING!          gdcsub_setslavewait(clk);
         nevent_set(NEVENT_GDCSLAVE, clk, gdcslavewait, NEVENT_ABSOLUTE);  }
   
   void gdcsub_setvectl(GDCVECT *vect, int x1, int y1, int x2, int y2) {
   
           UINT    ope;
           int             dy;
           int             dx;
           int             tmp;
   
           ope = 0;
           dy = y2 - y1;
           if (dy < 0) {
                   dy = 0 - dy;
           }
           dx = x2 - x1;
           if (dx == 0) {
                   if (y1 <= y2) {
                           ope = 7;
                   }
                   else {
                           ope = 3;
                   }
           }
           else {
                   if (dx > 0) {
                           if (y1 >= y2) {
                                   ope += 2;
                           }
                   }
                   else {
                           dx = 0 - dx;
                           ope += 4;
                           if (y1 <= y2) {
                                   ope += 2;
                           }
                   }
                   if (ope & 2) {
                           if (dx <= dy) {
                                   ope += 1;
                           }
                   }
                   else {
                           if (dx >= dy) {
                                   ope += 1;
                           }
                   }
           }
           if (!((ope + 1) & 2)) {
                   tmp = dx;
                   dx = dy;
                   dy = tmp;
           }
           vect->ope = (UINT8)(ope + 0x08);
           STOREINTELWORD(vect->DC, (UINT16)dx);
           dy = dy * 2;
           STOREINTELWORD(vect->D1, (UINT16)dy);
           dy -= dx;
           STOREINTELWORD(vect->D, (UINT16)dy);
           dy -= dx;
           STOREINTELWORD(vect->D2, (UINT16)dy);
 }  }
   
 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 72  void gdcsub_null(UINT32 csrw, const GDCV Line 205  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 152  void gdcsub_line(UINT32 csrw, const GDCV Line 285  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;  const VECTDIR   *dir;
         REG16           y;          BYTE            muly;
         UINT            i;          REG16           cx;
           REG16           cy;
         gdcpset_prepare(&pset, csrw, pat, ope);          UINT            xrem;
         d = (LOADINTELWORD(vect->D)) & 0x3fff;          BYTE            mulx;
         d2 = (LOADINTELWORD(vect->D2)) & 0x3fff;  
         x = pset.x;  
         y = pset.y;  
         // 回転はなしよ(手抜き)  
         switch((vect->ope) & 7) {  
                 case 0:  
                         for (i=0; i<d; i++) {  
                                 gdcpset(&pset, x, y++);  
                         }  
                         for (i=0; i<d2; i++) {  
                                 gdcpset(&pset, x++, y);  
                         }  
                         for (i=0; i<d; i++) {  
                                 gdcpset(&pset, x, y--);  
                         }  
                         for (i=0; i<d2; i++) {  
                                 gdcpset(&pset, x--, y);  
                         }  
                         break;  
   
                 case 2:  
                         for (i=0; i<d; i++) {  
                                 gdcpset(&pset, x++, y);  
                         }  
                         for (i=0; i<d2; i++) {  
                                 gdcpset(&pset, x, y--);  
                         }  
                         for (i=0; i<d; i++) {  
                                 gdcpset(&pset, x--, y);  
                         }  
                         for (i=0; i<d2; i++) {  
                                 gdcpset(&pset, x, y++);  
                         }  
                         break;  
   
                 case 4:          if (vect->ope & 0x80) {         // SL
                         for (i=0; i<d; i++) {                  pat = (REG16)((GDCPATREVERSE(pat) << 8) + GDCPATREVERSE(pat >> 8));
                                 gdcpset(&pset, x, y--);          }
                         }          gdcpset_prepare(&pset, csrw, 0xffff, ope);
                         for (i=0; i<d2; i++) {          multiple = (gdc.s.para[GDC_ZOOM] & 15) + 1;
                                 gdcpset(&pset, x--, y);  
                         }  
                         for (i=0; i<d; i++) {  
                                 gdcpset(&pset, x, y++);  
                         }  
                         for (i=0; i<d2; i++) {  
                                 gdcpset(&pset, x++, y);  
                         }  
                         break;  
   
                 case 6:          sx = LOADINTELWORD(vect->D);
                         for (i=0; i<d; i++) {          sx = ((sx - 1) & 0x3fff) + 1;
                                 gdcpset(&pset, x--, y);          if (sx >= 768) {
                         }                  sx = 768;
                         for (i=0; i<d2; i++) {          }
                                 gdcpset(&pset, x, y++);          dir = vectdir + ((vect->ope) & 7);
                         }  
                         for (i=0; i<d; i++) {          muly = multiple;
                                 gdcpset(&pset, x++, y);          while(muly--) {
                         }                  cx = pset.x;
                         for (i=0; i<d2; i++) {                  cy = pset.y;
                                 gdcpset(&pset, x, 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;
                                   }
                         }                          }
                         break;                  }
                   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 325  void gdcsub_circle(UINT32 csrw, const GD Line 434  void gdcsub_circle(UINT32 csrw, const GD
         calc_gdcslavewait(pset.dots);          calc_gdcslavewait(pset.dots);
 }  }
   
   void gdcsub_vectr(UINT32 csrw, const GDCVECT *vect, REG16 pat, REG8 ope) {
   
           _GDCPSET        pset;
           UINT            d;
           UINT            d2;
           REG16           x;
           REG16           y;
           UINT            i;
   const VECTDIR   *dir;
   
           gdcpset_prepare(&pset, csrw, pat, ope);
           d = (LOADINTELWORD(vect->D)) & 0x3fff;
           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(&pset, x, y);
                   x += dir->x2;
                   y += dir->y2;
           }
           for (i=0; i<d; i++) {
                   gdcpset(&pset, x, y);
                   x -= dir->x;
                   y -= dir->y;
           }
           for (i=0; i<d2; i++) {
                   gdcpset(&pset, x, y);
                   x -= dir->x2;
                   y -= dir->y2;
           }
           calc_gdcslavewait(pset.dots);
   }
   
 void gdcsub_text(UINT32 csrw, const GDCVECT *vect, const BYTE *pat,  void gdcsub_text(UINT32 csrw, const GDCVECT *vect, const BYTE *pat,
                                                                                                                                 REG8 ope) {                                                                                                                                  REG8 ope) {
   
Line 332  void gdcsub_text(UINT32 csrw, const GDCV Line 480  void gdcsub_text(UINT32 csrw, const GDCV
         BYTE            multiple;          BYTE            multiple;
         UINT            sx;          UINT            sx;
         UINT            sy;          UINT            sy;
 const TEXTDIR   *dir;  const VECTDIR   *dir;
         UINT            patnum;          UINT            patnum;
         BYTE            muly;          BYTE            muly;
         REG16           cx;          REG16           cx;
Line 343  const TEXTDIR *dir; Line 491  const TEXTDIR *dir;
   
         gdcpset_prepare(&pset, csrw, 0xffff, ope);          gdcpset_prepare(&pset, csrw, 0xffff, ope);
         multiple = (gdc.s.para[GDC_ZOOM] & 15) + 1;          multiple = (gdc.s.para[GDC_ZOOM] & 15) + 1;
 #if 0  #if 1
         sx = (LOADINTELWORD(vect->DC)) & 0x3fff) + 1;          sy = LOADINTELWORD(vect->DC);
         sy = (LOADINTELWORD(vect->D)) & 0x3fff) + 1;          sy = (sy & 0x3fff) + 1;
           sx = LOADINTELWORD(vect->D);
           sx = ((sx - 1) & 0x3fff) + 1;
   
           // てきとーにリミット
           if (sx >= 768) {
                   sx = 768;
           }
           if (sy >= 768) {
                   sy = 768;
           }
 #else  #else
         sx = 8;          sx = 8;
         sy = 8;          sy = 8;
 #endif  #endif
         dir = textdir + ((vect->ope) & 7);          dir = vectdir + (((vect->ope & 0x80) >> 4) + ((vect->ope) & 7));
         patnum = 0;          patnum = 0;
   
         while(sy--) {          while(sy--) {
Line 380  const TEXTDIR *dir; Line 538  const TEXTDIR *dir;
                                         }                                          }
                                 }                                  }
                         }                          }
                         pset.x += dir->sx;                          pset.x += dir->x2;
                         pset.y += dir->sy;                          pset.y += dir->y2;
                 }                  }
         }          }
         calc_gdcslavewait(pset.dots);          calc_gdcslavewait(pset.dots);
Line 465  void gdcsub_write(void) { Line 623  void gdcsub_write(void) {
         }          }
         gdcs.grphdisp |= (BYTE)updatebit;          gdcs.grphdisp |= (BYTE)updatebit;
   
         ptr += vramplaneseg[(adrs >> 14) & 3];          ptr += gdcplaneseg[(adrs >> 14) & 3];
         adrs = (adrs & 0x3fff) << 1;          adrs = (adrs & 0x3fff) << 1;
         calc_gdcslavewait(leng);          calc_gdcslavewait(leng);
   
Removed from v.1.8  
changed lines
  Added in v.1.19

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