ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/gen/replmarks.c
(Generate patch)

Comparing ray/src/gen/replmarks.c (file contents):
Revision 2.7 by schorsch, Sun Jun 8 12:03:10 2003 UTC vs.
Revision 2.22 by greg, Tue Jun 3 21:31:51 2025 UTC

# Line 1 | Line 1
1   #ifndef lint
2 < static const char RCSid[] = "$Id";
2 > static const char RCSid[] = "$Id$";
3   #endif
4   /*
5   * Replace markers in Radiance scene description with objects or instances.
# Line 13 | Line 13 | static const char RCSid[] = "$Id";
13   #include <stdio.h>
14  
15   #include "platform.h"
16 + #include "rtio.h"
17 + #include "paths.h"
18   #include "fvect.h"
19  
20   #ifdef  M_PI
# Line 21 | Line 23 | static const char RCSid[] = "$Id";
23   #define  PI             3.14159265358979323846
24   #endif
25  
24 – #define  FEQ(a,b)       ((a)-(b) <= 1e-7 && (b)-(a) <= 1e-7)
25 –
26   #define  MAXVERT        6       /* maximum number of vertices for markers */
27 < #define  MAXMARK        32      /* maximum number of markers */
27 > #define  MAXMARK        128     /* maximum number of markers */
28  
29 + #define  USE_XFORM      1       /* use !xform inline command */
30 + #define  USE_INSTANCE   2       /* use instance primitive */
31 + #define  USE_MESH       3       /* use mesh primitive */
32 +
33   typedef struct {
34          short   beg, end;               /* beginning and ending vertex */
35          float   len2;                   /* length squared */
# Line 36 | Line 40 | struct mrkr {
40          double  mscale;                 /* scale by this to get unit */
41          char    *modin;                 /* input modifier indicating marker */
42          char    *objname;               /* output object file or octree */
43 <        int     doxform;                /* true if xform, false if instance */
44 < }  marker[MAXMARK];             /* array of markers */
43 >        int     usetype;                /* one of USE_* above */
44 > }  marker[MAXMARK+1];           /* array of markers */
45   int     nmarkers = 0;           /* number of markers */
46  
47   int     expand;                 /* expand commands? */
48  
49 < char    *progname;
49 > static void convert(char *name, FILE *fin);
50 > static void cvcomm(char *fname, FILE *fin);
51 > static void cvobject(char *fname, FILE *fin);
52 > static void replace(char *fname, struct mrkr *m, char *mark, FILE *fin);
53 > static int edgecmp(const void *e1, const void *e2);
54 > static int buildxf(char *xf, double markscale, FILE *fin);
55 > static int addrot(char *xf, FVECT xp, FVECT yp, FVECT zp);
56  
57  
58 < main(argc, argv)
59 < int     argc;
60 < char    *argv[];
58 > int
59 > main(
60 >        int     argc,
61 >        char    *argv[]
62 > )
63   {
64          FILE    *fp;
65          int     i, j;
66  
67 <        progname = argv[0];
67 >        fixargv0(argv[0]);              /* sets global progname */
68          i = 1;
69          while (i < argc && argv[i][0] == '-') {
70                  do {
71                          switch (argv[i][1]) {
72                          case 'i':
73 <                                marker[nmarkers].doxform = 0;
73 >                                marker[nmarkers].usetype = USE_INSTANCE;
74                                  marker[nmarkers].objname = argv[++i];
75                                  break;
76 +                        case 'I':
77 +                                marker[nmarkers].usetype = USE_MESH;
78 +                                marker[nmarkers].objname = argv[++i];
79 +                                break;
80                          case 'x':
81 <                                marker[nmarkers].doxform = 1;
81 >                                marker[nmarkers].usetype = USE_XFORM;
82                                  marker[nmarkers].objname = argv[++i];
83                                  break;
84                          case 'e':
# Line 82 | Line 98 | char   *argv[];
98                  } while (argv[i][0] == '-');
99                  if (marker[nmarkers].objname == NULL)
100                          goto userr;
101 +                if (nmarkers >= MAXMARK) {
102 +                        fprintf(stderr, "%s: too many markers\n", progname);
103 +                        return 1;
104 +                }
105                  marker[nmarkers++].modin = argv[i++];
86 –                if (nmarkers >= MAXMARK)
87 –                        break;
106                  marker[nmarkers].mscale = marker[nmarkers-1].mscale;
107          }
108          if (nmarkers == 0)
# Line 107 | Line 125 | char   *argv[];
125                          convert(argv[i], fp);
126                          fclose(fp);
127                  }
128 <        exit(0);
128 >        return 0;
129   userr:
130          fprintf(stderr,
131 < "Usage: %s [-e][-s size][-m modout] {-x objfile|-i octree} modname .. [file ..]\n",
131 > "Usage: %s [-e][-s size][-m modout] {-x objfile|-i octree|-I mesh} modname .. [file ..]\n",
132                  progname);
133 <        exit(1);
133 >        return 1;
134   }
135  
136  
137 < convert(name, fin)              /* replace marks in a stream */
138 < char    *name;
139 < register FILE   *fin;
137 > void
138 > convert(                /* replace marks in a stream */
139 >        char    *name,
140 >        FILE    *fin
141 > )
142   {
143 <        register int    c;
143 >        int     c;
144  
145          while ((c = getc(fin)) != EOF) {
146                  if (isspace(c))                         /* blank */
# Line 143 | Line 163 | register FILE  *fin;
163   }
164  
165  
166 < cvcomm(fname, fin)              /* convert a command */
167 < char    *fname;
168 < FILE    *fin;
166 > void
167 > cvcomm(         /* convert a command */
168 >        char    *fname,
169 >        FILE    *fin
170 > )
171   {
172 <        FILE    *pin, *popen();
173 <        char    buf[512], *fgetline();
172 >        FILE    *pin;
173 >        char    buf[512];
174  
175          fgetline(buf, sizeof(buf), fin);
176          if (expand) {
# Line 159 | Line 181 | FILE   *fin;
181                          exit(1);
182                  }
183                  convert(buf, pin);
184 <                pclose(pin);
184 >                if (pclose(pin) != 0)
185 >                        fprintf(stderr,
186 >                        "%s: (%s): warning - bad status from \"%s\"\n",
187 >                                        progname, fname, buf);
188          } else
189                  printf("\n%s\n", buf);
190   }
191  
192  
193 < cvobject(fname, fin)            /* convert an object */
194 < char    *fname;
195 < FILE    *fin;
193 > void
194 > cvobject(               /* convert an object */
195 >        char    *fname,
196 >        FILE    *fin
197 > )
198   {
172 –        extern char     *fgetword();
199          char    buf[128], typ[16], nam[128];
200          int     i, n;
201 <        register int    j;
201 >        int     j;
202  
203 <        if (fscanf(fin, "%s %s %s", buf, typ, nam) != 3)
203 >        if (fgetword(buf, sizeof(buf), fin) == NULL ||
204 >                        fgetword(typ, sizeof(typ), fin) == NULL ||
205 >                        fgetword(nam, sizeof(nam), fin) == NULL)
206                  goto readerr;
207          if (!strcmp(typ, "polygon"))
208                  for (j = 0; j < nmarkers; j++)
# Line 182 | Line 210 | FILE   *fin;
210                                  replace(fname, &marker[j], nam, fin);
211                                  return;
212                          }
213 <        printf("\n%s %s %s\n", buf, typ, nam);
213 >        putchar('\n'); fputword(buf, stdout);
214 >        printf(" %s ", typ);
215 >        fputword(nam, stdout); putchar('\n');
216          if (!strcmp(typ, "alias")) {            /* alias special case */
217 <                if (fscanf(fin, "%s", buf) != 1)
217 >                if (fgetword(buf, sizeof(buf), fin) == NULL)
218                          goto readerr;
219 <                printf("\t%s\n", buf);
219 >                putchar('\t'); fputword(buf, stdout); putchar('\n');
220                  return;
221          }
222          for (i = 0; i < 3; i++) {               /* pass along arguments */
# Line 210 | Line 240 | readerr:
240   }
241  
242  
243 < replace(fname, m, mark, fin)            /* replace marker */
244 < char    *fname;
245 < register struct mrkr    *m;
246 < char    *mark;
247 < FILE    *fin;
243 > void
244 > replace(                /* replace marker */
245 >        char    *fname,
246 >        struct mrkr     *m,
247 >        char    *mark,
248 >        FILE    *fin
249 > )
250   {
251          int     n;
252          char    buf[256];
253  
254          buf[0] = '\0';                  /* bug fix thanks to schorsch */
255 <        if (m->doxform) {
256 <                sprintf(buf, "xform -e -n %s", mark);
255 >        if (m->usetype == USE_XFORM) {
256 >                sprintf(buf, "xform -n %s", mark);
257                  if (m->modout != NULL)
258                          sprintf(buf+strlen(buf), " -m %s", m->modout);
259                  if (buildxf(buf+strlen(buf), m->mscale, fin) < 0)
# Line 235 | Line 267 | FILE   *fin;
267          } else {
268                  if ((n = buildxf(buf, m->mscale, fin)) < 0)
269                          goto badxf;
270 <                printf("\n%s instance %s\n",
271 <                                m->modout==NULL?"void":m->modout, mark);
270 >                printf("\n%s %s %s\n",
271 >                                m->modout==NULL?"void":m->modout,
272 >                                m->usetype==USE_INSTANCE?"instance":"mesh",
273 >                                mark);
274                  printf("%d %s%s\n0\n0\n", n+1, m->objname, buf);
275          }
276          return;
# Line 247 | Line 281 | badxf:
281   }
282  
283  
284 < edgecmp(e1, e2)                 /* compare two edges, descending order */
285 < EDGE    *e1, *e2;
284 > int
285 > edgecmp(                        /* compare two edges, descending order */
286 >        const void *e1,
287 >        const void *e2
288 > )
289   {
290 <        if (e1->len2 > e2->len2)
290 >        if (((EDGE*)e1)->len2 > ((EDGE*)e2)->len2)
291                  return(-1);
292 <        if (e1->len2 < e2->len2)
292 >        if (((EDGE*)e1)->len2 < ((EDGE*)e2)->len2)
293                  return(1);
294          return(0);
295   }
296  
297  
298   int
299 < buildxf(xf, markscale, fin)             /* build transform for marker */
300 < register char   *xf;
301 < double  markscale;
302 < FILE    *fin;
299 > buildxf(                /* build transform for marker */
300 >        char    *xf,
301 >        double  markscale,
302 >        FILE    *fin
303 > )
304   {
305          static FVECT    vlist[MAXVERT];
306          static EDGE     elist[MAXVERT];
307          FVECT   xvec, yvec, zvec;
308          double  xlen;
309          int     n;
310 <        register int    i;
310 >        int     i;
311          /*
312           * Read and sort vectors:  longest is hypotenuse,
313           *      second longest is x' axis,
# Line 340 | Line 378 | FILE   *fin;
378   }
379  
380  
381 < addrot(xf, xp, yp, zp)          /* compute rotation (x,y,z) => (xp,yp,zp) */
382 < register char   *xf;
383 < FVECT   xp, yp, zp;
381 > int
382 > addrot(         /* compute rotation (x,y,z) => (xp,yp,zp) */
383 >        char    *xf,
384 >        FVECT xp,
385 >        FVECT yp,
386 >        FVECT zp
387 > )
388   {
389          int     n;
390          double  theta;
391  
392 +        if (yp[2]*yp[2] + zp[2]*zp[2] < 2.*FTINY*FTINY) {
393 +                /* Special case for X' along Z-axis */
394 +                theta = -atan2(yp[0], yp[1]);
395 +                sprintf(xf, " -ry %f -rz %f",
396 +                                xp[2] < 0.0 ? 90.0 : -90.0,
397 +                                theta*(180./PI));
398 +                return(4);
399 +        }
400          n = 0;
401          theta = atan2(yp[2], zp[2]);
402 <        if (!FEQ(theta,0.0)) {
402 >        if (!FABSEQ(theta,0.0)) {
403                  sprintf(xf, " -rx %f", theta*(180./PI));
404                  while (*xf) ++xf;
405                  n += 2;
406          }
407 <        theta = asin(-xp[2]);
408 <        if (!FEQ(theta,0.0)) {
407 >        theta = Asin(-xp[2]);
408 >        if (!FABSEQ(theta,0.0)) {
409                  sprintf(xf, " -ry %f", theta*(180./PI));
410                  while (*xf) ++xf;
411                  n += 2;
412          }
413          theta = atan2(xp[1], xp[0]);
414 <        if (!FEQ(theta,0.0)) {
414 >        if (!FABSEQ(theta,0.0)) {
415                  sprintf(xf, " -rz %f", theta*(180./PI));
416                  /* while (*xf) ++xf; */
417                  n += 2;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines