home *** CD-ROM | disk | FTP | other *** search
/ Doom Fever / Doom_Fever-1995_Maple_Media.iso / dmutil / doom_ps.zip / WAD.C < prev    next >
C/C++ Source or Header  |  1994-03-03  |  5KB  |  227 lines
  1. /*
  2.  * Doom PostScript map generator.
  3.  * Copyright James Bonfield, 3/3/94 
  4.  */
  5.  
  6. #include <stdio.h>
  7. #include <errno.h>
  8. #include <fcntl.h>
  9. #include <unistd.h>
  10.  
  11. #include "wad.h"
  12.  
  13. #ifdef BIG_ENDIAN
  14. /*
  15.  * Big endian machines need to swap around the bytes they read in.
  16.  * These include Sun machines.
  17.  */
  18.  
  19. void swap4(int4 *i) {
  20.     int4 tmp;
  21.     ((char *)&tmp)[0] = ((char *)i)[3];
  22.     ((char *)&tmp)[1] = ((char *)i)[2];
  23.     ((char *)&tmp)[2] = ((char *)i)[1];
  24.     ((char *)&tmp)[3] = ((char *)i)[0];
  25.     *i = tmp;
  26. }
  27.  
  28. void swap2(int2 *i) {
  29.     int2 tmp;
  30.     ((char *)&tmp)[0] = ((char *)i)[1];
  31.     ((char *)&tmp)[1] = ((char *)i)[0];
  32.     *i = tmp;
  33. }
  34.  
  35. #else
  36. /*
  37.  * Little endians (eg DECstations, SGI, Alphas) have it easy - they need to
  38.  * do nothing.
  39.  */
  40. #    define swap4(a)
  41. #    define swap2(a)
  42.  
  43. #endif
  44.  
  45. struct directory *open_wad(char *file, int *fd, int *size) {
  46.     struct wad_header h;
  47.     struct directory *d;
  48.     int i;
  49.  
  50.     if (-1 == (*fd = open(file, O_RDONLY))) {
  51.     perror(file);
  52.     return (struct directory *)0;
  53.     }
  54.  
  55.     (void)read(*fd, &h, sizeof(h));
  56.     swap4(&h.magic);
  57.     swap4(&h.dir_size);
  58.     swap4(&h.dir_off);
  59.  
  60.     if (NULL == (d = (struct directory *)calloc(h.dir_size, sizeof(*d)))) {
  61.     fprintf(stderr, "Couldn't allocated %d bytes.\n",
  62.         h.dir_size * sizeof(int));
  63.     return (struct directory *)0;
  64.     }
  65.  
  66.     *size = h.dir_size;
  67.  
  68.     lseek(*fd, h.dir_off, SEEK_SET);
  69.     (void)read(*fd, d, *size * sizeof(*d));
  70.  
  71. #ifdef BIG_ENDIAN
  72.     for (i = 0; i < *size; i++) {
  73.     swap4(&d[i].start);
  74.     swap4(&d[i].length);
  75.     }
  76. #endif
  77.  
  78.     return d;
  79. }
  80.  
  81. int get_index(struct directory *d, int size, char *name, int start) {
  82.     int i;
  83.  
  84.     for (i = start; i < size; i++) {
  85.     if (strncmp(d[i].name, name, 8) == 0)
  86.         return i;
  87.     }
  88.  
  89.     return 0;
  90. }
  91.  
  92. linedef *read_linedefs(int fd, struct directory *d, int size, int start,
  93.                int *num) {
  94.     int index;
  95.     linedef *indexp;
  96.     int i;
  97.     
  98.     index = get_index(d, size, "LINEDEFS", start);
  99.     indexp = (linedef *)malloc(d[index].length);
  100.     lseek(fd, d[index].start, SEEK_SET);
  101.     read(fd, indexp, d[index].length);
  102.     *num = d[index].length / sizeof(linedef);
  103. #ifdef BIG_ENDIAN
  104.     for (i = 0; i <*num; i++) {
  105.     swap2(&indexp[i].from_vertex);
  106.     swap2(&indexp[i].to_vertex);
  107.     swap2(&indexp[i].attrib);
  108.     swap2(&indexp[i].type);
  109.     swap2(&indexp[i].trigger);
  110.     swap2(&indexp[i].sidedef1);
  111.     swap2(&indexp[i].sidedef2);
  112.     }
  113. #endif
  114.  
  115.     return indexp;
  116. }
  117.  
  118. vertex *read_vertexes(int fd, struct directory *d, int size, int start,
  119.               int *num) {
  120.     int index;
  121.     vertex *indexp;
  122.     int i;
  123.     
  124.     index = get_index(d, size, "VERTEXES", start);
  125.     indexp = (vertex *)malloc(d[index].length);
  126.     lseek(fd, d[index].start, SEEK_SET);
  127.     read(fd, indexp, d[index].length);
  128.     *num = d[index].length / sizeof(vertex);
  129. #ifdef BIG_ENDIAN
  130.     for (i = 0; i <*num; i++) {
  131.     swap2(&indexp[i].x);
  132.     swap2(&indexp[i].y);
  133.     }
  134. #endif
  135.  
  136.     return indexp;
  137. }
  138.  
  139. blockmap *read_blockmap(int fd, struct directory *d, int size, int start,
  140.            int *num) {
  141.     int index;
  142.     blockmap *indexp;
  143.     int i;
  144.  
  145.     index = get_index(d, size, "BLOCKMAP", start);
  146.     indexp = (blockmap *)malloc(d[index].length);
  147.     lseek(fd, d[index].start, SEEK_SET);
  148.     read(fd, indexp, d[index].length);
  149.     *num = d[index].length / sizeof(blockmap);
  150. #ifdef BIG_ENDIAN
  151.     for (i = 0; i <*num; i++) {
  152.     swap2(&indexp[i]);
  153.     }
  154. #endif
  155.  
  156.     return indexp;
  157. }
  158.  
  159. sidedef *read_sidedefs(int fd, struct directory *d, int size, int start,
  160.                int *num) {
  161.     int index;
  162.     sidedef *indexp;
  163.     int i;
  164.  
  165.     index = get_index(d, size, "SIDEDEFS", start);
  166.     indexp = (sidedef *)malloc(d[index].length);
  167.     lseek(fd, d[index].start, SEEK_SET);
  168.     read(fd, indexp, d[index].length);
  169.     *num = d[index].length / sizeof(sidedef);
  170. #ifdef BIG_ENDIAN
  171.     for (i = 0; i <*num; i++) {
  172.     swap2(&indexp[i].x);
  173.     swap2(&indexp[i].y);
  174.     swap2(&indexp[i].sector);
  175.     }
  176. #endif
  177.  
  178.     return indexp;
  179. }
  180.  
  181. sector *read_sectors(int fd, struct directory *d, int size, int start,
  182.             int *num) {
  183.     int index;
  184.     sector *indexp;
  185.     int i;
  186.  
  187.     index = get_index(d, size, "SECTORS", start);
  188.     indexp = (sector *)malloc(d[index].length);
  189.     lseek(fd, d[index].start, SEEK_SET);
  190.     read(fd, indexp, d[index].length);
  191.     *num = d[index].length / sizeof(sector);
  192. #ifdef BIG_ENDIAN
  193.     for (i = 0; i <*num; i++) {
  194.     swap2(&indexp[i].bot_pos);
  195.     swap2(&indexp[i].top_pos);
  196.     swap2(&indexp[i].special);
  197.     swap2(&indexp[i].trigger);
  198.     }
  199. #endif
  200.  
  201.     return indexp;
  202. }
  203.  
  204. thing *read_things(int fd, struct directory *d, int size, int start,
  205.            int *num) {
  206.     int index;
  207.     thing *indexp;
  208.     int i;
  209.  
  210.     index = get_index(d, size, "THINGS", start);
  211.     indexp = (thing *)malloc(d[index].length);
  212.     lseek(fd, d[index].start, SEEK_SET);
  213.     read(fd, indexp, d[index].length);
  214.     *num = d[index].length / sizeof(thing);
  215. #ifdef BIG_ENDIAN
  216.     for (i = 0; i <*num; i++) {
  217.     swap2(&indexp[i].x);
  218.     swap2(&indexp[i].y);
  219.     swap2(&indexp[i].angle);
  220.     swap2(&indexp[i].type);
  221.     swap2(&indexp[i].attrib);
  222.     }
  223. #endif
  224.  
  225.     return indexp;
  226. }
  227.