[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.2 and 1.9

version 1.2, 2003/10/21 11:22:05 version 1.9, 2004/02/11 04:22:18
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        <math.h>  #include        <math.h>
 #include        "memory.h"  #include        "cpucore.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
 #include        "gdc_pset.h"  #include        "gdc_pset.h"
Line 16  enum { Line 16  enum {
 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];  static  UINT16  gdc_rt[RT_TABLEMAX+1];
   
 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}};
   
   
 void gdcsub_init(void) {  void gdcsub_init(void) {
Line 51  static void calc_gdcslavewait(UINT dots) Line 56  static void calc_gdcslavewait(UINT dots)
         SINT32  clk;          SINT32  clk;
   
         clk = dots;          clk = dots;
         if (pc.baseclock != PCBASECLOCK20) {          if (pccore.baseclock != PCBASECLOCK20) {
                 clk *= 27648;                  clk *= 27648;
         }          }
         else {          else {
                 clk *= 22464;                  clk *= 22464;
         }          }
         clk *= pc.multiple;          clk *= pccore.multiple;
         clk /= 15625;          clk /= 15625;
         clk += 30 * pc.multiple;          clk += 30 * pccore.multiple;
         gdc.s_drawing = 8;                                                      // GDC DRAWING!          gdc.s_drawing = 8;                                                      // GDC DRAWING!
         nevent_set(NEVENT_GDCSLAVE, clk, gdcslavewait, NEVENT_ABSOLUTE);          nevent_set(NEVENT_GDCSLAVE, clk, gdcslavewait, NEVENT_ABSOLUTE);
 }  }
   
 void gdcsub_line(UINT32 csrw, const GDCVECT *vect, UINT16 pat, BYTE ope) {  void gdcsub_null(UINT32 csrw, const GDCVECT *vect, REG16 pat, REG8 ope) {
   
           (void)csrw;
           (void)vect;
           (void)pat;
           (void)ope;
   }
   
   void gdcsub_line(UINT32 csrw, const GDCVECT *vect, REG16 pat, REG8 ope) {
   
         _GDCPSET        pset;          _GDCPSET        pset;
         UINT            dc;          UINT            dc;
         UINT16          x;          REG16           x;
         UINT16          y;          REG16           y;
         UINT            i;          UINT            i;
         UINT16          step;          UINT16          step;
         UINT            d1;          UINT            d1;
Line 87  void gdcsub_line(UINT32 csrw, const GDCV Line 100  void gdcsub_line(UINT32 csrw, const GDCV
                         case 0:                          case 0:
                                 for (i=0; i<=dc; i++) {                                  for (i=0; i<=dc; i++) {
                                         step = (UINT16)((((d1 * i) / dc) + 1) >> 1);                                          step = (UINT16)((((d1 * i) / dc) + 1) >> 1);
                                         gdcpset(&pset, (UINT16)(x + step), y++);                                          gdcpset(&pset, (REG16)(x + step), y++);
                                 }                                  }
                                 break;                                  break;
   
                         case 1:                          case 1:
                                 for (i=0; i<=dc; i++) {                                  for (i=0; i<=dc; i++) {
                                         step = (UINT16)((((d1 * i) / dc) + 1) >> 1);                                          step = (UINT16)((((d1 * i) / dc) + 1) >> 1);
                                         gdcpset(&pset, x++, (UINT16)(y + step));                                          gdcpset(&pset, x++, (REG16)(y + step));
                                 }                                  }
                                 break;                                  break;
   
                         case 2:                          case 2:
                                 for (i=0; i<=dc; i++) {                                  for (i=0; i<=dc; i++) {
                                         step = (UINT16)((((d1 * i) / dc) + 1) >> 1);                                          step = (UINT16)((((d1 * i) / dc) + 1) >> 1);
                                         gdcpset(&pset, x++, (UINT16)(y - step));                                          gdcpset(&pset, x++, (REG16)(y - step));
                                 }                                  }
                                 break;                                  break;
   
                         case 3:                          case 3:
                                 for (i=0; i<=dc; i++) {                                  for (i=0; i<=dc; i++) {
                                         step = (UINT16)((((d1 * i) / dc) + 1) >> 1);                                          step = (UINT16)((((d1 * i) / dc) + 1) >> 1);
                                         gdcpset(&pset, (UINT16)(x + step), y--);                                          gdcpset(&pset, (REG16)(x + step), y--);
                                 }                                  }
                                 break;                                  break;
   
                         case 4:                          case 4:
                                 for (i=0; i<=dc; i++) {                                  for (i=0; i<=dc; i++) {
                                         step = (UINT16)((((d1 * i) / dc) + 1) >> 1);                                          step = (UINT16)((((d1 * i) / dc) + 1) >> 1);
                                         gdcpset(&pset, (UINT16)(x - step), y--);                                          gdcpset(&pset, (REG16)(x - step), y--);
                                 }                                  }
                                 break;                                  break;
   
                         case 5:                          case 5:
                                 for (i=0; i<=dc; i++) {                                  for (i=0; i<=dc; i++) {
                                         step = (UINT16)((((d1 * i) / dc) + 1) >> 1);                                          step = (UINT16)((((d1 * i) / dc) + 1) >> 1);
                                         gdcpset(&pset, x--, (UINT16)(y - step));                                          gdcpset(&pset, x--, (REG16)(y - step));
                                 }                                  }
                                 break;                                  break;
   
                         case 6:                          case 6:
                                 for (i=0; i<=dc; i++) {                                  for (i=0; i<=dc; i++) {
                                         step = (UINT16)((((d1 * i) / dc) + 1) >> 1);                                          step = (UINT16)((((d1 * i) / dc) + 1) >> 1);
                                         gdcpset(&pset, x--, (UINT16)(y + step));                                          gdcpset(&pset, x--, (REG16)(y + step));
                                 }                                  }
                                 break;                                  break;
   
                         case 7:                          case 7:
                                 for (i=0; i<=dc; i++) {                                  for (i=0; i<=dc; i++) {
                                         step = (UINT16)((((d1 * i) / dc) + 1) >> 1);                                          step = (UINT16)((((d1 * i) / dc) + 1) >> 1);
                                         gdcpset(&pset, (UINT16)(x - step), y++);                                          gdcpset(&pset, (REG16)(x - step), y++);
                                 }                                  }
                                 break;                                  break;
                 }                  }
Line 144  void gdcsub_line(UINT32 csrw, const GDCV Line 157  void gdcsub_line(UINT32 csrw, const GDCV
         calc_gdcslavewait(pset.dots);          calc_gdcslavewait(pset.dots);
 }  }
   
 void gdcsub_box(UINT32 csrw, const GDCVECT *vect, UINT16 pat, BYTE ope) {  void gdcsub_box(UINT32 csrw, const GDCVECT *vect, REG16 pat, REG8 ope) {
   
         _GDCPSET        pset;          _GDCPSET        pset;
         UINT            d;          UINT            d;
         UINT            d2;          UINT            d2;
         UINT16          x;          REG16           x;
         UINT16          y;          REG16           y;
         UINT            i;          UINT            i;
   const VECTDIR   *dir;
   
         gdcpset_prepare(&pset, csrw, pat, ope);          gdcpset_prepare(&pset, csrw, pat, ope);
         d = (LOADINTELWORD(vect->D)) & 0x3fff;          d = (LOADINTELWORD(vect->D)) & 0x3fff;
Line 159  void gdcsub_box(UINT32 csrw, const GDCVE Line 173  void gdcsub_box(UINT32 csrw, const GDCVE
         x = pset.x;          x = pset.x;
         y = pset.y;          y = pset.y;
         // 回転はなしよ(手抜き)          // 回転はなしよ(手抜き)
         switch((vect->ope) & 7) {          dir = vectdir + ((vect->ope) & 7);
                 case 0:          for (i=0; i<d; i++) {
                         for (i=0; i<d; i++) {                  gdcpset(&pset, x, y);
                                 gdcpset(&pset, x, y++);                  x += dir->x;
                         }                  y += dir->y;
                         for (i=0; i<d2; i++) {          }
                                 gdcpset(&pset, x++, y);          for (i=0; i<d2; i++) {
                         }                  gdcpset(&pset, x, y);
                         for (i=0; i<d; i++) {                  x += dir->x2;
                                 gdcpset(&pset, x, y--);                  y += dir->y2;
                         }          }
                         for (i=0; i<d2; i++) {          for (i=0; i<d; i++) {
                                 gdcpset(&pset, x--, y);                  gdcpset(&pset, x, y);
                         }                  x -= dir->x;
                         break;                  y -= dir->y;
           }
                 case 2:          for (i=0; i<d2; i++) {
                         for (i=0; i<d; i++) {                  gdcpset(&pset, x, y);
                                 gdcpset(&pset, x++, y);                  x -= dir->x2;
                         }                  y -= dir->y2;
                         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:  
                         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 6:  
                         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;  
         }          }
         calc_gdcslavewait(pset.dots);          calc_gdcslavewait(pset.dots);
 }  }
   
 void gdcsub_circle(UINT32 csrw, const GDCVECT *vect, UINT16 pat, BYTE ope) {  void gdcsub_circle(UINT32 csrw, const GDCVECT *vect, REG16 pat, REG8 ope) {
   
         _GDCPSET        pset;          _GDCPSET        pset;
         UINT            r;          UINT            r;
Line 253  void gdcsub_circle(UINT32 csrw, const GD Line 227  void gdcsub_circle(UINT32 csrw, const GD
                                 for (; i<=t; i++) {                                  for (; i<=t; i++) {
                                         s = (gdc_rt[(i << RT_TABLEBIT) / m] * r);                                          s = (gdc_rt[(i << RT_TABLEBIT) / m] * r);
                                         s = (s + (1 << (RT_MULBIT - 1))) >> RT_MULBIT;                                          s = (s + (1 << (RT_MULBIT - 1))) >> RT_MULBIT;
                                         gdcpset(&pset, (UINT16)(x + s), (UINT16)(y + i));                                          gdcpset(&pset, (REG16)(x + s), (REG16)(y + i));
                                 }                                  }
                                 break;                                  break;
   
Line 261  void gdcsub_circle(UINT32 csrw, const GD Line 235  void gdcsub_circle(UINT32 csrw, const GD
                                 for (; i<=t; i++) {                                  for (; i<=t; i++) {
                                         s = (gdc_rt[(i << RT_TABLEBIT) / m] * r);                                          s = (gdc_rt[(i << RT_TABLEBIT) / m] * r);
                                         s = (s + (1 << (RT_MULBIT - 1))) >> RT_MULBIT;                                          s = (s + (1 << (RT_MULBIT - 1))) >> RT_MULBIT;
                                         gdcpset(&pset, (UINT16)(x + i), (UINT16)(y + s));                                          gdcpset(&pset, (REG16)(x + i), (REG16)(y + s));
                                 }                                  }
                                 break;                                  break;
   
Line 269  void gdcsub_circle(UINT32 csrw, const GD Line 243  void gdcsub_circle(UINT32 csrw, const GD
                                 for (; i<=t; i++) {                                  for (; i<=t; i++) {
                                         s = (gdc_rt[(i << RT_TABLEBIT) / m] * r);                                          s = (gdc_rt[(i << RT_TABLEBIT) / m] * r);
                                         s = (s + (1 << (RT_MULBIT - 1))) >> RT_MULBIT;                                          s = (s + (1 << (RT_MULBIT - 1))) >> RT_MULBIT;
                                         gdcpset(&pset, (UINT16)(x + i), (UINT16)(y - s));                                          gdcpset(&pset, (REG16)(x + i), (REG16)(y - s));
                                 }                                  }
                                 break;                                  break;
   
Line 277  void gdcsub_circle(UINT32 csrw, const GD Line 251  void gdcsub_circle(UINT32 csrw, const GD
                                 for (; i<=t; i++) {                                  for (; i<=t; i++) {
                                         s = (gdc_rt[(i << RT_TABLEBIT) / m] * r);                                          s = (gdc_rt[(i << RT_TABLEBIT) / m] * r);
                                         s = (s + (1 << (RT_MULBIT - 1))) >> RT_MULBIT;                                          s = (s + (1 << (RT_MULBIT - 1))) >> RT_MULBIT;
                                         gdcpset(&pset, (UINT16)(x + s), (UINT16)(y - i));                                          gdcpset(&pset, (REG16)(x + s), (REG16)(y - i));
                                 }                                  }
                                 break;                                  break;
   
Line 285  void gdcsub_circle(UINT32 csrw, const GD Line 259  void gdcsub_circle(UINT32 csrw, const GD
                                 for (; i<=t; i++) {                                  for (; i<=t; i++) {
                                         s = (gdc_rt[(i << RT_TABLEBIT) / m] * r);                                          s = (gdc_rt[(i << RT_TABLEBIT) / m] * r);
                                         s = (s + (1 << (RT_MULBIT - 1))) >> RT_MULBIT;                                          s = (s + (1 << (RT_MULBIT - 1))) >> RT_MULBIT;
                                         gdcpset(&pset, (UINT16)(x - s), (UINT16)(y - i));                                          gdcpset(&pset, (REG16)(x - s), (REG16)(y - i));
                                 }                                  }
                                 break;                                  break;
   
Line 293  void gdcsub_circle(UINT32 csrw, const GD Line 267  void gdcsub_circle(UINT32 csrw, const GD
                                 for (; i<=t; i++) {                                  for (; i<=t; i++) {
                                         s = (gdc_rt[(i << RT_TABLEBIT) / m] * r);                                          s = (gdc_rt[(i << RT_TABLEBIT) / m] * r);
                                         s = (s + (1 << (RT_MULBIT - 1))) >> RT_MULBIT;                                          s = (s + (1 << (RT_MULBIT - 1))) >> RT_MULBIT;
                                         gdcpset(&pset, (UINT16)(x - i), (UINT16)(y - s));                                          gdcpset(&pset, (REG16)(x - i), (REG16)(y - s));
                                 }                                  }
                                 break;                                  break;
   
Line 301  void gdcsub_circle(UINT32 csrw, const GD Line 275  void gdcsub_circle(UINT32 csrw, const GD
                                 for (; i<=t; i++) {                                  for (; i<=t; i++) {
                                         s = (gdc_rt[(i << RT_TABLEBIT) / m] * r);                                          s = (gdc_rt[(i << RT_TABLEBIT) / m] * r);
                                         s = (s + (1 << (RT_MULBIT - 1))) >> RT_MULBIT;                                          s = (s + (1 << (RT_MULBIT - 1))) >> RT_MULBIT;
                                         gdcpset(&pset, (UINT16)(x - i), (UINT16)(y + s));                                          gdcpset(&pset, (REG16)(x - i), (REG16)(y + s));
                                 }                                  }
                                 break;                                  break;
   
Line 309  void gdcsub_circle(UINT32 csrw, const GD Line 283  void gdcsub_circle(UINT32 csrw, const GD
                                 for (; i<=t; i++) {                                  for (; i<=t; i++) {
                                         s = (gdc_rt[(i << RT_TABLEBIT) / m] * r);                                          s = (gdc_rt[(i << RT_TABLEBIT) / m] * r);
                                         s = (s + (1 << (RT_MULBIT - 1))) >> RT_MULBIT;                                          s = (s + (1 << (RT_MULBIT - 1))) >> RT_MULBIT;
                                         gdcpset(&pset, (UINT16)(x - s), (UINT16)(y + i));                                          gdcpset(&pset, (REG16)(x - s), (REG16)(y + i));
                                 }                                  }
                                 break;                                  break;
                 }                  }
Line 317  void gdcsub_circle(UINT32 csrw, const GD Line 291  void gdcsub_circle(UINT32 csrw, const GD
         calc_gdcslavewait(pset.dots);          calc_gdcslavewait(pset.dots);
 }  }
   
 void gdcsub_text(UINT32 csrw, const GDCVECT *vect, UINT16 pat, BYTE ope) {  void gdcsub_text(UINT32 csrw, const GDCVECT *vect, const BYTE *pat,
                                                                                                                                   REG8 ope) {
   
         _GDCPSET        pset;          _GDCPSET        pset;
         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;
         UINT16          cx;          REG16           cx;
         UINT16          cy;          REG16           cy;
         UINT            xrem;          UINT            xrem;
         BYTE            bit;          BYTE            bit;
         BYTE            mulx;          BYTE            mulx;
   
         gdcpset_prepare(&pset, csrw, pat, 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 350  const TEXTDIR *dir; Line 335  const TEXTDIR *dir;
                 while(muly--) {                  while(muly--) {
                         cx = pset.x;                          cx = pset.x;
                         cy = pset.y;                          cy = pset.y;
                         bit = gdc.s.para[GDC_TEXTW + (patnum & 7)];                          bit = pat[patnum & 7];
                         xrem = sx;                          xrem = sx;
                         while(xrem--) {                          while(xrem--) {
                                 mulx = multiple;                                  mulx = multiple;
Line 371  const TEXTDIR *dir; Line 356  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 390  void gdcsub_write(void) { Line 375  void gdcsub_write(void) {
         BYTE    *ptr;          BYTE    *ptr;
         UINT16  updatebit;          UINT16  updatebit;
   
   #if 0
           TRACEOUT(("gdcsub_write"));
           if (grcg.gdcwithgrcg & 0x8) {
                   MessageBox(NULL, "!!! grcg working", "?", MB_OK);
           }
   #endif
   
         mask = LOADINTELWORD(gdc.s.para + GDC_MASK);          mask = LOADINTELWORD(gdc.s.para + GDC_MASK);
 #if defined(BYTESEX_LITTLE)  #if defined(BYTESEX_LITTLE)
         switch(gdc.s.cmd & 0x18) {          switch(gdc.s.cmd & 0x18) {
Removed from v.1.2  
changed lines
  Added in v.1.9

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