home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / GL / libgobj / write.c < prev   
Encoding:
C/C++ Source or Header  |  1994-08-02  |  10.5 KB  |  524 lines
  1. /*
  2.  * Copyright 1989, 1990, 1991, 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17.  
  18.  
  19. #include "gobj.h"
  20.  
  21. #include <gl.h>
  22. #include <stdio.h>
  23. #include <fcntl.h>
  24.  
  25.  
  26. FILE *ofp;
  27.  
  28. static object_t *curobj;
  29.  
  30.  
  31. writeobj(fname, obj)
  32.     char *fname;
  33.     object_t *obj;
  34. {
  35.     int i;
  36.  
  37.     ofp = fopen(fname, "w");
  38.  
  39.     fprintf(ofp, "R%f\n", obj->radius);
  40.     fprintf(ofp, "#---------------------- Branch nodes\n", i);
  41.     fprintf(ofp, "B%d    # number of branch nodes\n", obj->bcount);
  42.  
  43.     curobj = obj;
  44.  
  45.     for (i=0; i < obj->bcount; i++)
  46.     {
  47.     fprintf(ofp, "#---------------------- B%d\n", i);
  48.     writenode(&obj->blist[i]);
  49.     }
  50.  
  51.     fprintf(ofp, "#---------------------- Translation nodes\n", i);
  52.     fprintf(ofp, "T%d    # number of transformation nodes\n", obj->tcount);
  53.  
  54.     for (i=0; i < obj->tcount; i++)
  55.     {
  56.     writetrans(&obj->tlist[i]);
  57.     }
  58.  
  59.     if (obj->mcount)
  60.     {
  61.     fprintf(ofp, "#---------------------- Material nodes\n", i);
  62.     fprintf(ofp, "M%d    # number of material nodes\n",
  63.         obj->mcount);
  64.  
  65.     for (i=0; i < obj->mcount; i++)
  66.     {
  67.         fprintf(ofp, "#---------------------- M%d\n", i);
  68.         writemat(obj->mlist[i]);
  69.     }
  70.     }
  71.  
  72.     fprintf(ofp, "#---------------------- Geometry nodes\n", i);
  73.     fprintf(ofp, "G%d    # number of geometry nodes\n", obj->gcount);
  74.  
  75.     for (i=0; i < obj->gcount; i++)
  76.     {
  77.     fprintf(ofp, "#---------------------- G%d\n", i);
  78.     fprintf(ofp, "%d\n", obj->glist[i].type);
  79.     switch(obj->glist[i].type)
  80.     {
  81.         case SSECTION:
  82.         case LTV_GEOM:
  83.         writessect(&obj->glist[i]);
  84.         break;
  85.         case FSECTION:
  86.         writefsect(&obj->glist[i]);
  87.         break;
  88.         case PSECTION:
  89.         writepsect(&obj->glist[i]);
  90.         break;
  91.         case CSECTION:
  92.         case CLS_GEOM:
  93.         case CDS_GEOM:
  94.         writecsect(&obj->glist[i]);
  95.         break;
  96.         case CPV_GEOM:
  97.         case CDV_GEOM:
  98.         writecdvgeom(&obj->glist[i]);
  99.         break;
  100.         case CPU_GEOM:
  101.         case CDU_GEOM:
  102.         writecdugeom(&obj->glist[i]);
  103.         break;
  104.         case IMU_GEOM:
  105.         writeimugeom(&obj->glist[i]);
  106.         break;
  107.         case IMV_GEOM:
  108.         writeimvgeom(&obj->glist[i]);
  109.         break;
  110.         default:
  111.         fprintf(stderr, "Error in writing \"%s\"\n", fname);
  112.     }
  113.     }
  114.     fclose(ofp);
  115.  
  116.     return(1);
  117. }
  118.  
  119.  
  120. writenode(np)
  121.     node_t *np;
  122. {
  123.     int i;
  124.  
  125.     fprintf(ofp, "0x%X,0x%X\n", np->statebits, np->modebits);
  126.     fprintf(ofp, "%d", np->tcount);
  127.     for (i=0; i < np->tcount; i++)
  128.     fprintf(ofp, ",%d",  np->tlist[i]);
  129.     fprintf(ofp, "\n%d", np->scount);
  130.     for (i=0; i < np->scount; i++)
  131.     switch(np->stlist[i])
  132.     {
  133.         case BRANCH:
  134.         fprintf(ofp, ",B%d",  np->slist[i]);
  135.         break;
  136.         case GEOMETRY:
  137.         fprintf(ofp, ",G%d",  np->slist[i]);
  138.         break;
  139.         default:
  140.         break;
  141.     }
  142.     fprintf(ofp, "\n");
  143. }
  144.  
  145.  
  146. writetrans(t)
  147.     trans_t *t;
  148. {
  149.     switch(t->type)
  150.     {
  151.     case ROTX:
  152.     case ROTY:
  153.     case ROTZ:
  154.         fprintf(ofp, "%d,%d\n", t->type, t->angle);
  155.         break;
  156.     case TRANSLATE:
  157.     case SCALE:
  158.         fprintf(ofp, "%d,%f,%f,%f\n", t->type,  t->x, t->y, t->z);
  159.         break;
  160.     default:
  161.         break;
  162.     }
  163. }
  164.  
  165.  
  166. writessect(sect)
  167.     geometry_t *sect;
  168. {
  169.     int i, count;
  170.     polygon_t *p;
  171.     int vnum;
  172.  
  173.     write_mat_id(sect);
  174.     fprintf(ofp, "%d\n", sect->vcount);
  175.     for (i=0; i < sect->vcount; i++)
  176.     {
  177.     fprintf(ofp, "%f,%f,%f,%f,%f,%f\n",
  178.         sect->vlist[i][X], sect->vlist[i][Y], sect->vlist[i][Z],
  179.         sect->nlist[i][X], sect->nlist[i][Y], sect->nlist[i][Z]);
  180.     }
  181.  
  182.     fprintf(ofp, "%d\n", sect->pcount);
  183.     for (i=0; i < sect->pcount; i++)
  184.     {
  185.     p = §->plist[i];
  186.     for(count = 0; count < p->vcount; count++)
  187.     {
  188.         fprintf(ofp, "%d", p->vnlist[count]);
  189.         if (count < p->vcount-1)
  190.         {
  191.         fprintf(ofp, ",");
  192.         if (count && !(count % 10))
  193.             fprintf(ofp, "\\\n");
  194.         }
  195.         else
  196.         fprintf(ofp, "\n");
  197.     }
  198.     }
  199. }
  200.  
  201.  
  202. writefsect(sect)
  203.     geometry_t *sect;
  204. {
  205.     int i, count;
  206.     polygon_t *p;
  207.     int vnum;
  208.  
  209.     write_mat_id(sect);
  210.     fprintf(ofp, "%d\n", sect->vcount);
  211.     for (i=0; i < sect->vcount; i++)
  212.     {
  213.     fprintf(ofp, "%f,%f,%f\n",
  214.         sect->vlist[i][X], sect->vlist[i][Y], sect->vlist[i][Z]);
  215.     }
  216.  
  217.     fprintf(ofp, "%d\n", sect->pcount);
  218.     for (i=0; i < sect->pcount; i++)
  219.     {
  220.     p = §->plist[i];
  221.     fprintf(ofp, "%f,%f,%f,",
  222.         p->normal[X], p->normal[Y], p->normal[Z]);
  223.  
  224.     for(count = 0; count < p->vcount; count++)
  225.     {
  226.         fprintf(ofp, "%d", p->vnlist[count]);
  227.         if (count < p->vcount-1)
  228.         fprintf(ofp, ",");
  229.         else
  230.         fprintf(ofp, "\n");
  231.     }
  232.     }
  233. }
  234.  
  235.  
  236. writepsect(sect)
  237.     geometry_t *sect;
  238. {
  239.     int i, count;
  240.     polygon_t *p;
  241.     int vnum;
  242.  
  243.     write_mat_id(sect);
  244.     fprintf(ofp, "%f,%f,%f\n",
  245.         sect->normal[X], sect->normal[Y], sect->normal[Z]);
  246.     fprintf(ofp, "%d\n", sect->vcount);
  247.     for (i=0; i < sect->vcount; i++)
  248.     {
  249.     fprintf(ofp, "%f,%f,%f\n",
  250.         sect->vlist[i][X], sect->vlist[i][Y], sect->vlist[i][Z]);
  251.     }
  252.  
  253.     fprintf(ofp, "%d\n", sect->pcount);
  254.     for (i=0; i < sect->pcount; i++)
  255.     {
  256.     p = §->plist[i];
  257.     for(count = 0; count < p->vcount; count++)
  258.     {
  259.         fprintf(ofp, "%d", p->vnlist[count]);
  260.         if (count < p->vcount-1)
  261.         fprintf(ofp, ",");
  262.         else
  263.         fprintf(ofp, "\n");
  264.     }
  265.     }
  266. }
  267.  
  268.  
  269. writecsect(sect)
  270.     geometry_t *sect;
  271. {
  272.     int i, count;
  273.     polygon_t *p;
  274.     int vnum;
  275.  
  276.     fprintf(ofp, "0x%X\n", sect->color);
  277.     fprintf(ofp, "%d\n", sect->vcount);
  278.     for (i=0; i < sect->vcount; i++)
  279.     {
  280.     fprintf(ofp, "%f,%f,%f\n",
  281.         sect->vlist[i][X], sect->vlist[i][Y], sect->vlist[i][Z]);
  282.     }
  283.  
  284.     fprintf(ofp, "%d\n", sect->pcount);
  285.     for (i=0; i < sect->pcount; i++)
  286.     {
  287.     p = §->plist[i];
  288.     for(count = 0; count < p->vcount; count++)
  289.     {
  290.         fprintf(ofp, "%d", p->vnlist[count]);
  291.         if (count < p->vcount-1)
  292.         fprintf(ofp, ",");
  293.         else
  294.         fprintf(ofp, "\n");
  295.     }
  296.     }
  297. }
  298.  
  299.  
  300. writecdvgeom(sect)
  301.     geometry_t *sect;
  302. {
  303.     int i, count;
  304.     polygon_t *p;
  305.     int vnum;
  306.  
  307.     fprintf(ofp, "%d\n", sect->vcount);
  308.     for (i=0; i < sect->vcount; i++)
  309.     {
  310.     fprintf(ofp, "0x%X,%f,%f,%f\n", sect->clist[i],
  311.         sect->vlist[i][X], sect->vlist[i][Y], sect->vlist[i][Z]);
  312.     }
  313.  
  314.     fprintf(ofp, "%d\n", sect->pcount);
  315.     for (i=0; i < sect->pcount; i++)
  316.     {
  317.     p = §->plist[i];
  318.     for(count = 0; count < p->vcount; count++)
  319.     {
  320.         fprintf(ofp, "%d", p->vnlist[count]);
  321.         if (count < p->vcount-1)
  322.         fprintf(ofp, ",");
  323.         else
  324.         fprintf(ofp, "\n");
  325.     }
  326.     }
  327. }
  328.  
  329.  
  330. writecdugeom(sect)
  331.     geometry_t *sect;
  332. {
  333.     int i, count;
  334.     polygon_t *p;
  335.     int vnum;
  336.  
  337.     fprintf(ofp, "%d\n", sect->vcount);
  338.     for (i=0; i < sect->vcount; i++)
  339.     {
  340.     fprintf(ofp, "%f,%f,%f\n",
  341.         sect->vlist[i][X], sect->vlist[i][Y], sect->vlist[i][Z]);
  342.     }
  343.  
  344.     fprintf(ofp, "%d\n", sect->pcount);
  345.     for (i=0; i < sect->pcount; i++)
  346.     {
  347.     p = §->plist[i];
  348.     fprintf(ofp, "0x%x,", p->color);
  349.  
  350.     for(count = 0; count < p->vcount; count++)
  351.     {
  352.         fprintf(ofp, "%d", p->vnlist[count]);
  353.         if (count < p->vcount-1)
  354.         fprintf(ofp, ",");
  355.         else
  356.         fprintf(ofp, "\n");
  357.     }
  358.     }
  359. }
  360.  
  361.  
  362. writeimugeom(sect)
  363.     geometry_t *sect;
  364. {
  365.     int i, count;
  366.     polygon_t *p;
  367.     int vnum;
  368.  
  369.     fprintf(ofp, "%d\n", sect->vcount);
  370.     for (i=0; i < sect->vcount; i++) 
  371.     {
  372.     fprintf(ofp, "%f,%f,%f\n",
  373.         sect->vlist[i][X], sect->vlist[i][Y], sect->vlist[i][Z]);
  374.     }
  375.  
  376.     fprintf(ofp, "%d\n", sect->pcount);
  377.     for (i=0; i < sect->pcount; i++)
  378.     {
  379.     p = §->plist[i];
  380.     fprintf(ofp, "%d,%d,", p->type, p->color);
  381.  
  382.     for (count=0; count < p->vcount; count++)
  383.     {
  384.         fprintf(ofp, "%d", p->vnlist[count]);
  385.         if (count < p->vcount-1)
  386.         fprintf(ofp, ",");
  387.         else
  388.         fprintf(ofp, "\n");
  389.     }
  390.     }
  391. }
  392.  
  393.  
  394. writeimvgeom(sect)
  395.     geometry_t *sect;
  396. {
  397.     int i, count;
  398.     polygon_t *p;
  399.     int vnum;
  400.  
  401.     fprintf(ofp, "%d\n", sect->vcount);
  402.     for (i=0; i < sect->vcount; i++) 
  403.     {
  404.     fprintf(ofp, "%f,%f,%f,%d\n",
  405.         sect->vlist[i][X], sect->vlist[i][Y], sect->vlist[i][Z],
  406.         sect->clist[i]);
  407.     }
  408.  
  409.     fprintf(ofp, "%d\n", sect->pcount);
  410.     for (i=0; i < sect->pcount; i++)
  411.     {
  412.     p = §->plist[i];
  413.     fprintf(ofp, "%d,", p->type);
  414.  
  415.     for (count=0; count < p->vcount; count++)
  416.     {
  417.         fprintf(ofp, "%d", p->vnlist[count]);
  418.         if (count < p->vcount-1)
  419.         fprintf(ofp, ",");
  420.         else
  421.         fprintf(ofp, "\n");
  422.     }
  423.     }
  424. }
  425.  
  426.  
  427. bwriteobj(fname, obj)
  428.     char *fname;
  429.     object_t *obj;
  430. {
  431.     int ofd;
  432.     node_t *b;
  433.     geometry_t *g;
  434.     polygon_t *p;
  435.     int i, j;
  436.  
  437.     ofd = open(fname, O_WRONLY | O_CREAT, 0644);
  438.     if (ofd == -1)
  439.     fprintf(stderr, "can't open \"%s\"\n", fname);
  440.  
  441.     /*
  442.      *  write null byte that says this is a binary file
  443.      */
  444.     write(ofd, "\0", 1);
  445.  
  446.     write(ofd, obj, sizeof(object_t));
  447.  
  448.     write(ofd, obj->blist, sizeof(node_t) * obj->bcount);
  449.     for (i=0; i < obj->bcount; i++)
  450.     {
  451.     b = &obj->blist[i];
  452.     if (b->tcount)
  453.         write(ofd, b->tlist, sizeof(int) * b->tcount);
  454.     if (b->scount)
  455.     {
  456.         write(ofd, b->slist, sizeof(int) * b->scount);
  457.         write(ofd, b->stlist, sizeof(int) * b->scount);
  458.     }
  459.     }
  460.  
  461.     if (obj->tcount)
  462.     write(ofd, obj->tlist, sizeof(trans_t) * obj->tcount);
  463.  
  464.     write(ofd, obj->glist, sizeof(geometry_t) * obj->gcount);
  465.  
  466.     for (i=0; i < obj->gcount; i++)
  467.     {
  468.     g = &obj->glist[i];
  469.  
  470.     for (j=0; j < g->vcount; j++)
  471.         write(ofd, g->vlist[j], sizeof(float)*3);
  472.         
  473.     if (g->nlist)
  474.     {
  475.         for (j=0; j < g->vcount; j++)
  476.         write(ofd, g->nlist[j], sizeof(float)*3);
  477.     }
  478.  
  479.     if (g->clist)
  480.         write(ofd, g->clist, sizeof(long) * g->vcount);
  481.  
  482.     write(ofd, g->plist, sizeof(polygon_t) * g->pcount);
  483.     for (j=0; j < g->pcount; j++)
  484.     {
  485.         p = &g->plist[j];
  486.  
  487.         write(ofd, p->vnlist, sizeof(int) * p->vcount);
  488.     }
  489.     }
  490.  
  491.     close(ofd);
  492. }
  493.  
  494.  
  495. writemat(id)
  496.     int id;
  497. {
  498.     fprintf(ofp, "%f,%f,%f\n",
  499.         mlist[id].data[1], mlist[id].data[2], mlist[id].data[3]);
  500.     fprintf(ofp, "%f,%f,%f,%f\n",
  501.         mlist[id].data[5], mlist[id].data[6], mlist[id].data[7],
  502.         mlist[id].data[9]);
  503.     fprintf(ofp, "%f,%f,%f\n",
  504.         mlist[id].data[11], mlist[id].data[12], mlist[id].data[13]);
  505.     fprintf(ofp, "%f\n", mlist[id].data[15]);
  506.     fprintf(ofp, "%f,%f,%f\n",
  507.         mlist[id].data[17], mlist[id].data[18], mlist[id].data[19]);
  508. }
  509.  
  510. write_mat_id(sect)
  511.     geometry_t *sect;
  512. {
  513.     if (!curobj->mcount)
  514.     fprintf(ofp, "%d\n", sect->material);
  515.     else
  516.     {
  517.     int i;
  518.  
  519.     for (i=0; sect->material != mlist[curobj->mlist[i]].id; i++);
  520.  
  521.     fprintf(ofp, "%d\n", i);
  522.     }
  523. }
  524.