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

Comparing ray/src/cv/arch2rad.c (file contents):
Revision 2.2 by greg, Sat Feb 22 02:07:23 2003 UTC vs.
Revision 2.5 by greg, Thu Feb 9 21:54:10 2023 UTC

# Line 7 | Line 7 | static const char      RCSid[] = "$Id$";
7   *      Greg Ward
8   */
9  
10 – #include <stdio.h>
11 –
10   #include <stdlib.h>
11  
12 + #include "rtio.h"
13   #include "trans.h"
14  
15   #define DEFMAPFILE      "/usr/local/lib/ray/lib/arch.map"
# Line 93 | Line 92 | char   openmod[] = "opening";
92  
93   char    *progname;              /* argv[0] */
94  
95 + void arch2rad(FILE      *inp, FILE      *out);
96 + void arch2names(FILE    *inp);
97  
98 < main(argc, argv)                /* translate Architrion file */
99 < int     argc;
100 < char    *argv[];
98 > int hasmatch(BLOCK      *bp, RULEHD     *mp);
99 >
100 > void getfhead(FILE      *fp);
101 > void puthead(FILE       *fp);
102 >
103 > int getblock(BLOCK      *bp, FILE       *fp);
104 > void putblock(BLOCK     *bp, FILE       *fp);
105 > void doneblock(BLOCK    *bp);
106 >
107 > int getopening(OPNG     *op, FILE       *fp);
108 > void add2quals(BLOCK    *bp);
109 > int matchrule(BLOCK     *bp, RULEHD     *rp);
110 >
111 > void putopenmod(char    *sm, char       *ml[], int      nm, FILE        *fp);
112 > void putface(char       *m, char        *bn, char       *fn, PRISM      *p,
113 >        int     a, int b, int c, int d, FILE    *fp);
114 > void putfaces(char      *m, BLOCK       *bp, int        ff, FILE        *fp);
115 > void putpoint(PRISM     *p, int n, FILE *fp);
116 > void putopening(OPNG    *op, FILE       *fp);
117 >
118 > int checkface(PRISM     *p, int a, int b, int c, int d);
119 >
120 > void lcross(long        vr[3], long     v1[3], long     v2[3]);
121 >
122 >
123 > int
124 > main(           /* translate Architrion file */
125 >        int     argc,
126 >        char    *argv[]
127 > )
128   {
129          int     donames = 0;            /* -n flag, produce namelist */
130          int     i;
# Line 138 | Line 166 | userr:
166   }
167  
168  
169 < arch2rad(inp, out)      /* translate Architrion file to Radiance */
170 < FILE    *inp, *out;
169 > void
170 > arch2rad(       /* translate Architrion file to Radiance */
171 >        FILE    *inp,
172 >        FILE    *out
173 > )
174   {
175          int     nbs, nos;
176          BLOCK   blk;
# Line 163 | Line 194 | FILE   *inp, *out;
194   }
195  
196  
197 < arch2names(inp)         /* get name list from an Architrion file */
198 < FILE    *inp;
197 > void
198 > arch2names(             /* get name list from an Architrion file */
199 >        FILE    *inp
200 > )
201   {
202          BLOCK   blk;
203          
# Line 176 | Line 209 | FILE   *inp;
209   }
210  
211  
212 < hasmatch(bp, mp)                /* check for any match in rule list */
213 < BLOCK   *bp;
214 < RULEHD  *mp;
212 > int
213 > hasmatch(               /* check for any match in rule list */
214 >        BLOCK   *bp,
215 >        RULEHD  *mp
216 > )
217   {
218          if (mp == NULL)
219                  return(0);
# Line 188 | Line 223 | RULEHD *mp;
223   }
224  
225  
226 < getfhead(fp)                    /* get file header */
227 < FILE    *fp;
226 > void
227 > getfhead(                       /* get file header */
228 >        FILE    *fp
229 > )
230   {
231          char    buf[MAXSTR];
232          int     i, n;
233 <        register int    c;
233 >        int     c;
234                                          /* get file name */
235          if (fgets(buf, MAXSTR, fp) == NULL)
236                  goto readerr;
# Line 243 | Line 280 | readerr:
280   }
281  
282  
283 < puthead(fp)                     /* put out header information */
284 < FILE    *fp;
283 > void
284 > puthead(                        /* put out header information */
285 >        FILE    *fp
286 > )
287   {
288 <        register int    i;
288 >        int     i;
289          
290          fprintf(fp, "# File created by: %s\n", progname);
291          fprintf(fp, "# Input file: %s\n", fhead.filename);
# Line 259 | Line 298 | FILE   *fp;
298   }
299  
300  
301 < getblock(bp, fp)                        /* get an Architrion block */
302 < register BLOCK  *bp;
303 < FILE    *fp;
301 > int
302 > getblock(                       /* get an Architrion block */
303 >        BLOCK   *bp,
304 >        FILE    *fp
305 > )
306   {
307          char    word[32];
308          int     i;
# Line 300 | Line 341 | memerr:
341   }
342  
343  
344 < getopening(op, fp)              /* read in opening from fp */
345 < register OPNG   *op;
346 < FILE    *fp;
344 > int
345 > getopening(             /* read in opening from fp */
346 >        OPNG    *op,
347 >        FILE    *fp
348 > )
349   {
350 <        register int    c;
350 >        int     c;
351          char    word[32];
352  
353          if (fgets(word, sizeof(word), fp) == NULL)
# Line 339 | Line 382 | FILE   *fp;
382   }
383  
384  
385 < doneblock(bp)                   /* free data associated with bp */
386 < register BLOCK  *bp;
385 > void
386 > doneblock(                      /* free data associated with bp */
387 >        BLOCK   *bp
388 > )
389   {
390 <        register int    i;
390 >        int     i;
391  
392          if (bp->nopenings > 0) {
393                  for (i = 0; i < bp->nopenings; i++)
# Line 353 | Line 398 | register BLOCK *bp;
398   }
399  
400  
401 < add2quals(bp)                   /* add to qualifier lists */
402 < register BLOCK  *bp;
401 > void
402 > add2quals(                      /* add to qualifier lists */
403 >        BLOCK   *bp
404 > )
405   {
406          ID      tmpid;
407  
# Line 373 | Line 420 | register BLOCK *bp;
420   }
421  
422  
423 < putblock(bp, fp)                        /* put out a block */
424 < BLOCK   *bp;
425 < FILE    *fp;
423 > void
424 > putblock(                       /* put out a block */
425 >        BLOCK   *bp,
426 >        FILE    *fp
427 > )
428   {
429          RULEHD  *rp;
430          char    *mod[NFACES], *sillmod;
# Line 410 | Line 459 | FILE   *fp;
459   }
460  
461  
462 < putopenmod(sm, ml, nm, fp)              /* put out opening modifier */
463 < char    *sm, *ml[];
464 < int     nm;
465 < FILE    *fp;
462 > void
463 > putopenmod(             /* put out opening modifier */
464 >        char    *sm,
465 >        char    *ml[],
466 >        int     nm,
467 >        FILE    *fp
468 > )
469   {
470          int     rept, nrepts;
471 <        register int    i, j;
471 >        int     i, j;
472          
473          if (sm == NULL) {               /* if no sill modifier, use list */
474                  sm = *ml++;
# Line 446 | Line 498 | FILE   *fp;
498   }
499  
500  
501 < putopening(op, fp)                      /* put out an opening */
502 < OPNG    *op;
503 < FILE    *fp;
501 > void
502 > putopening(                     /* put out an opening */
503 >        OPNG    *op,
504 >        FILE    *fp
505 > )
506   {
507          static int      nopens = 0;
508          char    buf[32];
509 <        register PRISM  *p = &op->p;
509 >        PRISM   *p = &op->p;
510          PRISM   newp;
511 <        register int    i;
511 >        int     i;
512                                          /* copy original prism */
513          for (i = 0; i < 4; i++) {
514                  newp.x[i] = p->x[i];
# Line 497 | Line 551 | FILE   *fp;
551  
552  
553   int
554 < matchrule(bp, rp)                       /* see if block matches this rule */
555 < register BLOCK  *bp;
556 < register RULEHD *rp;
554 > matchrule(                      /* see if block matches this rule */
555 >        BLOCK   *bp,
556 >        RULEHD  *rp
557 > )
558   {
559 <        register int    i;
559 >        int     i;
560          ID      tmpid;
561          
562          if (rp->qflg & FL(Q_LAY)) {             /* check layer */
# Line 530 | Line 585 | register RULEHD        *rp;
585   }              
586  
587  
588 < putfaces(m, bp, ff, fp)                 /* put out faces */
589 < char    *m;
590 < BLOCK   *bp;
591 < register int    ff;
592 < FILE    *fp;
588 > void
589 > putfaces(                       /* put out faces */
590 >        char    *m,
591 >        BLOCK   *bp,
592 >        int     ff,
593 >        FILE    *fp
594 > )
595   {
596          char    *blkname(), *bn;
597  
# Line 557 | Line 614 | FILE   *fp;
614  
615  
616   char *
617 < blkname(bp)             /* think up a good name for this block */
618 < register BLOCK  *bp;
617 > blkname(                /* think up a good name for this block */
618 >        BLOCK   *bp
619 > )
620   {
621          static char     nambuf[32];
622          static int      blkcnt = 0;
623 <        register char   *nam;
624 <        register int    i, j;
623 >        char    *nam;
624 >        int     i, j;
625  
626          sprintf(nambuf, "l%d.", bp->layer);
627          i = strlen(nambuf);
# Line 591 | Line 649 | register BLOCK *bp;
649   }
650  
651  
652 < putface(m, bn, fn, p, a, b, c, d, fp)   /* put out a face */
653 < char    *m;
654 < char    *bn, *fn;
655 < PRISM   *p;
656 < int     a, b, c, d;
657 < FILE    *fp;
652 > void
653 > putface(        /* put out a face */
654 >        char    *m,
655 >        char    *bn,
656 >        char    *fn,
657 >        PRISM   *p,
658 >        int     a,
659 >        int b,
660 >        int c,
661 >        int d,
662 >        FILE    *fp
663 > )
664   {
665          int     cf;
666          
# Line 630 | Line 694 | FILE   *fp;
694   #define ldot(v1,v2)     (v1[0]*v2[0]+v1[1]*v2[1]+v1[2]*v2[2])
695  
696  
697 < long
698 < lcross(vr, v1, v2)                      /* compute cross product */
699 < register long   vr[3], v1[3], v2[3];
697 > void
698 > lcross(                 /* compute cross product */
699 >        long    vr[3],
700 >        long    v1[3],
701 >        long    v2[3]
702 > )
703   {
704          vr[0] = v1[1]*v2[2] - v1[2]*v2[1];
705          vr[1] = v1[2]*v2[0] - v1[0]*v2[2];
# Line 643 | Line 710 | register long  vr[3], v1[3], v2[3];
710   #define labs(a)         ((a)>0 ? (a) : -(a))
711  
712  
713 < checkface(p, a, b, c, d)                /* check a face for validity */
714 < register PRISM  *p;
715 < int     a, b, c, d;
713 > int
714 > checkface(              /* check a face for validity */
715 >        PRISM   *p,
716 >        int     a,
717 >        int b,
718 >        int c,
719 >        int d
720 > )
721   {
722          int     rval = 0;
723          long    lt;
# Line 693 | Line 765 | int    a, b, c, d;
765   }
766  
767  
768 < putpoint(p, n, fp)                      /* put out a point */
769 < register PRISM  *p;
770 < int     n;
771 < FILE    *fp;
768 > void
769 > putpoint(                       /* put out a point */
770 >        PRISM   *p,
771 >        int     n,
772 >        FILE    *fp
773 > )
774   {
775          register int    i = n&3;
776          
# Line 706 | Line 780 | FILE   *fp;
780  
781  
782   void
783 < eputs(s)
784 < char    *s;
783 > eputs(
784 >        const char      *s
785 > )
786   {
787          fputs(s, stderr);
788   }
789  
790  
791   void
792 < quit(code)
793 < int     code;
792 > quit(
793 >        int     code
794 > )
795   {
796          exit(code);
797   }
798 +

Diff Legend

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