13 |
|
#include <string.h> |
14 |
|
|
15 |
|
#include "platform.h" |
16 |
+ |
#include "rtprocess.h" /* win_popen() */ |
17 |
+ |
#include "paths.h" |
18 |
|
#include "ray.h" |
19 |
|
#include "source.h" |
20 |
|
#include "ambient.h" |
38 |
|
extern char *octname; |
39 |
|
|
40 |
|
|
41 |
< |
extern void |
41 |
> |
void |
42 |
|
getframe( /* get a new frame */ |
43 |
|
char *s |
44 |
|
) |
49 |
|
} |
50 |
|
|
51 |
|
|
52 |
< |
extern void |
52 |
> |
void |
53 |
|
getrepaint( /* get area and repaint */ |
54 |
|
char *s |
55 |
|
) |
58 |
|
|
59 |
|
if (getrect(s, &box) < 0) |
60 |
|
return; |
61 |
< |
paintrect(&ptrunk, 0, 0, hresolu, vresolu, &box); |
61 |
> |
paintrect(&ptrunk, &box); |
62 |
|
} |
63 |
|
|
64 |
|
|
65 |
< |
extern void |
66 |
< |
getview( /* get/show view parameters */ |
65 |
> |
void |
66 |
> |
getview( /* get/show/save view parameters */ |
67 |
|
char *s |
68 |
|
) |
69 |
|
{ |
82 |
|
error(COMMAND, "bad view option(s)"); |
83 |
|
return; |
84 |
|
} |
85 |
< |
if (sscanf(s, "%s", buf) == 1) { /* write parameters to a file */ |
85 |
> |
if (nextword(buf, sizeof(buf), s) != NULL) { /* write to a file */ |
86 |
|
if ((fname = getpath(buf, NULL, 0)) == NULL || |
87 |
|
(fp = fopen(fname, "a")) == NULL) { |
88 |
|
sprintf(errmsg, "cannot open \"%s\"", buf); |
155 |
|
} |
156 |
|
|
157 |
|
|
158 |
< |
extern void |
158 |
> |
void |
159 |
|
lastview( /* return to a previous view */ |
160 |
|
char *s |
161 |
|
) |
164 |
|
char *fname; |
165 |
|
int success; |
166 |
|
VIEW nv; |
167 |
< |
|
168 |
< |
if (sscanf(s, "%s", buf) == 1) { /* get parameters from a file */ |
167 |
> |
/* get parameters from a file */ |
168 |
> |
if (nextword(buf, sizeof(buf), s) != NULL) { |
169 |
|
nv = stdview; |
170 |
|
if ((fname = getpath(buf, "", R_OK)) == NULL || |
171 |
|
(success = viewfile(fname, &nv, NULL)) == -1) { |
186 |
|
nv = ourview; |
187 |
|
ourview = oldview; |
188 |
|
oldview = nv; |
189 |
< |
newimage(); |
189 |
> |
newimage(NULL); |
190 |
|
} |
191 |
|
|
192 |
|
|
193 |
< |
extern void |
193 |
> |
void |
194 |
|
saveview( /* save view to rad file */ |
195 |
|
char *s |
196 |
|
) |
206 |
|
} |
207 |
|
s = sskip(s); |
208 |
|
} |
209 |
< |
while (isspace(*s)) |
208 |
< |
s++; |
209 |
< |
if (*s) |
210 |
< |
atos(rifname, sizeof(rifname), s); |
211 |
< |
else if (rifname[0] == '\0') { |
209 |
> |
if (nextword(rifname, sizeof(rifname), s) == NULL && !rifname[0]) { |
210 |
|
error(COMMAND, "no previous rad file"); |
211 |
|
return; |
212 |
|
} |
224 |
|
} |
225 |
|
|
226 |
|
|
227 |
< |
extern void |
227 |
> |
void |
228 |
|
loadview( /* load view from rad file */ |
229 |
|
char *s |
230 |
|
) |
239 |
|
s = sskip(s); |
240 |
|
else |
241 |
|
strcat(buf, "1"); |
242 |
< |
if (*s) |
245 |
< |
atos(rifname, sizeof(rifname), s); |
246 |
< |
else if (rifname[0] == '\0') { |
242 |
> |
if (nextword(rifname, sizeof(rifname), s) == NULL && !rifname[0]) { |
243 |
|
error(COMMAND, "no previous rad file"); |
244 |
|
return; |
245 |
|
} |
265 |
|
} |
266 |
|
|
267 |
|
|
268 |
< |
extern void |
268 |
> |
void |
269 |
|
getaim( /* aim camera */ |
270 |
|
char *s |
271 |
|
) |
280 |
|
} |
281 |
|
|
282 |
|
|
283 |
< |
extern void |
283 |
> |
void |
284 |
|
getfocus( /* set focus distance */ |
285 |
|
char *s |
286 |
|
) |
287 |
|
{ |
288 |
< |
FVECT vc; |
288 |
> |
char buf[64]; |
289 |
|
double dist; |
290 |
|
|
291 |
|
if (sscanf(s, "%lf", &dist) < 1) { |
312 |
|
return; |
313 |
|
} |
314 |
|
ourview.vdist = dist; |
315 |
+ |
sprintf(buf, "Focus distance set to %f\n", dist); |
316 |
+ |
(*dev->comout)(buf); |
317 |
|
} |
318 |
|
|
319 |
|
|
320 |
< |
extern void |
320 |
> |
void |
321 |
|
getmove( /* move camera */ |
322 |
|
char *s |
323 |
|
) |
331 |
|
} |
332 |
|
|
333 |
|
|
334 |
< |
extern void |
334 |
> |
void |
335 |
|
getrotate( /* rotate camera */ |
336 |
|
char *s |
337 |
|
) |
338 |
|
{ |
339 |
|
VIEW nv = ourview; |
342 |
– |
FVECT v1; |
340 |
|
double angle, elev, zfact; |
341 |
|
|
342 |
|
elev = 0.0; zfact = 1.0; |
345 |
|
return; |
346 |
|
} |
347 |
|
spinvector(nv.vdir, ourview.vdir, ourview.vup, angle*(PI/180.)); |
348 |
< |
if (elev != 0.0) { |
349 |
< |
fcross(v1, nv.vdir, ourview.vup); |
350 |
< |
normalize(v1); |
354 |
< |
spinvector(nv.vdir, nv.vdir, v1, elev*(PI/180.)); |
355 |
< |
} |
348 |
> |
if (elev != 0.0) |
349 |
> |
geodesic(nv.vdir, nv.vdir, nv.vup, elev*(PI/180.), GEOD_RAD); |
350 |
> |
|
351 |
|
zoomview(&nv, zfact); |
352 |
|
newview(&nv); |
353 |
|
} |
354 |
|
|
355 |
|
|
356 |
< |
extern void |
356 |
> |
void |
357 |
|
getpivot( /* pivot viewpoint */ |
358 |
< |
register char *s |
358 |
> |
char *s |
359 |
|
) |
360 |
|
{ |
361 |
|
FVECT vc; |
372 |
|
} |
373 |
|
|
374 |
|
|
375 |
< |
extern void |
375 |
> |
void |
376 |
|
getexposure( /* get new exposure */ |
377 |
|
char *s |
378 |
|
) |
379 |
|
{ |
380 |
|
char buf[128]; |
381 |
< |
register char *cp; |
387 |
< |
RECT r; |
381 |
> |
char *cp; |
382 |
|
int x, y; |
383 |
< |
register PNODE *p = &ptrunk; |
383 |
> |
PNODE *p = &ptrunk; |
384 |
|
int adapt = 0; |
385 |
|
double e = 1.0; |
386 |
|
|
397 |
|
(*dev->comout)("Pick point for exposure\n"); |
398 |
|
if ((*dev->getcur)(&x, &y) == ABORT) |
399 |
|
return; |
400 |
< |
r.l = r.d = 0; |
407 |
< |
r.r = hresolu; r.u = vresolu; |
408 |
< |
p = findrect(x, y, &ptrunk, &r, -1); |
400 |
> |
p = findrect(x, y, &ptrunk, -1); |
401 |
|
} else { |
402 |
|
if (*cp == '=') { /* absolute setting */ |
403 |
|
p = NULL; |
420 |
|
e *= atof(cp); |
421 |
|
} |
422 |
|
if (p != NULL) { /* relative setting */ |
423 |
+ |
compavg(p); |
424 |
|
if (bright(p->v) < 1e-15) { |
425 |
|
error(COMMAND, "cannot normalize to zero"); |
426 |
|
return; |
438 |
|
} |
439 |
|
|
440 |
|
typedef union {int i; double d; COLOR C;} *MyUptr; |
441 |
+ |
#define FEQ(x,y) (fabs((x)-(y)) <= FTINY) |
442 |
|
|
443 |
< |
extern int |
443 |
> |
int |
444 |
|
getparam( /* get variable from user */ |
445 |
|
char *str, |
446 |
|
char *dsc, |
448 |
|
void *p |
449 |
|
) |
450 |
|
{ |
451 |
< |
register MyUptr ptr = (MyUptr)p; |
451 |
> |
MyUptr ptr = (MyUptr)p; |
452 |
|
int i0; |
453 |
|
double d0, d1, d2; |
454 |
|
char buf[48]; |
463 |
|
if (sscanf(buf, "%d", &i0) != 1) |
464 |
|
return(0); |
465 |
|
} |
466 |
+ |
if (ptr->i == i0) |
467 |
+ |
return(0); |
468 |
|
ptr->i = i0; |
469 |
< |
return(1); |
469 |
> |
break; |
470 |
|
case 'r': /* real */ |
471 |
|
if (sscanf(str, "%lf", &d0) != 1) { |
472 |
|
(*dev->comout)(dsc); |
476 |
|
if (sscanf(buf, "%lf", &d0) != 1) |
477 |
|
return(0); |
478 |
|
} |
479 |
+ |
if (FEQ(ptr->d, d0)) |
480 |
+ |
return(0); |
481 |
|
ptr->d = d0; |
482 |
< |
return(1); |
482 |
> |
break; |
483 |
|
case 'b': /* boolean */ |
484 |
|
if (sscanf(str, "%1s", buf) != 1) { |
485 |
|
(*dev->comout)(dsc); |
486 |
|
sprintf(buf, "? (%c): ", ptr->i ? 'y' : 'n'); |
487 |
|
(*dev->comout)(buf); |
488 |
|
(*dev->comin)(buf, NULL); |
489 |
< |
if (buf[0] == '\0' || |
492 |
< |
strchr("yY+1tTnN-0fF", buf[0]) == NULL) |
489 |
> |
if (buf[0] == '\0') |
490 |
|
return(0); |
491 |
|
} |
492 |
< |
ptr->i = strchr("yY+1tT", buf[0]) != NULL; |
493 |
< |
return(1); |
492 |
> |
if (strchr("yY+1tTnN-0fF", buf[0]) == NULL) |
493 |
> |
return(0); |
494 |
> |
i0 = strchr("yY+1tT", buf[0]) != NULL; |
495 |
> |
if (ptr->i == i0) |
496 |
> |
return(0); |
497 |
> |
ptr->i = i0; |
498 |
> |
break; |
499 |
|
case 'C': /* color */ |
500 |
|
if (sscanf(str, "%lf %lf %lf", &d0, &d1, &d2) != 3) { |
501 |
|
(*dev->comout)(dsc); |
508 |
|
if (sscanf(buf, "%lf %lf %lf", &d0, &d1, &d2) != 3) |
509 |
|
return(0); |
510 |
|
} |
511 |
+ |
if (FEQ(colval(ptr->C,RED), d0) && |
512 |
+ |
FEQ(colval(ptr->C,GRN), d1) && |
513 |
+ |
FEQ(colval(ptr->C,BLU), d2)) |
514 |
+ |
return(0); |
515 |
|
setcolor(ptr->C, d0, d1, d2); |
516 |
< |
return(1); |
516 |
> |
break; |
517 |
> |
default: |
518 |
> |
return(0); /* shouldn't happen */ |
519 |
|
} |
520 |
< |
return 0; /* nothing matched */ |
520 |
> |
newparam++; |
521 |
> |
return(1); |
522 |
|
} |
523 |
|
|
524 |
|
|
525 |
< |
extern void |
525 |
> |
void |
526 |
|
setparam( /* get/set program parameter */ |
527 |
< |
register char *s |
527 |
> |
char *s |
528 |
|
) |
529 |
|
{ |
530 |
+ |
int prev_newp = newparam; |
531 |
|
char buf[128]; |
532 |
|
|
533 |
|
if (s[0] == '\0') { |
534 |
|
(*dev->comout)( |
535 |
< |
"aa ab ad ar as av aw b dc dv dj ds dt i lr lw me ma mg ms ps pt R sj st bv: "); |
535 |
> |
"aa ab ad ar as av aw b bv dc dv dj ds dt i lr lw me ma mg ms ps pt ss st u: "); |
536 |
|
(*dev->comin)(buf, NULL); |
537 |
|
s = buf; |
538 |
|
} |
539 |
|
switch (s[0]) { |
540 |
< |
case 'R': /* random sampling */ |
541 |
< |
getparam(s+1, "random sampling", 'b', |
540 |
> |
case 'u': /* uncorrelated sampling */ |
541 |
> |
getparam(s+1, "uncorrelated sampling", 'b', |
542 |
|
(void *)&rand_samp); |
543 |
|
break; |
544 |
|
case 'l': /* limit */ |
593 |
|
case 'n': case 'N': case 'f': case 'F': case '0': case '-': |
594 |
|
getparam(s+1, "black and white", 'b', |
595 |
|
(void *)&greyscale); |
596 |
+ |
newparam = prev_newp; |
597 |
|
break; |
598 |
|
default: |
599 |
|
goto badparam; |
676 |
|
default: |
677 |
|
goto badparam; |
678 |
|
} |
679 |
+ |
newparam = prev_newp; |
680 |
|
break; |
681 |
|
case 's': /* specular */ |
682 |
|
switch (s[1]) { |
683 |
< |
case 'j': /* jitter */ |
684 |
< |
getparam(s+2, "specular jitter", 'r', |
683 |
> |
case 's': /* sampling */ |
684 |
> |
getparam(s+2, "specular sampling", 'r', |
685 |
|
(void *)&specjitter); |
686 |
|
break; |
687 |
|
case 't': /* threshold */ |
704 |
|
} |
705 |
|
|
706 |
|
|
707 |
< |
extern void |
708 |
< |
traceray(s) /* trace a single ray */ |
709 |
< |
char *s; |
707 |
> |
void |
708 |
> |
traceray( /* trace a single ray */ |
709 |
> |
char *s |
710 |
> |
) |
711 |
|
{ |
712 |
< |
char buf[128]; |
713 |
< |
int x, y; |
701 |
< |
OBJREC *ino; |
702 |
< |
RAY thisray; |
712 |
> |
RAY thisray; |
713 |
> |
char buf[512]; |
714 |
|
|
715 |
|
thisray.rmax = 0.0; |
716 |
|
|
717 |
|
if (!sscanvec(s, thisray.rorg) || |
718 |
|
!sscanvec(sskip2(s,3), thisray.rdir)) { |
719 |
+ |
int x, y; |
720 |
|
|
721 |
|
if (dev->getcur == NULL) |
722 |
|
return; |
735 |
|
return; |
736 |
|
} |
737 |
|
|
738 |
< |
rayorigin(&thisray, PRIMARY, NULL, NULL); |
727 |
< |
|
728 |
< |
rayvalue(&thisray); |
738 |
> |
ray_trace(&thisray); |
739 |
|
|
740 |
|
if (thisray.ro == NULL) |
741 |
|
(*dev->comout)("ray hit nothing"); |
742 |
|
else { |
743 |
|
OBJREC *mat = NULL; |
744 |
< |
OBJREC *mod = NULL;; |
744 |
> |
OBJREC *mod = NULL; |
745 |
|
char matspec[256]; |
746 |
+ |
OBJREC *ino; |
747 |
+ |
|
748 |
|
matspec[0] = '\0'; |
749 |
|
if (thisray.ro->omod != OVOID) { |
750 |
|
mod = objptr(thisray.ro->omod); |
787 |
|
} |
788 |
|
|
789 |
|
|
790 |
< |
extern void |
791 |
< |
writepict(s) /* write the picture to a file */ |
792 |
< |
char *s; |
790 |
> |
void |
791 |
> |
writepict( /* write the picture to a file */ |
792 |
> |
char *s |
793 |
> |
) |
794 |
|
{ |
795 |
|
static char buf[128]; |
796 |
|
char *fname; |
797 |
|
FILE *fp; |
798 |
|
COLR *scanline; |
799 |
|
int y; |
800 |
< |
|
801 |
< |
while (isspace(*s)) |
789 |
< |
s++; |
790 |
< |
if (*s) |
791 |
< |
atos(buf, sizeof(buf), s); |
792 |
< |
else if (buf[0] == '\0') { |
800 |
> |
/* XXX relies on words.c 2.11 behavior */ |
801 |
> |
if (nextword(buf, sizeof(buf), s) == NULL && !buf[0]) { |
802 |
|
error(COMMAND, "no file"); |
803 |
|
return; |
804 |
|
} |