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

Diff for /np2/bios/bios18.c between versions 1.13 and 1.15

version 1.13, 2004/02/09 20:39:39 version 1.15, 2004/02/11 17:39:59
Line 52  static const CSRFORM csrform[4] = { Line 52  static const CSRFORM csrform[4] = {
                                                 {0x07, 0x3b}, {0x09, 0x4b},                                                  {0x07, 0x3b}, {0x09, 0x4b},
                                                 {0x0f, 0x7b}, {0x13, 0x9b}};                                                  {0x0f, 0x7b}, {0x13, 0x9b}};
   
 static const UINT8 sync200l[8] = {0x02,0x26,0x03,0x11,0x86,0x0f,0xc8,0x84};  static const UINT8 sync200l[8] = {0x02,0x26,0x03,0x11,0x86,0x0f,0xc8,0x94};
 static const UINT8 sync200m[8] = {0x02,0x26,0x03,0x11,0x83,0x07,0x90,0x65};  static const UINT8 sync200m[8] = {0x02,0x26,0x03,0x11,0x83,0x07,0x90,0x65};
 static const UINT8 sync400m[8] = {0x02,0x4e,0x07,0x25,0x87,0x07,0x90,0x65};  static const UINT8 sync400m[8] = {0x02,0x4e,0x07,0x25,0x87,0x07,0x90,0x65};
   
