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

Diff for /np2/lio/gline.c between versions 1.2 and 1.8

version 1.2, 2003/12/08 00:55:33 version 1.8, 2004/02/21 06:55:44
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "cpucore.h"  #include        "cpucore.h"
 #include        "memory.h"  #include        "pccore.h"
   #include        "iocore.h"
   #include        "gdc_sub.h"
 #include        "lio.h"  #include        "lio.h"
   
   
Line 12  typedef struct { Line 14  typedef struct {
         BYTE    pal;          BYTE    pal;
         BYTE    type;          BYTE    type;
         BYTE    sw;          BYTE    sw;
         BYTE    style_l;          BYTE    style[2];
         BYTE    style_h;  
         BYTE    patleng;          BYTE    patleng;
         BYTE    off[2];          BYTE    off[2];
         BYTE    seg[2];          BYTE    seg[2];
 } MEMGLINE;  } GLINE;
   
   typedef struct {
           int             x1;
           int             y1;
           int             x2;
           int             y2;
           UINT16  pat;
           UINT8   pal;
   } LINEPT;
   
   
   static void gline(const _LIOWORK *lio, const LINEPT *lp) {
   
           int             x1;
           int             y1;
           int             x2;
           int             y2;
           int             swap;
           int             tmp;
           int             width;
           int             height;
           int             d1;
           int             d2;
           UINT16  pat;
           UINT32  csrw;
           GDCVECT vect;
   
           x1 = lp->x1;
           y1 = lp->y1;
           x2 = lp->x2;
           y2 = lp->y2;
   
           // びゅーぽいんと
           swap = 0;
           if (x1 > x2) {
                   tmp = x1;
                   x1 = x2;
                   x2 = tmp;
                   tmp = y1;
                   y1 = y2;
                   y2 = tmp;
                   swap = 1;
           }
           if ((x1 > lio->draw.x2) || (x2 < lio->draw.x1)) {
                   return;
           }
           width = x2 - x1;
           height = y2 - y1;
           d1 = lio->draw.x1 - x1;
           d2 = x2 - lio->draw.x2;
           if (d1 > 0) {
                   x1 = lio->draw.x1;
                   y1 += (((height * d1 * 2) / width) + 1) >> 1;
           }
           if (d2 > 0) {
                   x2 = lio->draw.x2;
                   y2 -= (((height * d2 * 2) / width) + 1) >> 1;
           }
           if (swap) {
                   tmp = x1;
                   x1 = x2;
                   x2 = tmp;
                   tmp = y1;
                   y1 = y2;
                   y2 = tmp;
           }
   
           swap = 0;
           if (y1 > y2) {
                   tmp = x1;
                   x1 = x2;
                   x2 = tmp;
                   tmp = y1;
                   y1 = y2;
                   y2 = tmp;
           }
           if ((y1 > lio->draw.y2) || (y2 < lio->draw.y1)) {
                   return;
           }
           width = x2 - x1;
           height = y2 - y1;
           d1 = lio->draw.y1 - y1;
           d2 = y2 - lio->draw.y2;
           if (d1 > 0) {
                   y1 = lio->draw.y1;
                   x1 += (((width * d1 * 2) / height) + 1) >> 1;
           }
           if (d2 > 0) {
                   y2 = lio->draw.y2;
                   x2 -= (((width * d2 * 2) / height) + 1) >> 1;
           }
           if (swap) {
                   tmp = x1;
                   x1 = x2;
                   x2 = tmp;
                   tmp = y1;
                   y1 = y2;
                   y2 = tmp;
           }
   
           // 進んだ距離計算
           d1 = x1 - lp->x1;
           if (d1 < 0) {
                   d1 = 0 - d1;
           }
           d2 = y1 - lp->y1;
           if (d2 < 0) {
                   d2 = 0 - d2;
           }
           d1 = max(d1, d2) & 15;
           pat = (UINT16)((lp->pat >> d1) | (lp->pat << (16 - d1)));
   
           csrw = (y1 * 40) + (x1 >> 4) + ((x1 & 0xf) << 20);
           if (lio->draw.flag & LIODRAW_UPPER) {
                   csrw += 16000 >> 1;
           }
           gdcsub_setvectl(&vect, x1, y1, x2, y2);
           if (!(lio->draw.flag & LIODRAW_MONO)) {
                   gdcsub_vectl(csrw + 0x4000, &vect, pat,
                                                           (REG8)((lp->pal & 1)?GDCOPE_SET:GDCOPE_CLEAR));
                   gdcsub_vectl(csrw + 0x8000, &vect, pat,
                                                           (REG8)((lp->pal & 2)?GDCOPE_SET:GDCOPE_CLEAR));
                   gdcsub_vectl(csrw + 0xc000, &vect, pat,
                                                           (REG8)((lp->pal & 4)?GDCOPE_SET:GDCOPE_CLEAR));
                   if (lio->draw.flag & LIODRAW_4BPP) {
                           gdcsub_vectl(csrw, &vect, pat,
                                                           (REG8)((lp->pal & 8)?GDCOPE_SET:GDCOPE_CLEAR));
                   }
           }
           else {
                   csrw += ((lio->draw.flag + 1) & LIODRAW_PMASK) << 12;
                   gdcsub_vectl(csrw, &vect, pat,
                                                                   (REG8)((lp->pal)?GDCOPE_SET:GDCOPE_CLEAR));
           }
   }
   
   
 static void nor_linebox(SINT16 x1, SINT16 y1,  // ----
                                                                                         SINT16 x2, SINT16 y2, BYTE pal) {  
   
         lio_line(x1, x2, y1, pal);  static void nor_linebox(const _LIOWORK *lio, SINT16 x1, SINT16 y1,
                                                                                           SINT16 x2, SINT16 y2, REG8 pal) {
   
           lio_line(lio, x1, x2, y1, pal);
         if (y1 != y2) {          if (y1 != y2) {
                 lio_line(x1, x2, y2, pal);                  lio_line(lio, x1, x2, y2, pal);
         }          }
         for (; y1<y2; y1++) {          for (; y1<y2; y1++) {
                 lio_pset(x1, y1, pal);                  lio_pset(lio, x1, y1, pal);
                 lio_pset(x2, y1, pal);                  lio_pset(lio, x2, y1, pal);
         }          }
 }  }
   
 static void nor_lineboxfill(SINT16 x1, SINT16 y1,  static void nor_lineboxfill(const _LIOWORK *lio, SINT16 x1, SINT16 y1,
                                                                                         SINT16 x2, SINT16 y2, BYTE pal) {                                                                                          SINT16 x2, SINT16 y2, REG8 pal) {
   
         for (; y1<=y2; y1++) {          for (; y1<=y2; y1++) {
                 lio_line(x1, x2, y1, pal);                  lio_line(lio, x1, x2, y1, pal);
         }          }
 }  }
   
 BYTE lio_gline(void) {  
   
         MEMGLINE        dat;  // ----
         SINT16          x1;  
         SINT16          y1;  REG8 lio_gline(LIOWORK lio) {
         SINT16          x2;  
         SINT16          y2;          GLINE   dat;
           LINEPT  lp;
           SINT16  x1;
           SINT16  y1;
           SINT16  x2;
           SINT16  y2;
   
           lio_updatedraw(lio);
         i286_memstr_read(CPU_DS, CPU_BX, &dat, sizeof(dat));          i286_memstr_read(CPU_DS, CPU_BX, &dat, sizeof(dat));
         if (dat.pal == 0xff) {          if (dat.pal == 0xff) {
                 dat.pal = lio.gcolor1.fgcolor;                  lp.pal = lio->mem.fgcolor;
           }
           else {
                   lp.pal = dat.pal;
           }
           if (lp.pal >= lio->draw.palmax) {
                   return(LIO_ILLEGALFUNC);
           }
           lp.x1 = (SINT16)LOADINTELWORD(dat.x1);
           lp.y1 = (SINT16)LOADINTELWORD(dat.y1);
           lp.x2 = (SINT16)LOADINTELWORD(dat.x2);
           lp.y2 = (SINT16)LOADINTELWORD(dat.y2);
           TRACEOUT(("line %d %d %d %d", lp.x1, lp.y1, lp.x2, lp.y2));
           if (dat.sw) {
                   lp.pat = (GDCPATREVERSE(dat.style[0]) << 8) +
                                                                                           GDCPATREVERSE(dat.style[1]);
           }
           else {
                   lp.pat = 0xffff;
           }
           if (dat.pal == 0xff) {
                   dat.pal = lio->mem.fgcolor;
         }          }
         else if (dat.pal >= lio.gcolor1.palmax) {          else if (dat.pal >= lio->draw.palmax) {
                 return(5);                  return(5);
         }          }
         x1 = (SINT16)LOADINTELWORD(dat.x1);          x1 = (SINT16)LOADINTELWORD(dat.x1);
Line 62  BYTE lio_gline(void) { Line 226  BYTE lio_gline(void) {
         y2 = (SINT16)LOADINTELWORD(dat.y2);          y2 = (SINT16)LOADINTELWORD(dat.y2);
         switch(dat.type) {          switch(dat.type) {
                 case 0:                  case 0:
                           gline(lio, &lp);
                         break;                          break;
   
                 case 1:                  case 1:
                         nor_linebox(x1, y1, x2, y2, dat.pal);                          nor_linebox(lio, x1, y1, x2, y2, dat.pal);
                         break;                          break;
   
                 case 2:                  case 2:
                         nor_lineboxfill(x1, y1, x2, y2, dat.pal);                          nor_lineboxfill(lio, x1, y1, x2, y2, dat.pal);
                         break;                          break;
   
                 default:                  default:
Removed from v.1.2  
changed lines
  Added in v.1.8

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