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

Diff for /np2/lio/gline.c between versions 1.6 and 1.10

version 1.6, 2004/02/21 04:48:35 version 1.10, 2004/02/22 00:05:56
Line 25  typedef struct { Line 25  typedef struct {
         int             y1;          int             y1;
         int             x2;          int             x2;
         int             y2;          int             y2;
         UINT16  pat;  
         UINT8   pal;          UINT8   pal;
 } LINEPT;  } LINEPT;
   
   
 static void gline(const _LIOWORK *lio, const LINEPT *lp) {  static void gline(const _GLIO *lio, const LINEPT *lp, UINT16 pat) {
   
         int             x1;          int             x1;
         int             y1;          int             y1;
Line 42  static void gline(const _LIOWORK *lio, c Line 41  static void gline(const _LIOWORK *lio, c
         int             height;          int             height;
         int             d1;          int             d1;
         int             d2;          int             d2;
         UINT16  pat;  
         UINT32  csrw;          UINT32  csrw;
         GDCVECT vect;          GDCVECT vect;
   
Line 129  static void gline(const _LIOWORK *lio, c Line 127  static void gline(const _LIOWORK *lio, c
                 d2 = 0 - d2;                  d2 = 0 - d2;
         }          }
         d1 = max(d1, d2) & 15;          d1 = max(d1, d2) & 15;
         pat = (UINT16)((lp->pat >> d1) | (lp->pat << (16 - d1)));          pat = (UINT16)((pat >> d1) | (pat << (16 - d1)));
   
         csrw = (y1 * 40) + (x1 >> 4) + ((x1 & 0xf) << 20);          csrw = (y1 * 40) + (x1 >> 4) + ((x1 & 0xf) << 20);
           if (lio->draw.flag & LIODRAW_UPPER) {
                   csrw += 16000 >> 1;
           }
         gdcsub_setvectl(&vect, x1, y1, x2, y2);          gdcsub_setvectl(&vect, x1, y1, x2, y2);
         if (!(lio->draw.flag & LIODRAW_MONO)) {          if (!(lio->draw.flag & LIODRAW_MONO)) {
                 gdcsub_vectl(csrw + 0x4000, &vect, pat,                  gdcsub_vectl(csrw + 0x4000, &vect, pat,
Line 140  static void gline(const _LIOWORK *lio, c Line 141  static void gline(const _LIOWORK *lio, c
                                                         (REG8)((lp->pal & 2)?GDCOPE_SET:GDCOPE_CLEAR));                                                          (REG8)((lp->pal & 2)?GDCOPE_SET:GDCOPE_CLEAR));
                 gdcsub_vectl(csrw + 0xc000, &vect, pat,                  gdcsub_vectl(csrw + 0xc000, &vect, pat,
                                                         (REG8)((lp->pal & 4)?GDCOPE_SET:GDCOPE_CLEAR));                                                          (REG8)((lp->pal & 4)?GDCOPE_SET:GDCOPE_CLEAR));
                 if (lio->palmode == 2) {                  if (lio->draw.flag & LIODRAW_4BPP) {
                         gdcsub_vectl(csrw, &vect, pat,                          gdcsub_vectl(csrw, &vect, pat,
                                                         (REG8)((lp->pal & 8)?GDCOPE_SET:GDCOPE_CLEAR));                                                          (REG8)((lp->pal & 8)?GDCOPE_SET:GDCOPE_CLEAR));
                 }                  }
Line 152  static void gline(const _LIOWORK *lio, c Line 153  static void gline(const _LIOWORK *lio, c
         }          }
 }  }
   
   static void glineb(const _GLIO *lio, const LINEPT *lp, UINT16 pat) {
   
           LINEPT  lpt;
   
           lpt = *lp;
           lpt.y2 = lp->y1;
           gline(lio, &lpt, pat);
           lpt.y2 = lp->y2;
   
           lpt.x2 = lp->x1;
           gline(lio, &lpt, pat);
           lpt.x2 = lp->x2;
   
           lpt.x1 = lp->x2;
           gline(lio, &lpt, pat);
           lpt.x1 = lp->x1;
   
           lpt.y1 = lp->y2;
           gline(lio, &lpt, pat);
           lpt.y1 = lp->y1;
   }
   
   
 // ----  // ----
   
 static void nor_linebox(const _LIOWORK *lio, SINT16 x1, SINT16 y1,  static void gbox(const _GLIO *lio, const LINEPT *lp, BYTE *tile, UINT leng) {
                                                                                         SINT16 x2, SINT16 y2, REG8 pal) {  
           int             x1;
           int             y1;
           int             x2;
           int             y2;
           int             tmp;
           UINT32  csrw;
           GDCVECT vect;
           UINT16  pat[4];
   
         lio_line(lio, x1, x2, y1, pal);          x1 = lp->x1;
         if (y1 != y2) {          y1 = lp->y1;
                 lio_line(lio, x1, x2, y2, pal);          x2 = lp->x2;
         }          y2 = lp->y2;
         for (; y1<y2; y1++) {  
                 lio_pset(lio, x1, y1, pal);          if (x1 > x2) {
                 lio_pset(lio, x2, y1, pal);                  tmp = x1;
                   x1 = x2;
                   x2 = tmp;
           }
           if (y1 > y2) {
                   tmp = y1;
                   y1 = y2;
                   y2 = tmp;
           }
           if ((x1 > lio->draw.x2) || (x2 < lio->draw.x1) ||
                   (y1 > lio->draw.y2) || (y2 < lio->draw.y1)) {
                   return;
           }
           x1 = max(x1, lio->draw.x1);
           y1 = max(y1, lio->draw.y1);
           x2 = min(x2, lio->draw.x2);
           y2 = min(y2, lio->draw.y2);
           pat[0] = 0xffff;
           pat[1] = 0xffff;
           pat[2] = 0xffff;
           pat[3] = 0xffff;
           if (leng != 0) {
           }
           if (!(lio->draw.flag & LIODRAW_MONO)) {
                   while(y1 <= y2) {
                           gdcsub_setvectl(&vect, x1, y1, x2, y1);
                           csrw = (y1 * 40) + (x1 >> 4) + ((x1 & 0xf) << 20);
                           if (lio->draw.flag & LIODRAW_UPPER) {
                                   csrw += 16000 >> 1;
                           }
                           gdcsub_vectl(csrw + 0x4000, &vect, pat[0],
                                                           (REG8)((lp->pal & 1)?GDCOPE_SET:GDCOPE_CLEAR));
                           gdcsub_vectl(csrw + 0x8000, &vect, pat[1],
                                                           (REG8)((lp->pal & 2)?GDCOPE_SET:GDCOPE_CLEAR));
                           gdcsub_vectl(csrw + 0xc000, &vect, pat[2],
                                                           (REG8)((lp->pal & 4)?GDCOPE_SET:GDCOPE_CLEAR));
                           if (lio->draw.flag & LIODRAW_4BPP) {
                                   gdcsub_vectl(csrw, &vect, pat[3],
                                                           (REG8)((lp->pal & 8)?GDCOPE_SET:GDCOPE_CLEAR));
                           }
                           y1++;
                   }
           }
           else {
                   while(y1 <= y2) {
                           gdcsub_setvectl(&vect, x1, y1, x2, y1);
                           csrw = (y1 * 40) + (x1 >> 4) + ((x1 & 0xf) << 20);
                           if (lio->draw.flag & LIODRAW_UPPER) {
                                   csrw += 16000 >> 1;
                           }
                           csrw += ((lio->draw.flag + 1) & LIODRAW_PMASK) << 12;
                           gdcsub_vectl(csrw, &vect, pat[0],
                                                                   (REG8)((lp->pal)?GDCOPE_SET:GDCOPE_CLEAR));
                           y1++;
                   }
         }          }
 }  }
   
 static void nor_lineboxfill(const _LIOWORK *lio, SINT16 x1, SINT16 y1,  
                                                                                         SINT16 x2, SINT16 y2, REG8 pal) {  
   
         for (; y1<=y2; y1++) {  // ---- CLS
                 lio_line(lio, x1, x2, y1, pal);  
         }  REG8 lio_gcls(GLIO lio) {
   
           LINEPT  lp;
   
           lio_updatedraw(lio);
           lp.x1 = lio->draw.x1;
           lp.y1 = lio->draw.y1;
           lp.x2 = lio->draw.x2;
           lp.y2 = lio->draw.y2;
           lp.pal = lio->work.bgcolor;
           gbox(lio, &lp, NULL, 0);
           return(LIO_SUCCESS);
 }  }
   
   
 // ----  // ----
   
 REG8 lio_gline(LIOWORK lio) {  REG8 lio_gline(GLIO lio) {
   
         GLINE   dat;          GLINE   dat;
         LINEPT  lp;          LINEPT  lp;
         SINT16  x1;          UINT16  pat;
         SINT16  y1;          UINT    leng;
         SINT16  x2;          UINT    lengmin;
         SINT16  y2;          BYTE    tile[256];
   
         lio_updatedraw(lio);          lio_updatedraw(lio);
         i286_memstr_read(CPU_DS, CPU_BX, &dat, sizeof(dat));          i286_memstr_read(CPU_DS, CPU_BX, &dat, sizeof(dat));
           lp.x1 = (SINT16)LOADINTELWORD(dat.x1);
           lp.y1 = (SINT16)LOADINTELWORD(dat.y1);
           lp.x2 = (SINT16)LOADINTELWORD(dat.x2);
           lp.y2 = (SINT16)LOADINTELWORD(dat.y2);
         if (dat.pal == 0xff) {          if (dat.pal == 0xff) {
                 lp.pal = lio->mem.fgcolor;                  lp.pal = lio->work.fgcolor;
         }          }
         else {          else {
                 lp.pal = dat.pal;                  lp.pal = dat.pal;
         }          }
         if (lp.pal >= lio->draw.palmax) {          if (lp.pal >= lio->draw.palmax) {
                 return(LIO_ILLEGALFUNC);                  goto gline_err;
         }          }
         lp.x1 = (SINT16)LOADINTELWORD(dat.x1);          pat = 0xffff;
         lp.y1 = (SINT16)LOADINTELWORD(dat.y1);          if (dat.type < 2) {
         lp.x2 = (SINT16)LOADINTELWORD(dat.x2);                  if (dat.sw) {
         lp.y2 = (SINT16)LOADINTELWORD(dat.y2);                          pat = (GDCPATREVERSE(dat.style[0]) << 8) +
         if (dat.sw) {  
                 lp.pat = (GDCPATREVERSE(dat.style[0]) << 8) +  
                                                                                         GDCPATREVERSE(dat.style[1]);                                                                                          GDCPATREVERSE(dat.style[1]);
                   }
                   if (dat.type == 0) {
                           gline(lio, &lp, pat);
                   }
                   else {
                           glineb(lio, &lp, pat);
                   }
         }          }
         else {          else if (dat.type == 2) {
                 lp.pat = 0xffff;                  leng = 0;
         }                  if (dat.sw != 2) {
                           leng = dat.patleng;
                           if (leng == 0) {
         if (dat.pal == 0xff) {                                  goto gline_err;
                 dat.pal = lio->mem.fgcolor;                          }
                           i286_memstr_read(LOADINTELWORD(dat.seg), LOADINTELWORD(dat.off),
                                                                                                                                   tile, leng);
                   }
                   gbox(lio, &lp, tile, leng);
         }          }
         else if (dat.pal >= lio->draw.palmax) {          else {
                 return(5);                  goto gline_err;
         }          }
         x1 = (SINT16)LOADINTELWORD(dat.x1);          return(LIO_SUCCESS);
         y1 = (SINT16)LOADINTELWORD(dat.y1);  
         x2 = (SINT16)LOADINTELWORD(dat.x2);  
         y2 = (SINT16)LOADINTELWORD(dat.y2);  
         switch(dat.type) {  
                 case 0:  
                         gline(lio, &lp);  
                         break;  
   
                 case 1:  
                         nor_linebox(lio, x1, y1, x2, y2, dat.pal);  
                         break;  
   
                 case 2:  
                         nor_lineboxfill(lio, x1, y1, x2, y2, dat.pal);  
                         break;  
   
                 default:  gline_err:
                         return(5);          return(LIO_ILLEGALFUNC);
         }  
         return(0);  
 }  }
   
Removed from v.1.6  
changed lines
  Added in v.1.10

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