开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
glm.c
资源名称：glut23-src.zip　[点击查看]
上传用户：xk288cn
上传日期：2007-05-28
资源大小：4876k
文件大小：53k
源码类别：

GIS编程

开发平台：

Visual C++

glm.c：源码内容
  1. /*    
  2.       glm.c
  3.       Nate Robins, 1997
  4.       ndr@pobox.com, http://www.pobox.com/~ndr/
  5.  
  6.       Wavefront OBJ model file format reader/writer/manipulator.
  8.       Includes routines for generating smooth normals with
  9.       preservation of edges, welding redundant vertices & texture
  10.       coordinate generation (spheremap and planar projections) + more.
  12.  */
  15. #include <math.h>
  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <string.h>
  19. #include <assert.h>
  20. #include "glm.h"
  23. #define T(x) (model->triangles[(x)])
  26. /* _GLMnode: general purpose node
  27.  */
  28. typedef struct _GLMnode {
  29.   GLuint           index;
  30.   GLboolean        averaged;
  31.   struct _GLMnode* next;
  32. } GLMnode;
  35. /* glmMax: returns the maximum of two floats */
  36. static GLfloat
  37. glmMax(GLfloat a, GLfloat b) 
  38. {
  39.   if (b > a)
  40.     return b;
  41.   return a;
  42. }
  44. /* glmAbs: returns the absolute value of a float */
  45. static GLfloat
  46. glmAbs(GLfloat f)
  47. {
  48.   if (f < 0)
  49.     return -f;
  50.   return f;
  51. }
  53. /* glmDot: compute the dot product of two vectors
  54.  *
  55.  * u - array of 3 GLfloats (GLfloat u[3])
  56.  * v - array of 3 GLfloats (GLfloat v[3])
  57.  */
  58. static GLfloat
  59. glmDot(GLfloat* u, GLfloat* v)
  60. {
  61.   assert(u); assert(v);
  63.   return u[0]*v[0] + u[1]*v[1] + u[2]*v[2];
  64. }
  66. /* glmCross: compute the cross product of two vectors
  67.  *
  68.  * u - array of 3 GLfloats (GLfloat u[3])
  69.  * v - array of 3 GLfloats (GLfloat v[3])
  70.  * n - array of 3 GLfloats (GLfloat n[3]) to return the cross product in
  71.  */
  72. static GLvoid
  73. glmCross(GLfloat* u, GLfloat* v, GLfloat* n)
  74. {
  75.   assert(u); assert(v); assert(n);
  77.   n[0] = u[1]*v[2] - u[2]*v[1];
  78.   n[1] = u[2]*v[0] - u[0]*v[2];
  79.   n[2] = u[0]*v[1] - u[1]*v[0];
  80. }
  82. /* glmNormalize: normalize a vector
  83.  *
  84.  * v - array of 3 GLfloats (GLfloat v[3]) to be normalized
  85.  */
  86. static GLvoid
  87. glmNormalize(GLfloat* v)
  88. {
  89.   GLfloat l;
  91.   assert(v);
  93.   l = (GLfloat)sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
  94.   v[0] /= l;
  95.   v[1] /= l;
  96.   v[2] /= l;
  97. }
  99. /* glmEqual: compares two vectors and returns GL_TRUE if they are
  100.  * equal (within a certain threshold) or GL_FALSE if not. An epsilon
  101.  * that works fairly well is 0.000001.
  102.  *
  103.  * u - array of 3 GLfloats (GLfloat u[3])
  104.  * v - array of 3 GLfloats (GLfloat v[3]) 
  105.  */
  106. static GLboolean
  107. glmEqual(GLfloat* u, GLfloat* v, GLfloat epsilon)
  108. {
  109.   if (glmAbs(u[0] - v[0]) < epsilon &&
  110.       glmAbs(u[1] - v[1]) < epsilon &&
  111.       glmAbs(u[2] - v[2]) < epsilon) 
  112.   {
  113.     return GL_TRUE;
  114.   }
  115.   return GL_FALSE;
  116. }
  118. /* glmWeldVectors: eliminate (weld) vectors that are within an
  119.  * epsilon of each other.
  120.  *
  121.  * vectors    - array of GLfloat[3]'s to be welded
  122.  * numvectors - number of GLfloat[3]'s in vectors
  123.  * epsilon    - maximum difference between vectors 
  124.  *
  125.  */
  126. GLfloat*
  127. glmWeldVectors(GLfloat* vectors, GLuint* numvectors, GLfloat epsilon)
  128. {
  129.   GLfloat* copies;
  130.   GLuint   copied;
  131.   GLuint   i, j;
  133.   copies = (GLfloat*)malloc(sizeof(GLfloat) * 3 * (*numvectors + 1));
  134.   memcpy(copies, vectors, (sizeof(GLfloat) * 3 * (*numvectors + 1)));
  136.   copied = 1;
  137.   for (i = 1; i <= *numvectors; i++) {
  138.     for (j = 1; j <= copied; j++) {
  139.       if (glmEqual(&vectors[3 * i], &copies[3 * j], epsilon)) {
  140. goto duplicate;
  141.       }
  142.     }
  144.     /* must not be any duplicates -- add to the copies array */
  145.     copies[3 * copied + 0] = vectors[3 * i + 0];
  146.     copies[3 * copied + 1] = vectors[3 * i + 1];
  147.     copies[3 * copied + 2] = vectors[3 * i + 2];
  148.     j = copied; /* pass this along for below */
  149.     copied++;
  151.   duplicate:
  152.     /* set the first component of this vector to point at the correct
  153.        index into the new copies array */
  154.     vectors[3 * i + 0] = (GLfloat)j;
  155.   }
  157.   *numvectors = copied-1;
  158.   return copies;
  159. }
  161. /* glmFindGroup: Find a group in the model
  162.  */
  163. GLMgroup*
  164. glmFindGroup(GLMmodel* model, char* name)
  165. {
  166.   GLMgroup* group;
  168.   assert(model);
  170.   group = model->groups;
  171.   while(group) {
  172.     if (!strcmp(name, group->name))
  173.       break;
  174.     group = group->next;
  175.   }
  177.   return group;
  178. }
  180. /* glmAddGroup: Add a group to the model
  181.  */
  182. GLMgroup*
  183. glmAddGroup(GLMmodel* model, char* name)
  184. {
  185.   GLMgroup* group;
  187.   group = glmFindGroup(model, name);
  188.   if (!group) {
  189.     group = (GLMgroup*)malloc(sizeof(GLMgroup));
  190.     group->name = strdup(name);
  191.     group->material = 0;
  192.     group->numtriangles = 0;
  193.     group->triangles = NULL;
  194.     group->next = model->groups;
  195.     model->groups = group;
  196.     model->numgroups++;
  197.   }
  199.   return group;
  200. }
  202. /* glmFindGroup: Find a material in the model
  203.  */
  204. GLuint
  205. glmFindMaterial(GLMmodel* model, char* name)
  206. {
  207.   GLuint i;
  209.   /* XXX doing a linear search on a string key'd list is pretty lame,
  210.      but it works and is fast enough for now. */
  211.   for (i = 0; i < model->nummaterials; i++) {
  212.     if (!strcmp(model->materials[i].name, name))
  213.       goto found;
  214.   }
  216.   /* didn't find the name, so print a warning and return the default
  217.      material (0). */
  218.   printf("glmFindMaterial():  can't find material "%s".n", name);
  219.   i = 0;
  221. found:
  222.   return i;
  223. }
  226. /* glmDirName: return the directory given a path
  227.  *
  228.  * path - filesystem path
  229.  *
  230.  * NOTE: the return value should be free'd.
  231.  */
  232. static char*
  233. glmDirName(char* path)
  234. {
  235.   char* dir;
  236.   char* s;
  238.   dir = strdup(path);
  240.   s = strrchr(dir, '/');
  241.   if (s)
  242.     s[1] = '';
  243.   else
  244.     dir[0] = '';
  246.   return dir;
  247. }
  250. /* glmReadMTL: read a wavefront material library file
  251.  *
  252.  * model - properly initialized GLMmodel structure
  253.  * name  - name of the material library
  254.  */
  255. static GLvoid
  256. glmReadMTL(GLMmodel* model, char* name)
  257. {
  258.   FILE* file;
  259.   char* dir;
  260.   char* filename;
  261.   char  buf[128];
  262.   GLuint nummaterials, i;
  264.   dir = glmDirName(model->pathname);
  265.   filename = (char*)malloc(sizeof(char) * (strlen(dir) + strlen(name) + 1));
  266.   strcpy(filename, dir);
  267.   strcat(filename, name);
  268.   free(dir);
  270.   file = fopen(filename, "r");
  271.   if (!file) {
  272.     fprintf(stderr, "glmReadMTL() failed: can't open material file "%s".n",
  273.     filename);
  274.     exit(1);
  275.   }
  276.   free(filename);
  278.   /* count the number of materials in the file */
  279.   nummaterials = 1;
  280.   while(fscanf(file, "%s", buf) != EOF) {
  281.     switch(buf[0]) {
  282.     case '#': /* comment */
  283.       /* eat up rest of line */
  284.       fgets(buf, sizeof(buf), file);
  285.       break;
  286.     case 'n': /* newmtl */
  287.       fgets(buf, sizeof(buf), file);
  288.       nummaterials++;
  289.       sscanf(buf, "%s %s", buf, buf);
  290.       break;
  291.     default:
  292.       /* eat up rest of line */
  293.       fgets(buf, sizeof(buf), file);
  294.       break;
  295.     }
  296.   }
  298.   rewind(file);
  300.   model->materials = (GLMmaterial*)malloc(sizeof(GLMmaterial) * nummaterials);
  301.   model->nummaterials = nummaterials;
  303.   /* set the default material */
  304.   for (i = 0; i < nummaterials; i++) {
  305.     model->materials[i].name = NULL;
  306.     model->materials[i].shininess = 65.0;
  307.     model->materials[i].diffuse[0] = 0.8;
  308.     model->materials[i].diffuse[1] = 0.8;
  309.     model->materials[i].diffuse[2] = 0.8;
  310.     model->materials[i].diffuse[3] = 1.0;
  311.     model->materials[i].ambient[0] = 0.2;
  312.     model->materials[i].ambient[1] = 0.2;
  313.     model->materials[i].ambient[2] = 0.2;
  314.     model->materials[i].ambient[3] = 1.0;
  315.     model->materials[i].specular[0] = 0.0;
  316.     model->materials[i].specular[1] = 0.0;
  317.     model->materials[i].specular[2] = 0.0;
  318.     model->materials[i].specular[3] = 1.0;
  319.   }
  320.   model->materials[0].name = strdup("default");
  322.   /* now, read in the data */
  323.   nummaterials = 0;
  324.   while(fscanf(file, "%s", buf) != EOF) {
  325.     switch(buf[0]) {
  326.     case '#': /* comment */
  327.       /* eat up rest of line */
  328.       fgets(buf, sizeof(buf), file);
  329.       break;
  330.     case 'n': /* newmtl */
  331.       fgets(buf, sizeof(buf), file);
  332.       sscanf(buf, "%s %s", buf, buf);
  333.       nummaterials++;
  334.       model->materials[nummaterials].name = strdup(buf);
  335.       break;
  336.     case 'N':
  337.       fscanf(file, "%f", &model->materials[nummaterials].shininess);
  338.       /* wavefront shininess is from [0, 1000], so scale for OpenGL */
  339.       model->materials[nummaterials].shininess /= 1000.0;
  340.       model->materials[nummaterials].shininess *= 128.0;
  341.       break;
  342.     case 'K':
  343.       switch(buf[1]) {
  344.       case 'd':
  345. fscanf(file, "%f %f %f",
  346.        &model->materials[nummaterials].diffuse[0],
  347.        &model->materials[nummaterials].diffuse[1],
  348.        &model->materials[nummaterials].diffuse[2]);
  349. break;
  350.       case 's':
  351. fscanf(file, "%f %f %f",
  352.        &model->materials[nummaterials].specular[0],
  353.        &model->materials[nummaterials].specular[1],
  354.        &model->materials[nummaterials].specular[2]);
  355. break;
  356.       case 'a':
  357. fscanf(file, "%f %f %f",
  358.        &model->materials[nummaterials].ambient[0],
  359.        &model->materials[nummaterials].ambient[1],
  360.        &model->materials[nummaterials].ambient[2]);
  361. break;
  362.       default:
  363. /* eat up rest of line */
  364. fgets(buf, sizeof(buf), file);
  365. break;
  366.       }
  367.       break;
  368.     default:
  369.       /* eat up rest of line */
  370.       fgets(buf, sizeof(buf), file);
  371.       break;
  372.     }
  373.   }
  374. }
  376. /* glmWriteMTL: write a wavefront material library file
  377.  *
  378.  * model      - properly initialized GLMmodel structure
  379.  * modelpath  - pathname of the model being written
  380.  * mtllibname - name of the material library to be written
  381.  */
  382. static GLvoid
  383. glmWriteMTL(GLMmodel* model, char* modelpath, char* mtllibname)
  384. {
  385.   FILE* file;
  386.   char* dir;
  387.   char* filename;
  388.   GLMmaterial* material;
  389.   GLuint i;
  391.   dir = glmDirName(modelpath);
  392.   filename = (char*)malloc(sizeof(char) * (strlen(dir)+strlen(mtllibname)));
  393.   strcpy(filename, dir);
  394.   strcat(filename, mtllibname);
  395.   free(dir);
  397.   /* open the file */
  398.   file = fopen(filename, "w");
  399.   if (!file) {
  400.     fprintf(stderr, "glmWriteMTL() failed: can't open file "%s".n",
  401.     filename);
  402.     exit(1);
  403.   }
  404.   free(filename);
  406.   /* spit out a header */
  407.   fprintf(file, "#  n");
  408.   fprintf(file, "#  Wavefront MTL generated by GLM libraryn");
  409.   fprintf(file, "#  n");
  410.   fprintf(file, "#  GLM libraryn");
  411.   fprintf(file, "#  Nate Robinsn");
  412.   fprintf(file, "#  ndr@pobox.comn");
  413.   fprintf(file, "#  http://www.pobox.com/~ndrn");
  414.   fprintf(file, "#  nn");
  416.   for (i = 0; i < model->nummaterials; i++) {
  417.     material = &model->materials[i];
  418.     fprintf(file, "newmtl %sn", material->name);
  419.     fprintf(file, "Ka %f %f %fn", 
  420.     material->ambient[0], material->ambient[1], material->ambient[2]);
  421.     fprintf(file, "Kd %f %f %fn", 
  422.     material->diffuse[0], material->diffuse[1], material->diffuse[2]);
  423.     fprintf(file, "Ks %f %f %fn", 
  424.     material->specular[0],material->specular[1],material->specular[2]);
  425.     fprintf(file, "Ns %fn", material->shininess / 128.0 * 1000.0);
  426.     fprintf(file, "n");
  427.   }
  428. }
  431. /* glmFirstPass: first pass at a Wavefront OBJ file that gets all the
  432.  * statistics of the model (such as #vertices, #normals, etc)
  433.  *
  434.  * model - properly initialized GLMmodel structure
  435.  * file  - (fopen'd) file descriptor 
  436.  */
  437. static GLvoid
  438. glmFirstPass(GLMmodel* model, FILE* file) 
  439. {
  440.   GLuint    numvertices; /* number of vertices in model */
  441.   GLuint    numnormals; /* number of normals in model */
  442.   GLuint    numtexcoords; /* number of texcoords in model */
  443.   GLuint    numtriangles; /* number of triangles in model */
  444.   GLMgroup* group; /* current group */
  445.   unsigned  v, n, t;
  446.   char      buf[128];
  448.   /* make a default group */
  449.   group = glmAddGroup(model, "default");
  451.   numvertices = numnormals = numtexcoords = numtriangles = 0;
  452.   while(fscanf(file, "%s", buf) != EOF) {
  453.     switch(buf[0]) {
  454.     case '#': /* comment */
  455.       /* eat up rest of line */
  456.       fgets(buf, sizeof(buf), file);
  457.       break;
  458.     case 'v': /* v, vn, vt */
  459.       switch(buf[1]) {
  460.       case '': /* vertex */
  461. /* eat up rest of line */
  462. fgets(buf, sizeof(buf), file);
  463. numvertices++;
  464. break;
  465.       case 'n': /* normal */
  466. /* eat up rest of line */
  467. fgets(buf, sizeof(buf), file);
  468. numnormals++;
  469. break;
  470.       case 't': /* texcoord */
  471. /* eat up rest of line */
  472. fgets(buf, sizeof(buf), file);
  473. numtexcoords++;
  474. break;
  475.       default:
  476. printf("glmFirstPass(): Unknown token "%s".n", buf);
  477. exit(1);
  478. break;
  479.       }
  480.       break;
  481.     case 'm':
  482.       fgets(buf, sizeof(buf), file);
  483.       sscanf(buf, "%s %s", buf, buf);
  484.       model->mtllibname = strdup(buf);
  485.       glmReadMTL(model, buf);
  486.       break;
  487.     case 'u':
  488.       /* eat up rest of line */
  489.       fgets(buf, sizeof(buf), file);
  490.       break;
  491.     case 'g': /* group */
  492.       /* eat up rest of line */
  493.       fgets(buf, sizeof(buf), file);
  494. #if SINGLE_STRING_GROUP_NAMES
  495.       sscanf(buf, "%s", buf);
  496. #else
  497.       buf[strlen(buf)-1] = ''; /* nuke 'n' */
  498. #endif
  499.       group = glmAddGroup(model, buf);
  500.       break;
  501.     case 'f': /* face */
  502.       v = n = t = 0;
  503.       fscanf(file, "%s", buf);
  504.       /* can be one of %d, %d//%d, %d/%d, %d/%d/%d %d//%d */
  505.       if (strstr(buf, "//")) {
  506. /* v//n */
  507. sscanf(buf, "%d//%d", &v, &n);
  508. fscanf(file, "%d//%d", &v, &n);
  509. fscanf(file, "%d//%d", &v, &n);
  510. numtriangles++;
  511. group->numtriangles++;
  512. while(fscanf(file, "%d//%d", &v, &n) > 0) {
  513.   numtriangles++;
  514.   group->numtriangles++;
  515. }
  516.       } else if (sscanf(buf, "%d/%d/%d", &v, &t, &n) == 3) {
  517. /* v/t/n */
  518. fscanf(file, "%d/%d/%d", &v, &t, &n);
  519. fscanf(file, "%d/%d/%d", &v, &t, &n);
  520. numtriangles++;
  521. group->numtriangles++;
  522. while(fscanf(file, "%d/%d/%d", &v, &t, &n) > 0) {
  523.   numtriangles++;
  524.   group->numtriangles++;
  525. }
  526.       } else if (sscanf(buf, "%d/%d", &v, &t) == 2) {
  527. /* v/t */
  528. fscanf(file, "%d/%d", &v, &t);
  529. fscanf(file, "%d/%d", &v, &t);
  530. numtriangles++;
  531. group->numtriangles++;
  532. while(fscanf(file, "%d/%d", &v, &t) > 0) {
  533.   numtriangles++;
  534.   group->numtriangles++;
  535. }
  536.       } else {
  537. /* v */
  538. fscanf(file, "%d", &v);
  539. fscanf(file, "%d", &v);
  540. numtriangles++;
  541. group->numtriangles++;
  542. while(fscanf(file, "%d", &v) > 0) {
  543.   numtriangles++;
  544.   group->numtriangles++;
  545. }
  546.       }
  547.       break;
  549.     default:
  550.       /* eat up rest of line */
  551.       fgets(buf, sizeof(buf), file);
  552.       break;
  553.     }
  554.   }
  556.   /* set the stats in the model structure */
  557.   model->numvertices  = numvertices;
  558.   model->numnormals   = numnormals;
  559.   model->numtexcoords = numtexcoords;
  560.   model->numtriangles = numtriangles;
  562.   /* allocate memory for the triangles in each group */
  563.   group = model->groups;
  564.   while(group) {
  565.     group->triangles = (GLuint*)malloc(sizeof(GLuint) * group->numtriangles);
  566.     group->numtriangles = 0;
  567.     group = group->next;
  568.   }
  569. }
  571. /* glmSecondPass: second pass at a Wavefront OBJ file that gets all
  572.  * the data.
  573.  *
  574.  * model - properly initialized GLMmodel structure
  575.  * file  - (fopen'd) file descriptor 
  576.  */
  577. static GLvoid
  578. glmSecondPass(GLMmodel* model, FILE* file) 
  579. {
  580.   GLuint    numvertices; /* number of vertices in model */
  581.   GLuint    numnormals; /* number of normals in model */
  582.   GLuint    numtexcoords; /* number of texcoords in model */
  583.   GLuint    numtriangles; /* number of triangles in model */
  584.   GLfloat*  vertices; /* array of vertices  */
  585.   GLfloat*  normals; /* array of normals */
  586.   GLfloat*  texcoords; /* array of texture coordinates */
  587.   GLMgroup* group; /* current group pointer */
  588.   GLuint    material; /* current material */
  589.   GLuint    v, n, t;
  590.   char      buf[128];
  592.   /* set the pointer shortcuts */
  593.   vertices     = model->vertices;
  594.   normals      = model->normals;
  595.   texcoords    = model->texcoords;
  596.   group        = model->groups;
  598.   /* on the second pass through the file, read all the data into the
  599.      allocated arrays */
  600.   numvertices = numnormals = numtexcoords = 1;
  601.   numtriangles = 0;
  602.   material = 0;
  603.   while(fscanf(file, "%s", buf) != EOF) {
  604.     switch(buf[0]) {
  605.     case '#': /* comment */
  606.       /* eat up rest of line */
  607.       fgets(buf, sizeof(buf), file);
  608.       break;
  609.     case 'v': /* v, vn, vt */
  610.       switch(buf[1]) {
  611.       case '': /* vertex */
  612. fscanf(file, "%f %f %f", 
  613.        &vertices[3 * numvertices + 0], 
  614.        &vertices[3 * numvertices + 1], 
  615.        &vertices[3 * numvertices + 2]);
  616. numvertices++;
  617. break;
  618.       case 'n': /* normal */
  619. fscanf(file, "%f %f %f", 
  620.        &normals[3 * numnormals + 0],
  621.        &normals[3 * numnormals + 1], 
  622.        &normals[3 * numnormals + 2]);
  623. numnormals++;
  624. break;
  625.       case 't': /* texcoord */
  626. fscanf(file, "%f %f", 
  627.        &texcoords[2 * numtexcoords + 0],
  628.        &texcoords[2 * numtexcoords + 1]);
  629. numtexcoords++;
  630. break;
  631.       }
  632.       break;
  633.     case 'u':
  634.       fgets(buf, sizeof(buf), file);
  635.       sscanf(buf, "%s %s", buf, buf);
  636.       group->material = material = glmFindMaterial(model, buf);
  637.       break;
  638.     case 'g': /* group */
  639.       /* eat up rest of line */
  640.       fgets(buf, sizeof(buf), file);
  641. #if SINGLE_STRING_GROUP_NAMES
  642.       sscanf(buf, "%s", buf);
  643. #else
  644.       buf[strlen(buf)-1] = ''; /* nuke 'n' */
  645. #endif
  646.       group = glmFindGroup(model, buf);
  647.       group->material = material;
  648.       break;
  649.     case 'f': /* face */
  650.       v = n = t = 0;
  651.       fscanf(file, "%s", buf);
  652.       /* can be one of %d, %d//%d, %d/%d, %d/%d/%d %d//%d */
  653.       if (strstr(buf, "//")) {
  654. /* v//n */
  655. sscanf(buf, "%d//%d", &v, &n);
  656. T(numtriangles).vindices[0] = v;
  657. T(numtriangles).nindices[0] = n;
  658. fscanf(file, "%d//%d", &v, &n);
  659. T(numtriangles).vindices[1] = v;
  660. T(numtriangles).nindices[1] = n;
  661. fscanf(file, "%d//%d", &v, &n);
  662. T(numtriangles).vindices[2] = v;
  663. T(numtriangles).nindices[2] = n;
  664. group->triangles[group->numtriangles++] = numtriangles;
  665. numtriangles++;
  666. while(fscanf(file, "%d//%d", &v, &n) > 0) {
  667.   T(numtriangles).vindices[0] = T(numtriangles-1).vindices[0];
  668.   T(numtriangles).nindices[0] = T(numtriangles-1).nindices[0];
  669.   T(numtriangles).vindices[1] = T(numtriangles-1).vindices[2];
  670.   T(numtriangles).nindices[1] = T(numtriangles-1).nindices[2];
  671.   T(numtriangles).vindices[2] = v;
  672.   T(numtriangles).nindices[2] = n;
  673.   group->triangles[group->numtriangles++] = numtriangles;
  674.   numtriangles++;
  675. }
  676.       } else if (sscanf(buf, "%d/%d/%d", &v, &t, &n) == 3) {
  677. /* v/t/n */
  678. T(numtriangles).vindices[0] = v;
  679. T(numtriangles).tindices[0] = t;
  680. T(numtriangles).nindices[0] = n;
  681. fscanf(file, "%d/%d/%d", &v, &t, &n);
  682. T(numtriangles).vindices[1] = v;
  683. T(numtriangles).tindices[1] = t;
  684. T(numtriangles).nindices[1] = n;
  685. fscanf(file, "%d/%d/%d", &v, &t, &n);
  686. T(numtriangles).vindices[2] = v;
  687. T(numtriangles).tindices[2] = t;
  688. T(numtriangles).nindices[2] = n;
  689. group->triangles[group->numtriangles++] = numtriangles;
  690. numtriangles++;
  691. while(fscanf(file, "%d/%d/%d", &v, &t, &n) > 0) {
  692.   T(numtriangles).vindices[0] = T(numtriangles-1).vindices[0];
  693.   T(numtriangles).tindices[0] = T(numtriangles-1).tindices[0];
  694.   T(numtriangles).nindices[0] = T(numtriangles-1).nindices[0];
  695.   T(numtriangles).vindices[1] = T(numtriangles-1).vindices[2];
  696.   T(numtriangles).tindices[1] = T(numtriangles-1).tindices[2];
  697.   T(numtriangles).nindices[1] = T(numtriangles-1).nindices[2];
  698.   T(numtriangles).vindices[2] = v;
  699.   T(numtriangles).tindices[2] = t;
  700.   T(numtriangles).nindices[2] = n;
  701.   group->triangles[group->numtriangles++] = numtriangles;
  702.   numtriangles++;
  703. }
  704.       } else if (sscanf(buf, "%d/%d", &v, &t) == 2) {
  705. /* v/t */
  706. T(numtriangles).vindices[0] = v;
  707. T(numtriangles).tindices[0] = t;
  708. fscanf(file, "%d/%d", &v, &t);
  709. T(numtriangles).vindices[1] = v;
  710. T(numtriangles).tindices[1] = t;
  711. fscanf(file, "%d/%d", &v, &t);
  712. T(numtriangles).vindices[2] = v;
  713. T(numtriangles).tindices[2] = t;
  714. group->triangles[group->numtriangles++] = numtriangles;
  715. numtriangles++;
  716. while(fscanf(file, "%d/%d", &v, &t) > 0) {
  717.   T(numtriangles).vindices[0] = T(numtriangles-1).vindices[0];
  718.   T(numtriangles).tindices[0] = T(numtriangles-1).tindices[0];
  719.   T(numtriangles).vindices[1] = T(numtriangles-1).vindices[2];
  720.   T(numtriangles).tindices[1] = T(numtriangles-1).tindices[2];
  721.   T(numtriangles).vindices[2] = v;
  722.   T(numtriangles).tindices[2] = t;
  723.   group->triangles[group->numtriangles++] = numtriangles;
  724.   numtriangles++;
  725. }
  726.       } else {
  727. /* v */
  728. sscanf(buf, "%d", &v);
  729. T(numtriangles).vindices[0] = v;
  730. fscanf(file, "%d", &v);
  731. T(numtriangles).vindices[1] = v;
  732. fscanf(file, "%d", &v);
  733. T(numtriangles).vindices[2] = v;
  734. group->triangles[group->numtriangles++] = numtriangles;
  735. numtriangles++;
  736. while(fscanf(file, "%d", &v) > 0) {
  737.   T(numtriangles).vindices[0] = T(numtriangles-1).vindices[0];
  738.   T(numtriangles).vindices[1] = T(numtriangles-1).vindices[2];
  739.   T(numtriangles).vindices[2] = v;
  740.   group->triangles[group->numtriangles++] = numtriangles;
  741.   numtriangles++;
  742. }
  743.       }
  744.       break;
  746.     default:
  747.       /* eat up rest of line */
  748.       fgets(buf, sizeof(buf), file);
  749.       break;
  750.     }
  751.   }
  753. #if 0
  754.   /* announce the memory requirements */
  755.   printf(" Memory: %d bytesn",
  756.  numvertices  * 3*sizeof(GLfloat) +
  757.  numnormals   * 3*sizeof(GLfloat) * (numnormals ? 1 : 0) +
  758.  numtexcoords * 3*sizeof(GLfloat) * (numtexcoords ? 1 : 0) +
  759.  numtriangles * sizeof(GLMtriangle));
  760. #endif
  761. }
  766. /* glmUnitize: "unitize" a model by translating it to the origin and
  767.  * scaling it to fit in a unit cube around the origin (-1 to 1 in all
  768.  * dimensions).  
  769.  * Returns the scalefactor used.
  770.  *
  771.  * model - properly initialized GLMmodel structure 
  772.  */
  773. GLfloat
  774. glmUnitize(GLMmodel* model)
  775. {
  776.   GLuint  i;
  777.   GLfloat maxx, minx, maxy, miny, maxz, minz;
  778.   GLfloat cx, cy, cz, w, h, d;
  779.   GLfloat scale;
  781.   assert(model);
  782.   assert(model->vertices);
  784.   /* get the max/mins */
  785.   maxx = minx = model->vertices[3 + 0];
  786.   maxy = miny = model->vertices[3 + 1];
  787.   maxz = minz = model->vertices[3 + 2];
  788.   for (i = 1; i <= model->numvertices; i++) {
  789.     if (maxx < model->vertices[3 * i + 0])
  790.       maxx = model->vertices[3 * i + 0];
  791.     if (minx > model->vertices[3 * i + 0])
  792.       minx = model->vertices[3 * i + 0];
  794.     if (maxy < model->vertices[3 * i + 1])
  795.       maxy = model->vertices[3 * i + 1];
  796.     if (miny > model->vertices[3 * i + 1])
  797.       miny = model->vertices[3 * i + 1];
  799.     if (maxz < model->vertices[3 * i + 2])
  800.       maxz = model->vertices[3 * i + 2];
  801.     if (minz > model->vertices[3 * i + 2])
  802.       minz = model->vertices[3 * i + 2];
  803.   }
  805.   /* calculate model width, height, and depth */
  806.   w = glmAbs(maxx) + glmAbs(minx);
  807.   h = glmAbs(maxy) + glmAbs(miny);
  808.   d = glmAbs(maxz) + glmAbs(minz);
  810.   /* calculate center of the model */
  811.   cx = (maxx + minx) / 2.0;
  812.   cy = (maxy + miny) / 2.0;
  813.   cz = (maxz + minz) / 2.0;
  815.   /* calculate unitizing scale factor */
  816.   scale = 2.0 / glmMax(glmMax(w, h), d);
  818.   /* translate around center then scale */
  819.   for (i = 1; i <= model->numvertices; i++) {
  820.     model->vertices[3 * i + 0] -= cx;
  821.     model->vertices[3 * i + 1] -= cy;
  822.     model->vertices[3 * i + 2] -= cz;
  823.     model->vertices[3 * i + 0] *= scale;
  824.     model->vertices[3 * i + 1] *= scale;
  825.     model->vertices[3 * i + 2] *= scale;
  826.   }
  828.   return scale;
  829. }
  831. /* glmDimensions: Calculates the dimensions (width, height, depth) of
  832.  * a model.
  833.  *
  834.  * model      - initialized GLMmodel structure
  835.  * dimensions - array of 3 GLfloats (GLfloat dimensions[3])
  836.  */
  837. GLvoid
  838. glmDimensions(GLMmodel* model, GLfloat* dimensions)
  839. {
  840.   GLuint i;
  841.   GLfloat maxx, minx, maxy, miny, maxz, minz;
  843.   assert(model);
  844.   assert(model->vertices);
  845.   assert(dimensions);
  847.   /* get the max/mins */
  848.   maxx = minx = model->vertices[3 + 0];
  849.   maxy = miny = model->vertices[3 + 1];
  850.   maxz = minz = model->vertices[3 + 2];
  851.   for (i = 1; i <= model->numvertices; i++) {
  852.     if (maxx < model->vertices[3 * i + 0])
  853.       maxx = model->vertices[3 * i + 0];
  854.     if (minx > model->vertices[3 * i + 0])
  855.       minx = model->vertices[3 * i + 0];
  857.     if (maxy < model->vertices[3 * i + 1])
  858.       maxy = model->vertices[3 * i + 1];
  859.     if (miny > model->vertices[3 * i + 1])
  860.       miny = model->vertices[3 * i + 1];
  862.     if (maxz < model->vertices[3 * i + 2])
  863.       maxz = model->vertices[3 * i + 2];
  864.     if (minz > model->vertices[3 * i + 2])
  865.       minz = model->vertices[3 * i + 2];
  866.   }
  868.   /* calculate model width, height, and depth */
  869.   dimensions[0] = glmAbs(maxx) + glmAbs(minx);
  870.   dimensions[1] = glmAbs(maxy) + glmAbs(miny);
  871.   dimensions[2] = glmAbs(maxz) + glmAbs(minz);
  872. }
  874. /* glmScale: Scales a model by a given amount.
  875.  * 
  876.  * model - properly initialized GLMmodel structure
  877.  * scale - scalefactor (0.5 = half as large, 2.0 = twice as large)
  878.  */
  879. GLvoid
  880. glmScale(GLMmodel* model, GLfloat scale)
  881. {
  882.   GLuint i;
  884.   for (i = 1; i <= model->numvertices; i++) {
  885.     model->vertices[3 * i + 0] *= scale;
  886.     model->vertices[3 * i + 1] *= scale;
  887.     model->vertices[3 * i + 2] *= scale;
  888.   }
  889. }
  891. /* glmReverseWinding: Reverse the polygon winding for all polygons in
  892.  * this model.  Default winding is counter-clockwise.  Also changes
  893.  * the direction of the normals.
  894.  * 
  895.  * model - properly initialized GLMmodel structure 
  896.  */
  897. GLvoid
  898. glmReverseWinding(GLMmodel* model)
  899. {
  900.   GLuint i, swap;
  902.   assert(model);
  904.   for (i = 0; i < model->numtriangles; i++) {
  905.     swap = T(i).vindices[0];
  906.     T(i).vindices[0] = T(i).vindices[2];
  907.     T(i).vindices[2] = swap;
  909.     if (model->numnormals) {
  910.       swap = T(i).nindices[0];
  911.       T(i).nindices[0] = T(i).nindices[2];
  912.       T(i).nindices[2] = swap;
  913.     }
  915.     if (model->numtexcoords) {
  916.       swap = T(i).tindices[0];
  917.       T(i).tindices[0] = T(i).tindices[2];
  918.       T(i).tindices[2] = swap;
  919.     }
  920.   }
  922.   /* reverse facet normals */
  923.   for (i = 1; i <= model->numfacetnorms; i++) {
  924.     model->facetnorms[3 * i + 0] = -model->facetnorms[3 * i + 0];
  925.     model->facetnorms[3 * i + 1] = -model->facetnorms[3 * i + 1];
  926.     model->facetnorms[3 * i + 2] = -model->facetnorms[3 * i + 2];
  927.   }
  929.   /* reverse vertex normals */
  930.   for (i = 1; i <= model->numnormals; i++) {
  931.     model->normals[3 * i + 0] = -model->normals[3 * i + 0];
  932.     model->normals[3 * i + 1] = -model->normals[3 * i + 1];
  933.     model->normals[3 * i + 2] = -model->normals[3 * i + 2];
  934.   }
  935. }
  937. /* glmFacetNormals: Generates facet normals for a model (by taking the
  938.  * cross product of the two vectors derived from the sides of each
  939.  * triangle).  Assumes a counter-clockwise winding.
  940.  *
  941.  * model - initialized GLMmodel structure
  942.  */
  943. GLvoid
  944. glmFacetNormals(GLMmodel* model)
  945. {
  946.   GLuint  i;
  947.   GLfloat u[3];
  948.   GLfloat v[3];
  949.   
  950.   assert(model);
  951.   assert(model->vertices);
  953.   /* clobber any old facetnormals */
  954.   if (model->facetnorms)
  955.     free(model->facetnorms);
  957.   /* allocate memory for the new facet normals */
  958.   model->numfacetnorms = model->numtriangles;
  959.   model->facetnorms = (GLfloat*)malloc(sizeof(GLfloat) *
  960.        3 * (model->numfacetnorms + 1));
  962.   for (i = 0; i < model->numtriangles; i++) {
  963.     model->triangles[i].findex = i+1;
  965.     u[0] = model->vertices[3 * T(i).vindices[1] + 0] -
  966.            model->vertices[3 * T(i).vindices[0] + 0];
  967.     u[1] = model->vertices[3 * T(i).vindices[1] + 1] -
  968.            model->vertices[3 * T(i).vindices[0] + 1];
  969.     u[2] = model->vertices[3 * T(i).vindices[1] + 2] -
  970.            model->vertices[3 * T(i).vindices[0] + 2];
  972.     v[0] = model->vertices[3 * T(i).vindices[2] + 0] -
  973.            model->vertices[3 * T(i).vindices[0] + 0];
  974.     v[1] = model->vertices[3 * T(i).vindices[2] + 1] -
  975.            model->vertices[3 * T(i).vindices[0] + 1];
  976.     v[2] = model->vertices[3 * T(i).vindices[2] + 2] -
  977.            model->vertices[3 * T(i).vindices[0] + 2];
  979.     glmCross(u, v, &model->facetnorms[3 * (i+1)]);
  980.     glmNormalize(&model->facetnorms[3 * (i+1)]);
  981.   }
  982. }
  984. /* glmVertexNormals: Generates smooth vertex normals for a model.
  985.  * First builds a list of all the triangles each vertex is in.  Then
  986.  * loops through each vertex in the the list averaging all the facet
  987.  * normals of the triangles each vertex is in.  Finally, sets the
  988.  * normal index in the triangle for the vertex to the generated smooth
  989.  * normal.  If the dot product of a facet normal and the facet normal
  990.  * associated with the first triangle in the list of triangles the
  991.  * current vertex is in is greater than the cosine of the angle
  992.  * parameter to the function, that facet normal is not added into the
  993.  * average normal calculation and the corresponding vertex is given
  994.  * the facet normal.  This tends to preserve hard edges.  The angle to
  995.  * use depends on the model, but 90 degrees is usually a good start.
  996.  *
  997.  * model - initialized GLMmodel structure
  998.  * angle - maximum angle (in degrees) to smooth across
  999.  */
  1000. GLvoid
  1001. glmVertexNormals(GLMmodel* model, GLfloat angle)
  1002. {
  1003.   GLMnode*  node;
  1004.   GLMnode*  tail;
  1005.   GLMnode** members;
  1006.   GLfloat*  normals;
  1007.   GLuint    numnormals;
  1008.   GLfloat   average[3];
  1009.   GLfloat   dot, cos_angle;
  1010.   GLuint    i, avg;
  1012.   assert(model);
  1013.   assert(model->facetnorms);
  1015.   /* calculate the cosine of the angle (in degrees) */
  1016.   cos_angle = cos(angle * M_PI / 180.0);
  1018.   /* nuke any previous normals */
  1019.   if (model->normals)
  1020.     free(model->normals);
  1022.   /* allocate space for new normals */
  1023.   model->numnormals = model->numtriangles * 3; /* 3 normals per triangle */
  1024.   model->normals = (GLfloat*)malloc(sizeof(GLfloat)* 3* (model->numnormals+1));
  1026.   /* allocate a structure that will hold a linked list of triangle
  1027.      indices for each vertex */
  1028.   members = (GLMnode**)malloc(sizeof(GLMnode*) * (model->numvertices + 1));
  1029.   for (i = 1; i <= model->numvertices; i++)
  1030.     members[i] = NULL;
  1031.   
  1032.   /* for every triangle, create a node for each vertex in it */
  1033.   for (i = 0; i < model->numtriangles; i++) {
  1034.     node = (GLMnode*)malloc(sizeof(GLMnode));
  1035.     node->index = i;
  1036.     node->next  = members[T(i).vindices[0]];
  1037.     members[T(i).vindices[0]] = node;
  1039.     node = (GLMnode*)malloc(sizeof(GLMnode));
  1040.     node->index = i;
  1041.     node->next  = members[T(i).vindices[1]];
  1042.     members[T(i).vindices[1]] = node;
  1044.     node = (GLMnode*)malloc(sizeof(GLMnode));
  1045.     node->index = i;
  1046.     node->next  = members[T(i).vindices[2]];
  1047.     members[T(i).vindices[2]] = node;
  1048.   }
  1050.   /* calculate the average normal for each vertex */
  1051.   numnormals = 1;
  1052.   for (i = 1; i <= model->numvertices; i++) {
  1053.     /* calculate an average normal for this vertex by averaging the
  1054.        facet normal of every triangle this vertex is in */
  1055.     node = members[i];
  1056.     if (!node)
  1057.       fprintf(stderr, "glmVertexNormals(): vertex w/o a trianglen");
  1058.     average[0] = 0.0; average[1] = 0.0; average[2] = 0.0;
  1059.     avg = 0;
  1060.     while (node) {
  1061.       /* only average if the dot product of the angle between the two
  1062.          facet normals is greater than the cosine of the threshold
  1063.          angle -- or, said another way, the angle between the two
  1064.          facet normals is less than (or equal to) the threshold angle */
  1065.       dot = glmDot(&model->facetnorms[3 * T(node->index).findex],
  1066.       &model->facetnorms[3 * T(members[i]->index).findex]);
  1067.       if (dot > cos_angle) {
  1068. node->averaged = GL_TRUE;
  1069. average[0] += model->facetnorms[3 * T(node->index).findex + 0];
  1070. average[1] += model->facetnorms[3 * T(node->index).findex + 1];
  1071. average[2] += model->facetnorms[3 * T(node->index).findex + 2];
  1072. avg = 1; /* we averaged at least one normal! */
  1073.       } else {
  1074. node->averaged = GL_FALSE;
  1075.       }
  1076.       node = node->next;
  1077.     }
  1079.     if (avg) {
  1080.       /* normalize the averaged normal */
  1081.       glmNormalize(average);
  1083.       /* add the normal to the vertex normals list */
  1084.       model->normals[3 * numnormals + 0] = average[0];
  1085.       model->normals[3 * numnormals + 1] = average[1];
  1086.       model->normals[3 * numnormals + 2] = average[2];
  1087.       avg = numnormals;
  1088.       numnormals++;
  1089.     }
  1091.     /* set the normal of this vertex in each triangle it is in */
  1092.     node = members[i];
  1093.     while (node) {
  1094.       if (node->averaged) {
  1095. /* if this node was averaged, use the average normal */
  1096. if (T(node->index).vindices[0] == i)
  1097.   T(node->index).nindices[0] = avg;
  1098. else if (T(node->index).vindices[1] == i)
  1099.   T(node->index).nindices[1] = avg;
  1100. else if (T(node->index).vindices[2] == i)
  1101.   T(node->index).nindices[2] = avg;
  1102.       } else {
  1103. /* if this node wasn't averaged, use the facet normal */
  1104. model->normals[3 * numnormals + 0] = 
  1105.   model->facetnorms[3 * T(node->index).findex + 0];
  1106. model->normals[3 * numnormals + 1] = 
  1107.   model->facetnorms[3 * T(node->index).findex + 1];
  1108. model->normals[3 * numnormals + 2] = 
  1109.   model->facetnorms[3 * T(node->index).findex + 2];
  1110. if (T(node->index).vindices[0] == i)
  1111.   T(node->index).nindices[0] = numnormals;
  1112. else if (T(node->index).vindices[1] == i)
  1113.   T(node->index).nindices[1] = numnormals;
  1114. else if (T(node->index).vindices[2] == i)
  1115.   T(node->index).nindices[2] = numnormals;
  1116. numnormals++;
  1117.       }
  1118.       node = node->next;
  1119.     }
  1120.   }
  1121.   
  1122.   model->numnormals = numnormals - 1;
  1124.   /* free the member information */
  1125.   for (i = 1; i <= model->numvertices; i++) {
  1126.     node = members[i];
  1127.     while (node) {
  1128.       tail = node;
  1129.       node = node->next;
  1130.       free(tail);
  1131.     }
  1132.   }
  1133.   free(members);
  1135.   /* pack the normals array (we previously allocated the maximum
  1136.      number of normals that could possibly be created (numtriangles *
  1137.      3), so get rid of some of them (usually alot unless none of the
  1138.      facet normals were averaged)) */
  1139.   normals = model->normals;
  1140.   model->normals = (GLfloat*)malloc(sizeof(GLfloat)* 3* (model->numnormals+1));
  1141.   for (i = 1; i <= model->numnormals; i++) {
  1142.     model->normals[3 * i + 0] = normals[3 * i + 0];
  1143.     model->normals[3 * i + 1] = normals[3 * i + 1];
  1144.     model->normals[3 * i + 2] = normals[3 * i + 2];
  1145.   }
  1146.   free(normals);
  1147. }
  1150. /* glmLinearTexture: Generates texture coordinates according to a
  1151.  * linear projection of the texture map.  It generates these by
  1152.  * linearly mapping the vertices onto a square.
  1153.  *
  1154.  * model - pointer to initialized GLMmodel structure
  1155.  */
  1156. GLvoid
  1157. glmLinearTexture(GLMmodel* model)
  1158. {
  1159.   GLMgroup *group;
  1160.   GLfloat dimensions[3];
  1161.   GLfloat x, y, scalefactor;
  1162.   GLuint i;
  1163.   
  1164.   assert(model);
  1166.   if (model->texcoords)
  1167.     free(model->texcoords);
  1168.   model->numtexcoords = model->numvertices;
  1169.   model->texcoords=(GLfloat*)malloc(sizeof(GLfloat)*2*(model->numtexcoords+1));
  1170.   
  1171.   glmDimensions(model, dimensions);
  1172.   scalefactor = 2.0 / 
  1173.     glmAbs(glmMax(glmMax(dimensions[0], dimensions[1]), dimensions[2]));
  1175.   /* do the calculations */
  1176.   for(i = 1; i <= model->numvertices; i++) {
  1177.     x = model->vertices[3 * i + 0] * scalefactor;
  1178.     y = model->vertices[3 * i + 2] * scalefactor;
  1179.     model->texcoords[2 * i + 0] = (x + 1.0) / 2.0;
  1180.     model->texcoords[2 * i + 1] = (y + 1.0) / 2.0;
  1181.   }
  1182.   
  1183.   /* go through and put texture coordinate indices in all the triangles */
  1184.   group = model->groups;
  1185.   while(group) {
  1186.     for(i = 0; i < group->numtriangles; i++) {
  1187.       T(group->triangles[i]).tindices[0] = T(group->triangles[i]).vindices[0];
  1188.       T(group->triangles[i]).tindices[1] = T(group->triangles[i]).vindices[1];
  1189.       T(group->triangles[i]).tindices[2] = T(group->triangles[i]).vindices[2];
  1190.     }    
  1191.     group = group->next;
  1192.   }
  1194. #if 0
  1195.   printf("glmLinearTexture(): generated %d linear texture coordinatesn",
  1196.   model->numtexcoords);
  1197. #endif
  1198. }
  1200. /* glmSpheremapTexture: Generates texture coordinates according to a
  1201.  * spherical projection of the texture map.  Sometimes referred to as
  1202.  * spheremap, or reflection map texture coordinates.  It generates
  1203.  * these by using the normal to calculate where that vertex would map
  1204.  * onto a sphere.  Since it is impossible to map something flat
  1205.  * perfectly onto something spherical, there is distortion at the
  1206.  * poles.  This particular implementation causes the poles along the X
  1207.  * axis to be distorted.
  1208.  *
  1209.  * model - pointer to initialized GLMmodel structure
  1210.  */
  1211. GLvoid
  1212. glmSpheremapTexture(GLMmodel* model)
  1213. {
  1214.   GLMgroup* group;
  1215.   GLfloat theta, phi, rho, x, y, z, r;
  1216.   GLuint i;
  1217.   
  1218.   assert(model);
  1219.   assert(model->normals);
  1221.   if (model->texcoords)
  1222.     free(model->texcoords);
  1223.   model->numtexcoords = model->numnormals;
  1224.   model->texcoords=(GLfloat*)malloc(sizeof(GLfloat)*2*(model->numtexcoords+1));
  1225.      
  1226.   for (i = 1; i <= model->numnormals; i++) {
  1227.     z = model->normals[3 * i + 0]; /* re-arrange for pole distortion */
  1228.     y = model->normals[3 * i + 1];
  1229.     x = model->normals[3 * i + 2];
  1230.     r = sqrt((x * x) + (y * y));
  1231.     rho = sqrt((r * r) + (z * z));
  1232.       
  1233.     if(r == 0.0) {
  1234. theta = 0.0;
  1235. phi = 0.0;
  1236.     } else {
  1237.       if(z == 0.0)
  1238. phi = 3.14159265 / 2.0;
  1239.       else
  1240. phi = acos(z / rho);
  1242.       if(y == 0.0)
  1243. theta = 3.141592365 / 2.0;
  1244.       else
  1245. theta = asin(y / r) + (3.14159265 / 2.0);
  1246.     }
  1247.     
  1248.     model->texcoords[2 * i + 0] = theta / 3.14159265;
  1249.     model->texcoords[2 * i + 1] = phi / 3.14159265;
  1250.   }
  1251.   
  1252.   /* go through and put texcoord indices in all the triangles */
  1253.   group = model->groups;
  1254.   while(group) {
  1255.     for (i = 0; i < group->numtriangles; i++) {
  1256.       T(group->triangles[i]).tindices[0] = T(group->triangles[i]).nindices[0];
  1257.       T(group->triangles[i]).tindices[1] = T(group->triangles[i]).nindices[1];
  1258.       T(group->triangles[i]).tindices[2] = T(group->triangles[i]).nindices[2];
  1259.     }
  1260.     group = group->next;
  1261.   }
  1262. }
  1264. /* glmDelete: Deletes a GLMmodel structure.
  1265.  *
  1266.  * model - initialized GLMmodel structure
  1267.  */
  1268. GLvoid
  1269. glmDelete(GLMmodel* model)
  1270. {
  1271.   GLMgroup* group;
  1272.   GLuint i;
  1274.   assert(model);
  1276.   if (model->pathname)   free(model->pathname);
  1277.   if (model->mtllibname) free(model->mtllibname);
  1278.   if (model->vertices)   free(model->vertices);
  1279.   if (model->normals)    free(model->normals);
  1280.   if (model->texcoords)  free(model->texcoords);
  1281.   if (model->facetnorms) free(model->facetnorms);
  1282.   if (model->triangles)  free(model->triangles);
  1283.   if (model->materials) {
  1284.     for (i = 0; i < model->nummaterials; i++)
  1285.       free(model->materials[i].name);
  1286.   }
  1287.   free(model->materials);
  1288.   while(model->groups) {
  1289.     group = model->groups;
  1290.     model->groups = model->groups->next;
  1291.     free(group->name);
  1292.     free(group->triangles);
  1293.     free(group);
  1294.   }
  1296.   free(model);
  1297. }
  1299. /* glmReadOBJ: Reads a model description from a Wavefront .OBJ file.
  1300.  * Returns a pointer to the created object which should be free'd with
  1301.  * glmDelete().
  1302.  *
  1303.  * filename - name of the file containing the Wavefront .OBJ format data.  
  1304.  */
  1305. GLMmodel* 
  1306. glmReadOBJ(char* filename)
  1307. {
  1308.   GLMmodel* model;
  1309.   FILE*     file;
  1311.   /* open the file */
  1312.   file = fopen(filename, "r");
  1313.   if (!file) {
  1314.     fprintf(stderr, "glmReadOBJ() failed: can't open data file "%s".n",
  1315.     filename);
  1316.     exit(1);
  1317.   }
  1319.   /* allocate a new model */
  1320.   model = (GLMmodel*)malloc(sizeof(GLMmodel));
  1321.   model->pathname      = strdup(filename);
  1322.   model->mtllibname    = NULL;
  1323.   model->numvertices   = 0;
  1324.   model->vertices      = NULL;
  1325.   model->numnormals    = 0;
  1326.   model->normals       = NULL;
  1327.   model->numtexcoords  = 0;
  1328.   model->texcoords     = NULL;
  1329.   model->numfacetnorms = 0;
  1330.   model->facetnorms    = NULL;
  1331.   model->numtriangles  = 0;
  1332.   model->triangles     = NULL;
  1333.   model->nummaterials  = 0;
  1334.   model->materials     = NULL;
  1335.   model->numgroups     = 0;
  1336.   model->groups        = NULL;
  1337.   model->position[0]   = 0.0;
  1338.   model->position[1]   = 0.0;
  1339.   model->position[2]   = 0.0;
  1341.   /* make a first pass through the file to get a count of the number
  1342.      of vertices, normals, texcoords & triangles */
  1343.   glmFirstPass(model, file);
  1345.   /* allocate memory */
  1346.   model->vertices = (GLfloat*)malloc(sizeof(GLfloat) *
  1347.      3 * (model->numvertices + 1));
  1348.   model->triangles = (GLMtriangle*)malloc(sizeof(GLMtriangle) *
  1349.   model->numtriangles);
  1350.   if (model->numnormals) {
  1351.     model->normals = (GLfloat*)malloc(sizeof(GLfloat) *
  1352.       3 * (model->numnormals + 1));
  1353.   }
  1354.   if (model->numtexcoords) {
  1355.     model->texcoords = (GLfloat*)malloc(sizeof(GLfloat) *
  1356. 2 * (model->numtexcoords + 1));
  1357.   }
  1359.   /* rewind to beginning of file and read in the data this pass */
  1360.   rewind(file);
  1362.   glmSecondPass(model, file);
  1364.   /* close the file */
  1365.   fclose(file);
  1367.   return model;
  1368. }
  1370. /* glmWriteOBJ: Writes a model description in Wavefront .OBJ format to
  1371.  * a file.
  1372.  *
  1373.  * model    - initialized GLMmodel structure
  1374.  * filename - name of the file to write the Wavefront .OBJ format data to
  1375.  * mode     - a bitwise or of values describing what is written to the file
  1376.  *            GLM_NONE     -  render with only vertices
  1377.  *            GLM_FLAT     -  render with facet normals
  1378.  *            GLM_SMOOTH   -  render with vertex normals
  1379.  *            GLM_TEXTURE  -  render with texture coords
  1380.  *            GLM_COLOR    -  render with colors (color material)
  1381.  *            GLM_MATERIAL -  render with materials
  1382.  *            GLM_COLOR and GLM_MATERIAL should not both be specified.  
  1383.  *            GLM_FLAT and GLM_SMOOTH should not both be specified.  
  1384.  */
  1385. GLvoid
  1386. glmWriteOBJ(GLMmodel* model, char* filename, GLuint mode)
  1387. {
  1388.   GLuint    i;
  1389.   FILE*     file;
  1390.   GLMgroup* group;
  1392.   assert(model);
  1394.   /* do a bit of warning */
  1395.   if (mode & GLM_FLAT && !model->facetnorms) {
  1396.     printf("glmWriteOBJ() warning: flat normal output requested "
  1397.    "with no facet normals defined.n");
  1398.     mode &= ~GLM_FLAT;
  1399.   }
  1400.   if (mode & GLM_SMOOTH && !model->normals) {
  1401.     printf("glmWriteOBJ() warning: smooth normal output requested "
  1402.    "with no normals defined.n");
  1403.     mode &= ~GLM_SMOOTH;
  1404.   }
  1405.   if (mode & GLM_TEXTURE && !model->texcoords) {
  1406.     printf("glmWriteOBJ() warning: texture coordinate output requested "
  1407.    "with no texture coordinates defined.n");
  1408.     mode &= ~GLM_TEXTURE;
  1409.   }
  1410.   if (mode & GLM_FLAT && mode & GLM_SMOOTH) {
  1411.     printf("glmWriteOBJ() warning: flat normal output requested "
  1412.    "and smooth normal output requested (using smooth).n");
  1413.     mode &= ~GLM_FLAT;
  1414.   }
  1415.   if (mode & GLM_COLOR && !model->materials) {
  1416.     printf("glmWriteOBJ() warning: color output requested "
  1417.    "with no colors (materials) defined.n");
  1418.     mode &= ~GLM_COLOR;
  1419.   }
  1420.   if (mode & GLM_MATERIAL && !model->materials) {
  1421.     printf("glmWriteOBJ() warning: material output requested "
  1422.    "with no materials defined.n");
  1423.     mode &= ~GLM_MATERIAL;
  1424.   }
  1425.   if (mode & GLM_COLOR && mode & GLM_MATERIAL) {
  1426.     printf("glmDraw() warning: color and material output requested "
  1427.    "outputting only materials.n");
  1428.     mode &= ~GLM_COLOR;
  1429.   }
  1432.   /* open the file */
  1433.   file = fopen(filename, "w");
  1434.   if (!file) {
  1435.     fprintf(stderr, "glmWriteOBJ() failed: can't open file "%s" to write.n",
  1436.     filename);
  1437.     exit(1);
  1438.   }
  1440.   /* spit out a header */
  1441.   fprintf(file, "#  n");
  1442.   fprintf(file, "#  Wavefront OBJ generated by GLM libraryn");
  1443.   fprintf(file, "#  n");
  1444.   fprintf(file, "#  GLM libraryn");
  1445.   fprintf(file, "#  Nate Robinsn");
  1446.   fprintf(file, "#  ndr@pobox.comn");
  1447.   fprintf(file, "#  http://www.pobox.com/~ndrn");
  1448.   fprintf(file, "#  n");
  1450.   if (mode & GLM_MATERIAL && model->mtllibname) {
  1451.     fprintf(file, "nmtllib %snn", model->mtllibname);
  1452.     glmWriteMTL(model, filename, model->mtllibname);
  1453.   }
  1455.   /* spit out the vertices */
  1456.   fprintf(file, "n");
  1457.   fprintf(file, "# %d verticesn", model->numvertices);
  1458.   for (i = 1; i <= model->numvertices; i++) {
  1459.     fprintf(file, "v %f %f %fn", 
  1460.     model->vertices[3 * i + 0],
  1461.     model->vertices[3 * i + 1],
  1462.     model->vertices[3 * i + 2]);
  1463.   }
  1465.   /* spit out the smooth/flat normals */
  1466.   if (mode & GLM_SMOOTH) {
  1467.     fprintf(file, "n");
  1468.     fprintf(file, "# %d normalsn", model->numnormals);
  1469.     for (i = 1; i <= model->numnormals; i++) {
  1470.       fprintf(file, "vn %f %f %fn", 
  1471.       model->normals[3 * i + 0],
  1472.       model->normals[3 * i + 1],
  1473.       model->normals[3 * i + 2]);
  1474.     }
  1475.   } else if (mode & GLM_FLAT) {
  1476.     fprintf(file, "n");
  1477.     fprintf(file, "# %d normalsn", model->numfacetnorms);
  1478.     for (i = 1; i <= model->numnormals; i++) {
  1479.       fprintf(file, "vn %f %f %fn", 
  1480.       model->facetnorms[3 * i + 0],
  1481.       model->facetnorms[3 * i + 1],
  1482.       model->facetnorms[3 * i + 2]);
  1483.     }
  1484.   }
  1486.   /* spit out the texture coordinates */
  1487.   if (mode & GLM_TEXTURE) {
  1488.     fprintf(file, "n");
  1489.     fprintf(file, "# %d texcoordsn", model->texcoords);
  1490.     for (i = 1; i <= model->numtexcoords; i++) {
  1491.       fprintf(file, "vt %f %fn", 
  1492.       model->texcoords[2 * i + 0],
  1493.       model->texcoords[2 * i + 1]);
  1494.     }
  1495.   }
  1497.   fprintf(file, "n");
  1498.   fprintf(file, "# %d groupsn", model->numgroups);
  1499.   fprintf(file, "# %d faces (triangles)n", model->numtriangles);
  1500.   fprintf(file, "n");
  1502.   group = model->groups;
  1503.   while(group) {
  1504.     fprintf(file, "g %sn", group->name);
  1505.     if (mode & GLM_MATERIAL)
  1506.       fprintf(file, "usemtl %sn", model->materials[group->material].name);
  1507.     for (i = 0; i < group->numtriangles; i++) {
  1508.       if (mode & GLM_SMOOTH && mode & GLM_TEXTURE) {
  1509. fprintf(file, "f %d/%d/%d %d/%d/%d %d/%d/%dn",
  1510. T(group->triangles[i]).vindices[0], 
  1511. T(group->triangles[i]).nindices[0], 
  1512. T(group->triangles[i]).tindices[0],
  1513. T(group->triangles[i]).vindices[1],
  1514. T(group->triangles[i]).nindices[1],
  1515. T(group->triangles[i]).tindices[1],
  1516. T(group->triangles[i]).vindices[2],
  1517. T(group->triangles[i]).nindices[2],
  1518. T(group->triangles[i]).tindices[2]);
  1519.       } else if (mode & GLM_FLAT && mode & GLM_TEXTURE) {
  1520. fprintf(file, "f %d/%d %d/%d %d/%dn",
  1521. T(group->triangles[i]).vindices[0],
  1522. T(group->triangles[i]).findex,
  1523. T(group->triangles[i]).vindices[1],
  1524. T(group->triangles[i]).findex,
  1525. T(group->triangles[i]).vindices[2],
  1526. T(group->triangles[i]).findex);
  1527.       } else if (mode & GLM_TEXTURE) {
  1528. fprintf(file, "f %d/%d %d/%d %d/%dn",
  1529. T(group->triangles[i]).vindices[0],
  1530. T(group->triangles[i]).tindices[0],
  1531. T(group->triangles[i]).vindices[1],
  1532. T(group->triangles[i]).tindices[1],
  1533. T(group->triangles[i]).vindices[2],
  1534. T(group->triangles[i]).tindices[2]);
  1535.       } else if (mode & GLM_SMOOTH) {
  1536. fprintf(file, "f %d//%d %d//%d %d//%dn",
  1537. T(group->triangles[i]).vindices[0],
  1538. T(group->triangles[i]).nindices[0],
  1539. T(group->triangles[i]).vindices[1],
  1540. T(group->triangles[i]).nindices[1],
  1541. T(group->triangles[i]).vindices[2], 
  1542. T(group->triangles[i]).nindices[2]);
  1543.       } else if (mode & GLM_FLAT) {
  1544. fprintf(file, "f %d//%d %d//%d %d//%dn",
  1545. T(group->triangles[i]).vindices[0], 
  1546. T(group->triangles[i]).findex,
  1547. T(group->triangles[i]).vindices[1],
  1548. T(group->triangles[i]).findex,
  1549. T(group->triangles[i]).vindices[2],
  1550. T(group->triangles[i]).findex);
  1551.       } else {
  1552. fprintf(file, "f %d %d %dn",
  1553. T(group->triangles[i]).vindices[0],
  1554. T(group->triangles[i]).vindices[1],
  1555. T(group->triangles[i]).vindices[2]);
  1556.       }
  1557.     }
  1558.     fprintf(file, "n");
  1559.     group = group->next;
  1560.   }
  1562.   fclose(file);
  1563. }
  1565. /* glmDraw: Renders the model to the current OpenGL context using the
  1566.  * mode specified.
  1567.  *
  1568.  * model    - initialized GLMmodel structure
  1569.  * mode     - a bitwise OR of values describing what is to be rendered.
  1570.  *            GLM_NONE     -  render with only vertices
  1571.  *            GLM_FLAT     -  render with facet normals
  1572.  *            GLM_SMOOTH   -  render with vertex normals
  1573.  *            GLM_TEXTURE  -  render with texture coords
  1574.  *            GLM_COLOR    -  render with colors (color material)
  1575.  *            GLM_MATERIAL -  render with materials
  1576.  *            GLM_COLOR and GLM_MATERIAL should not both be specified.  
  1577.  *            GLM_FLAT and GLM_SMOOTH should not both be specified.  
  1578.  */
  1579. GLvoid
  1580. glmDraw(GLMmodel* model, GLuint mode)
  1581. {
  1582.   static GLuint i;
  1583.   static GLMgroup* group;
  1584.   static GLMtriangle* triangle;
  1585.   static GLMmaterial* material;
  1587.   assert(model);
  1588.   assert(model->vertices);
  1590.   /* do a bit of warning */
  1591.   if (mode & GLM_FLAT && !model->facetnorms) {
  1592.     printf("glmDraw() warning: flat render mode requested "
  1593.    "with no facet normals defined.n");
  1594.     mode &= ~GLM_FLAT;
  1595.   }
  1596.   if (mode & GLM_SMOOTH && !model->normals) {
  1597.     printf("glmDraw() warning: smooth render mode requested "
  1598.    "with no normals defined.n");
  1599.     mode &= ~GLM_SMOOTH;
  1600.   }
  1601.   if (mode & GLM_TEXTURE && !model->texcoords) {
  1602.     printf("glmDraw() warning: texture render mode requested "
  1603.    "with no texture coordinates defined.n");
  1604.     mode &= ~GLM_TEXTURE;
  1605.   }
  1606.   if (mode & GLM_FLAT && mode & GLM_SMOOTH) {
  1607.     printf("glmDraw() warning: flat render mode requested "
  1608.    "and smooth render mode requested (using smooth).n");
  1609.     mode &= ~GLM_FLAT;
  1610.   }
  1611.   if (mode & GLM_COLOR && !model->materials) {
  1612.     printf("glmDraw() warning: color render mode requested "
  1613.    "with no materials defined.n");
  1614.     mode &= ~GLM_COLOR;
  1615.   }
  1616.   if (mode & GLM_MATERIAL && !model->materials) {
  1617.     printf("glmDraw() warning: material render mode requested "
  1618.    "with no materials defined.n");
  1619.     mode &= ~GLM_MATERIAL;
  1620.   }
  1621.   if (mode & GLM_COLOR && mode & GLM_MATERIAL) {
  1622.     printf("glmDraw() warning: color and material render mode requested "
  1623.    "using only material mode.n");
  1624.     mode &= ~GLM_COLOR;
  1625.   }
  1626.   if (mode & GLM_COLOR)
  1627.     glEnable(GL_COLOR_MATERIAL);
  1628.   else if (mode & GLM_MATERIAL)
  1629.     glDisable(GL_COLOR_MATERIAL);
  1631.   /* perhaps this loop should be unrolled into material, color, flat,
  1632.      smooth, etc. loops?  since most cpu's have good branch prediction
  1633.      schemes (and these branches will always go one way), probably
  1634.      wouldn't gain too much?  */
  1636.   group = model->groups;
  1637.   while (group) {
  1638.     if (mode & GLM_MATERIAL) {
  1639.       material = &model->materials[group->material];
  1640.       glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, material->ambient);
  1641.       glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, material->diffuse);
  1642.       glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, material->specular);
  1643.       glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, material->shininess);
  1644.     }
  1646.     if (mode & GLM_COLOR) {
  1647.       material = &model->materials[group->material];
  1648.       glColor3fv(material->diffuse);
  1649.     }
  1651.     glBegin(GL_TRIANGLES);
  1652.     for (i = 0; i < group->numtriangles; i++) {
  1653.       triangle = &T(group->triangles[i]);
  1655.       if (mode & GLM_FLAT)
  1656. glNormal3fv(&model->facetnorms[3 * triangle->findex]);
  1657.       
  1658.       if (mode & GLM_SMOOTH)
  1659. glNormal3fv(&model->normals[3 * triangle->nindices[0]]);
  1660.       if (mode & GLM_TEXTURE)
  1661. glTexCoord2fv(&model->texcoords[2 * triangle->tindices[0]]);
  1662.       glVertex3fv(&model->vertices[3 * triangle->vindices[0]]);
  1663.       
  1664.       if (mode & GLM_SMOOTH)
  1665. glNormal3fv(&model->normals[3 * triangle->nindices[1]]);
  1666.       if (mode & GLM_TEXTURE)
  1667. glTexCoord2fv(&model->texcoords[2 * triangle->tindices[1]]);
  1668.       glVertex3fv(&model->vertices[3 * triangle->vindices[1]]);
  1669.       
  1670.       if (mode & GLM_SMOOTH)
  1671. glNormal3fv(&model->normals[3 * triangle->nindices[2]]);
  1672.       if (mode & GLM_TEXTURE)
  1673. glTexCoord2fv(&model->texcoords[2 * triangle->tindices[2]]);
  1674.       glVertex3fv(&model->vertices[3 * triangle->vindices[2]]);
  1675.       
  1676.     }
  1677.     glEnd();
  1679.     group = group->next;
  1680.   }
  1681. }
  1683. /* glmList: Generates and returns a display list for the model using
  1684.  * the mode specified.
  1685.  *
  1686.  * model    - initialized GLMmodel structure
  1687.  * mode     - a bitwise OR of values describing what is to be rendered.
  1688.  *            GLM_NONE     -  render with only vertices
  1689.  *            GLM_FLAT     -  render with facet normals
  1690.  *            GLM_SMOOTH   -  render with vertex normals
  1691.  *            GLM_TEXTURE  -  render with texture coords
  1692.  *            GLM_COLOR    -  render with colors (color material)
  1693.  *            GLM_MATERIAL -  render with materials
  1694.  *            GLM_COLOR and GLM_MATERIAL should not both be specified.  
  1695.  * GLM_FLAT and GLM_SMOOTH should not both be specified.  */
  1696. GLuint
  1697. glmList(GLMmodel* model, GLuint mode)
  1698. {
  1699.   GLuint list;
  1701.   list = glGenLists(1);
  1702.   glNewList(list, GL_COMPILE);
  1703.   glmDraw(model, mode);
  1704.   glEndList();
  1706.   return list;
  1707. }
  1709. /* glmWeld: eliminate (weld) vectors that are within an epsilon of
  1710.  * each other.
  1711.  *
  1712.  * model      - initialized GLMmodel structure
  1713.  * epsilon    - maximum difference between vertices
  1714.  *              ( 0.00001 is a good start for a unitized model)
  1715.  *
  1716.  */
  1717. GLuint
  1718. glmWeld(GLMmodel* model, GLfloat epsilon)
  1719. {
  1720.   GLfloat* vectors;
  1721.   GLfloat* copies;
  1722.   GLuint   numvectors;
  1723.   GLuint   i, welded;
  1725.   /* vertices */
  1726.   numvectors = model->numvertices;
  1727.   vectors    = model->vertices;
  1728.   copies = glmWeldVectors(vectors, &numvectors, epsilon);
  1729.   welded = model->numvertices - numvectors - 1;
  1731.   for (i = 0; i < model->numtriangles; i++) {
  1732.     T(i).vindices[0] = (GLuint)vectors[3 * T(i).vindices[0] + 0];
  1733.     T(i).vindices[1] = (GLuint)vectors[3 * T(i).vindices[1] + 0];
  1734.     T(i).vindices[2] = (GLuint)vectors[3 * T(i).vindices[2] + 0];
  1735.   }
  1737.   /* free space for old vertices */
  1738.   free(vectors);
  1740.   /* allocate space for the new vertices */
  1741.   model->numvertices = numvectors;
  1742.   model->vertices = (GLfloat*)malloc(sizeof(GLfloat) * 
  1743.      3 * (model->numvertices + 1));
  1745.   /* copy the optimized vertices into the actual vertex list */
  1746.   for (i = 1; i <= model->numvertices; i++) {
  1747.     model->vertices[3 * i + 0] = copies[3 * i + 0];
  1748.     model->vertices[3 * i + 1] = copies[3 * i + 1];
  1749.     model->vertices[3 * i + 2] = copies[3 * i + 2];
  1750.   }
  1752.   free(copies);
  1754.   return welded;
  1755. }
  1758. #if 0
  1759.   /* normals */
  1760.   if (model->numnormals) {
  1761.   numvectors = model->numnormals;
  1762.   vectors    = model->normals;
  1763.   copies = glmOptimizeVectors(vectors, &numvectors);
  1765.   printf("glmOptimize(): %d redundant normals.n", 
  1766.  model->numnormals - numvectors);
  1768.   for (i = 0; i < model->numtriangles; i++) {
  1769.     T(i).nindices[0] = (GLuint)vectors[3 * T(i).nindices[0] + 0];
  1770.     T(i).nindices[1] = (GLuint)vectors[3 * T(i).nindices[1] + 0];
  1771.     T(i).nindices[2] = (GLuint)vectors[3 * T(i).nindices[2] + 0];
  1772.   }
  1774.   /* free space for old normals */
  1775.   free(vectors);
  1777.   /* allocate space for the new normals */
  1778.   model->numnormals = numvectors;
  1779.   model->normals = (GLfloat*)malloc(sizeof(GLfloat) * 
  1780.     3 * (model->numnormals + 1));
  1782.   /* copy the optimized vertices into the actual vertex list */
  1783.   for (i = 1; i <= model->numnormals; i++) {
  1784.     model->normals[3 * i + 0] = copies[3 * i + 0];
  1785.     model->normals[3 * i + 1] = copies[3 * i + 1];
  1786.     model->normals[3 * i + 2] = copies[3 * i + 2];
  1787.   }
  1789.   free(copies);
  1790.   }
  1792.   /* texcoords */
  1793.   if (model->numtexcoords) {
  1794.   numvectors = model->numtexcoords;
  1795.   vectors    = model->texcoords;
  1796.   copies = glmOptimizeVectors(vectors, &numvectors);
  1798.   printf("glmOptimize(): %d redundant texcoords.n", 
  1799.  model->numtexcoords - numvectors);
  1801.   for (i = 0; i < model->numtriangles; i++) {
  1802.     for (j = 0; j < 3; j++) {
  1803.       T(i).tindices[j] = (GLuint)vectors[3 * T(i).tindices[j] + 0];
  1804.     }
  1805.   }
  1807.   /* free space for old texcoords */
  1808.   free(vectors);
  1810.   /* allocate space for the new texcoords */
  1811.   model->numtexcoords = numvectors;
  1812.   model->texcoords = (GLfloat*)malloc(sizeof(GLfloat) * 
  1813.       2 * (model->numtexcoords + 1));
  1815.   /* copy the optimized vertices into the actual vertex list */
  1816.   for (i = 1; i <= model->numtexcoords; i++) {
  1817.     model->texcoords[2 * i + 0] = copies[2 * i + 0];
  1818.     model->texcoords[2 * i + 1] = copies[2 * i + 1];
  1819.   }
  1821.   free(copies);
  1822.   }
  1823. #endif
  1825. #if 0
  1826.   /* look for unused vertices */
  1827.   /* look for unused normals */
  1828.   /* look for unused texcoords */
  1829.   for (i = 1; i <= model->numvertices; i++) {
  1830.     for (j = 0; j < model->numtriangles; i++) {
  1831.       if (T(j).vindices[0] == i || 
  1832.   T(j).vindices[1] == i || 
  1833.   T(j).vindices[1] == i)
  1834. break;
  1835.     }
  1836.   }
  1837. #endif