home *** CD-ROM | disk | FTP | other *** search
/ Chip Hitware 7 B / CHIP_HITWARE_7B.iso / Gry / Orbit / src / ac3d.c next >
Encoding:
C/C++ Source or Header  |  1999-09-28  |  26.2 KB  |  1,343 lines
  1. /*
  2.  
  3. ORBIT, a freeware space combat simulator
  4. Copyright (C) 1999  Steve Belczyk <steve1@genesis.nred.ma.us>
  5.  
  6. This program is free software; you can redistribute it and/or
  7. modify it under the terms of the GNU General Public License
  8. as published by the Free Software Foundation; either version 2
  9. of the License, or (at your option) any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  
  20. */
  21.  
  22. #include "orbit.h"
  23.  
  24. /*
  25.  *  Stuff to load AC3D files
  26.  *
  27.  *  Most of this is based on ac-to-gl, by Steve Baker <sjbaker1@airmail.net>
  28.  */
  29.  
  30. int DoMaterial (char *s);
  31. int DoObject (char *s);
  32. int DoACName (char *s);
  33. int DoData (char *s);
  34. int DoTexture (char *s);
  35. int DoTexrep (char *s);
  36. int DoRot (char *s);
  37. int DoLoc (char *s);
  38. int DoUrl (char *s);
  39. int DoNumvert (char *s);
  40. int DoNumsurf (char *s);
  41. int DoSurf (char *s);
  42. int DoMat (char *s);
  43. int DoRefs (char *s);
  44. int DoKids (char *s);
  45.  
  46. int DoObjWorld (char *s);
  47. int DoObjPoly (char *s);
  48. int DoObjGroup (char *s);
  49. void SkipSpaces (char **s);
  50. void SkipQuotes (char **s);
  51. void RemoveQuotes (char *s);
  52. void load_sgi_texture (char *s);
  53.  
  54. #define MAX_TEXTURES 1000    /* This *ought* to be enough! */
  55. char *texture_fnames [MAX_TEXTURES];
  56.  
  57. int acsmooth;        /* Smooth surface? */
  58. int acsurfpass;        /* Pass through surface */
  59. #define PASS_NORMAL (0)    /* Get normals */
  60. #define PASS_RENDER (1) /* Render */
  61.  
  62. struct
  63. {
  64.     int id;            /* Texture id */
  65.     char name[64];    /* Name */
  66. } tex[MAX_TEXTURES];
  67. int ntex;
  68.  
  69. struct ACVertex
  70. {
  71.     float v[3];     /* Vertex coords */
  72.     float normal[3]; /* Normal */
  73.     float n;        /* Number of normals to average */
  74. } *vtab;
  75.  
  76. int num_materials = 0;
  77. int num_textures = 0;
  78. int nv;            /* Number of vertices in vtab */
  79.  
  80. int last_flags = -1;
  81. int last_mat;
  82. int last_num_kids = -1;
  83. int current_flags = -1;
  84. int texture_enabled = 0;
  85. int need_texture = 0;
  86. int firsttime2;
  87.  
  88. #define PARSE_CONT   0
  89. #define PARSE_POP    1
  90.  
  91. int matlist[1024];
  92. int modelnum;
  93. FILE *acfd;
  94.  
  95. struct Tag
  96. {
  97.     char *token;
  98.     int (*func) (char *s);
  99. };
  100.  
  101. struct Tag top_tags [] =
  102. {
  103.     {"MATERIAL", DoMaterial},
  104.     {"OBJECT"  , DoObject  },
  105. };
  106.  
  107. InitTextures()
  108. {
  109.     int t;
  110.  
  111.     for (t=0; t<MAX_TEXTURES; t++)
  112.     {
  113.         tex[t].id = (-1);
  114.         tex[t].name[0] = 0;
  115.     }
  116.  
  117.     ntex = 0;
  118. }
  119.  
  120. LoadAC3D (name)
  121. char *name;
  122. {
  123.     char buffer[1024], *s, fn[128];
  124.     int firsttime, m;
  125.  
  126.     /* See if it's already loaded */
  127.     for (m=0; m<NMODELS; m++)
  128.     {
  129.         if (!strcmp (model[m].name, name)) return (m);
  130.     }
  131.  
  132.     Log ("LoadAC3D: Loading model %s", name);
  133.  
  134.     /* Find an unused model index */
  135.     m = modelnum = FindModel();
  136.     strcpy (model[m].name, name);
  137.     model[m].in_use = 1;
  138.  
  139.     /* Init bounding box */
  140.     model[m].lobound[0] = model[m].lobound[1] = model[m].lobound[2] = 0.0;
  141.     model[m].hibound[0] = model[m].hibound[1] = model[m].hibound[2] = 0.0;
  142.  
  143.     /* Get a list id */
  144.     model[m].list = glGenLists (1);
  145.  
  146.     /* Construct file name */
  147.     sprintf (fn, "models/%s", name);
  148.  
  149.     /* Open it */
  150.     if (NULL == (acfd = fopen (fn, "rt")))
  151.     {
  152.         Log ("LoadAC3D: Can't open %s, giving up!", fn);
  153.         return (-1);
  154.     }
  155.  
  156.     firsttime = 1;
  157.     firsttime2 = 1;
  158.  
  159.     num_materials = 0;
  160.     num_textures = 0;
  161.     vtab = NULL;
  162.     last_flags = -1 ;
  163.     last_num_kids = -1 ;
  164.     current_flags = -1 ;
  165.     texture_enabled = 0;
  166.     need_texture = 0;
  167.     last_mat = -1;
  168.  
  169.     /* Look for and define textures */
  170.     ScanForTextures();
  171.  
  172.     while (fgets (buffer, 1024, acfd) != NULL)
  173.     {
  174.         s = buffer ;
  175.  
  176.         /* Skip leading whitespace */
  177.         SkipSpaces (&s);
  178.  
  179.         /* Skip blank lines and comments */
  180.         if ( *s < ' ' && *s != '\t' ) continue;
  181.         if ( *s == '#' || *s == ';' ) continue;
  182.  
  183.         if (firsttime)
  184.         {
  185.             firsttime = 0;
  186.  
  187.             if (strncmp (s, "AC3D", 4) != 0)
  188.             {
  189.                 Log ("LoadAC3d: %s is not an AC3D format file", fn);
  190.                 return (-1);
  191.             }
  192.         }
  193.         else
  194.         {
  195.             Search (top_tags, s);
  196.         }
  197.     }
  198.  
  199.     glShadeModel (GL_FLAT);
  200.     glEndList();
  201.     fclose (acfd);
  202.  
  203.     Log ("LoadAC3D: Lo bounds: %lf %lf %lf", model[m].lobound[0],
  204.             model[m].lobound[1], model[m].lobound[2]);
  205.     Log ("LoadAC3D: Hi bounds: %lf %lf %lf", model[m].hibound[0],
  206.             model[m].hibound[1], model[m].hibound[2]);
  207.  
  208.     /* All is well */
  209.     return m;
  210. }
  211.  
  212. ScanForTextures()
  213. /*
  214.  *  Look through the AC3D file for all "texture" lines
  215.  */
  216. {
  217.     char buf[1024], fn[256];
  218.  
  219.     /* Look for "texture" lines */
  220.     while (NULL != fgets (buf, 1024, acfd))
  221.     {
  222.         if (1 == sscanf (buf, "texture %s", fn))
  223.         {
  224.             RemoveQuotes (fn);
  225.             LoadTexture (fn);
  226.         }
  227.     }
  228.  
  229.     /* Rewind the file */
  230.     fseek (acfd, 0, SEEK_SET);
  231. }
  232.  
  233. LoadTexture (s)
  234. char *s;
  235. /*
  236.  *  Load a texture file
  237.  */
  238. {
  239.     char fn[256];
  240.  
  241.     Log ("LoadTexture: Loading texture %s", s);
  242.  
  243.     /* Construct file name */
  244.     sprintf (fn, "models/%s", s);
  245.  
  246.     /* Get a texture id */
  247.     glGenTextures (1, &tex[ntex].id);
  248.     strcpy (tex[ntex].name, s);
  249.  
  250.     /* Define the texture */
  251.     glBindTexture (GL_TEXTURE_2D, tex[ntex].id);
  252.     glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
  253.     load_sgi_texture (fn);
  254.     glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  255.     glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
  256.     glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  257.     glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  258.  
  259.     ntex++;
  260. }
  261.  
  262. void ACNormalize (float *v)
  263. {
  264.     float mag;
  265.  
  266.     mag = sqrt (v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
  267.  
  268.     if (mag == 0.0f)
  269.     {
  270.         v[0] = v[1] = 0.0f;
  271.         v[2] = 1.0f;
  272.         return;
  273.     }
  274.  
  275.     v[0] /= mag;
  276.     v[1] /= mag;
  277.     v[2] /= mag;
  278. }
  279.  
  280. void CrossProduct (float *dst, float *a, float *b)
  281. {
  282.     dst[0] = a[1] * b[2] - a[2] * b[1];
  283.     dst[1] = a[2] * b[0] - a[0] * b[2];
  284.     dst[2] = a[0] * b[1] - a[1] * b[0];
  285. }
  286.  
  287. void MakeNormal (float *dst, float *a, float *b, float *c)
  288. {
  289.     float ab[3];
  290.     float ac[3];
  291.  
  292.     ab[0] = b[0] - a[0];
  293.     ab[1] = b[1] - a[1];
  294.     ab[2] = b[2] - a[2];
  295.     ACNormalize (ab);
  296.  
  297.     ac[0] = c[0] - a[0];
  298.     ac[1] = c[1] - a[1];
  299.     ac[2] = c[2] - a[2];
  300.     ACNormalize (ac);
  301.  
  302.     CrossProduct (dst, ab, ac);
  303.     ACNormalize (dst);
  304. }
  305.  
  306. void SkipSpaces (char **s)
  307. {
  308.     while (**s == ' ' || **s == '\t') (*s)++;
  309. }
  310.  
  311. void SkipQuotes (char **s)
  312. {
  313.     char *t;
  314.  
  315.     SkipSpaces (s);
  316.  
  317.     if (**s == '\"')
  318.     {
  319.         (*s)++;
  320.         t = *s;
  321.         while (*t != '\0' && *t != '\"') t++;
  322.  
  323.         if ( *t != '\"' )
  324.             Log ("SkipQuotes: Mismatched double-quote in '%s'\n", *s);
  325.  
  326.         *t = '\0';
  327.     }
  328.     else
  329.     {
  330.         Log ("SkipQuuotes: Expected double-quote in '%s'", *s);
  331.     }
  332. }
  333.  
  334. void RemoveQuotes (char *s)
  335. /*
  336.  *  Remove quotes from string
  337.  */
  338. {
  339.     char *t;
  340.     int i, j, len;
  341.  
  342.     len = strlen (s);
  343.     t = (char *) malloc (len+1);
  344.     strcpy (t, s);
  345.     j = 0;
  346.  
  347.     for (i=0; i<len; i++)
  348.     {
  349.         if (t[i] != '"')
  350.         {
  351.             s[j++] = t[i];
  352.         }
  353.     }
  354.     s[j] = 0;
  355.  
  356.     free (t);
  357. }
  358.  
  359. int Search (struct Tag *tags, char *s)
  360. {
  361.     int i;
  362.  
  363.     SkipSpaces (&s);
  364.  
  365.     for (i=0; tags[i].token != NULL; i++)
  366.     {
  367.         if (!strncasecmp (tags[i].token, s, strlen (tags[i].token)))
  368.         {
  369.             s += strlen (tags[i].token);
  370.             SkipSpaces (&s);
  371.             return (*(tags[i].func))(s);
  372.         }
  373.     }
  374.  
  375.     Log ("Search: Unrecognised token '%s'", s);
  376.     exit (1);
  377.     return 0;
  378. }
  379.  
  380. struct Tag object_tags[] =
  381. {
  382.     {"name"   , DoACName},
  383.     {"data"   , DoData},
  384.     {"texture", DoTexture},
  385.     {"texrep" , DoTexrep},
  386.     {"rot"    , DoRot},
  387.     {"loc"    , DoLoc},
  388.     {"url"    , DoUrl},
  389.     {"numvert", DoNumvert},
  390.     {"numsurf", DoNumsurf},
  391.     {"kids"   , DoKids},
  392.     {NULL, NULL }
  393. };
  394.  
  395. struct Tag surf_tag[] =
  396. {
  397.     {"SURF", DoSurf},
  398.     {NULL, NULL}
  399. };
  400.  
  401. struct Tag surface_tags[] =
  402. {
  403.     {"mat" , DoMat },
  404.     {"refs", DoRefs},
  405.     {NULL, NULL}
  406. };
  407.  
  408. struct Tag obj_type_tags[] =
  409. {
  410.     {"world", DoObjWorld},
  411.     {"poly" , DoObjPoly },
  412.     {"group", DoObjGroup},
  413.     {NULL, NULL}
  414. };
  415.  
  416. #define OBJ_WORLD  0
  417. #define OBJ_POLY   1
  418. #define OBJ_GROUP  2
  419.  
  420. int DoObjWorld (char *s)
  421. {
  422.     return OBJ_WORLD;
  423. } 
  424.  
  425. int DoObjPoly (char *s)
  426. {
  427.     return OBJ_POLY;
  428. }
  429.  
  430. int DoObjGroup (char *s)
  431. {
  432.     return OBJ_GROUP;
  433. }
  434.  
  435. void DoBegin (int flags)
  436. {
  437.     if (last_flags == -1) last_flags = ~flags;
  438.  
  439.     if (((flags>>4) & 0x01) != ((last_flags>>4) & 0x01))
  440.     {
  441.         if ((flags>>4) & 0x01)
  442.         {
  443.             /* Smooth Shaded */
  444.             acsmooth = 1;
  445.         }
  446.         else
  447.         {
  448.             /* Flat Shaded */
  449.             acsmooth = 0;
  450.         }
  451.     }
  452. /**
  453.     if (((flags>>4) & 0x02) != ((last_flags>>4) & 0x02))
  454.     {
  455.         if ((flags>>4) & 0x02)
  456.         {
  457.             if (acsurfpass == PASS_RENDER) glDisable (GL_CULL_FACE);
  458.         }
  459.         else
  460.         {
  461.             if (acsurfpass == PASS_RENDER) glEnable (GL_CULL_FACE);
  462.         }
  463.     }
  464.  
  465.     if ((last_flags & 0x0F) == 0  && (flags & 0x0F) != 0)
  466.     {
  467.         if (acsurfpass == PASS_RENDER) glDisable (GL_LIGHTING);
  468.     }
  469.     else if ((last_flags & 0x0F) != 0  && (flags & 0x0F) == 0)
  470.     {
  471.         if (acsurfpass == PASS_RENDER) glEnable (GL_LIGHTING);
  472.     }
  473. **/
  474.     last_flags = flags;
  475.  
  476.     switch (flags & 0x0F)
  477.     {
  478.     case 0:    if (acsurfpass == PASS_RENDER) glBegin (GL_POLYGON);
  479.         break;
  480.  
  481.     case 1:    if (acsurfpass == PASS_RENDER) glBegin (GL_LINE_LOOP);
  482.         break;
  483.  
  484.     case 2:    if (acsurfpass == PASS_RENDER) glBegin (GL_LINE_STRIP);
  485.         break;
  486.  
  487.     default:
  488.         Log ("DoBegin: Illegal surface type 0x%02x", flags);
  489.         break;
  490.     }
  491. }
  492.  
  493. int DoMaterial (char *s)
  494. {
  495.     char name[1024], *nm;
  496.     float rgb[3], amb[3], emis[3], spec[3], trans;
  497.     int shi;
  498.  
  499.     if (15 != sscanf (s,
  500.         "%s rgb %f %f %f amb %f %f %f emis %f %f %f spec %f %f %f shi %d trans %f",
  501.         name, &rgb[0], &rgb[1], &rgb[2], &amb[0], &amb[1], &amb[2],
  502.         &emis[0], &emis[1], &emis[2], &spec[0], &spec[1], &spec[2], &shi, &trans))
  503.     {
  504.         Log ("DoMaterial: Can't parse this MATERIAL: %s", s);
  505.     }
  506.     else
  507.     {
  508.         nm = name;
  509.         SkipQuotes (&nm);
  510.  
  511.         /* Get a list for this material */
  512.         matlist[num_materials] = glGenLists (1);
  513.  
  514.         glNewList (matlist[num_materials], GL_COMPILE );
  515.         glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT, amb);
  516.         glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, rgb);
  517.         glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, spec);
  518.         glMaterialfv (GL_FRONT_AND_BACK, GL_EMISSION, emis);
  519.         glMaterialf  (GL_FRONT_AND_BACK, GL_SHININESS, shi);
  520.         glEndList();
  521.     }
  522.     num_materials++;
  523.  
  524.     return PARSE_CONT;
  525. }
  526.  
  527. int DoObject (char *s)
  528. {
  529.     int i, obj_type, num_kids;
  530.     char buffer[1024];
  531.  
  532.     if (firsttime2)
  533.     {
  534.         glNewList (model[modelnum].list, GL_COMPILE);
  535.         glShadeModel (GL_SMOOTH);
  536.         firsttime2 = 0;
  537.     }
  538.  
  539.     obj_type = Search (obj_type_tags, s);  
  540.  
  541.     switch (obj_type)
  542.     {
  543.     case OBJ_WORLD:
  544.         break;
  545.  
  546.     case OBJ_POLY:
  547.         break;
  548.  
  549.     case OBJ_GROUP:
  550.         break;
  551.     }
  552.  
  553.     need_texture = 0;
  554.  
  555.     glPushMatrix();
  556.  
  557.     while (NULL != fgets (buffer, 1024, acfd))
  558.     {
  559.         if (Search (object_tags, buffer) == PARSE_POP) break;
  560.     }
  561.  
  562.     num_kids = last_num_kids;
  563.  
  564.     for (i=0; i<num_kids; i++)
  565.     {
  566.         fgets (buffer, 1024, acfd);
  567.         Search (top_tags, buffer);
  568.     }
  569.  
  570.     glPopMatrix();
  571.  
  572.     return PARSE_CONT;
  573. }
  574.  
  575. int DoACName (char *s)
  576. {
  577.     SkipQuotes (&s);
  578.     return PARSE_CONT;
  579. }
  580.  
  581. int DoData (char *s)
  582. {
  583.     int i, len;
  584.  
  585.     len = strtol (s, NULL, 0);
  586.     Log ("DoData: WARNING - data string encountered");
  587.     for (i=0; i<len; i++) fgetc (acfd);
  588.  
  589.     return PARSE_CONT;
  590. }
  591.  
  592. int GetTexture (char *s)
  593. {
  594.     int t;
  595.  
  596.     for (t=0; t<ntex; t++)
  597.     {
  598.         if (!strcasecmp (s, tex[t].name)) return t;
  599.     }
  600.  
  601.     return 0;
  602. }
  603.  
  604. int DoTexture (char *s)
  605. {
  606.     static int last_tex = -1;
  607.     int t;
  608.  
  609.     SkipQuotes (&s);
  610.  
  611.     t = GetTexture (s);
  612.  
  613.     if (t != last_tex)
  614.     {
  615.         glBindTexture (GL_TEXTURE_2D, tex[t].id);
  616.  
  617.         last_tex = t;
  618.     }
  619.  
  620.     need_texture = 1;
  621.  
  622.     return PARSE_CONT;
  623. }
  624.  
  625. int DoTexrep (char *s)
  626. {
  627.     float texrep[2];
  628.  
  629.     if (2 != sscanf (s, "%f %f", &texrep[0], &texrep[1]))
  630.         Log ("DoTextrep: Illegal texrep record: %s", s);
  631.  
  632.     return PARSE_CONT;
  633. }
  634.  
  635. int DoRot (char *s)
  636. {
  637.     float mat[4][4];
  638.  
  639.     mat[0][3] = mat[1][3] = mat[2][3] = mat[3][0] = mat[3][1] = mat[3][2] = 0.0f;
  640.     mat[3][3] = 1.0f; 
  641.  
  642.     if (9 != sscanf (s, "%f %f %f %f %f %f %f %f %f",
  643.         &mat[0][0], &mat[0][1], &mat[0][2],
  644.         &mat[1][0], &mat[1][1], &mat[1][2],
  645.         &mat[2][0], &mat[2][1], &mat[2][2]))
  646.     {
  647.         Log ("DoRot: Illegal rot record: %s", s);
  648.     }
  649.  
  650.     glMultMatrixf (mat);
  651.  
  652.     return PARSE_CONT ;
  653. }
  654.  
  655. int DoLoc (char *s)
  656. {
  657.     float loc[3];
  658.  
  659.     if (3 != sscanf (s, "%f %f %f", &loc[0], &loc[1], &loc[2]))
  660.     {
  661.         Log ("DoLoc: Illegal loc record: %s", s);
  662.     }
  663.  
  664.     loc[0] /= 100.0;
  665.     loc[1] /= 100.0;
  666.     loc[2] /= 100.0;
  667.     glTranslatef (loc[0], loc[1], loc[2]);
  668.  
  669.     return PARSE_CONT;
  670. }
  671.  
  672. int DoUrl (char *s)
  673. {
  674.     SkipQuotes (&s);
  675.     return PARSE_CONT;
  676. }
  677.  
  678. int DoNumvert (char *s)
  679. {
  680.     char buffer[1024];
  681.     int i;
  682.  
  683.     nv = strtol (s, NULL, 0);
  684.  
  685.     if (vtab != NULL) free (vtab) ;
  686.  
  687.     vtab = (struct ACVertex *) malloc (3*nv*sizeof(struct ACVertex));
  688.  
  689.     for (i=0; i<nv; i++)
  690.     {
  691.         fgets (buffer, 1024, acfd);
  692.  
  693.         if (3 != sscanf (buffer, "%f %f %f", &vtab[i].v[0], &vtab[i].v[1], &vtab[i].v[2]))
  694.         {
  695.             Log ("DoNumvert: Illegal vertex record: %s", buffer);
  696.         }
  697.         vtab[i].v[0] /= 100.0;
  698.         vtab[i].v[1] /= 100.0;
  699.         vtab[i].v[2] /= 100.0;
  700.  
  701.         vtab[i].normal[0] = vtab[i].normal[1] = vtab[i].normal[2] = 0.0;
  702.         vtab[i].n = 0.0;
  703.  
  704.         if (vtab[i].v[0] < model[modelnum].lobound[0]) model[modelnum].lobound[0] = vtab[i].v[0];
  705.         if (vtab[i].v[1] < model[modelnum].lobound[1]) model[modelnum].lobound[1] = vtab[i].v[1];
  706.         if (vtab[i].v[2] < model[modelnum].lobound[2]) model[modelnum].lobound[2] = vtab[i].v[2];
  707.         if (vtab[i].v[0] > model[modelnum].hibound[0]) model[modelnum].hibound[0] = vtab[i].v[0];
  708.         if (vtab[i].v[1] > model[modelnum].hibound[1]) model[modelnum].hibound[1] = vtab[i].v[1];
  709.         if (vtab[i].v[2] > model[modelnum].hibound[2]) model[modelnum].hibound[2] = vtab[i].v[2];
  710.     }
  711.  
  712.     return PARSE_CONT;
  713. }
  714.  
  715. int DoNumsurf (char *s)
  716. {
  717.     int i, ns, v;
  718.     long pos, p;
  719.     char buffer[1024];
  720.  
  721.     ns = strtol (s, NULL, 0);
  722.  
  723.     /* Do first pass to average normals */
  724.     pos = ftell (acfd);
  725.     acsurfpass = PASS_NORMAL;
  726.     for (i=0; i<ns; i++)
  727.     {
  728.         p = ftell (acfd);
  729.         fgets (buffer, 1024, acfd);
  730.         Search (surf_tag, buffer);
  731.     }
  732.  
  733.     /* Back to beginning of object */
  734.     fseek (acfd, pos, SEEK_SET);
  735.  
  736.     /* Average normals */
  737.     for (v=0; v<nv; v++)
  738.     {
  739.         vtab[v].normal[0] /= vtab[v].n;
  740.         vtab[v].normal[1] /= vtab[v].n;
  741.         vtab[v].normal[2] /= vtab[v].n;
  742.     }
  743.  
  744.     /* Now render */
  745.     acsurfpass = PASS_RENDER;
  746.     last_mat = (-1);
  747.  
  748.     for (i=0; i<ns; i++)
  749.     {
  750.         p = ftell (acfd);
  751.         fgets (buffer, 1024, acfd);
  752.         Search (surf_tag, buffer);
  753.     }
  754.  
  755.     return PARSE_CONT;
  756. }
  757.  
  758. int DoSurf (char *s)
  759. {
  760.     char buffer[1024];
  761.  
  762.     current_flags = strtol (s, NULL, 0);
  763.  
  764.     while (NULL != fgets (buffer, 1024, acfd))
  765.     {
  766.         if (Search (surface_tags, buffer) == PARSE_POP) break;
  767.     }
  768.  
  769.     return PARSE_CONT ;
  770. }
  771.  
  772. int DoMat (char *s)
  773. {
  774.     int mat;
  775.  
  776.     mat = strtol (s, NULL, 0);
  777.  
  778.     if (mat != last_mat)
  779.     {
  780.         if (acsurfpass == PASS_RENDER) glCallList (matlist[mat]);
  781.         last_mat = mat;
  782.     }
  783.  
  784.     return PARSE_CONT ;
  785. }
  786.  
  787. int DoRefs (char *s)
  788. {
  789.     int i;
  790.     int nrefs;
  791.     char buffer[1024] ;
  792.     int *vlist;
  793.     float *tlistu, *tlistv, nrm[3];
  794.  
  795.     nrefs = strtol (s, NULL, 0);
  796.  
  797.     if (nrefs == 0) return PARSE_POP;
  798.  
  799.     if (need_texture && !texture_enabled)
  800.     {
  801.         if (acsurfpass == PASS_RENDER) glEnable (GL_TEXTURE_2D);
  802.         texture_enabled = 1;
  803.     }
  804.     else if (!need_texture && texture_enabled)
  805.     {
  806.         if (acsurfpass == PASS_RENDER) glDisable (GL_TEXTURE_2D);
  807.         texture_enabled = 0;
  808.     }
  809.  
  810.     vlist  = (int *) malloc (sizeof(int)*nrefs);
  811.     tlistu = (float *) malloc (sizeof(float)*nrefs) ;
  812.     tlistv = (float *) malloc (sizeof(float)*nrefs) ;
  813.  
  814.     DoBegin (current_flags);
  815.  
  816.     for (i=0; i<nrefs; i++)
  817.     {
  818.         fgets (buffer, 1024, acfd);
  819.  
  820.         if (3 != sscanf (buffer, "%d %f %f", &vlist[i], &tlistu[i], &tlistv[i]))
  821.         {
  822.             Log ("DoRefs: Illegal ref record: %s", buffer);
  823.             exit (1);
  824.         }
  825.     }
  826.  
  827.     if (nrefs >= 3)
  828.     {
  829.         MakeNormal (nrm, vtab[vlist[0]].v, vtab[vlist[1]].v, vtab[vlist[2]].v);
  830.  
  831.         if (!acsmooth && (acsurfpass == PASS_RENDER))
  832.         {
  833.             glNormal3fv (nrm);
  834.         }
  835.     }
  836.  
  837.     for (i=0; i<nrefs; i++)
  838.     {
  839.         /* Maintain normal first pass */
  840.         if (acsmooth && (acsurfpass == PASS_NORMAL))
  841.         {
  842.             MaintainNormal (vlist[i], nrm);
  843.         }
  844.  
  845.         /* Render second pass */
  846.         if (acsmooth && (acsurfpass == PASS_RENDER))
  847.         {
  848.             glNormal3fv (vtab[vlist[i]].normal);
  849.         }
  850.  
  851.         if (acsurfpass == PASS_RENDER)
  852.         {
  853.             glTexCoord2f (tlistu[i], tlistv[i]);
  854.             glVertex3fv (vtab[vlist[i]].v);
  855.         }
  856.     }
  857.  
  858.     free (vlist);
  859.     free (tlistu);
  860.     free (tlistv);
  861.  
  862.     if (acsurfpass == PASS_RENDER) glEnd();
  863.  
  864.     return PARSE_POP;
  865. }
  866.  
  867. int DoKids (char *s)
  868. {
  869.     last_num_kids = strtol (s, NULL, 0);
  870.     return PARSE_POP;
  871. }
  872.  
  873. MaintainNormal (i, n)
  874. int i;
  875. float n[3];
  876. /*
  877.  *  Maintain a vertex normal
  878.  */
  879. {
  880.     vtab[i].n += 1.0;
  881.  
  882.     vtab[i].normal[0] += n[0];
  883.     vtab[i].normal[1] += n[1];
  884.     vtab[i].normal[2] += n[2];
  885. }
  886.  
  887. /** ------------- The rest loads SGI texture files --------------- **/
  888.  
  889. /* Some magic constants in the file header. */
  890.  
  891. #define SGI_IMG_MAGIC           0x01DA
  892. #define SGI_IMG_SWABBED_MAGIC   0xDA01   /* This is how it appears on a PC */
  893. #define SGI_IMG_VERBATIM        0
  894. #define SGI_IMG_RLE             1
  895.  
  896. static int            sgi_max ;
  897. static int            sgi_min ;
  898. static int            sgi_colormap ;
  899. static unsigned short sgi_magic ;
  900. static char           sgi_type ;
  901. static char           sgi_bpp ;
  902. static unsigned int  *sgi_start ;
  903. static int           *sgi_leng ;
  904. static unsigned char *sgi_temp ;
  905. static int            sgi_swapped ;
  906. static FILE          *sgi_fd ;
  907. static unsigned short sgi_dim ;
  908. static unsigned short sgi_xsize ;
  909. static unsigned short sgi_ysize ;
  910. static unsigned short sgi_zsize ;
  911.  
  912. static void makeConsistentHeader ()
  913. {
  914.   /*
  915.     Sanity checks - and a workaround for buggy RGB files generated by
  916.     the MultiGen Paint program because it will sometimes get confused
  917.     about the way to represent maps with more than one component.
  918.  
  919.     eg   Y > 1, Number of dimensions == 1
  920.          Z > 1, Number of dimensions == 2
  921.   */
  922.  
  923.   if ( sgi_ysize > 1 && sgi_dim < 2 ) sgi_dim = 2 ;
  924.   if ( sgi_zsize > 1 && sgi_dim < 3 ) sgi_dim = 3 ;
  925.   if ( sgi_dim < 1 ) sgi_ysize = 1 ;
  926.   if ( sgi_dim < 2 ) sgi_zsize = 1 ;
  927.   if ( sgi_dim > 3 ) sgi_dim   = 3 ;
  928.   if ( sgi_zsize < 1 && sgi_ysize == 1 ) sgi_dim = 1 ;
  929.   if ( sgi_zsize < 1 && sgi_ysize != 1 ) sgi_dim = 2 ;
  930.   if ( sgi_zsize >= 1 ) sgi_dim = 3 ;
  931.  
  932.   /*
  933.     A very few SGI image files have 2 bytes per component - this
  934.     tool cannot deal with those kinds of files. 
  935.   */
  936.  
  937.   if ( sgi_bpp == 2 )
  938.   {
  939.     Log ("makeConsistentHeader: Can't work with SGI images with %d bpp", sgi_bpp);
  940.     exit (1);
  941.   }
  942.  
  943.   sgi_bpp = 1 ;
  944.   sgi_min = 0 ;
  945.   sgi_max = 255 ;
  946.   sgi_magic = SGI_IMG_MAGIC ;
  947.   sgi_colormap = 0 ;
  948. }
  949.  
  950. static void swab_short ( unsigned short *x )
  951. {
  952.   if ( sgi_swapped )
  953.     *x = (( *x >>  8 ) & 0x00FF ) | 
  954.          (( *x <<  8 ) & 0xFF00 ) ;
  955. }
  956.  
  957. static void swab_int ( unsigned int *x )
  958. {
  959.   if ( sgi_swapped )
  960.     *x = (( *x >> 24 ) & 0x000000FF ) | 
  961.          (( *x >>  8 ) & 0x0000FF00 ) | 
  962.          (( *x <<  8 ) & 0x00FF0000 ) | 
  963.          (( *x << 24 ) & 0xFF000000 ) ;
  964. }
  965.  
  966. static void swab_int_array ( int *x, int leng )
  967. {
  968.   int i;
  969.  
  970.   if ( ! sgi_swapped )
  971.     return ;
  972.  
  973.   for ( i = 0 ; i < leng ; i++ )
  974.   {
  975.     *x = (( *x >> 24 ) & 0x000000FF ) | 
  976.          (( *x >>  8 ) & 0x0000FF00 ) | 
  977.          (( *x <<  8 ) & 0x00FF0000 ) | 
  978.          (( *x << 24 ) & 0xFF000000 ) ;
  979.     x++ ;
  980.   }
  981. }
  982.  
  983.  
  984. static unsigned char readByte ()
  985. {
  986.   unsigned char x ;
  987.   fread ( & x, sizeof(unsigned char), 1, sgi_fd ) ;
  988.   return x ;
  989. }
  990.  
  991. static unsigned short readShort ()
  992. {
  993.   unsigned short x ;
  994.   fread ( & x, sizeof(unsigned short), 1, sgi_fd ) ;
  995.   swab_short ( & x ) ;
  996.   return x ;
  997. }
  998.  
  999. static unsigned int readInt ()
  1000. {
  1001.   unsigned int x ;
  1002.   fread ( & x, sizeof(unsigned int), 1, sgi_fd ) ;
  1003.   swab_int ( & x ) ;
  1004.   return x ;
  1005. }
  1006.  
  1007.  
  1008. static void getRow ( unsigned char *buf, int y, int z )
  1009. {
  1010.     unsigned char pixel, count ;
  1011.  
  1012.   if ( y >= sgi_ysize ) y = sgi_ysize - 1 ;
  1013.   if ( z >= sgi_zsize ) z = sgi_zsize - 1 ;
  1014.  
  1015.   fseek ( sgi_fd, sgi_start [ z * sgi_ysize + y ], SEEK_SET ) ;
  1016.  
  1017.   if ( sgi_type == SGI_IMG_RLE )
  1018.   {
  1019.     unsigned char *tmpp = sgi_temp ;
  1020.     unsigned char *bufp = buf ;
  1021.  
  1022.     fread ( sgi_temp, 1, sgi_leng [ z * sgi_ysize + y ], sgi_fd ) ;
  1023.  
  1024.     while ( 1 )
  1025.     {
  1026.       pixel = *tmpp++ ;
  1027.  
  1028.       count = ( pixel & 0x7f ) ;
  1029.  
  1030.       if ( count == 0 )
  1031.     break ;
  1032.  
  1033.       if ( pixel & 0x80 )
  1034.       {
  1035.         while ( count-- )
  1036.       *bufp++ = *tmpp++ ;
  1037.       }
  1038.       else
  1039.       {
  1040.         pixel = *tmpp++ ;
  1041.  
  1042.     while ( count-- )
  1043.           *bufp++ = pixel ;
  1044.       }
  1045.     }
  1046.   }
  1047.   else
  1048.     fread ( buf, 1, sgi_xsize, sgi_fd ) ;
  1049. }
  1050.  
  1051.  
  1052. static void getPlane ( unsigned char *buf, int z )
  1053. {
  1054.   int y;
  1055.   if ( sgi_fd == NULL )
  1056.     return ;
  1057.  
  1058.   if ( z >= sgi_zsize ) z = sgi_zsize - 1 ;
  1059.  
  1060.   for ( y = 0 ; y < sgi_ysize ; y++ )
  1061.     getRow ( & buf [ y * sgi_xsize ], y, z ) ;
  1062. }
  1063.  
  1064.  
  1065.  
  1066. static void getImage ( unsigned char *buf )
  1067. {
  1068.   int y, z;
  1069.  
  1070.   if ( sgi_fd == NULL )
  1071.     return ;
  1072.  
  1073.   for (y = 0 ; y < sgi_ysize ; y++ )
  1074.     for (z = 0 ; z < sgi_zsize ; z++ )
  1075.       getRow ( & buf [ ( z * sgi_ysize + y ) * sgi_xsize ], y, z ) ;
  1076. }
  1077.  
  1078. void load_sgi_texture ( char *fname )
  1079. {
  1080.   int i, tablen, x, y, l, maxlen;
  1081.   GLubyte *texels [ 20 ], *ptr ;
  1082.   unsigned char *rbuf, *gbuf, *bbuf, *abuf;
  1083.   int lev, map_level;
  1084.   int j, x2, y2, c;
  1085.  
  1086.   sgi_dim   = 0 ;
  1087.   sgi_start = NULL ;
  1088.   sgi_leng  = NULL ;
  1089.   sgi_temp  = NULL ;
  1090.  
  1091.   sgi_swapped = 0 ;
  1092.  
  1093.   sgi_fd = fopen ( fname, "rb" ) ;
  1094.  
  1095.   if ( sgi_fd == NULL )
  1096.   {
  1097.     Log ("load_sgi_texture: Failed to open '%s' for reading.", fname ) ;
  1098.     return ;
  1099.   }
  1100.  
  1101.   sgi_magic = readShort () ;
  1102.  
  1103.   if ( sgi_magic != SGI_IMG_MAGIC && sgi_magic != SGI_IMG_SWABBED_MAGIC )
  1104.   {
  1105.     Log ("load_sgi_texture: %s: Unrecognised magic number 0x%04x", fname, sgi_magic ) ;
  1106.     exit ( 1 ) ;
  1107.   }
  1108.  
  1109.   if ( sgi_magic == SGI_IMG_SWABBED_MAGIC )
  1110.   {
  1111.     sgi_swapped = 1 ;
  1112.     swab_short ( & sgi_magic ) ;
  1113.   }
  1114.  
  1115.   sgi_type  = readByte  () ;
  1116.   sgi_bpp   = readByte  () ;
  1117.   sgi_dim   = readShort () ;
  1118.  
  1119.   /*
  1120.     This is a backstop test - if for some reason the magic number isn't swabbed, this
  1121.     test will still catch a swabbed file. Of course images with more than 256 dimensions
  1122.     are not catered for :-)
  1123.   */
  1124.  
  1125.   if ( sgi_dim > 255 )
  1126.   {
  1127.     Log ("load_sgi_texture: %s: Bad swabbing?!?", fname ) ;
  1128.     sgi_swapped = ! sgi_swapped ;
  1129.     swab_short ( & sgi_dim ) ;
  1130.     sgi_magic = SGI_IMG_MAGIC ;
  1131.   }
  1132.  
  1133.   sgi_xsize = readShort () ;
  1134.   sgi_ysize = readShort () ;
  1135.   sgi_zsize = readShort () ;
  1136.   sgi_min   = readInt   () ;  
  1137.   sgi_max   = readInt   () ;  
  1138.               readInt   () ;  /* Dummy field */
  1139.  
  1140.   for (i = 0 ; i < 80 ; i++ )
  1141.     readByte () ;         /* Name field */
  1142.  
  1143.   sgi_colormap = readInt () ;
  1144.  
  1145.   for (i = 0 ; i < 404 ; i++ )
  1146.     readByte () ;         /* Dummy field */
  1147.  
  1148.   makeConsistentHeader () ;
  1149.  
  1150.   tablen = sgi_ysize * sgi_zsize ;
  1151.   sgi_start = (unsigned int *) malloc (tablen*sizeof(unsigned int)) ;
  1152.   sgi_leng  = (int *) malloc (sizeof(int)*tablen) ;
  1153.  
  1154.   if ( sgi_type == SGI_IMG_RLE )
  1155.   {
  1156.     fread ( sgi_start, sizeof ( unsigned int ), tablen, sgi_fd ) ;
  1157.     fread ( sgi_leng , sizeof (  int ), tablen, sgi_fd ) ;
  1158.     swab_int_array ( (int *) sgi_start, tablen ) ;
  1159.     swab_int_array ( (int *) sgi_leng , tablen ) ;
  1160.  
  1161.     maxlen = 0 ;
  1162.  
  1163.     for (i = 0 ; i < tablen ; i++ )
  1164.       if ( sgi_leng [ i ] > maxlen )
  1165.         maxlen = sgi_leng [ i ] ;
  1166.  
  1167.     sgi_temp = (unsigned char *) malloc (maxlen) ;
  1168.   }
  1169.   else
  1170.   {
  1171.     sgi_temp = NULL ;
  1172.  
  1173.     for (i = 0 ; i < sgi_zsize ; i++ )
  1174.       for (j = 0 ; j < sgi_ysize ; j++ )
  1175.       {
  1176.         sgi_start [ i * sgi_ysize + j ] = sgi_xsize * ( i * sgi_ysize + j ) + 512 ;
  1177.         sgi_leng  [ i * sgi_ysize + j ] = sgi_xsize ;
  1178.       }
  1179.   }
  1180.  
  1181.   if ( sgi_zsize <= 0 || sgi_zsize > 4 )
  1182.   {
  1183.     Log ("load_sgi_texture: %s: Not an int/inta/rgb/rgba image?!?", fname ) ;
  1184.     exit ( 1 ) ;
  1185.   }
  1186.  
  1187.  
  1188.   for (i = 0 ; i < 20 ; i++ )
  1189.     texels [ 0 ] = NULL ;
  1190.  
  1191.   texels [ 0 ] = (GLubyte *) malloc (sizeof(GLubyte)* sgi_xsize * sgi_ysize * sgi_zsize ) ;
  1192.  
  1193.   ptr = texels [ 0 ] ;
  1194.  
  1195.   rbuf = malloc (sgi_xsize);
  1196.   gbuf = (sgi_zsize>1) ? malloc(sgi_xsize): (unsigned char *) NULL ;
  1197.   bbuf = (sgi_zsize>2) ? malloc(sgi_xsize): (unsigned char *) NULL ;
  1198.   abuf = (sgi_zsize>3) ? malloc(sgi_xsize): (unsigned char *) NULL ;
  1199.  
  1200.   for ( y = 0 ; y < sgi_ysize ; y++ )
  1201.   {
  1202.     switch ( sgi_zsize )
  1203.     {
  1204.       case 1 :
  1205.     getRow ( rbuf, y, 0 ) ;
  1206.  
  1207.     for ( x = 0 ; x < sgi_xsize ; x++ )
  1208.       *ptr++ = rbuf [ x ] ;
  1209.  
  1210.     break ;
  1211.  
  1212.       case 2 :
  1213.     getRow ( rbuf, y, 0 ) ;
  1214.     getRow ( gbuf, y, 1 ) ;
  1215.  
  1216.     for (x = 0 ; x < sgi_xsize ; x++ )
  1217.     {
  1218.       *ptr++ = rbuf [ x ] ;
  1219.       *ptr++ = gbuf [ x ] ;
  1220.     }
  1221.     break ;
  1222.  
  1223.       case 3 :
  1224.         getRow ( rbuf, y, 0 ) ;
  1225.     getRow ( gbuf, y, 1 ) ;
  1226.     getRow ( bbuf, y, 2 ) ;
  1227.  
  1228.     for (x = 0 ; x < sgi_xsize ; x++ )
  1229.     {
  1230.       *ptr++ = rbuf [ x ] ;
  1231.       *ptr++ = gbuf [ x ] ;
  1232.       *ptr++ = bbuf [ x ] ;
  1233.     }
  1234.     break ;
  1235.  
  1236.       case 4 :
  1237.         getRow ( rbuf, y, 0 ) ;
  1238.     getRow ( gbuf, y, 1 ) ;
  1239.     getRow ( bbuf, y, 2 ) ;
  1240.     getRow ( abuf, y, 3 ) ;
  1241.  
  1242.     for (x = 0 ; x < sgi_xsize ; x++ )
  1243.     {
  1244.       *ptr++ = rbuf [ x ] ;
  1245.       *ptr++ = gbuf [ x ] ;
  1246.       *ptr++ = bbuf [ x ] ;
  1247.       *ptr++ = abuf [ x ] ;
  1248.     }
  1249.     break ;
  1250.     }
  1251.   }
  1252.  
  1253.   for ( lev = 0 ; (( sgi_xsize >> (lev+1) ) != 0 ||
  1254.                    ( sgi_ysize >> (lev+1) ) != 0 ) ; lev++ )
  1255.   {
  1256.     /* Suffix '1' is the higher level map, suffix '2' is the lower level. */
  1257.  
  1258.     int l1 =  lev  ;
  1259.     int l2 = lev+1 ;
  1260.     int w1 = sgi_xsize >> l1 ;
  1261.     int h1 = sgi_ysize >> l1 ;
  1262.     int w2 = sgi_xsize >> l2 ;
  1263.     int h2 = sgi_ysize >> l2 ;
  1264.  
  1265.     if ( w1 <= 0 ) w1 = 1 ;
  1266.     if ( h1 <= 0 ) h1 = 1 ;
  1267.     if ( w2 <= 0 ) w2 = 1 ;
  1268.     if ( h2 <= 0 ) h2 = 1 ;
  1269.  
  1270.     texels[l2] = (GLubyte *) malloc (sizeof(GLubyte)*  w2 * h2 * sgi_zsize ) ;
  1271.  
  1272.     for (x2 = 0 ; x2 < w2 ; x2++ )
  1273.       for (y2 = 0 ; y2 < h2 ; y2++ )
  1274.         for (c = 0 ; c < sgi_zsize ; c++ )
  1275.         {
  1276.           int x1   = x2 + x2 ;
  1277.           int x1_1 = ( x1 + 1 ) % w1 ;
  1278.           int y1   = y2 + y2 ;
  1279.           int y1_1 = ( y1 + 1 ) % h1 ;
  1280.  
  1281.       int t1 = texels [ l1 ] [ (y1   * w1 + x1  ) * sgi_zsize + c ] ;
  1282.       int t2 = texels [ l1 ] [ (y1_1 * w1 + x1  ) * sgi_zsize + c ] ;
  1283.       int t3 = texels [ l1 ] [ (y1   * w1 + x1_1) * sgi_zsize + c ] ;
  1284.       int t4 = texels [ l1 ] [ (y1_1 * w1 + x1_1) * sgi_zsize + c ] ;
  1285.  
  1286.           texels [ l2 ] [ (y2 * w2 + x2) * sgi_zsize + c ] =
  1287.                                            ( t1 + t2 + t3 + t4 ) / 4 ;
  1288.         }
  1289.   }
  1290.  
  1291.   texels [ lev+1 ] = NULL ;
  1292.  
  1293.   if (rbuf != NULL) free (rbuf)  ;
  1294.   if (gbuf != NULL) free (gbuf)  ;
  1295.   if (bbuf != NULL) free (bbuf)  ;
  1296.   if (abuf != NULL) free (abuf)  ;
  1297.  
  1298.   if ( ! ((sgi_xsize & (sgi_xsize-1))==0) ||
  1299.        ! ((sgi_ysize & (sgi_ysize-1))==0) )
  1300.   {
  1301.     Log ("load_sgi_texture: %s: Map is not a power-of-two in size!", fname ) ;
  1302.     exit ( 1 ) ;
  1303.   }
  1304.  
  1305.   glPixelStorei ( GL_UNPACK_ALIGNMENT, 1 ) ;
  1306.  
  1307.   map_level = 0 ;
  1308.  
  1309.   if ( sgi_xsize > 256 || sgi_ysize > 256 )
  1310.   {
  1311.     while ( sgi_xsize > 256 || sgi_ysize > 256 )
  1312.     {
  1313.       if (texels[0] != NULL) free (texels[0]) ;
  1314.       sgi_xsize >>= 1 ;
  1315.       sgi_ysize >>= 1 ;
  1316.  
  1317.       for (l = 0 ; texels [ l ] != NULL ; l++ )
  1318.     texels [ l ] = texels [ l+1 ] ;
  1319.     }
  1320.   }
  1321.  
  1322.   for (i = 0 ; texels [ i ] != NULL ; i++ )
  1323.   {
  1324.     int w = sgi_xsize>>i ;
  1325.     int h = sgi_ysize>>i ;
  1326.  
  1327.     if ( w <= 0 ) w = 1 ;
  1328.     if ( h <= 0 ) h = 1 ;
  1329.  
  1330.     glTexImage2D  ( GL_TEXTURE_2D,
  1331.                      map_level, sgi_zsize, w, h, 0 /* Border */,
  1332.                             (sgi_zsize==1)?GL_LUMINANCE:
  1333.                             (sgi_zsize==2)?GL_LUMINANCE_ALPHA:
  1334.                             (sgi_zsize==3)?GL_RGB:
  1335.                                            GL_RGBA,
  1336.                             GL_UNSIGNED_BYTE, (GLvoid *) texels[i] ) ;
  1337.     map_level++ ;
  1338.   }
  1339.  
  1340.   fclose (sgi_fd);
  1341. }
  1342.  
  1343.