Line 121  static REG8 swapbit(REG8 bit) { Line 121  static REG8 swapbit(REG8 bit) {
         return(ret);          return(ret);
 }  }
   
   static void setbiosgdc(UINT32 csrw, const GDCVECT *vect, UINT vcnt,
                                                                                                                                   UINT8 ope) {
   
           gdc.s.para[GDC_CSRW + 0] = (BYTE)csrw;
           gdc.s.para[GDC_CSRW + 1] = (BYTE)(csrw >> 8);
           gdc.s.para[GDC_CSRW + 2] = (BYTE)(csrw >> 16);
   
           vcnt = min(vcnt, 11);
           if (vcnt) {
                   CopyMemory(gdc.s.para + GDC_VECTW, vect, vcnt);
           }
   
           gdc.s.para[GDC_WRITE] = ope;
           mem[MEMB_PRXDUPD] &= ~3;
           mem[MEMB_PRXDUPD] |= ope;
   }
   
   
 static void bios18_47(void) {  static void bios18_47(void) {
   
         UCWTBL          ucw;          UCWTBL          ucw;
Line 132  static void bios18_47(void) { Line 150  static void bios18_47(void) {
         GDCSUBFN        func;          GDCSUBFN        func;
         UINT32          csrw;          UINT32          csrw;
         UINT16          data;          UINT16          data;
           UINT16          data2;
         UINT16          GBMDOTI;          UINT16          GBMDOTI;
         UINT8           ope;          UINT8           ope;
           SINT16          dx;
           SINT16          dy;
   
         // GDCバッファを空に          // GDCバッファを空に
         if (gdc.s.cnt) {          if (gdc.s.cnt) {
Line 149  static void bios18_47(void) { Line 170  static void bios18_47(void) {
         GBSY2 = LOADINTELWORD(ucw.GBSY2);          GBSY2 = LOADINTELWORD(ucw.GBSY2);
         ZeroMemory(&vect, sizeof(vect));          ZeroMemory(&vect, sizeof(vect));
         if (ucw.GBDTYP == 0x01) {          if (ucw.GBDTYP == 0x01) {
                 short dx, dy;  
                 func = gdcsub_line;                  func = gdcsub_line;
                 if ((GBSX1 > GBSX2) ||                  if ((GBSX1 > GBSX2) ||
                         ((GBSX1 == GBSX2) && (GBSY1 > GBSY2))) {                          ((GBSX1 == GBSX2) && (GBSY1 > GBSY2))) {
Line 177  static void bios18_47(void) { Line 197  static void bios18_47(void) {
                                 SWAPU16(dx, dy);                                  SWAPU16(dx, dy);
                         }                          }
                 }                  }
                   vect.ope += 0x08;
                 STOREINTELWORD(vect.DC, dx);                  STOREINTELWORD(vect.DC, dx);
                 data = dy * 2;                  data = dy * 2;
                 STOREINTELWORD(vect.D1, data);                  STOREINTELWORD(vect.D1, data);
Line 185  static void bios18_47(void) { Line 206  static void bios18_47(void) {
                 data -= dx;                  data -= dx;
                 STOREINTELWORD(vect.D2, data);                  STOREINTELWORD(vect.D2, data);
         }          }
         else if (ucw.GBDTYP == 0x02) {          else if (ucw.GBDTYP <= 0x02) {
                 func = gdcsub_box;                  func = gdcsub_box;
                 if (GBSX1 > GBSX2) {                  vect.ope = 0x40 + (ucw.GBDSP & 7);
                         SWAPU16(GBSX1, GBSX2);                  dx = GBSX2 - GBSX1;
                   if (dx < 0) {
                           dx = 0 - dx;
                 }                  }
                 if (GBSY1 > GBSY2) {                  dy = GBSY2 - GBSY1;
                         SWAPU16(GBSY1, GBSY2);                  if (dy < 0) {
                           dy = 0 - dy;
                   }
                   switch(ucw.GBDSP & 3) {
                           case 0:
                                   data = dy;
                                   data2 = dx;
                                   break;
   
                           case 1:
                                   data2 = (UINT16)dx + (UINT16)dy;
                                   data2 >>= 1;
                                   data = (UINT16)dx - (UINT16)dy;
                                   data = (data >> 1) & 0x3fff;
                                   break;
   
                           case 2:
                                   data = dx;
                                   data2 = dy;
                                   break;
   
                           case 3:
                                   data2 = (UINT16)dx + (UINT16)dy;
                                   data2 >>= 1;
                                   data = (UINT16)dy - (UINT16)dx;
                                   data = (data >> 1) & 0x3fff;
                                   break;
                 }                  }
                 STOREINTELWORD(vect.DC, 3);                  STOREINTELWORD(vect.DC, 3);
                   STOREINTELWORD(vect.D, data);
                   STOREINTELWORD(vect.D2, data2);
                 STOREINTELWORD(vect.D1, 0xffff);                  STOREINTELWORD(vect.D1, 0xffff);
                 data = GBSX2 - GBSX1;  
                 STOREINTELWORD(vect.DM, data);                  STOREINTELWORD(vect.DM, data);
                 STOREINTELWORD(vect.D2, data);  
                 data = GBSY2 - GBSY1;  
                 STOREINTELWORD(vect.D, data);  
         }          }
         else {          else {
                 func = gdcsub_null;                  func = gdcsub_circle;
                   vect.ope = 0x20 + (ucw.GBDSP & 7);
                   vect.DC[0] = ucw.GBLNG1[0];
                   vect.DC[1] = ucw.GBLNG1[1];
                   data = LOADINTELWORD(ucw.GBLNG2) - 1;
                   STOREINTELWORD(vect.D, data);
                   data >>= 1;
                   STOREINTELWORD(vect.D2, data);
                   STOREINTELWORD(vect.D1, 0x3fff);
                   if (ucw.GBDTYP == 0x04) {
                           vect.DM[0] = ucw.GBMDOT[0];
                           vect.DM[1] = ucw.GBMDOT[1];
                   }
         }          }
         if ((CPU_CH & 0xc0) == 0x40) {          if ((CPU_CH & 0xc0) == 0x40) {
                 GBSY1 += 200;                  GBSY1 += 200;
Line 228  static void bios18_47(void) { Line 287  static void bios18_47(void) {
         // 最後に使った奴を記憶          // 最後に使った奴を記憶
         *(UINT16 *)(mem + MEMW_PRXGLS) = *(UINT16 *)(ucw.GBMDOTI);          *(UINT16 *)(mem + MEMW_PRXGLS) = *(UINT16 *)(ucw.GBMDOTI);
         *(UINT16 *)(gdc.s.para + GDC_TEXTW) = *(UINT16 *)(ucw.GBMDOTI);          *(UINT16 *)(gdc.s.para + GDC_TEXTW) = *(UINT16 *)(ucw.GBMDOTI);
           setbiosgdc(csrw, &vect, (ucw.GBDTYP != 0x01)?11:9, ope);
         gdc.s.para[GDC_WRITE] = ope;  
         mem[MEMB_PRXDUPD] &= ~3;  
         mem[MEMB_PRXDUPD] |= ope;  
 }  }
   
 static void bios18_49(void) {  static void bios18_49(void) {
Line 294  static void bios18_49(void) { Line 350  static void bios18_49(void) {
         }          }
   
         // 最後に使った奴を記憶          // 最後に使った奴を記憶
         gdc.s.para[GDC_WRITE] = ope;          setbiosgdc(csrw, &vect, 5, ope);
         mem[MEMB_PRXDUPD] &= ~3;  
         mem[MEMB_PRXDUPD] |= ope;  
 }  }
   
   
Line 492  const CRTDATA *crt; Line 546  const CRTDATA *crt;
                                 gdc_work(GDCWORK_MASTER);                                  gdc_work(GDCWORK_MASTER);
                         }                          }
                         gdc_forceready(&gdc.m);                          gdc_forceready(&gdc.m);
   
                         bios0x18_10((REG8)(CPU_AL & 1));                          bios0x18_10((REG8)(CPU_AL & 1));
                         break;                          break;
   
Line 501  const CRTDATA *crt; Line 556  const CRTDATA *crt;
                                 gdc_work(GDCWORK_MASTER);                                  gdc_work(GDCWORK_MASTER);
                         }                          }
                         gdc_forceready(&gdc.m);                          gdc_forceready(&gdc.m);
                                                                                                         // 00/08/02  
                         if (gdc.m.para[GDC_CSRFORM] != (mem[MEMB_CRT_RASTER] | 0x80)) {                          if (gdc.m.para[GDC_CSRFORM] != (mem[MEMB_CRT_RASTER] | 0x80)) {
                                 gdc.m.para[GDC_CSRFORM] = mem[MEMB_CRT_RASTER] | 0x80;                                  gdc.m.para[GDC_CSRFORM] = mem[MEMB_CRT_RASTER] | 0x80;
                         }                          }
Line 514  const CRTDATA *crt; Line 569  const CRTDATA *crt;
                                 gdc_work(GDCWORK_MASTER);                                  gdc_work(GDCWORK_MASTER);
                         }                          }
                         gdc_forceready(&gdc.m);                          gdc_forceready(&gdc.m);
                                                                                                         // 00/08/02  
                         if (gdc.m.para[GDC_CSRFORM] != mem[MEMB_CRT_RASTER]) {                          if (gdc.m.para[GDC_CSRFORM] != mem[MEMB_CRT_RASTER]) {
                                 gdc.m.para[GDC_CSRFORM] = mem[MEMB_CRT_RASTER];                                  gdc.m.para[GDC_CSRFORM] = mem[MEMB_CRT_RASTER];
                                 gdcs.textdisp |= GDCSCRN_ALLDRAW | GDCSCRN_EXT;                                  gdcs.textdisp |= GDCSCRN_ALLDRAW | GDCSCRN_EXT;
Line 703  const CRTDATA *crt; Line 758  const CRTDATA *crt;
                         }                          }
                         break;                          break;
   
                 case 0x44:                                              // ボーダカラー                  case 0x44:                                              // ボーダカラーの設定
 //                      if (!(mem[MEMB_PRXCRT] & 0x40)) {  //                      if (!(mem[MEMB_PRXCRT] & 0x40)) {
 //                              color = i286_membyte_read(CPU_DS, CPU_BX + 1);  //                              color = i286_membyte_read(CPU_DS, CPU_BX + 1);
 //                      }  //                      }
                         break;                          break;
   
                 case 0x47:                                              // 直線、矩形の描画                  case 0x47:                                              // 直線、矩形の描画
                 case 0x48:                  case 0x48:                                              // 円の描画
                         bios18_47();                          bios18_47();
                         break;                          break;
   
                 case 0x49:                                              //                   case 0x49:                                              // グラフィック文字の描画
                         bios18_49();                          bios18_49();
                         break;                          break;
   
                 case 0x4a:                                              //                   case 0x4a:                                              // 描画モードの設定
                         if (!(mem[MEMB_PRXCRT] & 0x01)) {                          if (!(mem[MEMB_PRXCRT] & 0x01)) {
                                 gdc.s.para[GDC_SYNC] = CPU_CH;                                  gdc.s.para[GDC_SYNC] = CPU_CH;
                                 gdcs.grphdisp |= GDCSCRN_EXT;                                  gdcs.grphdisp |= GDCSCRN_EXT;
Line 730  const CRTDATA *crt; Line 785  const CRTDATA *crt;
                                 }                                  }
                         }                          }
                         break;                          break;
   
         }          }
 }  }
   
Removed from v.1.13  
changed lines
  Added in v.1.15

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