| 55 |
|
static RAY thisray; /* for our convenience */ |
| 56 |
|
|
| 57 |
|
typedef void putf_t(RREAL *v, int n); |
| 58 |
< |
static putf_t puta, putd, putf; |
| 58 |
> |
static putf_t puta, putd, putf, putrgbe; |
| 59 |
|
|
| 60 |
|
typedef void oputf_t(RAY *r); |
| 61 |
|
static oputf_t oputo, oputd, oputv, oputV, oputl, oputL, oputc, oputp, |
| 117 |
|
{ |
| 118 |
|
unsigned long vcount = (hresolu > 1) ? (unsigned long)hresolu*vresolu |
| 119 |
|
: (unsigned long)vresolu; |
| 120 |
< |
long nextflush = (vresolu > 0) & (hresolu > 1) ? 0 : hresolu; |
| 120 |
> |
long nextflush = (!vresolu | (hresolu <= 1)) * hresolu; |
| 121 |
> |
int something2flush = 0; |
| 122 |
|
FILE *fp; |
| 123 |
|
double d; |
| 124 |
|
FVECT orig, direc; |
| 137 |
|
castonly = 0; |
| 138 |
|
else if (castonly) |
| 139 |
|
nproc = 1; /* don't bother multiprocessing */ |
| 140 |
+ |
if ((nextflush > 0) & (nproc > nextflush)) { |
| 141 |
+ |
error(WARNING, "reducing number of processes to match flush interval"); |
| 142 |
+ |
nproc = nextflush; |
| 143 |
+ |
} |
| 144 |
|
switch (outform) { |
| 145 |
|
case 'a': putreal = puta; break; |
| 146 |
|
case 'f': putreal = putf; break; |
| 147 |
|
case 'd': putreal = putd; break; |
| 148 |
|
case 'c': |
| 149 |
< |
if (strcmp(outvals, "v")) |
| 150 |
< |
error(USER, "color format with value output only"); |
| 151 |
< |
break; |
| 149 |
> |
if (outvals[0] && (outvals[1] || !strchr("vrx", outvals[0]))) |
| 150 |
> |
error(USER, "color format only with -ov, -or, -ox"); |
| 151 |
> |
putreal = putrgbe; break; |
| 152 |
|
default: |
| 153 |
|
error(CONSISTENCY, "botched output format"); |
| 154 |
|
} |
| 159 |
|
if (hresolu > 0) { |
| 160 |
|
if (vresolu > 0) |
| 161 |
|
fprtresolu(hresolu, vresolu, stdout); |
| 162 |
< |
fflush(stdout); |
| 162 |
> |
else |
| 163 |
> |
fflush(stdout); |
| 164 |
|
} |
| 165 |
|
/* process file */ |
| 166 |
|
while (getvec(orig, inform, fp) == 0 && |
| 167 |
|
getvec(direc, inform, fp) == 0) { |
| 168 |
|
|
| 169 |
|
d = normalize(direc); |
| 170 |
< |
if (d == 0.0) { /* zero ==> flush */ |
| 171 |
< |
if ((--nextflush <= 0) | !vcount) { |
| 170 |
> |
if (d == 0.0) { /* bogus ray */ |
| 171 |
> |
bogusray(); |
| 172 |
> |
/* flush request? */ |
| 173 |
> |
if (something2flush) { |
| 174 |
|
if (ray_pnprocs > 1 && ray_fifo_flush() < 0) |
| 175 |
|
error(USER, "child(ren) died"); |
| 168 |
– |
bogusray(); |
| 176 |
|
fflush(stdout); |
| 177 |
< |
nextflush = (vresolu > 0) & (hresolu > 1) ? 0 : |
| 178 |
< |
hresolu; |
| 179 |
< |
} else |
| 173 |
< |
bogusray(); |
| 177 |
> |
nextflush = (!vresolu | (hresolu <= 1)) * hresolu; |
| 178 |
> |
something2flush = 0; |
| 179 |
> |
} |
| 180 |
|
} else { /* compute and print */ |
| 181 |
|
rtcompute(orig, direc, lim_dist ? d : 0.0); |
| 182 |
|
/* flush if time */ |
| 185 |
|
error(USER, "child(ren) died"); |
| 186 |
|
fflush(stdout); |
| 187 |
|
nextflush = hresolu; |
| 188 |
< |
} |
| 188 |
> |
} else |
| 189 |
> |
something2flush = 1; |
| 190 |
|
} |
| 191 |
|
if (ferror(stdout)) |
| 192 |
|
error(SYSTEM, "write error"); |
| 266 |
|
break; |
| 267 |
|
case 'V': /* contribution */ |
| 268 |
|
*table++ = oputV; |
| 262 |
– |
castonly = 0; |
| 269 |
|
if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0)) |
| 270 |
|
error(WARNING, |
| 271 |
|
"-otV accuracy depends on -aa 0 -as 0"); |
| 299 |
|
case 'W': /* coefficient */ |
| 300 |
|
*table++ = oputW; |
| 301 |
|
castonly = 0; |
| 302 |
< |
if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0)) |
| 302 |
> |
if (ambounce > 0 && (ambacc > FTINY) | (ambssamp > 0)) |
| 303 |
|
error(WARNING, |
| 304 |
|
"-otW accuracy depends on -aa 0 -as 0"); |
| 305 |
|
break; |
| 314 |
|
break; |
| 315 |
|
} |
| 316 |
|
*table = NULL; |
| 317 |
+ |
/* compatibility */ |
| 318 |
+ |
for (table = ray_out; *table != NULL; table++) { |
| 319 |
+ |
if ((*table == oputV) | (*table == oputW)) |
| 320 |
+ |
error(WARNING, "-oVW options require trace mode"); |
| 321 |
+ |
if ((do_irrad | imm_irrad) && |
| 322 |
+ |
(*table == oputr) | (*table == oputR) | |
| 323 |
+ |
(*table == oputx) | (*table == oputX)) |
| 324 |
+ |
error(WARNING, "-orRxX options incompatible with -I+ and -i+"); |
| 325 |
+ |
} |
| 326 |
|
} |
| 327 |
|
|
| 328 |
|
|
| 329 |
|
static void |
| 330 |
|
bogusray(void) /* print out empty record */ |
| 331 |
|
{ |
| 317 |
– |
memset(&thisray, 0, sizeof(thisray)); |
| 332 |
|
rayorigin(&thisray, PRIMARY, NULL, NULL); |
| 333 |
|
printvals(&thisray); |
| 334 |
|
} |
| 593 |
|
{ |
| 594 |
|
RREAL cval[3]; |
| 595 |
|
|
| 582 |
– |
if (outform == 'c') { |
| 583 |
– |
COLR cout; |
| 584 |
– |
setcolr(cout, colval(r->rcol,RED), |
| 585 |
– |
colval(r->rcol,GRN), |
| 586 |
– |
colval(r->rcol,BLU)); |
| 587 |
– |
putbinary(cout, sizeof(cout), 1, stdout); |
| 588 |
– |
return; |
| 589 |
– |
} |
| 596 |
|
cval[0] = colval(r->rcol,RED); |
| 597 |
|
cval[1] = colval(r->rcol,GRN); |
| 598 |
|
cval[2] = colval(r->rcol,BLU); |
| 662 |
|
RAY *r |
| 663 |
|
) |
| 664 |
|
{ |
| 665 |
< |
if (r->rot < FHUGE) |
| 666 |
< |
(*putreal)(r->ron, 3); |
| 667 |
< |
else |
| 665 |
> |
if (r->rot < FHUGE) { |
| 666 |
> |
if (r->rflips & 1) { /* undo any flippin' flips */ |
| 667 |
> |
FVECT unrm; |
| 668 |
> |
unrm[0] = -r->ron[0]; |
| 669 |
> |
unrm[1] = -r->ron[1]; |
| 670 |
> |
unrm[2] = -r->ron[2]; |
| 671 |
> |
(*putreal)(unrm, 3); |
| 672 |
> |
} else |
| 673 |
> |
(*putreal)(r->ron, 3); |
| 674 |
> |
} else |
| 675 |
|
(*putreal)(vdummy, 3); |
| 676 |
|
} |
| 677 |
|
|
| 790 |
|
|
| 791 |
|
|
| 792 |
|
static void |
| 793 |
< |
putd(RREAL *v, int n) /* print binary double(s) */ |
| 793 |
> |
putd(RREAL *v, int n) /* output binary double(s) */ |
| 794 |
|
{ |
| 795 |
|
#ifdef SMLFLT |
| 796 |
|
double da[3]; |
| 808 |
|
|
| 809 |
|
|
| 810 |
|
static void |
| 811 |
< |
putf(RREAL *v, int n) /* print binary float(s) */ |
| 811 |
> |
putf(RREAL *v, int n) /* output binary float(s) */ |
| 812 |
|
{ |
| 813 |
|
#ifndef SMLFLT |
| 814 |
|
float fa[3]; |
| 822 |
|
#else |
| 823 |
|
putbinary(v, sizeof(RREAL), n, stdout); |
| 824 |
|
#endif |
| 825 |
+ |
} |
| 826 |
+ |
|
| 827 |
+ |
|
| 828 |
+ |
static void |
| 829 |
+ |
putrgbe(RREAL *v, int n) /* output RGBE color */ |
| 830 |
+ |
{ |
| 831 |
+ |
COLR cout; |
| 832 |
+ |
|
| 833 |
+ |
if (n != 3) |
| 834 |
+ |
error(INTERNAL, "putrgbe() not called with 3 components"); |
| 835 |
+ |
setcolr(cout, v[0], v[1], v[2]); |
| 836 |
+ |
putbinary(cout, sizeof(cout), 1, stdout); |
| 837 |
|
} |