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

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

version 1.8, 2004/02/21 00:25:33 version 1.9, 2004/02/21 04:48:35
Line 114  const UINT32 lioplaneadrs[4] = {VRAM_B,  Line 114  const UINT32 lioplaneadrs[4] = {VRAM_B, 
   
 void lio_updatedraw(LIOWORK lio) {  void lio_updatedraw(LIOWORK lio) {
   
         lio->draw.x1 = max(lio->gview.x1, 0);          UINT8   flag;
         lio->draw.y1 = max(lio->gview.y1, 0);          UINT8   colorbit;
         lio->draw.x2 = min(lio->gview.x2, 639);          SINT16  maxline;
         lio->draw.y2 = min(lio->gview.x2, (lio->scrn.lines - 1));          SINT16  tmp;
   
           flag = 0;
           colorbit = 3;
           maxline = 399;
           if (lio->palmode == 2) {
                   flag |= LIODRAW_4BPP;
                   colorbit = 4;
           }
           switch(lio->mem.scrnmode) {
                   case 0:
                           if (lio->mem.pos & 1) {
                                   flag |= LIODRAW_UPPER;
                           }
                           maxline = 199;
                           break;
   
                   case 1:
                           flag |= lio->mem.pos % colorbit;
                           flag |= LIODRAW_MONO;
                           if (lio->mem.pos >= colorbit) {
                                   flag |= LIODRAW_UPPER;
                           }
                           maxline = 199;
                           break;
   
                   case 2:
                           flag |= lio->mem.pos % colorbit;
                           flag |= LIODRAW_MONO;
                           break;
           }
           lio->draw.flag = flag;
           lio->draw.palmax = 1 << colorbit;
   
           tmp = (SINT16)LOADINTELWORD(lio->mem.viewx1);
           lio->draw.x1 = max(tmp, 0);
           tmp = (SINT16)LOADINTELWORD(lio->mem.viewy1);
           lio->draw.y1 = max(tmp, 0);
           tmp = (SINT16)LOADINTELWORD(lio->mem.viewx2);
           lio->draw.x2 = min(tmp, 639);
           tmp = (SINT16)LOADINTELWORD(lio->mem.viewy2);
           lio->draw.y2 = min(tmp, maxline);
         if (!gdcs.access) {          if (!gdcs.access) {
                 lio->draw.base = 0;                  lio->draw.base = 0;
                 lio->draw.bank = 0;                  lio->draw.bank = 0;
Line 133  void lio_updatedraw(LIOWORK lio) { Line 174  void lio_updatedraw(LIOWORK lio) {
   
 // ----  // ----
   
 static const BYTE bit_l[8] = {0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01};  static void pixed8(const _LIOWORK *lio, UINT addr, REG8 bit, REG8 pal) {
 static const BYTE bit_r[8] = {0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe};  
   
 static void pixed8(const _LIOWORK *lio, UINT32 vadrs, BYTE bit, REG8 pal) {          BYTE    *ptr;
   
         if (lio->scrn.plane & 0x80) {          addr = LOW15(addr);
           vramupdate[addr] |= lio->draw.sbit;
           ptr = mem + lio->draw.base + addr;
           if (!(lio->draw.flag & LIODRAW_MONO)) {
                 if (pal & 1) {                  if (pal & 1) {
                         mem[vadrs + VRAM_B] |= bit;                          ptr[VRAM_B] |= bit;
                 }                  }
                 else {                  else {
                         mem[vadrs + VRAM_B] &= ~bit;                          ptr[VRAM_B] &= ~bit;
                 }                  }
                 if (pal & 2) {                  if (pal & 2) {
                         mem[vadrs + VRAM_R] |= bit;                          ptr[VRAM_R] |= bit;
                 }                  }
                 else {                  else {
                         mem[vadrs + VRAM_R] &= ~bit;                          ptr[VRAM_R] &= ~bit;
                 }                  }
                 if (pal & 4) {                  if (pal & 4) {
                         mem[vadrs + VRAM_G] |= bit;                          ptr[VRAM_G] |= bit;
                 }                  }
                 else {                  else {
                         mem[vadrs + VRAM_G] &= ~bit;                          ptr[VRAM_G] &= ~bit;
                 }                  }
                 if (lio->gcolor1.palmode == 2) {                  if (lio->palmode == 2) {
                         if (pal & 8) {                          if (pal & 8) {
                                 mem[vadrs + VRAM_E] |= bit;                                  ptr[VRAM_E] |= bit;
                         }                          }
                         else {                          else {
                                 mem[vadrs + VRAM_E] &= ~bit;                                  ptr[VRAM_E] &= ~bit;
                         }                          }
                 }                  }
         }          }
         else {          else {
                 vadrs += lioplaneadrs[lio->scrn.plane & 3];                  ptr += lioplaneadrs[lio->draw.flag & LIODRAW_PMASK];
                 if (pal) {                  if (pal) {
                         mem[vadrs] |= bit;                          *ptr |= bit;
                 }                  }
                 else {                  else {
                         mem[vadrs] &= ~bit;                          *ptr &= ~bit;
                 }                  }
         }          }
 }  }
   
 void lio_pset(const _LIOWORK *lio, SINT16 x, SINT16 y, REG8 pal) {  void lio_pset(const _LIOWORK *lio, SINT16 x, SINT16 y, REG8 pal) {
   
         UINT32  adrs;          UINT    addr;
         BYTE    bit;          BYTE    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)) {
                 return;                  return;
         }          }
         adrs = (y * 80) + (x >> 3);          addr = (y * 80) + (x >> 3);
         bit = 0x80 >> (x & 7);          bit = 0x80 >> (x & 7);
         if (lio->scrn.top) {          if (lio->draw.flag & LIODRAW_UPPER) {
                 adrs += 16000;                  addr += 16000;
         }          }
         vramupdate[adrs] |= lio->draw.sbit;  
         gdcs.grphdisp |= lio->draw.sbit;          gdcs.grphdisp |= lio->draw.sbit;
         adrs += lio->draw.base;          pixed8(lio, addr, bit, pal);
         pixed8(lio, adrs, bit, pal);  
 }  }
   
 void lio_line(const _LIOWORK *lio, SINT16 x1, SINT16 x2, SINT16 y, REG8 pal) {  void lio_line(const _LIOWORK *lio, SINT16 x1, SINT16 x2, SINT16 y, REG8 pal) {
   
         UINT    adrs;          UINT    addr;
         UINT32  vadrs;          BYTE    bit, dbit;
         BYTE    bit, dbit, sbit;  
         SINT16  width;          SINT16  width;
   
         if ((lio->draw.y1 > y) || (lio->draw.y2 < y)) {          if ((lio->draw.y1 > y) || (lio->draw.y2 < y)) {
Line 217  void lio_line(const _LIOWORK *lio, SINT1 Line 257  void lio_line(const _LIOWORK *lio, SINT1
         if (width <= 0) {          if (width <= 0) {
                 return;                  return;
         }          }
         adrs = (y * 80) + (x1 >> 3);          addr = (y * 80) + (x1 >> 3);
         bit = 0x80 >> (x1 & 7);          bit = 0x80 >> (x1 & 7);
         if (lio->scrn.top) {          if (lio->draw.flag & LIODRAW_UPPER) {
                 adrs += 16000;                  addr += 16000;
         }  
         if (!lio->scrn.bank) {  
                 vadrs = adrs;  
                 sbit = 1;  
                 gdcs.grphdisp |= 1;  
         }          }
         else {          gdcs.grphdisp |= lio->draw.sbit;
                 vadrs = adrs + VRAM_STEP;  
                 sbit = 2;  
                 gdcs.grphdisp |= 2;  
         }  
   
         dbit = 0;          dbit = 0;
         while(bit && width--) {          while(bit && width--) {
                 dbit |= bit;                  dbit |= bit;
                 bit >>= 1;                  bit >>= 1;
         }          }
         pixed8(lio, vadrs++, dbit, pal);          pixed8(lio, addr, dbit, pal);
         vramupdate[adrs++] |= sbit;          addr++;
         while(width >= 8) {          while(width >= 8) {
                 width -= 8;                  width -= 8;
                 pixed8(lio, vadrs++, 0xff, pal);                  pixed8(lio, addr, 0xff, pal);
                 vramupdate[adrs++] |= sbit;                  addr++;
         }          }
         dbit = 0;          dbit = 0;
         bit = 0x80;          bit = 0x80;
Line 252  void lio_line(const _LIOWORK *lio, SINT1 Line 282  void lio_line(const _LIOWORK *lio, SINT1
                 bit >>= 1;                  bit >>= 1;
         }          }
         if (dbit) {          if (dbit) {
                 pixed8(lio, vadrs, dbit, pal);                  pixed8(lio, addr, dbit, pal);
                 vramupdate[adrs] |= sbit;  
         }          }
 }  }
   
Removed from v.1.8  
changed lines
  Added in v.1.9

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