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

Comparing ray/src/gen/gensurf.c (file contents):
Revision 2.7 by greg, Tue Mar 11 22:48:20 2003 UTC vs.
Revision 2.16 by greg, Sat Aug 21 11:54:06 2004 UTC

# Line 17 | Line 17 | static const char RCSid[] = "$Id$";
17  
18   #include  "standard.h"
19  
20 + #include  "paths.h"
21 + #include  "resolu.h"
22 + #include  "rterror.h"
23 + #include  "calcomp.h"
24 +
25   char  XNAME[] =         "X`SYS";                /* x function name */
26   char  YNAME[] =         "Y`SYS";                /* y function name */
27   char  ZNAME[] =         "Z`SYS";                /* z function name */
# Line 25 | Line 30 | char  VNAME[] =        "valid";                /* valid vertex name */
30  
31   #define  ABS(x)         ((x)>=0 ? (x) : -(x))
32  
33 + #define  ZEROVECT(v)    (DOT(v,v) <= FTINY*FTINY)
34 +
35   #define  pvect(p)       printf(vformat, (p)[0], (p)[1], (p)[2])
36  
37   char  vformat[] = "%15.9g %15.9g %15.9g\n";
# Line 43 | Line 50 | char  *modname, *surfname;
50   struct {
51          int     flags;                  /* data type */
52          short   m, n;                   /* number of s and t values */
53 <        FLOAT   *data;                  /* the data itself, s major sort */
53 >        RREAL   *data;                  /* the data itself, s major sort */
54   } datarec;                      /* our recorded data */
55  
56 + /* XXX this is redundant with rt/noise3.c, should go to a library */
57   double  l_hermite(), l_bezier(), l_bspline(), l_dataval();
50 – extern double  funvalue(), argument();
58  
59   typedef struct {
60          int  valid;     /* point is valid (vertex number) */
61          FVECT  p;       /* vertex position */
62          FVECT  n;       /* average normal */
63 <        FLOAT  uv[2];   /* (u,v) position */
63 >        RREAL  uv[2];   /* (u,v) position */
64   } POINT;
65  
66  
67 + void loaddata(char *file, int m, int n, int pointsize);
68 + double l_dataval(char *nam);
69 + void putobjrow(POINT *rp, int n);
70 + void putsquare(POINT *p0, POINT *p1, POINT *p2, POINT *p3);
71 + void comprow(double s, POINT *row, int siz);
72 + void compnorms(POINT *r0, POINT *r1, POINT *r2, int siz);
73 + int norminterp(FVECT resmat[4], POINT *p0, POINT *p1, POINT *p2, POINT *p3);
74 +
75 +
76 + int
77   main(argc, argv)
78   int  argc;
79   char  *argv[];
80   {
64 –        extern long     eclock;
81          POINT  *row0, *row1, *row2, *rp;
82          int  i, j, m, n;
83          char  stmp[256];
# Line 122 | Line 138 | char  *argv[];
138          }
139          row0++; row1++; row2++;
140                                                  /* print header */
141 <        printhead(argc, argv);
141 >        fputs("# ", stdout);
142 >        printargs(argc, argv, stdout);
143          eclock = 0;
144                                                  /* initialize */
145          comprow(-1.0/m, row0, n);
146          comprow(0.0, row1, n);
147          comprow(1.0/m, row2, n);
148          compnorms(row0, row1, row2, n);
149 <        if (objout)
149 >        if (objout) {
150 >                printf("\nusemtl %s\n\n", modname);
151                  putobjrow(row1, n);
152 +        }
153                                                  /* for each row */
154          for (i = 0; i < m; i++) {
155                                                  /* compute next row */
# Line 159 | Line 178 | char  *argv[];
178                  }
179          }
180  
181 <        quit(0);
181 >        return 0;
182  
183   userror:
184          fprintf(stderr, "Usage: %s material name ", argv[0]);
185          fprintf(stderr, "x(s,t) y(s,t) z(s,t) m n [-s][-e expr][-f file]\n");
186 <        quit(1);
186 >        return 1;
187   }
188  
189  
190 < loaddata(file, m, n, pointsize)         /* load point data from file */
191 < char  *file;
192 < int  m, n;
193 < int  pointsize;
190 > void
191 > loaddata(               /* load point data from file */
192 >        char  *file,
193 >        int  m,
194 >        int  n,
195 >        int  pointsize
196 > )
197   {
198          FILE  *fp;
199          char  word[64];
200          register int  size;
201 <        register FLOAT  *dp;
201 >        register RREAL  *dp;
202  
203          datarec.flags = HASBORDER;              /* assume border values */
204          datarec.m = m+1;
# Line 184 | Line 206 | int  pointsize;
206          size = datarec.m*datarec.n*pointsize;
207          if (pointsize == 3)
208                  datarec.flags |= TRIPLETS;
209 <        dp = (FLOAT *)malloc(size*sizeof(FLOAT));
209 >        dp = (RREAL *)malloc(size*sizeof(RREAL));
210          if ((datarec.data = dp) == NULL) {
211                  fputs("Out of memory\n", stderr);
212                  exit(1);
# Line 207 | Line 229 | int  pointsize;
229                  size--;
230          }
231          if (size == (m+n+1)*pointsize) {        /* no border after all */
232 <                dp = (FLOAT *)realloc((char *)datarec.data,
233 <                                m*n*pointsize*sizeof(FLOAT));
232 >                dp = (RREAL *)realloc((void *)datarec.data,
233 >                                m*n*pointsize*sizeof(RREAL));
234                  if (dp != NULL)
235                          datarec.data = dp;
236                  datarec.flags &= ~HASBORDER;
# Line 227 | Line 249 | int  pointsize;
249  
250  
251   double
252 < l_dataval(nam)                          /* return recorded data value */
253 < char  *nam;
252 > l_dataval(                              /* return recorded data value */
253 >        char  *nam
254 > )
255   {
256          double  u, v;
257          register int  i, j;
258 <        register FLOAT  *dp;
258 >        register RREAL  *dp;
259          double  d00, d01, d10, d11;
260                                                  /* compute coordinates */
261          u = argument(1); v = argument(2);
# Line 268 | Line 291 | char  *nam;
291   }
292  
293  
294 < putobjrow(rp, n)                        /* output vertex row to .OBJ */
295 < register POINT  *rp;
296 < int  n;
294 > void
295 > putobjrow(                      /* output vertex row to .OBJ */
296 >        register POINT  *rp,
297 >        int  n
298 > )
299   {
300          static int      nverts = 0;
301  
# Line 278 | Line 303 | int  n;
303                  if (!rp->valid)
304                          continue;
305                  fputs("v ", stdout);
306 <                printf(vformat, rp->p[0], rp->p[1], rp->p[2]);
307 <                if (smooth)
306 >                pvect(rp->p);
307 >                if (smooth && !ZEROVECT(rp->n))
308                          printf("\tvn %.9g %.9g %.9g\n",
309                                          rp->n[0], rp->n[1], rp->n[2]);
310                  printf("\tvt %.9g %.9g\n", rp->uv[0], rp->uv[1]);
# Line 288 | Line 313 | int  n;
313   }
314  
315  
316 < putsquare(p0, p1, p2, p3)               /* put out a square */
317 < POINT  *p0, *p1, *p2, *p3;
316 > void
317 > putsquare(              /* put out a square */
318 >        POINT *p0,
319 >        POINT *p1,
320 >        POINT *p2,
321 >        POINT *p3
322 > )
323   {
324          static int  nout = 0;
325          FVECT  norm[4];
# Line 299 | Line 329 | POINT  *p0, *p1, *p2, *p3;
329                                          /* compute exact normals */
330          ok1 = (p0->valid && p1->valid && p2->valid);
331          if (ok1) {
332 <                fvsum(v1, p1->p, p0->p, -1.0);
333 <                fvsum(v2, p2->p, p0->p, -1.0);
332 >                VSUB(v1, p1->p, p0->p);
333 >                VSUB(v2, p2->p, p0->p);
334                  fcross(vc1, v1, v2);
335                  ok1 = (normalize(vc1) != 0.0);
336          }
337          ok2 = (p1->valid && p2->valid && p3->valid);
338          if (ok2) {
339 <                fvsum(v1, p2->p, p3->p, -1.0);
340 <                fvsum(v2, p1->p, p3->p, -1.0);
339 >                VSUB(v1, p2->p, p3->p);
340 >                VSUB(v2, p1->p, p3->p);
341                  fcross(vc2, v1, v2);
342                  ok2 = (normalize(vc2) != 0.0);
343          }
# Line 316 | Line 346 | POINT  *p0, *p1, *p2, *p3;
346          if (objout) {                   /* output .OBJ faces */
347                  int     p0n=0, p1n=0, p2n=0, p3n=0;
348                  if (smooth) {
349 <                        p0n = p0->valid;
350 <                        p1n = p1->valid;
351 <                        p2n = p2->valid;
352 <                        p3n = p3->valid;
349 >                        if (!ZEROVECT(p0->n))
350 >                                p0n = p0->valid;
351 >                        if (!ZEROVECT(p1->n))
352 >                                p1n = p1->valid;
353 >                        if (!ZEROVECT(p2->n))
354 >                                p2n = p2->valid;
355 >                        if (!ZEROVECT(p3->n))
356 >                                p3n = p3->valid;
357                  }
358                  if (ok1 & ok2 && fdot(vc1,vc2) >= 1.0-FTINY*FTINY) {
359                          printf("f %d/%d/%d %d/%d/%d %d/%d/%d %d/%d/%d\n",
360 <                                        p0->valid, p0n, p0->valid,
361 <                                        p1->valid, p1n, p1->valid,
362 <                                        p3->valid, p3n, p3->valid,
363 <                                        p2->valid, p2n, p2->valid);
360 >                                        p0->valid, p0->valid, p0n,
361 >                                        p1->valid, p1->valid, p1n,
362 >                                        p3->valid, p3->valid, p3n,
363 >                                        p2->valid, p2->valid, p2n);
364                          return;
365                  }
366                  if (ok1)
367                          printf("f %d/%d/%d %d/%d/%d %d/%d/%d\n",
368 <                                        p0->valid, p0n, p0->valid,
369 <                                        p1->valid, p1n, p1->valid,
370 <                                        p2->valid, p2n, p2->valid);
368 >                                        p0->valid, p0->valid, p0n,
369 >                                        p1->valid, p1->valid, p1n,
370 >                                        p2->valid, p2->valid, p2n);
371                  if (ok2)
372                          printf("f %d/%d/%d %d/%d/%d %d/%d/%d\n",
373 <                                        p2->valid, p2n, p2->valid,
374 <                                        p1->valid, p1n, p1->valid,
375 <                                        p3->valid, p3n, p3->valid);
373 >                                        p2->valid, p2->valid, p2n,
374 >                                        p1->valid, p1->valid, p1n,
375 >                                        p3->valid, p3->valid, p3n);
376                  return;
377          }
378                                          /* compute normal interpolation */
# Line 409 | Line 443 | POINT  *p0, *p1, *p2, *p3;
443   }
444  
445  
446 < comprow(s, row, siz)                    /* compute row of values */
447 < double  s;
448 < register POINT  *row;
449 < int  siz;
446 > void
447 > comprow(                        /* compute row of values */
448 >        double  s,
449 >        register POINT  *row,
450 >        int  siz
451 > )
452   {
453          double  st[2];
454          int  end;
# Line 449 | Line 485 | int  siz;
485   }
486  
487  
488 < compnorms(r0, r1, r2, siz)              /* compute row of averaged normals */
489 < register POINT  *r0, *r1, *r2;
490 < int  siz;
488 > void
489 > compnorms(              /* compute row of averaged normals */
490 >        register POINT  *r0,
491 >        register POINT  *r1,
492 >        register POINT  *r2,
493 >        int  siz
494 > )
495   {
496          FVECT  v1, v2;
497  
# Line 489 | Line 529 | int  siz;
529  
530  
531   int
532 < norminterp(resmat, p0, p1, p2, p3)      /* compute normal interpolation */
533 < register FVECT  resmat[4];
534 < POINT  *p0, *p1, *p2, *p3;
532 > norminterp(     /* compute normal interpolation */
533 >        register FVECT  resmat[4],
534 >        POINT  *p0,
535 >        POINT  *p1,
536 >        POINT  *p2,
537 >        POINT  *p3
538 > )
539   {
540   #define u  ((ax+1)%3)
541   #define v  ((ax+2)%3)
# Line 544 | Line 588 | POINT  *p0, *p1, *p2, *p3;
588   }
589  
590  
547 – void
548 – eputs(msg)
549 – char  *msg;
550 – {
551 –        fputs(msg, stderr);
552 – }
553 –
554 –
555 – void
556 – wputs(msg)
557 – char  *msg;
558 – {
559 –        eputs(msg);
560 – }
561 –
562 –
563 – void
564 – quit(code)
565 – int  code;
566 – {
567 –        exit(code);
568 – }
569 –
570 –
571 – printhead(ac, av)               /* print command header */
572 – register int  ac;
573 – register char  **av;
574 – {
575 –        putchar('#');
576 –        while (ac--) {
577 –                putchar(' ');
578 –                fputs(*av++, stdout);
579 –        }
580 –        putchar('\n');
581 – }
582 –
583 –
591   double
592 < l_hermite()                    
592 > l_hermite(char *nm)
593   {
594          double  t;
595          
# Line 595 | Line 602 | l_hermite()                    
602  
603  
604   double
605 < l_bezier()
605 > l_bezier(char *nm)
606   {
607          double  t;
608  
# Line 608 | Line 615 | l_bezier()
615  
616  
617   double
618 < l_bspline()
618 > l_bspline(char *nm)
619   {
620          double  t;
621  

Diff Legend

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