1 |
– |
/* Copyright (c) 1990 Regents of the University of California */ |
2 |
– |
|
1 |
|
#ifndef lint |
2 |
< |
static char SCCSid[] = "$SunId$ LBL"; |
2 |
> |
static const char RCSid[] = "$Id$"; |
3 |
|
#endif |
6 |
– |
|
4 |
|
/* |
5 |
|
* Convert Architrion file to Radiance |
6 |
|
* |
7 |
|
* Greg Ward |
8 |
|
*/ |
9 |
|
|
10 |
< |
#include <stdio.h> |
10 |
> |
#include <stdlib.h> |
11 |
|
|
12 |
+ |
#include "rtio.h" |
13 |
|
#include "trans.h" |
14 |
|
|
15 |
|
#define DEFMAPFILE "/usr/local/lib/ray/lib/arch.map" |
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; |
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; |
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 |
|
|
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); |
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; |
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; |
289 |
|
|
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 |
> |
register BLOCK *bp, |
304 |
> |
FILE *fp |
305 |
> |
) |
306 |
|
{ |
307 |
|
char word[32]; |
308 |
|
int i; |
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 |
> |
register OPNG *op, |
347 |
> |
FILE *fp |
348 |
> |
) |
349 |
|
{ |
350 |
|
register int c; |
351 |
|
char word[32]; |
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 |
> |
register BLOCK *bp |
388 |
> |
) |
389 |
|
{ |
390 |
|
register int i; |
391 |
|
|
392 |
|
if (bp->nopenings > 0) { |
393 |
|
for (i = 0; i < bp->nopenings; i++) |
394 |
|
doneid(&bp->opening[i].frame); |
395 |
< |
free((char *)bp->opening); |
395 |
> |
free((void *)bp->opening); |
396 |
|
} |
397 |
|
doneid(&bp->refid); |
398 |
|
} |
399 |
|
|
400 |
|
|
401 |
< |
add2quals(bp) /* add to qualifier lists */ |
402 |
< |
register BLOCK *bp; |
401 |
> |
void |
402 |
> |
add2quals( /* add to qualifier lists */ |
403 |
> |
register BLOCK *bp |
404 |
> |
) |
405 |
|
{ |
406 |
|
ID tmpid; |
407 |
|
|
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; |
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; |
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]; |
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 |
> |
register BLOCK *bp, |
556 |
> |
register RULEHD *rp |
557 |
> |
) |
558 |
|
{ |
559 |
|
register int i; |
560 |
|
ID tmpid; |
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 |
> |
register int ff, |
593 |
> |
FILE *fp |
594 |
> |
) |
595 |
|
{ |
596 |
|
char *blkname(), *bn; |
597 |
|
|
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 |
> |
register BLOCK *bp |
619 |
> |
) |
620 |
|
{ |
621 |
|
static char nambuf[32]; |
622 |
|
static int blkcnt = 0; |
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 |
|
|
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 |
> |
register long vr[3], |
700 |
> |
register long v1[3], |
701 |
> |
register 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]; |
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 |
> |
register PRISM *p, |
716 |
> |
int a, |
717 |
> |
int b, |
718 |
> |
int c, |
719 |
> |
int d |
720 |
> |
) |
721 |
|
{ |
722 |
|
int rval = 0; |
723 |
|
long lt; |
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 |
> |
register PRISM *p, |
771 |
> |
int n, |
772 |
> |
FILE *fp |
773 |
> |
) |
774 |
|
{ |
775 |
|
register int i = n&3; |
776 |
|
|
779 |
|
} |
780 |
|
|
781 |
|
|
782 |
< |
eputs(s) |
783 |
< |
char *s; |
782 |
> |
void |
783 |
> |
eputs( |
784 |
> |
char *s |
785 |
> |
) |
786 |
|
{ |
787 |
|
fputs(s, stderr); |
788 |
|
} |
789 |
|
|
790 |
|
|
791 |
< |
quit(code) |
792 |
< |
int code; |
791 |
> |
void |
792 |
> |
quit( |
793 |
> |
int code |
794 |
> |
) |
795 |
|
{ |
796 |
|
exit(code); |
797 |
|
} |
798 |
+ |
|