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

Diff for /np2/lio/gput1.c between versions 1.6 and 1.8

version 1.6, 2004/02/20 16:20:41 version 1.8, 2004/02/21 04:48:35
Line 57  typedef struct { Line 57  typedef struct {
         UINT    addr;          UINT    addr;
         UINT    sft;          UINT    sft;
         UINT    width;          UINT    width;
           UINT8   mask;
   } GETCNTX;
   
   typedef struct {
           BYTE    *baseptr;
           UINT    addr;
           UINT    sft;
           UINT    width;
         UINT8   maskl;          UINT8   maskl;
         UINT8   maskr;          UINT8   maskr;
         UINT8   masklr;          UINT8   masklr;
Line 64  typedef struct { Line 72  typedef struct {
         BYTE    pat[84];          BYTE    pat[84];
 } PUTCNTX;  } PUTCNTX;
   
 #if 0  
 static void getvram(const PUTCNTX *pt) {  static void getvram(const GETCNTX *gt, BYTE *dst) {
   
         BYTE    *baseptr;          BYTE    *baseptr;
         UINT    addr;          UINT    addr;
         BYTE    *dst;  
         UINT    width;          UINT    width;
         UINT    dat;          UINT    dat;
         UINT    sft;          UINT    sft;
   
         baseptr = pt->baseptr;          baseptr = gt->baseptr;
         addr = pt->addr;          addr = gt->addr;
         src = pt->pat;          width = gt->width;
         width = pt->width;          sft = 8 - gt->sft;
         sft = 8 - pt->sft;  
         dat = baseptr[LOW15(addr)];          dat = baseptr[LOW15(addr)];
         addr++;          addr++;
         while(width > 8) {          while(width > 8) {
Line 86  static void getvram(const PUTCNTX *pt) { Line 92  static void getvram(const PUTCNTX *pt) {
                 dat = (dat << 8) + baseptr[LOW15(addr)];                  dat = (dat << 8) + baseptr[LOW15(addr)];
                 addr++;                  addr++;
                 *dst = (UINT8)(dat >> sft);                  *dst = (UINT8)(dat >> sft);
                 dst++                  dst++;
         }          }
         dat = (dat << 8) + baseptr[LOW15(addr)];          dat = (dat << 8) + baseptr[LOW15(addr)];
         *dst = (UINT8)((dat >> sft) & pt->mask);          *dst = (UINT8)((dat >> sft) & gt->mask);
 }  }
 #endif  
   
 static void setdirty(UINT addr, UINT width, UINT height, REG8 bit) {  static void setdirty(UINT addr, UINT width, UINT height, REG8 bit) {
   
Line 319  const BYTE *src; Line 324  const BYTE *src;
 static REG8 putsub(LIOWORK lio, const LIOPUT *lput) {  static REG8 putsub(LIOWORK lio, const LIOPUT *lput) {
   
         UINT    addr;          UINT    addr;
         UINT8   sbit;  
         PUTCNTX pt;          PUTCNTX pt;
         UINT    datacnt;          UINT    datacnt;
         UINT    off;          UINT    off;
Line 328  static REG8 putsub(LIOWORK lio, const LI Line 332  static REG8 putsub(LIOWORK lio, const LI
         UINT    pl;          UINT    pl;
         UINT    writecnt;          UINT    writecnt;
   
         if ((lput->x < lio->range.x1) ||          if ((lput->x < lio->draw.x1) ||
                 (lput->y < lio->range.y1) ||                  (lput->y < lio->draw.y1) ||
                 ((lput->x + lput->width) > lio->range.x2) ||                  ((lput->x + lput->width) > lio->draw.x2) ||
                 ((lput->y + lput->height) > lio->range.y2)) {                  ((lput->y + lput->height) > lio->draw.y2)) {
                 return(LIO_ILLEGALFUNC);                  return(LIO_ILLEGALFUNC);
         }          }
         if ((lput->width <= 0) || (lput->height <= 0)) {          if ((lput->width <= 0) || (lput->height <= 0)) {
Line 339  static REG8 putsub(LIOWORK lio, const LI Line 343  static REG8 putsub(LIOWORK lio, const LI
         }          }
   
         addr = (lput->x >> 3) + (lput->y * 80);          addr = (lput->x >> 3) + (lput->y * 80);
         if (lio->scrn.top) {          if (lio->draw.flag & LIODRAW_UPPER) {
                 addr += 16000;                  addr += 16000;
         }          }
         if (!lio->scrn.bank) {          setdirty(addr, (lput->x & 7) + lput->width, lput->height, lio->draw.sbit);
                 sbit = 1;  
         }  
         else {  
                 addr += VRAM_STEP;  
                 sbit = 2;  
         }  
         setdirty(addr, (lput->x & 7) + lput->width, lput->height, sbit);  
   
         pt.sft = lput->x & 7;          pt.sft = lput->x & 7;
         pt.width = lput->width;          pt.width = lput->width;
Line 360  static REG8 putsub(LIOWORK lio, const LI Line 357  static REG8 putsub(LIOWORK lio, const LI
         datacnt = (lput->width + 7) >> 3;          datacnt = (lput->width + 7) >> 3;
         off = lput->off;          off = lput->off;
   
         flag = (lio->gcolor1.palmode == 2)?0x0f:0x07;          flag = (lio->palmode == 2)?0x0f:0x07;
         flag |= (lput->fg & 15) << 4;          flag |= (lput->fg & 15) << 4;
         flag |= (lput->bg & 15) << 8;          flag |= (lput->bg & 15) << 8;
   
         TRACEOUT(("mode = %d [%.x]", lput->mode, flag));  
   
         // さて表示。          // さて表示。
         writecnt = 0;          writecnt = 0;
         for (pl=0; pl<4; pl++) {          for (pl=0; pl<4; pl++) {
                 if (flag & 1) {                  if (flag & 1) {
                         pt.baseptr = mem + lioplaneadrs[pl];                          pt.baseptr = mem + lio->draw.base + lioplaneadrs[pl];
                         pt.addr = addr;                          pt.addr = addr;
                         height = lput->height;                          height = lput->height;
                         do {                          do {
Line 460  static REG8 putsub(LIOWORK lio, const LI Line 455  static REG8 putsub(LIOWORK lio, const LI
 REG8 lio_gget(LIOWORK lio) {  REG8 lio_gget(LIOWORK lio) {
   
         GGET    dat;          GGET    dat;
           SINT32  x;
           SINT32  y;
           int             x2;
           int             y2;
           UINT    off;
           UINT    seg;
           UINT32  leng;
           UINT32  size;
           UINT    datacnt;
           UINT    mask;
           UINT    addr;
           GETCNTX gt;
           BYTE    pat[84];
           UINT    pl;
           UINT    height;
   
         lio_updaterange(lio);          lio_updatedraw(lio);
         i286_memstr_read(CPU_DS, CPU_BX, &dat, sizeof(dat));          i286_memstr_read(CPU_DS, CPU_BX, &dat, sizeof(dat));
           x = (SINT16)LOADINTELWORD(dat.x1);
           y = (SINT16)LOADINTELWORD(dat.y1);
           x2 = (SINT16)LOADINTELWORD(dat.x2);
           y2 = (SINT16)LOADINTELWORD(dat.y2);
           if ((x < lio->draw.x1) || (y < lio->draw.y1) ||
                   (x2 > lio->draw.x2) || (y2 > lio->draw.y2)) {
                   return(LIO_ILLEGALFUNC);
           }
           x2 = x2 - x + 1;
           y2 = y2 - y + 1;
           if ((x2 <= 0) || (y2 <= 0)) {
                   return(LIO_ILLEGALFUNC);
           }
           off = LOADINTELWORD(dat.off);
           seg = (SINT16)LOADINTELWORD(dat.seg);
   
         return(0);          datacnt = (x2 + 7) >> 3;
           size = datacnt * y2;
           leng = LOADINTELWORD(dat.leng);
           if (!(lio->draw.flag & LIODRAW_MONO)) {
                   if (lio->draw.flag & LIODRAW_4BPP) {
                           size *= 4;
                           mask = 0x0f;
                   }
                   else {
                           size *= 3;
                           mask = 0x07;
                   }
           }
           else {
                   mask = 1 << (lio->draw.flag & LIODRAW_PMASK);
           }
           if (leng < (size + 4)) {
                   return(LIO_ILLEGALFUNC);
           }
           i286_memword_write(seg, off, (REG16)x2);
           i286_memword_write(seg, off+2, (REG16)y2);
           off += 4;
           addr = (x >> 3) + (y * 80);
           if (lio->draw.flag & LIODRAW_UPPER) {
                   addr += 16000;
           }
           gt.sft = x & 7;
           gt.width = x2;
           gt.mask = (UINT8)((~0x7f) >> ((x2 - 1) & 7));
           for (pl=0; pl<4; pl++) {
                   if (mask & 1) {
                           gt.baseptr = mem + lio->draw.base + lioplaneadrs[pl];
                           gt.addr = addr;
                           height = y2;
                           do {
                                   getvram(&gt, pat);
                                   gt.addr += 80;
                                   i286_memstr_write(seg, off, pat, datacnt);
                                   off += datacnt;
                           } while(--height);
                   }
                   mask >>= 1;
           }
           lio->wait = size * 12;
           return(LIO_SUCCESS);
 }  }
   
   
Line 477  REG8 lio_gput1(LIOWORK lio) { Line 546  REG8 lio_gput1(LIOWORK lio) {
         UINT    leng;          UINT    leng;
         UINT    size;          UINT    size;
   
         lio_updaterange(lio);          lio_updatedraw(lio);
         i286_memstr_read(CPU_DS, CPU_BX, &dat, sizeof(dat));          i286_memstr_read(CPU_DS, CPU_BX, &dat, sizeof(dat));
         lput.x = (SINT16)LOADINTELWORD(dat.x);          lput.x = (SINT16)LOADINTELWORD(dat.x);
         lput.y = (SINT16)LOADINTELWORD(dat.y);          lput.y = (SINT16)LOADINTELWORD(dat.y);
Line 498  REG8 lio_gput1(LIOWORK lio) { Line 567  REG8 lio_gput1(LIOWORK lio) {
                         lput.bg = dat.bg;                          lput.bg = dat.bg;
                 }                  }
                 else {                  else {
                         lput.fg = lio->gcolor1.fgcolor;                          lput.fg = lio->mem.fgcolor;
                         lput.bg = lio->gcolor1.bgcolor;                          lput.bg = lio->mem.bgcolor;
                 }                  }
         }          }
         else {          else {
Line 511  REG8 lio_gput1(LIOWORK lio) { Line 580  REG8 lio_gput1(LIOWORK lio) {
                 else {                  else {
                         lput.sw = 1;                          lput.sw = 1;
                         lput.fg = 0x0f;                          lput.fg = 0x0f;
                         lput.bg = 0x0f;                          lput.bg = 0;
                 }                  }
         }          }
         return(putsub(lio, &lput));          return(putsub(lio, &lput));
Line 527  REG8 lio_gput2(LIOWORK lio) { Line 596  REG8 lio_gput2(LIOWORK lio) {
         UINT16  jis;          UINT16  jis;
         REG16   size;          REG16   size;
   
         lio_updaterange(lio);          lio_updatedraw(lio);
         i286_memstr_read(CPU_DS, CPU_BX, &dat, sizeof(dat));          i286_memstr_read(CPU_DS, CPU_BX, &dat, sizeof(dat));
         lput.x = (SINT16)LOADINTELWORD(dat.x);          lput.x = (SINT16)LOADINTELWORD(dat.x);
         lput.y = (SINT16)LOADINTELWORD(dat.y);          lput.y = (SINT16)LOADINTELWORD(dat.y);
Line 552  REG8 lio_gput2(LIOWORK lio) { Line 621  REG8 lio_gput2(LIOWORK lio) {
                 lput.bg = dat.bg;                  lput.bg = dat.bg;
         }          }
         else {          else {
                 lput.fg = lio->gcolor1.fgcolor;                  lput.fg = lio->mem.fgcolor;
                 lput.bg = lio->gcolor1.bgcolor;                  lput.bg = lio->mem.bgcolor;
         }          }
         return(putsub(lio, &lput));          return(putsub(lio, &lput));
 }  }
Removed from v.1.6  
changed lines
  Added in v.1.8

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