home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 097.lha / Ic.Source / lader.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-11-21  |  4.9 KB  |  218 lines
  1. /*
  2.  
  3. InvaderCraft von J.Hertel
  4. (C) CW-Publikationen
  5.  
  6.   "lader.c"
  7.  
  8.  
  9. Kompilieren mit Aztec C Version 3.20a.
  10.  
  11. Aufruf:  cc lader -a
  12.          as lader
  13.  
  14. Linken:  siehe invadercraft.c
  15.  
  16. */
  17.  
  18. #include <libraries/dos.h>
  19. #include <graphics/gfx.h>
  20. #include <exec/memory.h>
  21.  
  22. extern struct GfxBase *GfxBase;
  23. extern long Read();
  24.  
  25. struct FileHandle *fpointer,*Open();
  26. char *AllocMem(),*buffer;
  27. char *ifferrord[4]={"ist nicht vorhanden!","ist keine IFF-Datei!",
  28. "fehlerhaft!","ist keine Grafik-Datei!"};
  29.  
  30. struct chunk {
  31.    char name[4];
  32.    ULONG len;
  33. } form,*chunk;
  34.  
  35. struct bmhd {
  36.    WORD width,height,xpos,ypos;
  37.    UBYTE planes,mask,comp,pad;
  38.    WORD trans;
  39.    BYTE xasp,yasp;
  40.    WORD pw,ph;
  41. } *bmhd;
  42.  
  43. struct cmap {
  44.    UBYTE rgb[32][3];
  45. } *cmap;
  46.  
  47. getiff(name,b,c)
  48. char *name;
  49. struct BitMap *b;
  50. UWORD c[];
  51.  
  52. /* Laden eines IFF-Bilds von Diskette
  53. name   Zeiger auf Dateiname
  54. b      Zeiger auf eine uninitialisierte Bitmap-Struktur
  55. c      Zeiger auf ein uninitialisiertes Array von UWORDs
  56. Mit dieser Funktion wird eine Bitmap mit den Ausmassen und der Grafik des
  57. IFF-Bilds, oder IFF-Pinsels, bereitgestellt. In das Array c[] werden die
  58. Farben uebertragen (Format wie in Color-Table: 0xrgb). Die Anzahl an UWORDs
  59. muss groesser oder gleich der Anzahl an Farben sein. */
  60.  
  61. {
  62.    ULONG index;
  63.    int n,i,j,k,z;
  64.    BYTE *body,*plane;
  65.    LONG yversatz=0;
  66.  
  67.    if((fpointer=Open(name,MODE_OLDFILE))==0)
  68.       iffend(name,0);
  69.    if(Read(fpointer,&form,8L)!=8L)
  70.       iffend(name,1);
  71.    if(cmp("FORM",form.name))
  72.       iffend(name,1);
  73.    if((buffer=AllocMem(form.len,MEMF_PUBLIC))==0)
  74.       iffend(name,-1);
  75.    if(Read(fpointer,buffer,form.len)!=form.len)
  76.       iffend(name,2);
  77.    index=0;
  78.    if(cmp("ILBM",buffer+index))
  79.       iffend(name,3);
  80.    index+=4; chunk=(struct chunk *)(buffer+index);
  81.    if(cmp("BMHD",chunk->name))
  82.       iffend(name,2);
  83.    index+=8; bmhd=(struct bmhd *)(buffer+index);
  84.    allocbitmap(b,(long)bmhd->planes,(long)bmhd->width,(long)bmhd->height);
  85.    index+=chunk->len; index+=index%2;
  86.    chunk=(struct chunk *)(buffer+index);
  87.    while(cmp("CMAP",chunk)) {
  88.       index+=chunk->len+8; index+=index%2;
  89.       chunk=(struct chunk *)(buffer+index);
  90.       if(index>form.len-8)
  91.          iffend(name,2);
  92.    }
  93.    index+=8; cmap=(struct cmap *)(buffer+index);
  94.    for(i=0;i<chunk->len/3;i++) {
  95.       c[i]=(UWORD)cmap->rgb[i][0]<<4|(UWORD)cmap->rgb[i][1]|
  96.        (UWORD)cmap->rgb[i][2]>>4;
  97.    }
  98.    index+=chunk->len; index+=index%2;
  99.    chunk=(struct chunk *)(buffer+index);
  100.    while(cmp("BODY",chunk)) {
  101.       index+=chunk->len+8; index+=index%2;
  102.       chunk=(struct chunk *)(buffer+index);
  103.       if(index>form.len-8)
  104.          iffend(name,2);
  105.    }
  106.    index+=8; body=buffer+index;
  107.    if(chunk->len==0)
  108.       iffend(name,2);
  109.    if(bmhd->comp) {
  110. /* Dekomprimieren */
  111.       for(i=0;i<bmhd->height;i++) {
  112.          for(j=0;j<bmhd->planes;j++) {
  113.             plane=(BYTE *)b->Planes[j]+yversatz;
  114.             z=0;
  115.             while(z<b->BytesPerRow) {
  116.                n=*body++;
  117.                if(n<0) {
  118.                   for(k=0;k<-n;k++)
  119.                      *plane++=*body;
  120.                   *plane++=*body++;
  121.                   z++;
  122.                }
  123.                else {
  124.                   for(k=0;k<n+1;k++)
  125.                      *plane++=*body++;
  126.                }
  127.                z+=k;
  128.             }
  129.          }
  130.          yversatz+=b->BytesPerRow;
  131.       }
  132.    }
  133.    else {
  134. /* Unkomprimierte Daten */
  135.       for(i=0;i<bmhd->height;i++) {
  136.          for(j=0;j<bmhd->planes;j++) {
  137.             plane=(BYTE *)b->Planes[j]+yversatz;
  138.             for(k=0;k<b->BytesPerRow;k++) {
  139.                *plane++=*body++;
  140.             }
  141.          }
  142.          yversatz+=b->BytesPerRow;
  143.       }
  144.    }
  145.    iffend(name,-2);
  146. }
  147.  
  148. cmp(s1,s2)
  149. char *s1,*s2;
  150. /* Vergleich zweier Chunk-Namen, cmp()==1, wenn ungleich */
  151. {
  152.    if(*s1!=*s2 || *(s1+1)!=*(s2+1) || *(s1+2)!=*(s2+2) || *(s1+3)!=*(s2+3))
  153.       return(1);
  154.    else
  155.       return(0);
  156. }
  157.  
  158. iffend(name,fehler)
  159. char *name;
  160. int fehler;
  161. /* Alles wieder dem System zurueckgeben und evtl. Ausdrucken einer Fehler-
  162. meldung */
  163. {
  164.    if(fpointer)
  165.       Close(fpointer);
  166.    if(buffer) {
  167.       FreeMem(buffer,form.len);
  168.       buffer=0;
  169.    }
  170.    if(fehler==-2)
  171.       return();
  172.    else if(fehler==-1)
  173.       closeall(1);
  174.    else {
  175.       printf("Datei %s %s\n",name,ifferrord[fehler]);
  176.       closeall(0);
  177.    }
  178. }
  179.  
  180. allocbitmap(b,t,w,h)
  181. struct BitMap *b;
  182. long t,w,h;
  183.  
  184. /* Bitmap initialisieren und entsprechend Speicher anfordern
  185. b     Zeiger auf uninitialisierte Bitmap-Struktur
  186. t     Tiefe (Anzahl an Bitplanes)    Anzahl Farben = 2 ^ t
  187. w     Breite
  188. h     Hoehe                   */
  189.  
  190. {
  191.    int i;
  192.  
  193.    InitBitMap(b,t,w,h);
  194.    for(i=0;i<t;i++) {
  195.       if((b->Planes[i]=(PLANEPTR)AllocMem((long)RASSIZE(w,h),
  196.        MEMF_CHIP|MEMF_CLEAR))==0)
  197.          closeall(1);
  198.    }
  199. }
  200.  
  201. freebitmap(b)
  202. struct BitMap *b;
  203.  
  204. /* Speicher fuer Bitmap freigeben, b ist Zeiger auf Bitmap-Struktur */
  205.  
  206. {
  207.    int i;
  208.  
  209.    for(i=0;i<b->Depth;i++)
  210.       if(b->Planes[i]) {
  211.          FreeMem(b->Planes[i],(long)RASSIZE(8L*b->BytesPerRow,
  212.           (long)b->Rows));
  213.          b->Planes[i]=0;
  214.       }
  215. }
  216.  
  217.  
  218.