home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / BOBOLI.ZIP / SRC / MGRAPH.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-05  |  5.3 KB  |  292 lines
  1. #include <stdio.h>
  2. #include <dpmi.h>
  3. #include <sys\movedata.h>
  4. #include <stdlib.h>
  5. #include <sys\nearptr.h>
  6. #include "mgraph.h"
  7. #include <pc.h>
  8.  
  9. scrntype screen;
  10.  
  11. void gmode(byte mode)
  12. {
  13.   __dpmi_regs regs;
  14.   regs.x.ax=mode;
  15.   __dpmi_int(0x10,®s);
  16. }
  17.  
  18. void scrcpy(scrntype src,scrntype dst)
  19. {
  20.   memcpy(dst,src,64000);  /* could be faster? */
  21. }
  22.  
  23. void near_scrcpy(scrntype src,scrntype dst)
  24. {
  25.   memcpy(dst,src,64000);  /* could be faster? */
  26. }
  27.  
  28. void initmg()
  29. {
  30.   screen=(scrntype)(0xa0000 + __djgpp_conventional_base);
  31. }
  32.  
  33. void loadpal(char *name,paltype p)
  34. {
  35.   FILE *f;
  36.   f=fopen(name,"rb");
  37.   fread(p,768,1,f);
  38.   fclose(f);
  39. }
  40.  
  41. void getpal(paltype p)
  42. {
  43.   int i;
  44.   for(i=0;i<256;i++) {
  45.     outportb(0x3C7,i);
  46.     p[i][0]=inportb(0x3C9) & 0x3F;
  47.     p[i][1]=inportb(0x3C9) & 0x3F;
  48.     p[i][2]=inportb(0x3C9) & 0x3F;
  49.   }
  50. }
  51.  
  52. void fade_in(byte r, byte g, byte b, paltype p1)
  53. {
  54.   paltype p2;
  55.   int i,j,k,l;
  56.   for(i=0;i<256;i++) {
  57.     p2[i][0]=r;
  58.     p2[i][1]=g;
  59.     p2[i][2]=b;
  60.   }
  61.   do {
  62.     k=0;
  63.     for(i=0;i<256;i++) {
  64.       j=0;
  65.       for(l=0;l<3;l++) {
  66.         if(p2[i][l]!=p1[i][l])
  67.           p2[i][l]+=(p1[i][l]>p2[i][l])-(p1[i][l]<p2[i][l]);
  68.         else j++;
  69.       }
  70.       if(j==3) k++;
  71.     }
  72.     waitretrace();
  73.     setpal(p2);
  74.   } while(k<256);
  75. }
  76.  
  77. void fade_out(byte r, byte g, byte b, paltype p1)
  78. {
  79.   paltype p2;
  80.   int i,j,k;
  81.   for(i=0;i<256;i++) {
  82.     p2[i][0]=p1[i][0];
  83.     p2[i][1]=p1[i][1];
  84.     p2[i][2]=p1[i][2];
  85.   }
  86.   do {
  87.     k=0;
  88.     for(i=0;i<256;i++) {
  89.       j=0;
  90.       if(p2[i][0]!=r)
  91.         p2[i][0]+=(r>p2[i][0])-(r<p2[i][0]);
  92.       else j++;
  93.       if(p2[i][1]!=g)
  94.         p2[i][1]+=(g>p2[i][1])-(g<p2[i][1]);
  95.       else j++;
  96.       if(p2[i][2]!=b)
  97.         p2[i][2]+=(b>p2[i][2])-(b<p2[i][2]);
  98.       else j++;
  99.       if(j==3) k++;
  100.     }
  101.     waitretrace();
  102.     setpal(p2);
  103.   } while(k<256);
  104. }
  105.  
  106. void waitretrace()
  107. {
  108.   while(inportb(0x3DA)&0x8);
  109.   while(!(inportb(0x3DA)&0x8));
  110. }
  111.  
  112. void setcol(byte c, byte r, byte g,byte b)
  113. {
  114.   outportb(0x3C8,c);
  115.   outportb(0x3C9,r);
  116.   outportb(0x3C9,g);
  117.   outportb(0x3C9,b);
  118. }
  119.  
  120. void setpal(paltype pal)
  121. {
  122.   int i;
  123.   outportb(0x3C8,0);
  124.   for(i=0;i<256;i++) {
  125.     outportb(0x3C9,pal[i][0]);
  126.     outportb(0x3C9,pal[i][1]);
  127.     outportb(0x3C9,pal[i][2]);
  128.   }
  129. }
  130.  
  131. void line(short x,short y,short x2,short y2,byte col,scrntype scrn)
  132. {
  133.   short count,slope,ypos,ydir,xpos,xdir,dx,dy;
  134.   ypos=y;
  135.   dy=y2-y;
  136.   if(dy<0) ydir=-1;
  137.   if(dy>0) ydir=1;
  138.   if(dy==0) ydir=0;
  139.   dy=abs(dy);  
  140.   xpos=x;
  141.   dx=x2-x;
  142.   if(dx<0) xdir=-1;
  143.   if(dx>0) xdir=1;
  144.   if(dx==0) xdir=0;
  145.   dx=abs(dx);
  146.   if(dx<=dy) {
  147.     slope=dx*2-dy;
  148.     for(count=0;count<=dy;count++) {
  149.       if((xpos>-1)&&(xpos<320)&&(ypos>-1)&&(ypos<200))
  150.         scrn[xpos+ypos*320]=col;
  151.       if(slope>0) {
  152.         slope+=2*(dx-dy);
  153.         xpos+=xdir;
  154.       } else slope+=2*dx;
  155.       ypos+=ydir;
  156.     }
  157.     return;
  158.   }
  159.   slope=2*dy-dx;
  160.   for(count=0;count<=dx;count++) {
  161.     if((xpos>-1)&&(xpos<320)&&(ypos>-1)&&(ypos<200))
  162.       scrn[xpos+ypos*320]=col;
  163.     if(slope>0) {
  164.       slope+=2*(dy-dx);
  165.       ypos+=ydir;
  166.     } else slope+=2*dy;
  167.     xpos+=xdir;
  168.   }
  169. }
  170.  
  171. void scale_xfer(rect s,rect d,scrntype src,scrntype dst)
  172. {
  173.   unsigned int i,j,dx,dy;
  174.   unsigned int wid,hgt;
  175.   unsigned int x,y,ty,maxy;
  176.   wid=((s.x2-s.x)<<6)/(d.x2-d.x);
  177.   hgt=((s.y2-s.y)<<6)/(d.y2-d.y);
  178.   y=s.y<<6;
  179.   dy=d.y*320;
  180.   maxy=(d.y2+1)*320;
  181.   do {
  182.     ty=(y>>6)*320;
  183.     dx=d.x;
  184.     x=s.x<<6;
  185.     do {
  186.       x+=wid;
  187.       dst[dx+dy]=src[(x>>6)+ty];
  188.       dx++;   
  189.     } while(dx<d.x2);
  190.     dy+=320;
  191.     y+=hgt;
  192.   } while(dy<maxy);
  193.  
  194. }
  195.  
  196. void clear(byte col,scrntype scrn)
  197. {
  198.   memset(scrn,col,64000);
  199. }
  200.  
  201. void xfer(short x,short y,short x2,short y2,scrntype src,scrntype dst)
  202. {
  203.   unsigned short yy,xx,w;
  204.   w=x2-x+1;
  205.   for(yy=y;yy<=y2;yy++) {
  206.     xx=x+yy*320;
  207.     memcpy(&(dst[xx]),&(src[xx]),w);
  208.   }
  209. }
  210.  
  211. byte loadPCX(char *name,paltype pal,scrntype scrn)
  212. {
  213.   FILE *f;
  214.   byte *buf;
  215.   long amt,bpos=0;
  216.   int i,j;
  217.   int pos=0;
  218.   byte v,x;
  219.   f=fopen(name,"rb");
  220.   fseek(f,-768L,SEEK_END);
  221.   amt=ftell(f)-128;
  222.   fread(pal,1,768,f);
  223.   for(i=0;i<256;i++)
  224.     for(j=0;j<3;j++) pal[i][j]=pal[i][j]>>2;
  225.   fseek(f,128,SEEK_SET);
  226.   if(!(buf=malloc(amt))) {
  227.     fclose(f);
  228.     return -1;
  229.   }  
  230.   fread(buf,1,amt,f);
  231.   fclose(f);
  232.   while(pos<64000) {
  233.     v=buf[bpos++];
  234.     if((v&0xC0)==0xC0) {
  235.       x=v&0x3F;
  236.       v=buf[bpos++];
  237.       while((x--)>0) scrn[pos++]=v;
  238.     } else scrn[pos++]=v;
  239.   }
  240.   free(buf);
  241.   return 0;
  242. }
  243.  
  244. void box(short x,short y,short x2,short y2,byte col, scrntype dst)
  245. {
  246.   unsigned short yy,xx,w;
  247.   w=x2-x+1;
  248.   for(yy=y;yy<=y2;yy++) {
  249.     xx=x+yy*320;
  250.     memset(&(dst[xx]),col,w);
  251.   }
  252. }
  253.  
  254. /* LAME ASS PRINTING CRAP WITH BIOS... */
  255.  
  256. void lame_gotoxy(byte x,byte y)
  257. {
  258.   __dpmi_regs r;
  259.   r.h.dh=y;
  260.   r.h.dl=x;
  261.   r.h.bh=0;
  262.   r.h.ah=2;
  263.   __dpmi_int(0x10,&r);
  264. }
  265.  
  266. void lame_printchar(char c, byte col)
  267. {
  268.   __dpmi_regs r;
  269.   r.h.al=c;
  270.   r.h.bl=col;
  271.   r.h.ah=14;
  272.   __dpmi_int(0x10,&r);
  273.  
  274. }
  275.  
  276. void lame_print(char *s, byte col)
  277. {
  278.   int i;
  279.   for(i=1;i<strlen(s);i++)
  280.     lame_printchar(s[i],col);
  281. }
  282.  
  283. void lame_printat(byte x,byte y, char *s, byte col)
  284. {
  285.   int i;
  286.   lame_gotoxy(x,y);
  287.   for(i=0;i<(strlen(s)-1);i++)
  288.     lame_printchar(s[i],col);
  289. }
  290.  
  291. /* END LAME ASS PRINTING CRAP WITH BIOS... */
  292.