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

Diff for /np2/lio/lio.c between versions 1.9 and 1.21

version 1.9, 2004/02/21 04:48:35 version 1.21, 2005/05/20 13:59:47
Line 7 Line 7
 #include        "biosmem.h"  #include        "biosmem.h"
 #include        "vram.h"  #include        "vram.h"
 #include        "lio.h"  #include        "lio.h"
   #include        "lio.res"
   
 static  _LIOWORK        liowork;  
   
   
 void lio_initialize(void) {  void lio_initialize(void) {
   
         UINT    i;          CopyMemory(mem + (LIO_SEGMENT << 4), liorom, sizeof(liorom));
   
         mem[0xf9900] = 0x11;  
         for (i=0; i<0x11; i++) {  
                 mem[0xf9904 + i*4] = 0xa0 + i;  
                 mem[0xf9905 + i*4] = 0x00;  
                 SETBIOSMEM16(0xf9906 + i*4, 0x100 + i*4);  
                 SETBIOSMEM32(0xf9a00 + i*4, 0xcf90fb90);  
         }  
         mem[0xf9944] = 0xce;  
 }  }
   
 void bios_lio(REG8 cmd) {  void bios_lio(REG8 cmd) {
   
         LIOWORK lio;          _GLIO   lio;
         UINT8   ret;          UINT8   ret;
   
 //      TRACEOUT(("lio command %.2x", cmd));  //      TRACEOUT(("lio command %.2x", cmd));
           MEMR_READS(CPU_DS, 0x0620, &lio.work, sizeof(lio.work));
         lio = &liowork;          lio.palmode = MEMR_READ8(CPU_DS, 0x0a08);
         lio->wait = 500;          lio.wait = 0;
         switch(cmd) {          switch(cmd) {
                 case 0x00:                      // a0: GINIT                  case 0x00:                      // a0: GINIT
                         ret = lio_ginit(lio);                          ret = lio_ginit(&lio);
                         break;                          break;
   
                 case 0x01:                      // a1: GSCREEN                  case 0x01:                      // a1: GSCREEN
                         ret = lio_gscreen(lio);                          ret = lio_gscreen(&lio);
                         break;                          break;
   
                 case 0x02:                      // a2: GVIEW                  case 0x02:                      // a2: GVIEW
                         ret = lio_gview(lio);                          ret = lio_gview(&lio);
                         break;                          break;
   
                 case 0x03:                      // a3: GCOLOR1                  case 0x03:                      // a3: GCOLOR1
                         ret = lio_gcolor1(lio);                          ret = lio_gcolor1(&lio);
                         break;                          break;
   
                 case 0x04:                      // a4: GCOLOR2                  case 0x04:                      // a4: GCOLOR2
                         ret = lio_gcolor2(lio);                          ret = lio_gcolor2(&lio);
                         break;                          break;
   
                 case 0x05:                      // a5: GCLS                  case 0x05:                      // a5: GCLS
                         ret = lio_gcls(lio);                          ret = lio_gcls(&lio);
                         break;                          break;
   
                 case 0x06:                      // a6: GPSET                  case 0x06:                      // a6: GPSET
                         ret = lio_gpset(lio);                          ret = lio_gpset(&lio);
                         break;                          break;
   
                 case 0x07:                      // a7: GLINE                  case 0x07:                      // a7: GLINE
                         ret = lio_gline(lio);                          ret = lio_gline(&lio);
                         break;                          break;
   
 //              case 0x08:                      // a8: GCIRCLE                  case 0x08:                      // a8: GCIRCLE
 //                      break;                          ret = lio_gcircle(&lio);
                           break;
   
 //              case 0x09:                      // a9: GPAINT1  //              case 0x09:                      // a9: GPAINT1
 //                      break;  //                      break;
Line 78  void bios_lio(REG8 cmd) { Line 68  void bios_lio(REG8 cmd) {
 //                      break;  //                      break;
   
                 case 0x0b:                      // ab: GGET                  case 0x0b:                      // ab: GGET
                         ret = lio_gget(lio);                          ret = lio_gget(&lio);
                         break;                          break;
   
                 case 0x0c:                      // ac: GPUT1                  case 0x0c:                      // ac: GPUT1
                         ret = lio_gput1(lio);                          ret = lio_gput1(&lio);
                         break;                          break;
   
                 case 0x0d:                      // ad: GPUT2                  case 0x0d:                      // ad: GPUT2
                         ret = lio_gput2(lio);                          ret = lio_gput2(&lio);
                         break;                          break;
   
 //              case 0x0e:                      // ae: GROLL  //              case 0x0e:                      // ae: GROLL
 //                      break;  //                      break;
   
                 case 0x0f:                      // af: GPOINT2                  case 0x0f:                      // af: GPOINT2
                         ret = lio_gpoint2(lio);                          ret = lio_gpoint2(&lio);
                         break;                          break;
   
 //              case 0x10:                      // ce: GCOPY  //              case 0x10:                      // ce: GCOPY
Line 104  void bios_lio(REG8 cmd) { Line 94  void bios_lio(REG8 cmd) {
                         break;                          break;
         }          }
         CPU_AH = ret;          CPU_AH = ret;
         gdcsub_setslavewait(lio->wait);          if (lio.wait) {
                   gdcsub_setslavewait(lio.wait);
           }
 }  }
   
   
Line 112  void bios_lio(REG8 cmd) { Line 104  void bios_lio(REG8 cmd) {
   
 const UINT32 lioplaneadrs[4] = {VRAM_B, VRAM_R, VRAM_G, VRAM_E};  const UINT32 lioplaneadrs[4] = {VRAM_B, VRAM_R, VRAM_G, VRAM_E};
   
 void lio_updatedraw(LIOWORK lio) {  void lio_updatedraw(GLIO lio) {
   
         UINT8   flag;          UINT8   flag;
         UINT8   colorbit;          UINT8   colorbit;
Line 126  void lio_updatedraw(LIOWORK lio) { Line 118  void lio_updatedraw(LIOWORK lio) {
                 flag |= LIODRAW_4BPP;                  flag |= LIODRAW_4BPP;
                 colorbit = 4;                  colorbit = 4;
         }          }
         switch(lio->mem.scrnmode) {          switch(lio->work.scrnmode) {
                 case 0:                  case 0:
                         if (lio->mem.pos & 1) {                          if (lio->work.pos & 1) {
                                 flag |= LIODRAW_UPPER;                                  flag |= LIODRAW_UPPER;
                         }                          }
                         maxline = 199;                          maxline = 199;
                         break;                          break;
   
                 case 1:                  case 1:
                         flag |= lio->mem.pos % colorbit;                          flag |= lio->work.pos % colorbit;
                         flag |= LIODRAW_MONO;                          flag |= LIODRAW_MONO;
                         if (lio->mem.pos >= colorbit) {                          if (lio->work.pos >= colorbit) {
                                 flag |= LIODRAW_UPPER;                                  flag |= LIODRAW_UPPER;
                         }                          }
                         maxline = 199;                          maxline = 199;
                         break;                          break;
   
                 case 2:                  case 2:
                         flag |= lio->mem.pos % colorbit;                          flag |= lio->work.pos % colorbit;
                         flag |= LIODRAW_MONO;                          flag |= LIODRAW_MONO;
                         break;                          break;
         }          }
         lio->draw.flag = flag;          lio->draw.flag = flag;
         lio->draw.palmax = 1 << colorbit;          lio->draw.palmax = 1 << colorbit;
   
         tmp = (SINT16)LOADINTELWORD(lio->mem.viewx1);          tmp = (SINT16)LOADINTELWORD(lio->work.viewx1);
         lio->draw.x1 = max(tmp, 0);          lio->draw.x1 = max(tmp, 0);
         tmp = (SINT16)LOADINTELWORD(lio->mem.viewy1);          tmp = (SINT16)LOADINTELWORD(lio->work.viewy1);
         lio->draw.y1 = max(tmp, 0);          lio->draw.y1 = max(tmp, 0);
         tmp = (SINT16)LOADINTELWORD(lio->mem.viewx2);          tmp = (SINT16)LOADINTELWORD(lio->work.viewx2);
         lio->draw.x2 = min(tmp, 639);          lio->draw.x2 = min(tmp, 639);
         tmp = (SINT16)LOADINTELWORD(lio->mem.viewy2);          tmp = (SINT16)LOADINTELWORD(lio->work.viewy2);
         lio->draw.y2 = min(tmp, maxline);          lio->draw.y2 = min(tmp, maxline);
         if (!gdcs.access) {          if (!gdcs.access) {
                 lio->draw.base = 0;                  lio->draw.base = 0;
Line 174  void lio_updatedraw(LIOWORK lio) { Line 166  void lio_updatedraw(LIOWORK lio) {
   
 // ----  // ----
   
 static void pixed8(const _LIOWORK *lio, UINT addr, REG8 bit, REG8 pal) {  static void pixed8(const _GLIO *lio, UINT addr, REG8 bit, REG8 pal) {
   
         BYTE    *ptr;          UINT8   *ptr;
   
         addr = LOW15(addr);          addr = LOW15(addr);
         vramupdate[addr] |= lio->draw.sbit;          vramupdate[addr] |= lio->draw.sbit;
Line 200  static void pixed8(const _LIOWORK *lio,  Line 192  static void pixed8(const _LIOWORK *lio, 
                 else {                  else {
                         ptr[VRAM_G] &= ~bit;                          ptr[VRAM_G] &= ~bit;
                 }                  }
                 if (lio->palmode == 2) {                  if (lio->draw.flag & LIODRAW_4BPP) {
                         if (pal & 8) {                          if (pal & 8) {
                                 ptr[VRAM_E] |= bit;                                  ptr[VRAM_E] |= bit;
                         }                          }
Line 220  static void pixed8(const _LIOWORK *lio,  Line 212  static void pixed8(const _LIOWORK *lio, 
         }          }
 }  }
   
 void lio_pset(const _LIOWORK *lio, SINT16 x, SINT16 y, REG8 pal) {  void lio_pset(const _GLIO *lio, SINT16 x, SINT16 y, REG8 pal) {
   
         UINT    addr;          UINT    addr;
         BYTE    bit;          UINT8   bit;
   
         if ((lio->draw.x1 > x) || (lio->draw.x2 < x) ||          if ((lio->draw.x1 > x) || (lio->draw.x2 < x) ||
                 (lio->draw.y1 > y) || (lio->draw.y2 < y)) {                  (lio->draw.y1 > y) || (lio->draw.y2 < y)) {
Line 238  void lio_pset(const _LIOWORK *lio, SINT1 Line 230  void lio_pset(const _LIOWORK *lio, SINT1
         pixed8(lio, addr, bit, pal);          pixed8(lio, addr, bit, pal);
 }  }
   
 void lio_line(const _LIOWORK *lio, SINT16 x1, SINT16 x2, SINT16 y, REG8 pal) {  #if 0
   void lio_line(const _GLIO *lio, SINT16 x1, SINT16 x2, SINT16 y, REG8 pal) {
   
         UINT    addr;          UINT    addr;
         BYTE    bit, dbit;          UINT8   bit, dbit;
         SINT16  width;          SINT16  width;
   
         if ((lio->draw.y1 > y) || (lio->draw.y2 < y)) {          if ((lio->draw.y1 > y) || (lio->draw.y2 < y)) {
Line 264  void lio_line(const _LIOWORK *lio, SINT1 Line 257  void lio_line(const _LIOWORK *lio, SINT1
         }          }
         gdcs.grphdisp |= lio->draw.sbit;          gdcs.grphdisp |= lio->draw.sbit;
         dbit = 0;          dbit = 0;
         while(bit && width--) {          while((bit) && (width)) {
                 dbit |= bit;                  dbit |= bit;
                 bit >>= 1;                  bit >>= 1;
                   width--;
         }          }
         pixed8(lio, addr, dbit, pal);          pixed8(lio, addr, dbit, pal);
         addr++;          addr++;
Line 277  void lio_line(const _LIOWORK *lio, SINT1 Line 271  void lio_line(const _LIOWORK *lio, SINT1
         }          }
         dbit = 0;          dbit = 0;
         bit = 0x80;          bit = 0x80;
         while(bit && width--) {          while((bit) && (width)) {
                 dbit |= bit;                  dbit |= bit;
                 bit >>= 1;                  bit >>= 1;
                   width--;
         }          }
         if (dbit) {          if (dbit) {
                 pixed8(lio, addr, dbit, pal);                  pixed8(lio, addr, dbit, pal);
         }          }
 }  }
   #endif
   
 void lio_look(UINT vect) {  
   
         BYTE    work[16];  
   
         TRACEOUT(("lio command %.2x [%.4x:%.4x]", vect, CPU_CS, CPU_IP));  
         if (vect == 0xa7) {  
                 i286_memstr_read(CPU_DS, CPU_BX, work, 16);  
                 TRACEOUT(("LINE %d %d %d %d - %d %d / %d : %.2x %.2x",  
                                         LOADINTELWORD(work),  
                                         LOADINTELWORD(work+2),  
                                         LOADINTELWORD(work+4),  
                                         LOADINTELWORD(work+6),  
                                         work[8], work[9], work[10], work[11], work[12]));  
         }  
         else if (vect == 0xad) {  
                 i286_memstr_read(CPU_DS, CPU_BX, work, 16);  
                 TRACEOUT(("GPUT2 x=%d / y=%d / chr=%.4x / %d / %d %d %d",  
                         LOADINTELWORD(work),  
                         LOADINTELWORD(work+2),  
                         LOADINTELWORD(work+4),  
                         work[6], work[7], work[8], work[9]));  
         }  
 }  
   
Removed from v.1.9  
changed lines
  Added in v.1.21

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