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

Diff for /np2/vram/makegrph.c between versions 1.1 and 1.6

version 1.1, 2003/10/16 17:58:18 version 1.6, 2004/08/15 19:22:29
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "memory.h"  #include        "cpucore.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
 #include        "scrndraw.h"  
 #include        "vram.h"  #include        "vram.h"
   #include        "scrndraw.h"
   #include        "dispsync.h"
 #include        "makegrph.h"  #include        "makegrph.h"
 #include        "makegrph.mcr"  #include        "makegrph.mcr"
 #include        "dispsync.h"  
   
   
 typedef struct {  typedef struct {
         UINT32  *vm;          UINT32  *vm;
         UINT    liney;          UINT    liney;
         UINT    pitch;  //      UINT    pitch;
         UINT    lr;          UINT    lr;
 } _MKGRPH, *MKGRPH;  } _MKGRPH, *MKGRPH;
   
Line 21  typedef struct { Line 21  typedef struct {
   
         UINT32  grph_table[4*256*2];          UINT32  grph_table[4*256*2];
   
 void VRAMCALL makegrph_init(void) {  void makegrph_initialize(void) {
   
         int             i, j;          int             i, j;
         BYTE    bit;          BYTE    bit;
Line 64  void VRAMCALL makegrph_init(void) { Line 64  void VRAMCALL makegrph_init(void) {
   
         UINT32  grph_table1[256*2];          UINT32  grph_table1[256*2];
   
 void VRAMCALL makegrph_init(void) {  void makegrph_initialize(void) {
   
         int             i;          int             i;
         BYTE    bit;          BYTE    bit;
Line 103  void VRAMCALL makegrph_init(void) { Line 103  void VRAMCALL makegrph_init(void) {
   
         UINT32  grph_table0[16];          UINT32  grph_table0[16];
   
 void VRAMCALL makegrph_init(void) {  void makegrph_initialize(void) {
   
         int             i;          int             i;
         BYTE    bit;          BYTE    bit;
Line 133  static BOOL grphput_indirty0(MKGRPH mkgr Line 133  static BOOL grphput_indirty0(MKGRPH mkgr
         _MKGRPH mg;          _MKGRPH mg;
         UINT    vad;          UINT    vad;
         UINT    remain;          UINT    remain;
           UINT    pitch;
         UINT    mul;          UINT    mul;
         UINT    vc;          UINT    vc;
         UINT32  *p;          UINT32  *p;
         UINT32  *pterm;          UINT32  *pterm;
   
         mg = *mkgrph;          mg = *mkgrph;
         vad = (LOADINTELWORD(gdc.s.para + GDC_SCROLL + gpos + 0) & 0x3fff) << 1;          vad = LOADINTELWORD(gdc.s.para + GDC_SCROLL + gpos + 0);
         remain = (LOADINTELWORD(gdc.s.para + GDC_SCROLL + gpos + 2)) >> 4;          vad = LOW15(vad << 1);
         remain &= 0x3ff;          remain = LOADINTELWORD(gdc.s.para + GDC_SCROLL + gpos + 2);
         do {          pitch = gdc.s.para[GDC_PITCH];
                 mul = mg.lr;          if (!(remain & (1 << 14))) {
                 do {                  pitch <<= 1;
                         if ((!(mg.liney & 1)) || (!(gdc.mode1 & 0x10))) {          }
                                 vc = vad;          pitch &= 0xfe;
                                 p = mg.vm;          remain = LOW14(remain) >> 4;
                                 pterm = p + (80 * 2);          mul = mg.lr;
                                 do {          while(1) {
                                         if (vramupdate[vc] & 1) {                  if ((!(mg.liney & 1)) || (!(gdc.mode1 & 0x10))) {
                                                 renewal_line[mg.liney] |= 1;                          vc = vad;
                                                 GRPHDATASET(p, vc);                          p = mg.vm;
                                         }                          pterm = p + (80 * 2);
                                         vc = (vc + 1) & 0x7fff;                          do {
                                         p += 2;                                  if (vramupdate[vc] & 1) {
                                 } while(p < pterm);                                          renewal_line[mg.liney] |= 1;
                         }                                          GRPHDATASET(p, vc);
                         mg.liney++;                                  }
                         if (mg.liney >= dsync.grphymax) {                                  vc = LOW15(vc + 1);
                                 return(TRUE);                                  p += 2;
                         }                          } while(p < pterm);
                         mg.vm += 80*2;                  }
                 } while(--mul);                  mg.liney++;
                 vad = (vad + mg.pitch) & 0x7fff;                  if (mg.liney >= dsync.grphymax) {
         } while(--remain);                          return(TRUE);
                   }
                   mg.vm += 80*2;
                   remain--;
                   if (!remain) {
                           break;
                   }
                   mul--;
                   if (!mul) {
                           mul = mg.lr;
                           vad = LOW15(vad + pitch);
                   }
           }
         mkgrph->vm = mg.vm;          mkgrph->vm = mg.vm;
         mkgrph->liney = mg.liney;          mkgrph->liney = mg.liney;
         return(FALSE);          return(FALSE);
Line 176  static BOOL grphput_indirty1(MKGRPH mkgr Line 189  static BOOL grphput_indirty1(MKGRPH mkgr
         _MKGRPH mg;          _MKGRPH mg;
         UINT    vad;          UINT    vad;
         UINT    remain;          UINT    remain;
           UINT    pitch;
         UINT    mul;          UINT    mul;
         UINT    vc;          UINT    vc;
         UINT32  *p;          UINT32  *p;
         UINT32  *pterm;          UINT32  *pterm;
   
         mg = *mkgrph;          mg = *mkgrph;
         vad = (LOADINTELWORD(gdc.s.para + GDC_SCROLL + gpos + 0) & 0x3fff) << 1;          vad = LOADINTELWORD(gdc.s.para + GDC_SCROLL + gpos + 0);
         remain = (LOADINTELWORD(gdc.s.para + GDC_SCROLL + gpos + 2)) >> 4;          vad = LOW15(vad << 1);
         remain &= 0x3ff;          remain = LOADINTELWORD(gdc.s.para + GDC_SCROLL + gpos + 2);
         do {          pitch = gdc.s.para[GDC_PITCH];
                 mul = mg.lr;          if (!(remain & (1 << 14))) {
                 do {                  pitch <<= 1;
                         if ((!(mg.liney & 1)) || (!(gdc.mode1 & 0x10))) {          }
                                 vc = vad;          pitch &= 0xfe;
                                 p = mg.vm;          remain = LOW14(remain) >> 4;
                                 pterm = p + (80 * 2);          mul = mg.lr;
                                 do {          while(1) {
                                         if (vramupdate[vc] & 2) {                  if ((!(mg.liney & 1)) || (!(gdc.mode1 & 0x10))) {
                                                 renewal_line[mg.liney] |= 2;                          vc = vad;
                                                 GRPHDATASET(p, vc + VRAM_STEP);                          p = mg.vm;
                                         }                          pterm = p + (80 * 2);
                                         vc = (vc + 1) & 0x7fff;                          do {
                                         p += 2;                                  if (vramupdate[vc] & 2) {
                                 } while(p < pterm);                                          renewal_line[mg.liney] |= 2;
                         }                                          GRPHDATASET(p, vc + VRAM_STEP);
                         mg.liney++;                                  }
                         if (mg.liney >= dsync.grphymax) {                                  vc = LOW15(vc + 1);
                                 return(TRUE);                                  p += 2;
                         }                          } while(p < pterm);
                         mg.vm += 80*2;                  }
                 } while(--mul);                  mg.liney++;
                 vad = (vad + mg.pitch) & 0x7fff;                  if (mg.liney >= dsync.grphymax) {
         } while(--remain);                          return(TRUE);
                   }
                   mg.vm += 80*2;
                   remain--;
                   if (!remain) {
                           break;
                   }
                   mul--;
                   if (!mul) {
                           mul = mg.lr;
                           vad = LOW15(vad + pitch);
                   }
           }
         mkgrph->vm = mg.vm;          mkgrph->vm = mg.vm;
         mkgrph->liney = mg.liney;          mkgrph->liney = mg.liney;
         return(FALSE);          return(FALSE);
Line 219  static BOOL grphput_all0(MKGRPH mkgrph,  Line 245  static BOOL grphput_all0(MKGRPH mkgrph, 
         _MKGRPH mg;          _MKGRPH mg;
         UINT    vad;          UINT    vad;
         UINT    remain;          UINT    remain;
           UINT    pitch;
         UINT    mul;          UINT    mul;
         UINT    vc;          UINT    vc;
         UINT32  *p;          UINT32  *p;
         UINT32  *pterm;          UINT32  *pterm;
   
         mg = *mkgrph;          mg = *mkgrph;
         vad = (LOADINTELWORD(gdc.s.para + GDC_SCROLL + gpos + 0) & 0x3fff) << 1;          vad = LOADINTELWORD(gdc.s.para + GDC_SCROLL + gpos + 0);
         remain = (LOADINTELWORD(gdc.s.para + GDC_SCROLL + gpos + 2)) >> 4;          vad = LOW15(vad << 1);
         remain &= 0x3ff;          remain = LOADINTELWORD(gdc.s.para + GDC_SCROLL + gpos + 2);
         do {          pitch = gdc.s.para[GDC_PITCH];
                 mul = mg.lr;          if (!(remain & (1 << 14))) {
                 do {                  pitch <<= 1;
                         if ((!(mg.liney & 1)) || (!(gdc.mode1 & 0x10))) {          }
                                 vc = vad;          pitch &= 0xfe;
                                 p = mg.vm;          remain = LOW14(remain) >> 4;
                                 pterm = p + (80 * 2);          mul = mg.lr;
                                 do {          while(1) {
                                         GRPHDATASET(p, vc);                  if ((!(mg.liney & 1)) || (!(gdc.mode1 & 0x10))) {
                                         vc = (vc + 1) & 0x7fff;                          vc = vad;
                                         p += 2;                          p = mg.vm;
                                 } while(p < pterm);                          pterm = p + (80 * 2);
                         }                          do {
                         renewal_line[mg.liney] |= 1;                                  GRPHDATASET(p, vc);
                         mg.liney++;                                  vc = LOW15(vc + 1);
                         if (mg.liney >= dsync.grphymax) {                                  p += 2;
                                 return(TRUE);                          } while(p < pterm);
                         }                  }
                         mg.vm += 80*2;                  renewal_line[mg.liney] |= 1;
                 } while(--mul);                  mg.liney++;
                 vad = (vad + mg.pitch) & 0x7fff;                  if (mg.liney >= dsync.grphymax) {
         } while(--remain);                          return(TRUE);
                   }
                   mg.vm += 80*2;
                   remain--;
                   if (!remain) {
                           break;
                   }
                   mul--;
                   if (!mul) {
                           mul = mg.lr;
                           vad = LOW15(vad + pitch);
                   }
           }
         mkgrph->vm = mg.vm;          mkgrph->vm = mg.vm;
         mkgrph->liney = mg.liney;          mkgrph->liney = mg.liney;
         return(FALSE);          return(FALSE);
Line 260  static BOOL grphput_all1(MKGRPH mkgrph,  Line 299  static BOOL grphput_all1(MKGRPH mkgrph, 
         _MKGRPH mg;          _MKGRPH mg;
         UINT    vad;          UINT    vad;
         UINT    remain;          UINT    remain;
           UINT    pitch;
         UINT    mul;          UINT    mul;
         UINT    vc;          UINT    vc;
         UINT32  *p;          UINT32  *p;
         UINT32  *pterm;          UINT32  *pterm;
   
         mg = *mkgrph;          mg = *mkgrph;
         vad = (LOADINTELWORD(gdc.s.para + GDC_SCROLL + gpos + 0) & 0x3fff) << 1;          vad = LOADINTELWORD(gdc.s.para + GDC_SCROLL + gpos + 0);
         remain = (LOADINTELWORD(gdc.s.para + GDC_SCROLL + gpos + 2)) >> 4;          vad = LOW15(vad << 1);
         remain &= 0x3ff;          remain = LOADINTELWORD(gdc.s.para + GDC_SCROLL + gpos + 2);
         do {          pitch = gdc.s.para[GDC_PITCH];
                 mul = mg.lr;          if (!(remain & (1 << 14))) {
                 do {                  pitch <<= 1;
                         if ((!(mg.liney & 1)) || (!(gdc.mode1 & 0x10))) {          }
                                 vc = vad;          pitch &= 0xfe;
                                 p = mg.vm;          remain = LOW14(remain) >> 4;
                                 pterm = p + (80 * 2);          mul = mg.lr;
                                 do {          while(1) {
                                         GRPHDATASET(p, vc + VRAM_STEP);                  if ((!(mg.liney & 1)) || (!(gdc.mode1 & 0x10))) {
                                         vc = (vc + 1) & 0x7fff;                          vc = vad;
                                         p += 2;                          p = mg.vm;
                                 } while(p < pterm);                          pterm = p + (80 * 2);
                         }                          do {
                         renewal_line[mg.liney] |= 2;                                  GRPHDATASET(p, vc + VRAM_STEP);
                         mg.liney++;                                  vc = LOW15(vc + 1);
                         if (mg.liney >= dsync.grphymax) {                                  p += 2;
                                 return(TRUE);                          } while(p < pterm);
                         }                  }
                         mg.vm += 80*2;                  renewal_line[mg.liney] |= 2;
                 } while(--mul);                  mg.liney++;
                 vad = (vad + mg.pitch) & 0x7fff;                  if (mg.liney >= dsync.grphymax) {
         } while(--remain);                          return(TRUE);
                   }
                   mg.vm += 80*2;
                   remain--;
                   if (!remain) {
                           break;
                   }
                   mul--;
                   if (!mul) {
                           mul = mg.lr;
                           vad = LOW15(vad + pitch);
                   }
           }
         mkgrph->vm = mg.vm;          mkgrph->vm = mg.vm;
         mkgrph->liney = mg.liney;          mkgrph->liney = mg.liney;
         return(FALSE);          return(FALSE);
Line 301  void VRAMCALL makegrph(int page, int all Line 353  void VRAMCALL makegrph(int page, int all
         _MKGRPH mg;          _MKGRPH mg;
         int             i;          int             i;
   
         mg.pitch = gdc.s.para[GDC_PITCH];  //      mg.pitch = gdc.s.para[GDC_PITCH];
         if (!(gdc.clock & 0x80)) {  //      if (!(gdc.clock & 0x80)) {
                 mg.pitch <<= 1;  //              mg.pitch <<= 1;
         }  //      }
         mg.pitch &= 0xfe;  //      mg.pitch &= 0xfe;
         mg.lr = (gdc.s.para[GDC_CSRFORM] & 0x1f) + 1;          mg.lr = (gdc.s.para[GDC_CSRFORM] & 0x1f) + 1;
         mg.liney = dsync.grph_vbp;          mg.liney = dsync.grph_vbp;
   
Removed from v.1.1  
changed lines
  Added in v.1.6

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