home *** CD-ROM | disk | FTP | other *** search
/ Encyclopedia of Graphics File Formats Companion / GFF_CD.ISO / formats / ttddd / spec / t3d_src / readtddd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-30  |  39.9 KB  |  1,428 lines
  1. /* ReadTDDD.c - read a TDDD (Three Dimension Data Decription) file
  2.  *            - written by Glenn M. Lewis - 9/4/91
  3.  */
  4.  
  5. static char rcs_id[] = "$Id: readtddd.c,v 1.30 1993/02/14 07:27:06 glewis Exp glewis $";
  6.  
  7. #include <stdio.h>
  8. #include <ctype.h>
  9. #include <math.h>
  10. #include "t3dlib.h"
  11. #ifdef __STDC__
  12. #include <stdlib.h>
  13. #include <strings.h>
  14. #include "readtddd_protos.h"
  15. #endif
  16. #define MAXLINE 132
  17. #ifndef PI
  18. #define PI (3.14159265)
  19. #endif
  20.  
  21. int verbose_flag=0;
  22.  
  23. static void process_DESC();
  24. static OBJECT *process_EXTR();
  25. static void process_INFO();
  26. static void process_OBJ();
  27. void insert_into_sorted_list();
  28.  
  29. /* Here are a few necessary utilities */
  30.  
  31. static void get_name(name, size, world)
  32. register char  *name;
  33. register int size;
  34. WORLD *world;
  35. {
  36.     while (size--) *name++ = fgetc(world->inp);
  37.     *name = '\0';
  38. }
  39.  
  40. static BYTE get_BYTE(world)
  41. WORLD *world;
  42. {
  43.     return((BYTE)fgetc(world->inp));
  44. }
  45.  
  46. static UBYTE get_UBYTE(world)
  47. WORLD *world;
  48. {
  49.     return((UBYTE)fgetc(world->inp));
  50. }
  51.  
  52. static WORD get_WORD(world)
  53. WORLD *world;
  54. {
  55.     WORD tmp = (WORD)get_UBYTE(world)<<8;
  56.     return((WORD)(tmp|get_UBYTE(world)));
  57. }
  58.  
  59. static UWORD get_UWORD(world)
  60. WORLD *world;
  61. {
  62.     UWORD tmp = (UWORD)get_UBYTE(world)<<8;
  63.     return((UWORD)(tmp|get_UBYTE(world)));
  64. }
  65.  
  66. static ULONG get_ULONG(world)
  67. WORLD *world;
  68. {
  69.     ULONG tmp = (ULONG)get_UWORD(world)<<16;
  70.     return(tmp|get_UWORD(world));
  71. }
  72.  
  73. static double get_FRACT(world)    /* This sets the precision to 10^(-3) */
  74. WORLD *world;
  75. {
  76.     register double whole, fract;
  77.  
  78.     whole =  (double)get_WORD(world);
  79.     fract = ((double)get_UWORD(world))/(double)65536.0;
  80.     return((double)(whole+fract));
  81. }
  82.  
  83. static void stuff_XYZ(st, world)
  84. XYZ_st *st;
  85. WORLD *world;
  86. {
  87.     st->x = get_FRACT(world);
  88.     st->y = get_FRACT(world);
  89.     st->z = get_FRACT(world);
  90. }
  91.  
  92. static void stuff_RGB(st, world)
  93. RGB_st *st;
  94. WORLD *world;
  95. {
  96.     get_UBYTE(world);    /* pad byte */
  97.     st->r = get_UBYTE(world);
  98.     st->g = get_UBYTE(world);
  99.     st->b = get_UBYTE(world);
  100. }
  101.  
  102. static void output_warning(world, area, name, size)
  103. WORLD *world;
  104. char *area, *name;
  105. ULONG size;
  106. {
  107.     ULONG i;
  108.     int j;
  109.     unsigned char tmpstr[20];
  110.  
  111.     fprintf(stderr, "WARNING: Unknown %ssub-chunk: '%s', size %lu...\n",
  112.         area, name, size);
  113.     for (i=0; i<size; i+=16) {
  114.         fprintf(stderr, "%04lx:", i);
  115.         for (j=0; j<16 && i+j<size; j++)
  116.             fprintf(stderr, " %02x", tmpstr[j] = (fgetc(world->inp)&0xff));
  117.         while (j++ < 16) fputs("   ", stderr);
  118.         fputs("    ", stderr);
  119.         /* Print out the ASCII equivalent */
  120.         for (j=0; j<16 && i+j<size; j++) {
  121.             tmpstr[j] &= 0x7F;   /* Strip off upper bit */
  122.             if (isprint(tmpstr[j]))
  123.                 fputc(tmpstr[j], stderr);
  124.             else fputc('.', stderr);
  125.         }
  126.         fputs("\n", stderr);
  127.     }
  128. }
  129.  
  130. /********************/
  131. /* The MAIN section */
  132. /********************/
  133.  
  134. int already_read_header = 0;
  135. unsigned char header_storage[13];
  136.  
  137. WORLD *read_World(file)
  138. FILE *file;
  139. {
  140.     int i;
  141.     for (i=0; i<4; i++) header_storage[i] = fgetc(file);
  142.     already_read_header = 4;
  143.     if (strncmp(header_storage, "FORM", 4)==0) {
  144.         while (i<12) header_storage[i++] = fgetc(file);
  145.         already_read_header = 12;
  146.         if (strncmp(&header_storage[8], "TDDD", 4)==0) return(read_TDDD(file));
  147. #if 0
  148.         if (strncmp(&header_storage[8], "LWOB", 4)==0) return(read_LWOB(file));
  149. #endif
  150.         if (strncmp(&header_storage[8], "ISTG", 4)==0) return(read_ISTG(file));
  151.         /* BAD IFF */
  152.         header_storage[12] = 0;
  153.         fprintf(stderr, "ERROR! Unknown FORM: '%s'\n", &header_storage[8]);
  154.         return(0);
  155.     } else {
  156.         return(read_TTDDD(file));
  157.     }
  158. }
  159.  
  160. WORLD *read_TDDD(file)
  161. FILE *file;
  162. {
  163.     register ULONG i, len, size;
  164.     WORLD *world;
  165.     char name[5];
  166.  
  167.     if (!file) return(0L);    /* File not open */
  168.  
  169.     if (!(world = (WORLD*)malloc(sizeof(WORLD)))) { OUT_MEM("WORLD"); }
  170.     bzero((char*)world, sizeof(WORLD));
  171.     world->inp = file;
  172.  
  173.     if (!already_read_header) {
  174.         /* Parse the IFF TDDD file */
  175.         get_name(name, 4, world);
  176.         if (strcmp(name, "FORM") != 0) {
  177.             fprintf(stderr, "ERROR: Input is not an IFF file.\n"); exit(-1); }
  178.         if (!(len = get_ULONG(world))) {
  179.             fprintf(stderr, "ERROR: Bad FORM length in IFF file.\n"); exit(-1); }
  180.         get_name(name, 4, world);
  181.         if (strcmp(name, "TDDD") != 0) {
  182.             fprintf(stderr, "ERROR: IFF file is not a TDDD file.\n"); exit(-1); }
  183.     } else {
  184.         len =    (header_storage[4]<<24) | (header_storage[5]<<16) |
  185.                 (header_storage[6]<< 8) | (header_storage[7]    );
  186.         already_read_header = 0;
  187.     }
  188.     len -= 4;
  189.  
  190. /* Here is the main loop: */
  191.     while (len>0) {
  192.         get_name(name, 4, world);
  193.         size = get_ULONG(world);
  194.         len -= 8;
  195.         if (strcmp(name, "INFO")==0) process_INFO(size, world);
  196.         else
  197.         if (strcmp(name, "OBJ ")==0) process_OBJ(size, world);
  198.         else {
  199.             if (verbose_flag) output_warning(world, "", name, size);
  200.             else {
  201.                 for (i=size; i--; ) fgetc(world->inp);    /* Skip this section */
  202.             }
  203.         }
  204.         if (size&1) { fgetc(world->inp); len--; }    /* Skip odd byte */
  205.         len -= size;
  206.     }
  207.  
  208. /* All done. */
  209.     return(world);
  210. }
  211.  
  212. static void process_INFO(len, world)
  213. register ULONG len;
  214. WORLD *world;
  215. {
  216.     register INFO *info;
  217.     register ULONG i, size;
  218.     char name[5];
  219.  
  220.     if (world->info) {
  221.         fputs("ERROR: More than one INFO chunk!\n", stderr); exit(-1); }
  222.     if (!(info = world->info = (INFO*)malloc(sizeof(INFO)))) { OUT_MEM("INFO"); }
  223.     bzero((char*)world->info, sizeof(INFO));
  224.  
  225.     if (verbose_flag>1) fprintf(stderr, "INFO chunk.\n");
  226.     while (len>0) {
  227.         get_name(name, 4, world);
  228.         size = get_ULONG(world);
  229.         len -= 8;
  230.         if (verbose_flag>1) fprintf(stderr, "%s chunk.\n", name);
  231.         if (strcmp(name, "BRSH")==0) {
  232.             i = get_UWORD(world);
  233.             if (i<0 || i>7) { i=0; fputs("BRSH error.\n", stderr); }
  234.             get_name(info->brsh[i], 80, world);
  235.         } else
  236.         if (strcmp(name, "STNC")==0) {
  237.             i = get_UWORD(world);
  238.             if (i<0 || i>7) { i=0; fputs("STNC error.\n", stderr); }
  239.             get_name(info->stnc[i], 80, world);
  240.         } else
  241.         if (strcmp(name, "TXTR")==0) {
  242.             i = get_UWORD(world);
  243.             if (i<0 || i>7) { i=0; fputs("TXTR error.\n", stderr); }
  244.             get_name(info->txtr[i], 80, world);
  245.         } else
  246.         if (strcmp(name, "OBSV")==0) {
  247.             if (!info->obsv) info->obsv=(OBSV*)malloc(sizeof(OBSV));
  248.             if (!info->obsv) { OUT_MEM("OBSV"); }
  249.             stuff_XYZ(&info->obsv->came, world);
  250.             stuff_XYZ(&info->obsv->rota, world);
  251.             info->obsv->foca = get_FRACT(world);
  252.         } else
  253.         if (strcmp(name, "OTRK")==0) {
  254.             get_name(info->otrk, 18, world);
  255.         } else
  256.         if (strcmp(name, "OSTR")==0) {
  257.             if (!info->ostr) info->ostr=(STRY*)malloc(sizeof(STRY));
  258.             if (!info->ostr) { OUT_MEM("OSTR"); }
  259.             get_name(info->ostr->path, 18, world);
  260.             stuff_XYZ(&info->ostr->tran, world);
  261.             stuff_XYZ(&info->ostr->rota, world);
  262.             stuff_XYZ(&info->ostr->scal, world);
  263.             info->ostr->info = get_UWORD(world);
  264.         } else
  265.         if (strcmp(name, "FADE")==0) {
  266.             if (!info->fade) info->fade=(FADE*)malloc(sizeof(FADE));
  267.             if (!info->fade) { OUT_MEM("FADE"); }
  268.             info->fade->at = get_FRACT(world);
  269.             info->fade->by = get_FRACT(world);
  270.             stuff_RGB(&info->fade->to, world);
  271.         } else
  272.         if (strcmp(name, "SKYC")==0) {
  273.             if (!info->skyc) info->skyc=(SKYC*)malloc(sizeof(SKYC));
  274.             if (!info->skyc) { OUT_MEM("SKYC"); }
  275.             stuff_RGB(&info->skyc->hori, world);
  276.             stuff_RGB(&info->skyc->zeni, world);
  277.         } else
  278.         if (strcmp(name, "AMBI")==0) {
  279.             if (!info->ambi) info->ambi=(RGB_st*)malloc(sizeof(RGB_st));
  280.             if (!info->ambi) { OUT_MEM("AMBI"); }
  281.             stuff_RGB(info->ambi, world);
  282.         } else
  283.         if (strcmp(name, "GLB0")==0) {
  284.             if (!info->glb0) info->glb0=(BYTE*)malloc(8*sizeof(BYTE));
  285.             if (!info->glb0) { OUT_MEM("GLB0"); }
  286.             for (i=0; i<8; i++)
  287.                 info->glb0[i] = get_UBYTE(world);
  288.         } else {
  289.             if (verbose_flag) output_warning(world, "INFO ", name, size);
  290.             else {
  291.                 for (i=size; i--; ) fgetc(world->inp);    /* Skip this section */
  292.             }
  293.         }
  294.         if (size&1) { fgetc(world->inp); len--; }    /* Skip odd byte */
  295.         len -= size;
  296.     }
  297. }
  298.  
  299. static void process_OBJ(len, world)
  300. register ULONG len;
  301. WORLD *world;
  302. {
  303.     register ULONG i, size;
  304.     register OBJECT *p;
  305.     char name[5];
  306.     int depth=0;
  307.  
  308.     if (verbose_flag>1) fprintf(stderr, "OBJ chunk.\n");
  309.     while (len>0) {
  310.         get_name(name, 4, world);
  311.         size = get_ULONG(world);
  312.         len -= 8;
  313.         if (verbose_flag>1) fprintf(stderr, "%s chunk.\n", name);
  314.         if (strcmp(name, "EXTR")==0) {
  315.             p = process_EXTR(size, create_object(), world);
  316.             if (world->curobj) {
  317.                 world->curobj->next = p;
  318.                 p->parent = world->curobj->parent;
  319.             } else {
  320.                 world->object = p;
  321.                 p->parent = 0;
  322.             }
  323.             world->curobj = p;
  324.         } else if (strcmp(name, "DESC")==0) {
  325.             p = create_object();
  326.             if (world->num_DESC > world->num_TOBJ+depth) {  /* This is a child */
  327.                 depth++;    /* Down one in the hierarchy */
  328.                 world->curobj->child = p;
  329.                 p->parent = world->curobj;
  330.             } else {
  331.                 if (world->curobj) {
  332.                     world->curobj->next = p;
  333.                     p->parent = world->curobj->parent;
  334.                 } else {
  335.                     world->object = p;
  336.                     p->parent = 0;
  337.                 }
  338.             }
  339.             world->curobj = p;
  340.             process_DESC(size, &p->desc, world);
  341.         } else if (strcmp(name, "TOBJ")==0) {
  342.             world->num_TOBJ++;
  343.             if (world->num_TOBJ > world->num_DESC) {
  344.                 fprintf(stderr, "Warning: TOBJ without DESC.  Ignored.\n");
  345.             }
  346.             if (world->num_TOBJ+depth > world->num_DESC) {  /* Up a level */
  347.                 depth--;
  348.                 world->curobj=world->curobj->parent;
  349.             }
  350.         } else {
  351.             if (verbose_flag) output_warning(world, "OBJ ", name, size);
  352.             else {
  353.                 for (i=size; i--; ) fgetc(world->inp);    /* Skip this section */
  354.             }
  355.         }
  356.         if (size&1) { fgetc(world->inp); len--; }    /* Skip odd byte */
  357.         len -= size;
  358.     }
  359. }
  360.  
  361. OBJECT *load_external_object(filename, mtrx)
  362. char *filename;
  363. MTRX *mtrx;
  364. {
  365.     WORLD *new;
  366.     FILE *newinp;
  367.     register OBJECT *p;
  368.  
  369.     /* Now, load in the external object */
  370. TRY_EXTR_AGAIN:
  371.     if (!(newinp=fopen(filename, "r"))) {
  372.         fprintf(stderr, "Can't load in EXTR object: '%s'.\n",
  373.             filename);
  374.         fprintf(stderr, "Enter filneame (or CR to abort): "); fflush(stderr);
  375.         fgets(filename, 512, stdin);
  376.         if (!filename[0] || filename[0]=='\n') return(0L);
  377.         goto TRY_EXTR_AGAIN;
  378.     }
  379.     new = read_World(newinp);
  380.     fclose(newinp);
  381.     /* scale, rotate, and translate new object hierarchy */
  382.     for (p=new->object; p; p=p->next)
  383.         move_extr(p, mtrx);
  384.  
  385.     p = new->object;
  386.     free((char*)new);
  387.     return(p);
  388. }
  389.  
  390. static OBJECT *process_EXTR(len, obj, world)
  391. register ULONG len;
  392. OBJECT *obj;
  393. WORLD *world;
  394. {
  395.     register ULONG i, size;
  396.     register EXTR *extr;
  397.     char name[5];
  398.     MTRX *mtrx;
  399.  
  400.     if (!(extr = obj->extr = (EXTR*)malloc(sizeof(EXTR))))
  401.         { OUT_MEM("EXTR"); }
  402.     bzero((char*)extr, sizeof(EXTR));
  403.     mtrx = &extr->mtrx;
  404.     /* Initialize structure */
  405.     mtrx->tran.x  = mtrx->tran.y  = mtrx->tran.z  = 0.0;
  406.     mtrx->scal.x  = mtrx->scal.y  = mtrx->scal.z  = 1.0;
  407.     mtrx->rota1.y = mtrx->rota1.z = 0.0;
  408.     mtrx->rota2.x = mtrx->rota2.z = 0.0;
  409.     mtrx->rota3.x = mtrx->rota3.y = 0.0;
  410.     mtrx->rota1.x = mtrx->rota2.y = mtrx->rota3.z = 1.0;
  411.  
  412.     if (verbose_flag>1) fprintf(stderr, "EXTR chunk.\n");
  413.     while (len>0) {
  414.         get_name(name, 4, world);
  415.         size = get_ULONG(world);
  416.         len -= 8;
  417.         if (verbose_flag>1) fprintf(stderr, "%s chunk.\n", name);
  418.         if (strcmp(name, "MTRX")==0) {
  419.             stuff_XYZ(&mtrx->tran, world);
  420.             stuff_XYZ(&mtrx->scal, world);
  421.             stuff_XYZ(&mtrx->rota1, world);
  422.             stuff_XYZ(&mtrx->rota2, world);
  423.             stuff_XYZ(&mtrx->rota3, world);
  424.         } else
  425.         if (strcmp(name, "LOAD")==0) {
  426.             get_name(extr->filename, 80, world);
  427.         } else {
  428.             if (verbose_flag) output_warning(world, "EXTR ", name, size);
  429.             else {
  430.                 for (i=size; i--; ) fgetc(world->inp);    /* Skip this section */
  431.             }
  432.         }
  433.         if (size&1) { fgetc(world->inp); len--; }    /* Skip odd byte */
  434.         len -= size;
  435.     }
  436.  
  437.     /* Free up unused memory */
  438.     free((char*)obj->extr);
  439.     free((char*)obj);
  440.  
  441.     obj = load_external_object(extr->filename, mtrx);
  442.     return(obj);
  443. }
  444.  
  445. static UBYTE defclst[3], defrlst[3], deftlst[3], defspc1[3];
  446.  
  447. static void malloc_arrays(i, desc)
  448. register int i;
  449. register DESC *desc;
  450. {
  451.     if (!desc->fcount) {
  452.         desc->fcount = i;
  453. if (!(desc->face=(UWORD*)malloc(3*desc->fcount*sizeof(UWORD))))OUT_MEM((char*)0);
  454. if (!(desc->clst=(UBYTE*)malloc(3*desc->fcount*sizeof(UBYTE))))OUT_MEM((char*)0);
  455. if (!(desc->rlst=(UBYTE*)malloc(3*desc->fcount*sizeof(UBYTE))))OUT_MEM((char*)0);
  456. if (!(desc->tlst=(UBYTE*)malloc(3*desc->fcount*sizeof(UBYTE))))OUT_MEM((char*)0);
  457.         /* Initialize arrays */
  458.         for (i=0; i<3*desc->fcount; i+=3) {
  459.             desc->face[i]   = desc->face[i+1] = desc->face[i+2] = 0;
  460.             desc->clst[i]   = defclst[0];
  461.             desc->clst[i+1] = defclst[1];
  462.             desc->clst[i+2] = defclst[2];
  463.             desc->rlst[i]   = defrlst[0];
  464.             desc->rlst[i+1] = defrlst[1];
  465.             desc->rlst[i+2] = defrlst[2];
  466.             desc->tlst[i]   = deftlst[0];
  467.             desc->tlst[i+1] = deftlst[1];
  468.             desc->tlst[i+2] = deftlst[2];
  469.         }
  470.     } else if (i != desc->fcount) {
  471.         fprintf(stderr, "ERROR: FACE and [C|R|T]LST 'Count' values inconsistant.\n");
  472.         OUT_MEM((char*)0);
  473.     }
  474. }
  475.  
  476. static void process_DESC(len, orig, world)
  477. register ULONG len;
  478. DESC **orig;
  479. WORLD *world;
  480. {
  481.     register ULONG size;
  482.     register DESC *desc;
  483.     register int i, j;
  484.     FGRP *fgrp;
  485.     char name[5];
  486.     ULONG ccsize;
  487.  
  488.     if (!(desc = *orig = (DESC*)malloc(sizeof(DESC))))
  489.         { OUT_MEM("DESC"); }
  490.     bzero((char*)desc, sizeof(DESC));
  491.  
  492.     /* Set up defaults: */
  493.     defclst[0] = defclst[1] = defclst[2] = 240; /* TS default */
  494.     defrlst[0] = defrlst[1] = defrlst[2] = 0;
  495.     deftlst[0] = deftlst[1] = deftlst[2] = 0;
  496.     defspc1[0] = defspc1[1] = defspc1[2] = 0;
  497.  
  498.     world->num_DESC++;
  499.  
  500.     if (verbose_flag>1) fprintf(stderr, "DESC chunk.\n");
  501.     while (len>0) {
  502.         get_name(name, 4, world);
  503.         size = get_ULONG(world);
  504.         len -= 8;
  505.         if (verbose_flag>1) fprintf(stderr, "%s chunk.\n", name);
  506.         if (strcmp(name, "NAME")==0) {
  507.             get_name(desc->name, 18, world);
  508.         } else
  509.         if (strcmp(name, "SHAP")==0) {
  510.             if (!desc->shap) {
  511.                 if (!(desc->shap=(WORD*)malloc(2*sizeof(WORD))))
  512.                     { OUT_MEM("SHAP"); }
  513.                 desc->shap[0] = 2;  /* TS defaults */
  514.                 desc->shap[1] = 0;
  515.             }
  516.             desc->shap[0] = get_UWORD(world);
  517.             desc->shap[1] = get_UWORD(world);
  518.         } else
  519.         if (strcmp(name, "POSI")==0) {
  520.             if (!desc->posi) {
  521.                 if (!(desc->posi=(XYZ_st*)malloc(sizeof(XYZ_st))))
  522.                     { OUT_MEM("POSI"); }
  523.             }
  524.             stuff_XYZ(desc->posi, world);
  525.         } else
  526.         if (strcmp(name, "AXIS")==0) {
  527.             if (!desc->axis) {
  528.                 if (!(desc->axis=(AXIS*)malloc(sizeof(AXIS))))
  529.                     { OUT_MEM("AXIS"); }
  530.                 bzero((char*)desc->axis, sizeof(AXIS));
  531.                 desc->axis->xaxi.x = 1;
  532.                 desc->axis->yaxi.y = 1;
  533.                 desc->axis->zaxi.z = 1;
  534.             }
  535.             stuff_XYZ(&desc->axis->xaxi, world);
  536.             stuff_XYZ(&desc->axis->yaxi, world);
  537.             stuff_XYZ(&desc->axis->zaxi, world);
  538.         } else
  539.         if (strcmp(name, "SIZE")==0) {
  540.             if (!desc->size) {
  541.                 if (!(desc->size=(XYZ_st*)malloc(sizeof(XYZ_st))))
  542.                     { OUT_MEM("SIZE"); }
  543.             }
  544.             stuff_XYZ(desc->size, world);
  545.         } else
  546.         if (strcmp(name, "PNTS")==0) {
  547.             i = desc->pcount = get_UWORD(world);    /* Number of points */
  548.             if (!(desc->pnts = (XYZ_st*)malloc(desc->pcount*sizeof(XYZ_st))))
  549.                 OUT_MEM("PNTS");
  550.             for (j=0; j<i; j++)
  551.                 { stuff_XYZ(&desc->pnts[j], world); }
  552.         } else
  553.         if (strcmp(name, "EDGE")==0) {
  554.             i = desc->ecount = get_UWORD(world);    /* Number of edges */
  555.             if (!(desc->edge = (UWORD*)malloc(2*desc->ecount*sizeof(UWORD))))
  556.                 OUT_MEM("EDGE");
  557.             for (j=0; j<2*i; j++)
  558.                 { desc->edge[j] = get_UWORD(world); }
  559.         } else
  560.         if (strcmp(name, "EFLG")==0) {        /* An undocumented chunk */
  561.             if (!(desc->eflg = (EFLG*)malloc(sizeof(EFLG))))
  562.                 OUT_MEM("EFLG");
  563.             i = desc->eflg->num = get_UWORD(world);    /* Number of edge flags */
  564.             if (!(desc->eflg->eflg=(UBYTE*)malloc(desc->eflg->num*sizeof(UBYTE))))
  565.                 OUT_MEM("EFLG");
  566.             for (j=0; j<i; j++)
  567.                 { desc->eflg->eflg[j] = get_UBYTE(world); }
  568.         } else
  569.         if (strcmp(name, "FACE")==0) {
  570.             i = get_UWORD(world);                /* Number of faces */
  571.             malloc_arrays(i, desc);
  572.             for (j=0; j<i; j++) {
  573.                 desc->face[3*j]   = get_UWORD(world);
  574.                 desc->face[3*j+1] = get_UWORD(world);
  575.                 desc->face[3*j+2] = get_UWORD(world);
  576.             }
  577.         } else
  578.         if (strcmp(name, "TXT2")==0) {
  579.             for (i=0; i<4 && desc->txt2[i]; i++) ;
  580.             if (i==4) {        /* ERROR! */
  581.                 fprintf(stderr, "WARNING! More than 4 TXT2 chunks!\n");
  582.                 i--;
  583.             }
  584.             if (!(desc->txt2[i] = (TXT2*)malloc(sizeof(TXT2)))) OUT_MEM("TXT2");
  585.             desc->txt2[i]->Flags = get_UWORD(world);
  586.             ccsize = 2;
  587.             stuff_XYZ(&desc->txt2[i]->TAxis.tran, world);
  588.             stuff_XYZ(&desc->txt2[i]->TAxis.rota1, world);
  589.             stuff_XYZ(&desc->txt2[i]->TAxis.rota2, world);
  590.             stuff_XYZ(&desc->txt2[i]->TAxis.rota3, world);
  591.             stuff_XYZ(&desc->txt2[i]->TAxis.scal, world);
  592.             ccsize = ccsize + 60;
  593.             for (j = 0; j < 16; j++) desc->txt2[i]->Params[j] = get_FRACT(world);
  594.             ccsize = ccsize + 64;
  595.             for (j = 0; j < 16; j++) desc->txt2[i]->PFlags[j] = get_UBYTE(world);
  596.             ccsize = ccsize + 16;
  597.             ccsize = ccsize + 17;
  598.             get_name(desc->txt2[i]->SubName, 17, world);
  599.             j = get_UWORD(world);
  600.             ccsize = ccsize + 2 + j;
  601.             desc->txt2[i]->Length = j;
  602.             get_name(desc->txt2[i]->Name, j, world);
  603.             for (j=ccsize; j < size; j++) get_UBYTE(world);
  604.         } else
  605. #if 0
  606.         if (strcmp(name, "FOR2")==0) {        /* Another undocumented chunk */
  607.             newsize = size;
  608.             i = get_UWORD(world);    /* NumC */
  609.             newsize -= 2;
  610.             NumC = i;
  611.             fprintf(stderr, "Encountered 'FOR2' chunk...size=%lu\n  NumC=%u\n", size, i);
  612.             i = get_UWORD(world);    /* NumF */
  613.             newsize -= 2;
  614.             NumF = i;
  615.             fprintf(stderr, "  NumF=%u\n", i);
  616.             i = get_UWORD(world);    /* Flags */
  617.             newsize -= 2;
  618.             fprintf(stderr, "  Flags=%u\n", i);
  619.             i = get_UWORD(world);    /* pad */
  620.             newsize -= 2;
  621.             fprintf(stderr, "  pad=%u\n", i);
  622.             for (j=0; j<9; j++) fprintf(stderr, "  MTRX[%d]=%.12g\n", j, get_FRACT(world));
  623.             newsize -= 36;
  624.             fprintf(stderr, "  ShiftX=%.12g ", get_FRACT(world));
  625.             fprintf(stderr, "ShiftY=%.12g ", get_FRACT(world));
  626.             fprintf(stderr, "ShiftZ=%.12g\n", get_FRACT(world));
  627.             newsize -= 12;
  628.             for (j=0; j<NumC+4*NumF; j++) {
  629.                 fprintf(stderr, "  Point[%d]: X=%.12g ", j, get_FRACT(world));
  630.                 fprintf(stderr, "Y=%.12g ", get_FRACT(world));
  631.                 fprintf(stderr, "Z=%.12g\n", get_FRACT(world));
  632.                 newsize -= 12;
  633.             }
  634.             output_warning(world, "DESC ", "FOR2", newsize);
  635.         } else
  636. #endif
  637.         if (strcmp(name, "FGRP")==0) {        /* Another undocumented chunk */
  638.             if (!(fgrp = (FGRP*)malloc(sizeof(FGRP))))
  639.                 OUT_MEM("FGRP");
  640.             i = fgrp->num = get_UWORD(world);    /* Number of faces in group */
  641.             if (!(fgrp->face = (UWORD*)malloc(i*sizeof(UWORD))))
  642.                 OUT_MEM("FGRP");
  643.             get_name(fgrp->name, 18, world);
  644.             for (j=0; j<i; j++)
  645.                 fgrp->face[j] = get_UWORD(world);
  646.             /* Link this new FGRP into list */
  647.             fgrp->next = desc->fgrp;
  648.             desc->fgrp = fgrp;
  649.         } else
  650.         if (strcmp(name, "COLR")==0) {
  651.             if (!desc->colr) {
  652.                 if (!(desc->colr = (RGB_st*)malloc(sizeof(RGB_st))))
  653.                     { OUT_MEM("COLR"); }
  654.             }
  655.             stuff_RGB((RGB_st*)&defclst[0], world);
  656.             desc->colr->r = defclst[0];
  657.             desc->colr->g = defclst[1];
  658.             desc->colr->b = defclst[2];
  659.         } else
  660.         if (strcmp(name, "REFL")==0) {
  661.             if (!desc->refl) {
  662.                 if (!(desc->refl = (RGB_st*)malloc(sizeof(RGB_st))))
  663.                     { OUT_MEM("REFL"); }
  664.             }
  665.             stuff_RGB((RGB_st*)&defrlst[0], world);
  666.             desc->refl->r = defrlst[0];
  667.             desc->refl->g = defrlst[1];
  668.             desc->refl->b = defrlst[2];
  669.         } else
  670.         if (strcmp(name, "TRAN")==0) {
  671.             if (!desc->tran) {
  672.                 if (!(desc->tran = (RGB_st*)malloc(sizeof(RGB_st))))
  673.                     { OUT_MEM("TRAN"); }
  674.             }
  675.             stuff_RGB((RGB_st*)&deftlst[0], world);
  676.             desc->tran->r = deftlst[0];
  677.             desc->tran->g = deftlst[1];
  678.             desc->tran->b = deftlst[2];
  679.         } else
  680.         if (strcmp(name, "SPC1")==0) {
  681.             if (!desc->spc1) {
  682.                 if (!(desc->spc1 = (RGB_st*)malloc(sizeof(RGB_st))))
  683.                     { OUT_MEM("SPC1"); }
  684.             }
  685.             stuff_RGB((RGB_st*)&defspc1[0], world);
  686.             desc->spc1->r = defspc1[0];
  687.             desc->spc1->g = defspc1[1];
  688.             desc->spc1->b = defspc1[2];
  689.         } else
  690.         if (strcmp(name, "CLST")==0) {
  691.             i = get_UWORD(world);        /* Number of faces */
  692.             malloc_arrays(i, desc);
  693.             for (j=0; j<i; j++) {
  694.                 desc->clst[3*j+0] = get_UBYTE(world);
  695.                 desc->clst[3*j+1] = get_UBYTE(world);
  696.                 desc->clst[3*j+2] = get_UBYTE(world);
  697.             }
  698.         } else
  699.         if (strcmp(name, "RLST")==0) {
  700.             i = get_UWORD(world);        /* Number of faces */
  701.             malloc_arrays(i, desc);
  702.             for (j=0; j<i; j++) {
  703.                 desc->rlst[3*j+0] = get_UBYTE(world);
  704.                 desc->rlst[3*j+1] = get_UBYTE(world);
  705.                 desc->rlst[3*j+2] = get_UBYTE(world);
  706.             }
  707.         } else
  708.         if (strcmp(name, "TLST")==0) {
  709.             i = get_UWORD(world);        /* Number of faces */
  710.             malloc_arrays(i, desc);
  711.             for (j=0; j<i; j++) {
  712.                 desc->tlst[3*j+0] = get_UBYTE(world);
  713.                 desc->tlst[3*j+1] = get_UBYTE(world);
  714.                 desc->tlst[3*j+2] = get_UBYTE(world);
  715.             }
  716.         } else
  717.         if (strcmp(name, "TPAR")==0) {
  718.             if (!desc->tpar) {
  719.                 if (!(desc->tpar=(double*)malloc(16*sizeof(double))))
  720.                     { OUT_MEM("TPAR"); }
  721.                 bzero((char*)desc->tpar, 16*sizeof(double));
  722.             }
  723.             for (i=0; i<16; i++)
  724.                 desc->tpar[i] = get_FRACT(world);
  725.         } else
  726.         if (strcmp(name, "SURF")==0) {
  727.             if (!desc->surf) {
  728.                 if (!(desc->surf=(UBYTE*)malloc(5*sizeof(UBYTE))))
  729.                     { OUT_MEM("SURF"); }
  730.                 bzero((char*)desc->surf, 5*sizeof(UBYTE));
  731.             }
  732.             for (i=0; i<5; i++)
  733.                 desc->surf[i] = get_BYTE(world);
  734.         } else
  735.         if (strcmp(name, "MTTR")==0) {
  736.             if (!desc->mttr) {
  737.                 if (!(desc->mttr=(MTTR*)malloc(sizeof(MTTR))))
  738.                     { OUT_MEM("MTTR"); }
  739.                 bzero((char*)desc->mttr, sizeof(MTTR));
  740.             }
  741.             desc->mttr->type = get_UBYTE(world);
  742.             desc->mttr->indx = (get_UBYTE(world)/100.0)+1.0;
  743.         } else
  744.         if (strcmp(name, "SPEC")==0) {
  745.             if (!desc->spec) {
  746.                 if (!(desc->spec=(UBYTE*)malloc(2*sizeof(UBYTE))))
  747.                     { OUT_MEM("SPEC"); }
  748.                 bzero((char*)desc->spec, 2*sizeof(UBYTE));
  749.             }
  750.             desc->spec[0] = get_UBYTE(world);
  751.             desc->spec[1] = get_UBYTE(world);
  752.         } else
  753.         if (strcmp(name, "PRP0")==0) {
  754.             if (!desc->prp0) {
  755.                 if (!(desc->prp0=(UBYTE*)malloc(6*sizeof(UBYTE))))
  756.                     { OUT_MEM("PRP0"); }
  757.                 bzero((char*)desc->prp0, 6*sizeof(UBYTE));
  758.             }
  759.             for (i=0; i<6; i++)
  760.                 desc->prp0[i] = get_UBYTE(world);
  761.         } else
  762.         if (strcmp(name, "PRP1")==0) {
  763.             if (!desc->prp1) {
  764.                 if (!(desc->prp1=(UBYTE*)malloc(8*sizeof(UBYTE))))
  765.                     { OUT_MEM("PRP1"); }
  766.                 bzero((char*)desc->prp1, 8*sizeof(UBYTE));
  767.             }
  768.             for (i=0; i<8; i++)
  769.                 desc->prp1[i] = get_UBYTE(world);
  770.         } else
  771.         if (strcmp(name, "INTS")==0) {
  772.             if (!desc->ints) {
  773.                 if (!(desc->ints=(double*)malloc(sizeof(double))))
  774.                     { OUT_MEM("INTS"); }
  775.             }
  776.             *desc->ints = get_FRACT(world);
  777.         } else
  778.         if (strcmp(name, "INT1")==0) {
  779.             if (!desc->int1) desc->int1=(XYZ_st*)malloc(sizeof(XYZ_st));
  780.             if (!desc->int1) { OUT_MEM("INT1"); }
  781.             stuff_XYZ(desc->int1, world);
  782.         } else
  783.         if (strcmp(name, "STRY")==0) {
  784.             get_name(desc->stry->path, 18, world);
  785.             stuff_XYZ(&desc->stry->tran, world);
  786.             stuff_XYZ(&desc->stry->rota, world);
  787.             stuff_XYZ(&desc->stry->scal, world);
  788.             desc->stry->info = get_UWORD(world);
  789.         } else {
  790.             if (verbose_flag) output_warning(world, "DESC ", name, size);
  791.             else {
  792.                 for (i=size; i--; ) fgetc(world->inp);    /* Skip this section */
  793.             }
  794.         }
  795.         if (size&1) { fgetc(world->inp); len--; }    /* Skip odd byte */
  796.         len -= size;
  797.     }
  798. }
  799.  
  800. /* readistg.c - read an Imagine Stage file
  801.  *            - written by Glenn M. Lewis - 8/11/92
  802.  */
  803.  
  804. static void process_OSIZ();
  805. static void process_POSN();
  806. static void process_ALGN();
  807. static void process_PALN();
  808. static void process_TALN();
  809. static void process_PTH2();
  810. static void process_GLB2();
  811. static void process_AXIS();
  812. static void process_LITE();
  813. static void process_FILE();
  814. static void process_SOBJ();
  815.  
  816. WORLD *read_ISTG(file)
  817. FILE *file;
  818. {
  819.     register ULONG i, len, size;
  820.     WORLD *world;
  821.     char name[5];
  822.  
  823.     if (!file) return(0L);    /* File not open */
  824.  
  825.     if (!(world = (WORLD*)malloc(sizeof(WORLD)))) { OUT_MEM("WORLD"); }
  826.     bzero((char*)world, sizeof(WORLD));
  827.     world->inp = file;
  828.  
  829.     if (!already_read_header) {
  830.         /* Parse the IFF ISTG file */
  831.         get_name(name, 4, world);
  832.         if (strcmp(name, "FORM") != 0) {
  833.             fprintf(stderr, "ERROR: Input is not an IFF file.\n"); exit(-1); }
  834.         if (!(len = get_ULONG(world))) {
  835.             fprintf(stderr, "ERROR: Bad FORM length in IFF file.\n"); exit(-1); }
  836.         get_name(name, 4, world);
  837.         if (strcmp(name, "ISTG") != 0) {
  838.             fprintf(stderr, "ERROR: IFF file is not a ISTG file.\n"); exit(-1); }
  839.     } else {
  840.         len =    (header_storage[4]<<24) | (header_storage[5]<<16) |
  841.                 (header_storage[6]<< 8) | (header_storage[7]    );
  842.         already_read_header = 0;
  843.     }
  844.     len -= 4;
  845.  
  846.     /* Allocate the ISTG structure */
  847.     if (!(world->istg = (ISTG*)malloc(sizeof(ISTG)))) { OUT_MEM("ISTG"); }
  848.     bzero((char*)world->istg, sizeof(ISTG));
  849.  
  850. /* Here is the main loop: */
  851.     while (len>0) {
  852.         get_name(name, 4, world);
  853.         size = get_ULONG(world);
  854.         len -= 8;
  855.         if (strcmp(name, "MAXF")==0) world->istg->maxf = get_UWORD(world);
  856.         else
  857.         if (strcmp(name, "SOBJ")==0) process_SOBJ(size, world);
  858.         else {
  859.             if (verbose_flag) output_warning(world, "ISTG ", name, size);
  860.             else {
  861.                 for (i=size; i--; ) fgetc(world->inp);    /* Skip this section */
  862.             }
  863.         }
  864.         if (size&1) { fgetc(world->inp); len--; }    /* Skip odd byte */
  865.         len -= size;
  866.     }
  867.  
  868. /* All done. */
  869.     return(world);
  870. }
  871.  
  872. SOBJ *add_SOBJ(istg)    /* to tail of ISTG's SOBJ list */
  873. ISTG *istg;
  874. {
  875.     SOBJ *new;
  876.  
  877.     if (!(new = (SOBJ*)malloc(sizeof(SOBJ)))) OUT_MEM("SOBJ");
  878.     bzero((char*)new, sizeof(SOBJ));
  879.  
  880.     if (!istg->head) {
  881.         istg->head = istg->tail = new;
  882.         return(new);
  883.     }
  884.     /* Add this SOBJ to the tail */
  885.     new->prev = istg->tail;
  886.     istg->tail->next = new;
  887.     istg->tail = new;
  888.     return(new);
  889. }
  890.  
  891. static void process_SOBJ(len, world)
  892. register ULONG len;
  893. WORLD *world;
  894. {
  895.     register ULONG i, size;
  896.     char name[5];
  897.     SOBJ *sobj;
  898.  
  899.     if (verbose_flag>1) fprintf(stderr, "SOBJ chunk.\n");
  900.     /* Add another SOBJ to the current ISTG list */
  901.     sobj = add_SOBJ(world->istg);
  902.     while (len>0) {
  903.         get_name(name, 4, world);
  904.         size = get_ULONG(world);
  905.         len -= 8;
  906.         if (verbose_flag>1) fprintf(stderr, "%s chunk.\n", name);
  907.         if (strcmp(name, "NAME")==0) { get_name(sobj->name, (int)size, world);
  908.         } else if (strcmp(name, "STGF")==0) { sobj->stgf = get_UWORD(world);
  909.         } else if (strcmp(name, "OSIZ")==0) { process_OSIZ(size, sobj, world);
  910.         } else if (strcmp(name, "POSN")==0) { process_POSN(size, sobj, world);
  911.         } else if (strcmp(name, "ALGN")==0) { process_ALGN(size, sobj, world);
  912.         } else if (strcmp(name, "PALN")==0) { process_PALN(size, sobj, world);
  913.         } else if (strcmp(name, "TALN")==0) { process_TALN(size, sobj, world);
  914.         } else if (strcmp(name, "PTH2")==0) { process_PTH2(size, sobj, world);
  915.         } else if (strcmp(name, "GLB2")==0) { process_GLB2(size, sobj, world);
  916.         } else if (strcmp(name, "AXIS")==0) { process_AXIS(size, sobj, world);
  917.         } else if (strcmp(name, "LITE")==0) { process_LITE(size, sobj, world);
  918.         } else if (strcmp(name, "FILE")==0) { process_FILE(size, sobj, world);
  919.         } else {
  920.             if (verbose_flag) output_warning(world, "SOBJ ", name, size);
  921.             else {
  922.                 for (i=size; i--; ) fgetc(world->inp);    /* Skip this section */
  923.             }
  924.         }
  925.         if (size&1) { fgetc(world->inp); len--; }    /* Skip odd byte */
  926.         len -= size;
  927.     }
  928. }
  929.  
  930. static void process_OSIZ(size, sobj, world)
  931. ULONG size;
  932. SOBJ *sobj;
  933. WORLD *world;
  934. {
  935.     register OSIZ *osiz;
  936.  
  937.     if (!(osiz = (OSIZ*)malloc(sizeof(OSIZ)))) OUT_MEM("OSIZ");
  938.     osiz->flags = get_UWORD(world);
  939.     osiz->start = get_UWORD(world);
  940.     osiz->stop  = get_UWORD(world);
  941.     stuff_XYZ(&osiz->size, world);
  942.     insert_into_sorted_list((PALN**)&sobj->osiz, (PALN*)osiz);
  943. }
  944.  
  945. static void process_POSN(size, sobj, world)
  946. ULONG size;
  947. SOBJ *sobj;
  948. WORLD *world;
  949. {
  950.     register POSN *posn;
  951.  
  952.     if (!(posn = (POSN*)malloc(sizeof(POSN)))) OUT_MEM("POSN");
  953.     posn->flags = get_UWORD(world);
  954.     posn->start = get_UWORD(world);
  955.     posn->stop  = get_UWORD(world);
  956.     stuff_XYZ(&posn->posn, world);
  957.     insert_into_sorted_list((PALN**)&sobj->posn, (PALN*)posn);
  958. }
  959.  
  960. static void process_ALGN(size, sobj, world)
  961. ULONG size;
  962. SOBJ *sobj;
  963. WORLD *world;
  964. {
  965.     register ALGN *algn;
  966.  
  967.     if (!(algn = (ALGN*)malloc(sizeof(ALGN)))) OUT_MEM("ALGN");
  968.     algn->flags = get_UWORD(world);
  969.     algn->start = get_UWORD(world);
  970.     algn->stop  = get_UWORD(world);
  971.     stuff_XYZ(&algn->algn, world);
  972.     insert_into_sorted_list((PALN**)&sobj->algn, (PALN*)algn);
  973. }
  974.  
  975. static void process_PALN(size, sobj, world)
  976. ULONG size;
  977. SOBJ *sobj;
  978. WORLD *world;
  979. {
  980.     register PALN *paln;
  981.  
  982.     if (!(paln = (PALN*)malloc(sizeof(PALN)))) OUT_MEM("PALN");
  983.     paln->flags = get_UWORD(world);
  984.     paln->start = get_UWORD(world);
  985.     paln->stop  = get_UWORD(world);
  986.     insert_into_sorted_list(&sobj->paln, paln);
  987. }
  988.  
  989. static void process_TALN(size, sobj, world)
  990. ULONG size;
  991. SOBJ *sobj;
  992. WORLD *world;
  993. {
  994.     register TALN *taln;
  995.  
  996.     if (!(taln = (TALN*)malloc(sizeof(TALN)))) OUT_MEM("TALN");
  997.     bzero((char*)taln, sizeof(TALN));
  998.     taln->flags = get_UWORD(world);
  999.     taln->start = get_UWORD(world);
  1000.     taln->stop  = get_UWORD(world);
  1001.     taln->initial_y = get_FRACT(world);
  1002.     taln->final_y   = get_FRACT(world);
  1003.     size -= 15L;
  1004.     /* BCPL string... byte followed by string, followed by zero */
  1005.     get_UBYTE(world);
  1006.     if (size)
  1007.         get_name(taln->trackobj, (int)size, world);
  1008.     insert_into_sorted_list((PALN**)&sobj->taln, (PALN*)taln);
  1009. }
  1010.  
  1011. static void process_PTH2(size, sobj, world)
  1012. ULONG size;
  1013. SOBJ *sobj;
  1014. WORLD *world;
  1015. {
  1016.     register PTH2 *pth2;
  1017.  
  1018.     if (!(pth2 = (PTH2*)malloc(sizeof(PTH2)))) OUT_MEM("PTH2");
  1019.     bzero((char*)pth2, sizeof(PTH2));
  1020.     pth2->flags = get_UWORD(world);
  1021.     pth2->start = get_UWORD(world);
  1022.     pth2->stop  = get_UWORD(world);
  1023.     pth2->acceleration_frames = get_ULONG(world);
  1024.     pth2->start_speed = get_FRACT(world);
  1025.     pth2->deacceleration_frames = get_ULONG(world);
  1026.     pth2->end_speed = get_FRACT(world);
  1027.     size -= 23L;
  1028.     /* BCPL string... byte followed by string, followed by zero */
  1029.     get_UBYTE(world);
  1030.     if (size)
  1031.         get_name(pth2->path, (int)size, world);
  1032.     insert_into_sorted_list((PALN**)&sobj->pth2, (PALN*)pth2);
  1033. }
  1034.  
  1035. static void process_GLB2(size, sobj, world)
  1036. ULONG size;
  1037. SOBJ *sobj;
  1038. WORLD *world;
  1039. {
  1040.     register GLB2 *glb2;
  1041.  
  1042.     if (!(glb2 = (GLB2*)malloc(sizeof(GLB2)))) OUT_MEM("GLB2");
  1043.     bzero((char*)glb2, sizeof(GLB2));
  1044.     glb2->flags = get_UWORD(world);
  1045.     glb2->start = get_UWORD(world);
  1046.     glb2->stop  = get_UWORD(world);
  1047.     glb2->sky_blending = get_ULONG(world);
  1048.     glb2->starfield = get_FRACT(world);
  1049.     glb2->transition = get_ULONG(world);
  1050.     /* The following are FRACTional colors */
  1051.     stuff_XYZ(&glb2->ambient, world);
  1052.     stuff_XYZ(&glb2->horizon, world);
  1053.     stuff_XYZ(&glb2->zenith1, world);
  1054.     stuff_XYZ(&glb2->zenith2, world);
  1055.     stuff_XYZ(&glb2->fog_color, world);
  1056.     glb2->fog_bottom = get_FRACT(world);
  1057.     glb2->fog_top    = get_FRACT(world);
  1058.     glb2->fog_length = get_FRACT(world);
  1059.     glb2->brush_seq  = get_ULONG(world);
  1060.     glb2->backdrop_seq = get_ULONG(world);
  1061.     get_name(glb2->backdrop, 256, world);        /* Fixed size */
  1062.     size -= 355L;
  1063.     /* BCPL string... byte followed by string, followed by zero */
  1064.     get_UBYTE(world);
  1065.     if (size)
  1066.         get_name(glb2->globalbrush, (int)size, world);    /* Var. size */
  1067.     insert_into_sorted_list((PALN**)&sobj->glb2, (PALN*)glb2);
  1068. }
  1069.  
  1070. static void process_AXIS(size, sobj, world)
  1071. ULONG size;
  1072. SOBJ *sobj;
  1073. WORLD *world;
  1074. {
  1075.     register SAXIS *axis;
  1076.  
  1077.     if (!(axis = (SAXIS*)malloc(sizeof(SAXIS)))) OUT_MEM("SAXIS");
  1078.     axis->flags = get_UWORD(world);
  1079.     axis->start = get_UWORD(world);
  1080.     axis->stop  = get_UWORD(world);
  1081.     insert_into_sorted_list((PALN**)&sobj->axis, (PALN*)axis);
  1082. }
  1083.  
  1084. static void process_LITE(size, sobj, world)
  1085. ULONG size;
  1086. SOBJ *sobj;
  1087. WORLD *world;
  1088. {
  1089.     register LITE *lite;
  1090.  
  1091.     if (!(lite = (LITE*)malloc(sizeof(LITE)))) OUT_MEM("LITE");
  1092.     lite->flags = get_UWORD(world);
  1093.     lite->start = get_UWORD(world);
  1094.     lite->stop  = get_UWORD(world);
  1095.     /* The following is a FRACTional color */
  1096.     stuff_XYZ(&lite->color, world);
  1097.     lite->transition = get_ULONG(world);
  1098.     insert_into_sorted_list((PALN**)&sobj->lite, (PALN*)lite);
  1099. }
  1100.  
  1101. static void process_FILE(size, sobj, world)
  1102. ULONG size;
  1103. SOBJ *sobj;
  1104. WORLD *world;
  1105. {
  1106.     register SFILE *file;
  1107.  
  1108.     if (!(file = (SFILE*)malloc(sizeof(SFILE)))) OUT_MEM("SFILE");
  1109.     bzero((char*)file, sizeof(SFILE));
  1110.     file->flags = get_UWORD(world);
  1111.     file->start = get_UWORD(world);
  1112.     file->stop  = get_UWORD(world);
  1113.     file->cycles_to_perform = get_FRACT(world);
  1114.     file->initial_cycle_phase = get_FRACT(world);
  1115.     file->transition = get_ULONG(world);
  1116.     size -= 19L;
  1117.     /* BCPL string... byte followed by string, followed by zero */
  1118.     get_UBYTE(world);
  1119.     if (size)
  1120.         get_name(file->object_description, (int)size, world);
  1121.     insert_into_sorted_list((PALN**)&sobj->file, (PALN*)file);
  1122. }
  1123.  
  1124. /* We use "PALN" here, even though this routine inserts all SOBJ sub-types
  1125.  * into their proper list, because all be need is "START" and "STOP"
  1126.  * information, and "PALN" is the minimal structure that provides this
  1127.  */
  1128. void insert_into_sorted_list(ppaln, paln)
  1129. PALN **ppaln, *paln;
  1130. {
  1131.     register PALN *p;
  1132.  
  1133.     if (!*ppaln) { *ppaln = paln; return; }        /* First in list */
  1134.     /* Now search through the list and insert in the proper place */
  1135.     for (p= *ppaln; p; p=p->next) {
  1136.         if (paln->start == p->start ||
  1137.             paln->start == p->stop  ||
  1138.             paln->stop  == p->start ||
  1139.             paln->stop  == p->stop) {
  1140.             fprintf(stderr, "WARNING!!! start and stop times collide! (%u-%u) vs (%u-%u)\n",
  1141.                 paln->start, paln->stop, p->start, p->stop);
  1142.         }
  1143.         if (paln->stop < p->start) {    /* Insert the item before this one */
  1144.             paln->prev = p->prev;
  1145.             paln->next = p;
  1146.             p->prev = paln;
  1147.             if (p == *ppaln) { *ppaln = paln; }    /* New head of list */
  1148.             return;
  1149.         }
  1150.         if (!p->next) {    /* Insert after this item */
  1151.             p->next = paln;
  1152.             paln->prev = p;
  1153.             return;
  1154.         }
  1155.     }
  1156.     /* Never will reach here! */
  1157. }
  1158.  
  1159. /* Find the last existing key frame that would be applicable for "frame" */
  1160. void delete_unused_frames(orig, frame)
  1161. PALN **orig;
  1162. {
  1163.     register PALN *p;
  1164.     PALN *p2;
  1165.  
  1166.     for (p= *orig; p; ) {
  1167.         if (frame>=p->start && frame<=p->stop) return;        /* It falls within this keyframe */
  1168.         if (frame>=p->stop && (!p->next || (p->next && frame<p->next->start))) return;        /* This is the one! */
  1169.         /* Otherwise, delete it */
  1170.         if (p->next) p->next->prev = p->prev;
  1171.         if (p->prev) p->prev->next = p->next;
  1172.         if (p== *orig) *orig = p->next;
  1173.         p2 = p->next;
  1174.         free(p);
  1175.         p = p2;
  1176.     }
  1177. }
  1178.  
  1179. static void mtrx_ident(mtrx)
  1180. register MTRX *mtrx;
  1181. {
  1182.     mtrx->tran.x  = mtrx->tran.y  = mtrx->tran.z  = 0.0;
  1183.     mtrx->scal.x  = mtrx->scal.y  = mtrx->scal.z  = 1.0;
  1184.     mtrx->rota1.y = mtrx->rota1.z = 0.0;
  1185.     mtrx->rota2.x = mtrx->rota2.z = 0.0;
  1186.     mtrx->rota3.x = mtrx->rota3.y = 0.0;
  1187.     mtrx->rota1.x = mtrx->rota2.y = mtrx->rota3.z = 1.0;
  1188. }
  1189.  
  1190. static void mmultiply(s, d)
  1191. register double *s;
  1192. register double *d;
  1193. {
  1194.     register int j;
  1195.     double tmp[9];
  1196.     tmp[0] = s[0]*d[0] + s[1]*d[3] + s[2]*d[6];
  1197.     tmp[1] = s[0]*d[1] + s[1]*d[4] + s[2]*d[7];
  1198.     tmp[2] = s[0]*d[2] + s[1]*d[5] + s[2]*d[8];
  1199.     tmp[3] = s[3]*d[0] + s[4]*d[3] + s[5]*d[6];
  1200.     tmp[4] = s[3]*d[1] + s[4]*d[4] + s[5]*d[7];
  1201.     tmp[5] = s[3]*d[2] + s[4]*d[5] + s[5]*d[8];
  1202.     tmp[6] = s[6]*d[0] + s[7]*d[3] + s[8]*d[6];
  1203.     tmp[7] = s[6]*d[1] + s[7]*d[4] + s[8]*d[7];
  1204.     tmp[8] = s[6]*d[2] + s[7]*d[5] + s[8]*d[8];
  1205.     for (j = 9; j--; ) d[j] = tmp[j];
  1206. }
  1207.  
  1208. /*
  1209. Matrix Inversion
  1210. by Richard Carling
  1211. from "Graphics Gems", Academic Press, 1990
  1212. tweaked heavily by Glenn M. Lewis to not require "GraphicsGems.h" and
  1213. to work only on 3x3 matrices
  1214. */
  1215.  
  1216.  
  1217. #define SMALL_NUMBER    1.e-8
  1218. #define det2x2(a,b,c,d)    ((a)*(d)-(b)*(c))
  1219. #define det3x3(a1, a2, a3, b1, b2, b3, c1, c2, c3)    \
  1220.     ((a1) * det2x2((b2), (b3), (c2), (c3))    \
  1221.     -(b1) * det2x2((a2), (a3), (c2), (c3))    \
  1222.     +(c1) * det2x2((a2), (a3), (b2), (b3)))
  1223.  
  1224. /* 
  1225.  *   inverse(original_matrix, inverse_matrix)
  1226.  * 
  1227.  *    calculate the inverse of a 3x3 matrix
  1228.  *
  1229.  *     -1     
  1230.  *     A  = ___1__ adjoint A
  1231.  *         det A
  1232.  */
  1233.  
  1234. void inverse(in, out)
  1235. register double *in, *out;
  1236. {
  1237.     int i;
  1238.     double det;
  1239.     void adjoint();
  1240.  
  1241.     /* calculate the adjoint matrix */
  1242.     adjoint(in, out);
  1243.     /*  calculate the 3x3 determinent
  1244.      *  if the determinent is zero, 
  1245.      *  then the inverse matrix is not unique.
  1246.      */
  1247.     det = det3x3(
  1248.         in[0], in[1], in[2],
  1249.         in[3], in[4], in[5],
  1250.         in[6], in[7], in[8]
  1251.     );
  1252.     if (fabs(det) < SMALL_NUMBER) return;    /* non-singular matrix */
  1253.     /* scale the adjoint matrix to get the inverse */
  1254.     det = 1.0/det;
  1255.     for (i=0; i<9; i++) out[i] *= det;
  1256. }
  1257.  
  1258. /* 
  1259.  *   adjoint(original_matrix, inverse_matrix)
  1260.  * 
  1261.  *     calculate the adjoint of a 4x4 matrix
  1262.  *
  1263.  *      Let  a   denote the minor determinant of matrix A obtained by
  1264.  *           ij
  1265.  *
  1266.  *      deleting the ith row and jth column from A.
  1267.  *
  1268.  *                    i+j
  1269.  *     Let  b   = (-1)    a
  1270.  *          ij            ji
  1271.  *
  1272.  *    The matrix B = (b  ) is the adjoint of A
  1273.  *                     ij
  1274.  */
  1275.  
  1276. void adjoint(in, out)
  1277. register double *in, *out;
  1278. {
  1279.     /* row column labeling reversed since we transpose rows & columns */
  1280.     out[0]  =   det2x2(in[4], in[7], in[5], in[8]);
  1281.     out[4]  = - det2x2(in[3], in[6], in[5], in[8]);
  1282.     out[6]  =   det2x2(in[3], in[6], in[4], in[7]);
  1283.  
  1284.     out[1]  = - det2x2(in[1], in[7], in[2], in[8]);
  1285.     out[4]  =   det2x2(in[0], in[6], in[2], in[8]);
  1286.     out[7]  = - det2x2(in[0], in[6], in[1], in[7]);
  1287.  
  1288.     out[2]  =   det2x2(in[1], in[4], in[2], in[5]);
  1289.     out[5]  = - det2x2(in[0], in[3], in[2], in[5]);
  1290.     out[8]  =   det2x2(in[0], in[3], in[1], in[4]);
  1291. }
  1292.  
  1293. OBJECT *load_staging_object(filename, mtrx)
  1294. char *filename;
  1295. MTRX *mtrx;
  1296. {
  1297.     WORLD *new;
  1298.     FILE *newinp;
  1299.     register OBJECT *p;
  1300.  
  1301.     /* Now, load in the external object */
  1302. TRY_EXTR_AGAIN:
  1303.     if (!(newinp=fopen(filename, "r"))) {
  1304.         fprintf(stderr, "Can't load in EXTR object: '%s'.\n",
  1305.             filename);
  1306.         fprintf(stderr, "Enter filneame (or CR to abort): "); fflush(stderr);
  1307.         fgets(filename, 512, stdin);
  1308.         if (!filename[0] || filename[0]=='\n') return(0L);
  1309.         goto TRY_EXTR_AGAIN;
  1310.     }
  1311.     new = read_World(newinp);
  1312.     fclose(newinp);
  1313.  
  1314.     /* scale, rotate, and translate new object hierarchy */
  1315.     /* First, take a look at the root object's size an orientation,
  1316.      * and scale all subobjects appropriately
  1317.      */
  1318.  
  1319.     p = new->object;
  1320.     if (p) {
  1321.         if (p->desc->size) {
  1322.             if (p->desc->size->x != 0.0)
  1323.                 mtrx->scal.x /= p->desc->size->x;
  1324.             if (p->desc->size->y != 0.0)
  1325.                 mtrx->scal.y /= p->desc->size->y;
  1326.             if (p->desc->size->z != 0.0)
  1327.                 mtrx->scal.z /= p->desc->size->z;
  1328.         }
  1329.         if (p->desc->axis) {
  1330. /*            inverse(&p->desc->axis->xaxi.x, &newmtrx.rota1.x);    */
  1331. /*            mmultiply(&newmtrx.rota1.x, &mtrx->rota1.x);            */
  1332.             mmultiply(&p->desc->axis->xaxi.x, &mtrx->rota1.x);
  1333.         }
  1334.     }
  1335.     for (p=new->object; p; p=p->next)
  1336.         move_extr(p, mtrx);
  1337.  
  1338.     p = new->object;
  1339.     free((char*)new);
  1340.     return(p);
  1341. }
  1342.  
  1343. void load_staging_frame_objects(world, frame)
  1344. WORLD *world;
  1345. int frame;
  1346. {
  1347.     register SOBJ *sobj;
  1348.     MTRX mtrx, tmpmtrx;
  1349.     OBJECT *obj;
  1350.     double angle, sin(), cos();
  1351.  
  1352.     if (!world) return;
  1353.     if (!world->istg) return;
  1354.     if (frame<1 || frame>world->istg->maxf) {
  1355.         fprintf(stderr, "ERROR: desired frame (%d) is larger than MAXF (%d)\n",
  1356.             frame, world->istg->maxf);
  1357.         return;
  1358.     }
  1359.     /* Search through all of the "SOBJ" chunks and load in objects that
  1360.      * are active during the specified frame
  1361.      */
  1362.     for (sobj=world->istg->head; sobj; sobj=sobj->next) {
  1363.         /* Easiest method is to simply delete all the information in the SOBJ
  1364.          * sub-chunks that does not fall within the specified frame time.
  1365.          */
  1366.         delete_unused_frames((PALN**)&sobj->osiz, frame);        /* Size */
  1367.         delete_unused_frames((PALN**)&sobj->posn, frame);        /* Position */
  1368.         delete_unused_frames((PALN**)&sobj->algn, frame);        /* Alignment */
  1369.         delete_unused_frames((PALN**)&sobj->paln, frame);        /* Path Alignment */
  1370.         delete_unused_frames((PALN**)&sobj->taln, frame);        /* Track Alignment */
  1371.         delete_unused_frames((PALN**)&sobj->pth2, frame);        /* Follow Path */
  1372.         delete_unused_frames((PALN**)&sobj->glb2, frame);        /* Globals */
  1373.         delete_unused_frames((PALN**)&sobj->axis, frame);        /* Stagefile AXIS */
  1374.         delete_unused_frames((PALN**)&sobj->lite, frame);        /* Light */
  1375.         delete_unused_frames((PALN**)&sobj->file, frame);        /* Stage file */
  1376.  
  1377.         /* Now, we have a list of SOBJ chunks with information for this frame */
  1378.         if (!sobj->file) continue;    /* No filename information */
  1379.  
  1380.         /* Initialize transformation matrix structure */
  1381.         mtrx_ident(&mtrx);
  1382.  
  1383.         /* Now modify matrix based upon requested transformations */
  1384.         if (sobj->posn) { bcopy((char*)&sobj->posn->posn.x, (char*)&mtrx.tran.x, sizeof(XYZ_st)); }
  1385.         if (sobj->osiz) { bcopy((char*)&sobj->osiz->size.x, (char*)&mtrx.scal.x, sizeof(XYZ_st)); }
  1386.         if (sobj->algn) {
  1387.             /* First Z rotation, then X, then Y */
  1388.             if (sobj->algn->algn.z != 0.0) {
  1389.                 angle = sobj->algn->algn.z * PI / 180.0;
  1390.                 mtrx_ident(&tmpmtrx);    /* Initialize it */
  1391.                 tmpmtrx.rota1.x = tmpmtrx.rota2.y = cos(angle);
  1392.                 tmpmtrx.rota2.x = sin(angle);
  1393.                 tmpmtrx.rota1.y = -tmpmtrx.rota2.x;
  1394.                 mmultiply(&tmpmtrx.rota1.x, &mtrx.rota1.x);
  1395.             } else if (sobj->algn->algn.x != 0.0) {
  1396.                 angle = sobj->algn->algn.x * PI / 180.0;
  1397.                 mtrx_ident(&tmpmtrx);    /* Initialize it */
  1398.                 tmpmtrx.rota2.y = tmpmtrx.rota3.z = cos(angle);
  1399.                 tmpmtrx.rota3.y = sin(angle);
  1400.                 tmpmtrx.rota2.z = -tmpmtrx.rota3.y;
  1401.                 mmultiply(&tmpmtrx.rota1.x, &mtrx.rota1.x);
  1402.             } else if (sobj->algn->algn.y != 0.0) {
  1403.                 angle = sobj->algn->algn.y * PI / 180.0;
  1404.                 mtrx_ident(&tmpmtrx);    /* Initialize it */
  1405.                 tmpmtrx.rota1.x = tmpmtrx.rota3.z = cos(angle);
  1406.                 tmpmtrx.rota1.z = sin(angle);
  1407.                 tmpmtrx.rota3.x = -tmpmtrx.rota1.z;
  1408.                 mmultiply(&tmpmtrx.rota1.x, &mtrx.rota1.x);
  1409.             }
  1410.         }
  1411.         /* Okeydokey... let's load in that object! */
  1412.         obj = load_staging_object(sobj->file->object_description, &mtrx);
  1413.         if (world->curobj) {
  1414.             world->curobj->next = obj;
  1415.             obj->parent = world->curobj->parent;
  1416.             while (obj->next) {
  1417.                 obj->next->parent = obj->parent;
  1418.                 obj = obj->next;
  1419.                 world->curobj = obj;
  1420.             }
  1421.         } else {
  1422.             world->object = obj;
  1423.             obj->parent = 0;
  1424.         }
  1425.         world->curobj = obj;
  1426.     }
  1427. }
  1428.