12 |
|
#include "platform.h" |
13 |
|
#include "ray.h" |
14 |
|
#include "otypes.h" |
15 |
+ |
#include "otspecial.h" |
16 |
|
#include "resolu.h" |
17 |
|
#include "ambient.h" |
18 |
|
#include "random.h" |
78 |
|
|
79 |
|
#define newambval() (AMBVAL *)malloc(sizeof(AMBVAL)) |
80 |
|
|
81 |
+ |
#define tfunc(lwr, x, upr) (((x)-(lwr))/((upr)-(lwr))) |
82 |
+ |
|
83 |
|
static void initambfile(int creat); |
84 |
|
static void avsave(AMBVAL *av); |
85 |
|
static AMBVAL *avstore(AMBVAL *aval); |
96 |
|
static int avlmemi(AMBVAL *avaddr); |
97 |
|
static void sortambvals(int always); |
98 |
|
|
99 |
+ |
static int plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang); |
100 |
+ |
static double sumambient(COLOR acol, RAY *r, FVECT rn, int al, |
101 |
+ |
AMBTREE *at, FVECT c0, double s); |
102 |
+ |
static int makeambient(COLOR acol, RAY *r, FVECT rn, int al); |
103 |
+ |
static int extambient(COLOR cr, AMBVAL *ap, FVECT pv, FVECT nv, |
104 |
+ |
FVECT uvw[3]); |
105 |
+ |
|
106 |
|
#ifdef F_SETLKW |
107 |
|
static void aflock(int typ); |
108 |
|
#endif |
141 |
|
newa *= (newa > 0); |
142 |
|
if (fabs(newa - olda) >= .05*(newa + olda)) { |
143 |
|
ambacc = newa; |
144 |
< |
if (nambvals > 0) |
144 |
> |
if (ambacc > FTINY && nambvals > 0) |
145 |
|
sortambvals(1); /* rebuild tree */ |
146 |
|
} |
147 |
|
} |
264 |
|
} |
265 |
|
} |
266 |
|
|
257 |
– |
/************ THE FOLLOWING ROUTINES DIFFER BETWEEN NEW & OLD ***************/ |
267 |
|
|
259 |
– |
#ifndef OLDAMB |
260 |
– |
|
261 |
– |
#define tfunc(lwr, x, upr) (((x)-(lwr))/((upr)-(lwr))) |
262 |
– |
|
263 |
– |
static int plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang); |
264 |
– |
static double sumambient(COLOR acol, RAY *r, FVECT rn, int al, |
265 |
– |
AMBTREE *at, FVECT c0, double s); |
266 |
– |
static int makeambient(COLOR acol, RAY *r, FVECT rn, int al); |
267 |
– |
static int extambient(COLOR cr, AMBVAL *ap, FVECT pv, FVECT nv, |
268 |
– |
FVECT uvw[3]); |
269 |
– |
|
268 |
|
void |
269 |
|
multambient( /* compute ambient component & multiply by coef. */ |
270 |
|
COLOR aval, |
274 |
|
{ |
275 |
|
static int rdepth = 0; /* ambient recursion */ |
276 |
|
COLOR acol, caustic; |
277 |
< |
int ok; |
277 |
> |
int i, ok; |
278 |
|
double d, l; |
279 |
|
|
280 |
|
/* PMAP: Factor in ambient from photon map, if enabled and ray is |
300 |
|
goto dumbamb; |
301 |
|
|
302 |
|
if (ambacc <= FTINY) { /* no ambient storage */ |
303 |
+ |
FVECT uvd[2]; |
304 |
+ |
float dgrad[2], *dgp = NULL; |
305 |
+ |
|
306 |
+ |
if (nrm != r->ron && DOT(nrm,r->ron) < 0.9999) |
307 |
+ |
dgp = dgrad; /* compute rotational grad. */ |
308 |
|
copycolor(acol, aval); |
309 |
|
rdepth++; |
310 |
|
ok = doambient(acol, r, r->rweight, |
311 |
< |
NULL, NULL, NULL, NULL, NULL); |
311 |
> |
uvd, NULL, NULL, dgp, NULL); |
312 |
|
rdepth--; |
313 |
|
if (!ok) |
314 |
|
goto dumbamb; |
315 |
+ |
if ((ok > 0) & (dgp != NULL)) { /* apply texture */ |
316 |
+ |
FVECT v1; |
317 |
+ |
VCROSS(v1, r->ron, nrm); |
318 |
+ |
d = 1.0; |
319 |
+ |
for (i = 3; i--; ) |
320 |
+ |
d += v1[i] * (dgp[0]*uvd[0][i] + dgp[1]*uvd[1][i]); |
321 |
+ |
if (d >= 0.05) |
322 |
+ |
scalecolor(acol, d); |
323 |
+ |
} |
324 |
|
copycolor(aval, acol); |
325 |
|
|
326 |
|
/* PMAP: add in caustic */ |
413 |
|
VSUM(rtst.rdir, vdif, anorm, t[1]); /* further dist. > plane */ |
414 |
|
rtst.rmax = normalize(rtst.rdir); /* short ray test */ |
415 |
|
while (localhit(&rtst, &thescene)) { /* check for occluder */ |
416 |
< |
if (rtst.ro->omod != OVOID && |
416 |
> |
OBJREC *m = findmaterial(rtst.ro); |
417 |
> |
if (m != NULL && !istransp(m->otype) && !isBSDFproxy(m) && |
418 |
|
(rtst.clipset == NULL || |
419 |
|
!inset(rtst.clipset, rtst.ro->omod))) |
420 |
|
return(1); /* plug light leak */ |
653 |
|
} |
654 |
|
|
655 |
|
|
643 |
– |
#else /* ! NEWAMB */ |
644 |
– |
|
645 |
– |
static double sumambient(COLOR acol, RAY *r, FVECT rn, int al, |
646 |
– |
AMBTREE *at, FVECT c0, double s); |
647 |
– |
static double makeambient(COLOR acol, RAY *r, FVECT rn, int al); |
648 |
– |
static void extambient(COLOR cr, AMBVAL *ap, FVECT pv, FVECT nv); |
649 |
– |
|
650 |
– |
|
651 |
– |
void |
652 |
– |
multambient( /* compute ambient component & multiply by coef. */ |
653 |
– |
COLOR aval, |
654 |
– |
RAY *r, |
655 |
– |
FVECT nrm |
656 |
– |
) |
657 |
– |
{ |
658 |
– |
static int rdepth = 0; /* ambient recursion */ |
659 |
– |
COLOR acol, caustic; |
660 |
– |
double d, l; |
661 |
– |
|
662 |
– |
/* PMAP: Factor in ambient from global photon map (if enabled) and return |
663 |
– |
* as all ambient components accounted for */ |
664 |
– |
if (ambPmap(aval, r, rdepth)) |
665 |
– |
return; |
666 |
– |
|
667 |
– |
/* PMAP: Otherwise factor in ambient from caustic photon map |
668 |
– |
* (ambPmapCaustic() returns zero if caustic photons disabled) and |
669 |
– |
* continue with RADIANCE ambient calculation */ |
670 |
– |
copycolor(caustic, aval); |
671 |
– |
ambPmapCaustic(caustic, r, rdepth); |
672 |
– |
|
673 |
– |
if (ambdiv <= 0) /* no ambient calculation */ |
674 |
– |
goto dumbamb; |
675 |
– |
/* check number of bounces */ |
676 |
– |
if (rdepth >= ambounce) |
677 |
– |
goto dumbamb; |
678 |
– |
/* check ambient list */ |
679 |
– |
if (ambincl != -1 && r->ro != NULL && |
680 |
– |
ambincl != inset(ambset, r->ro->omod)) |
681 |
– |
goto dumbamb; |
682 |
– |
|
683 |
– |
if (ambacc <= FTINY) { /* no ambient storage */ |
684 |
– |
copycolor(acol, aval); |
685 |
– |
rdepth++; |
686 |
– |
d = doambient(acol, r, r->rweight, NULL, NULL); |
687 |
– |
rdepth--; |
688 |
– |
if (d <= FTINY) |
689 |
– |
goto dumbamb; |
690 |
– |
copycolor(aval, acol); |
691 |
– |
|
692 |
– |
/* PMAP: add in caustic */ |
693 |
– |
addcolor(aval, caustic); |
694 |
– |
return; |
695 |
– |
} |
696 |
– |
|
697 |
– |
if (tracktime) /* sort to minimize thrashing */ |
698 |
– |
sortambvals(0); |
699 |
– |
/* interpolate ambient value */ |
700 |
– |
setcolor(acol, 0.0, 0.0, 0.0); |
701 |
– |
d = sumambient(acol, r, nrm, rdepth, |
702 |
– |
&atrunk, thescene.cuorg, thescene.cusize); |
703 |
– |
|
704 |
– |
if (d > FTINY) { |
705 |
– |
d = 1.0/d; |
706 |
– |
scalecolor(acol, d); |
707 |
– |
multcolor(aval, acol); |
708 |
– |
|
709 |
– |
/* PMAP: add in caustic */ |
710 |
– |
addcolor(aval, caustic); |
711 |
– |
return; |
712 |
– |
} |
713 |
– |
|
714 |
– |
rdepth++; /* need to cache new value */ |
715 |
– |
d = makeambient(acol, r, nrm, rdepth-1); |
716 |
– |
rdepth--; |
717 |
– |
|
718 |
– |
if (d > FTINY) { |
719 |
– |
multcolor(aval, acol); /* got new value */ |
720 |
– |
|
721 |
– |
/* PMAP: add in caustic */ |
722 |
– |
addcolor(aval, caustic); |
723 |
– |
return; |
724 |
– |
} |
725 |
– |
|
726 |
– |
dumbamb: /* return global value */ |
727 |
– |
if ((ambvwt <= 0) | (navsum == 0)) { |
728 |
– |
multcolor(aval, ambval); |
729 |
– |
|
730 |
– |
/* PMAP: add in caustic */ |
731 |
– |
addcolor(aval, caustic); |
732 |
– |
return; |
733 |
– |
} |
734 |
– |
|
735 |
– |
l = bright(ambval); /* average in computations */ |
736 |
– |
if (l > FTINY) { |
737 |
– |
d = (log(l)*(double)ambvwt + avsum) / |
738 |
– |
(double)(ambvwt + navsum); |
739 |
– |
d = exp(d) / l; |
740 |
– |
scalecolor(aval, d); |
741 |
– |
multcolor(aval, ambval); /* apply color of ambval */ |
742 |
– |
} else { |
743 |
– |
d = exp( avsum / (double)navsum ); |
744 |
– |
scalecolor(aval, d); /* neutral color */ |
745 |
– |
} |
746 |
– |
} |
747 |
– |
|
748 |
– |
|
749 |
– |
static double |
750 |
– |
sumambient( /* get interpolated ambient value */ |
751 |
– |
COLOR acol, |
752 |
– |
RAY *r, |
753 |
– |
FVECT rn, |
754 |
– |
int al, |
755 |
– |
AMBTREE *at, |
756 |
– |
FVECT c0, |
757 |
– |
double s |
758 |
– |
) |
759 |
– |
{ |
760 |
– |
double d, e1, e2, wt, wsum; |
761 |
– |
COLOR ct; |
762 |
– |
FVECT ck0; |
763 |
– |
int i; |
764 |
– |
int j; |
765 |
– |
AMBVAL *av; |
766 |
– |
|
767 |
– |
wsum = 0.0; |
768 |
– |
/* do this node */ |
769 |
– |
for (av = at->alist; av != NULL; av = av->next) { |
770 |
– |
double rn_dot = -2.0; |
771 |
– |
if (tracktime) |
772 |
– |
av->latick = ambclock; |
773 |
– |
/* |
774 |
– |
* Ambient level test. |
775 |
– |
*/ |
776 |
– |
if (av->lvl > al || /* list sorted, so this works */ |
777 |
– |
(av->lvl == al) & (av->weight < 0.9*r->rweight)) |
778 |
– |
break; |
779 |
– |
/* |
780 |
– |
* Ambient radius test. |
781 |
– |
*/ |
782 |
– |
VSUB(ck0, av->pos, r->rop); |
783 |
– |
e1 = DOT(ck0, ck0) / (av->rad * av->rad); |
784 |
– |
if (e1 > ambacc*ambacc*1.21) |
785 |
– |
continue; |
786 |
– |
/* |
787 |
– |
* Direction test using closest normal. |
788 |
– |
*/ |
789 |
– |
d = DOT(av->dir, r->ron); |
790 |
– |
if (rn != r->ron) { |
791 |
– |
rn_dot = DOT(av->dir, rn); |
792 |
– |
if (rn_dot > 1.0-FTINY) |
793 |
– |
rn_dot = 1.0-FTINY; |
794 |
– |
if (rn_dot >= d-FTINY) { |
795 |
– |
d = rn_dot; |
796 |
– |
rn_dot = -2.0; |
797 |
– |
} |
798 |
– |
} |
799 |
– |
e2 = (1.0 - d) * r->rweight; |
800 |
– |
if (e2 < 0.0) |
801 |
– |
e2 = 0.0; |
802 |
– |
else if (e1 + e2 > ambacc*ambacc*1.21) |
803 |
– |
continue; |
804 |
– |
/* |
805 |
– |
* Ray behind test. |
806 |
– |
*/ |
807 |
– |
d = 0.0; |
808 |
– |
for (j = 0; j < 3; j++) |
809 |
– |
d += (r->rop[j] - av->pos[j]) * |
810 |
– |
(av->dir[j] + r->ron[j]); |
811 |
– |
if (d*0.5 < -minarad*ambacc-.001) |
812 |
– |
continue; |
813 |
– |
/* |
814 |
– |
* Jittering final test reduces image artifacts. |
815 |
– |
*/ |
816 |
– |
e1 = sqrt(e1); |
817 |
– |
e2 = sqrt(e2); |
818 |
– |
wt = e1 + e2; |
819 |
– |
if (wt > ambacc*(.9+.2*urand(9015+samplendx))) |
820 |
– |
continue; |
821 |
– |
/* |
822 |
– |
* Recompute directional error using perturbed normal |
823 |
– |
*/ |
824 |
– |
if (rn_dot > 0.0) { |
825 |
– |
e2 = sqrt((1.0 - rn_dot)*r->rweight); |
826 |
– |
wt = e1 + e2; |
827 |
– |
} |
828 |
– |
if (wt <= 1e-3) |
829 |
– |
wt = 1e3; |
830 |
– |
else |
831 |
– |
wt = 1.0 / wt; |
832 |
– |
wsum += wt; |
833 |
– |
extambient(ct, av, r->rop, rn); |
834 |
– |
scalecolor(ct, wt); |
835 |
– |
addcolor(acol, ct); |
836 |
– |
} |
837 |
– |
if (at->kid == NULL) |
838 |
– |
return(wsum); |
839 |
– |
/* do children */ |
840 |
– |
s *= 0.5; |
841 |
– |
for (i = 0; i < 8; i++) { |
842 |
– |
for (j = 0; j < 3; j++) { |
843 |
– |
ck0[j] = c0[j]; |
844 |
– |
if (1<<j & i) |
845 |
– |
ck0[j] += s; |
846 |
– |
if (r->rop[j] < ck0[j] - OCTSCALE*s) |
847 |
– |
break; |
848 |
– |
if (r->rop[j] > ck0[j] + (1.0+OCTSCALE)*s) |
849 |
– |
break; |
850 |
– |
} |
851 |
– |
if (j == 3) |
852 |
– |
wsum += sumambient(acol, r, rn, al, |
853 |
– |
at->kid+i, ck0, s); |
854 |
– |
} |
855 |
– |
return(wsum); |
856 |
– |
} |
857 |
– |
|
858 |
– |
|
859 |
– |
static double |
860 |
– |
makeambient( /* make a new ambient value for storage */ |
861 |
– |
COLOR acol, |
862 |
– |
RAY *r, |
863 |
– |
FVECT rn, |
864 |
– |
int al |
865 |
– |
) |
866 |
– |
{ |
867 |
– |
AMBVAL amb; |
868 |
– |
FVECT gp, gd; |
869 |
– |
int i; |
870 |
– |
|
871 |
– |
amb.weight = 1.0; /* compute weight */ |
872 |
– |
for (i = al; i-- > 0; ) |
873 |
– |
amb.weight *= AVGREFL; |
874 |
– |
if (r->rweight < 0.1*amb.weight) /* heuristic override */ |
875 |
– |
amb.weight = 1.25*r->rweight; |
876 |
– |
setcolor(acol, AVGREFL, AVGREFL, AVGREFL); |
877 |
– |
/* compute ambient */ |
878 |
– |
amb.rad = doambient(acol, r, amb.weight, gp, gd); |
879 |
– |
if (amb.rad <= FTINY) { |
880 |
– |
setcolor(acol, 0.0, 0.0, 0.0); |
881 |
– |
return(0.0); |
882 |
– |
} |
883 |
– |
scalecolor(acol, 1./AVGREFL); /* undo assumed reflectance */ |
884 |
– |
/* store value */ |
885 |
– |
VCOPY(amb.pos, r->rop); |
886 |
– |
VCOPY(amb.dir, r->ron); |
887 |
– |
amb.lvl = al; |
888 |
– |
copycolor(amb.val, acol); |
889 |
– |
VCOPY(amb.gpos, gp); |
890 |
– |
VCOPY(amb.gdir, gd); |
891 |
– |
/* insert into tree */ |
892 |
– |
avsave(&amb); /* and save to file */ |
893 |
– |
if (rn != r->ron) |
894 |
– |
extambient(acol, &amb, r->rop, rn); /* texture */ |
895 |
– |
return(amb.rad); |
896 |
– |
} |
897 |
– |
|
898 |
– |
|
656 |
|
static void |
900 |
– |
extambient( /* extrapolate value at pv, nv */ |
901 |
– |
COLOR cr, |
902 |
– |
AMBVAL *ap, |
903 |
– |
FVECT pv, |
904 |
– |
FVECT nv |
905 |
– |
) |
906 |
– |
{ |
907 |
– |
FVECT v1; |
908 |
– |
int i; |
909 |
– |
double d; |
910 |
– |
|
911 |
– |
d = 1.0; /* zeroeth order */ |
912 |
– |
/* gradient due to translation */ |
913 |
– |
for (i = 0; i < 3; i++) |
914 |
– |
d += ap->gpos[i]*(pv[i]-ap->pos[i]); |
915 |
– |
/* gradient due to rotation */ |
916 |
– |
VCROSS(v1, ap->dir, nv); |
917 |
– |
d += DOT(ap->gdir, v1); |
918 |
– |
if (d <= 0.0) { |
919 |
– |
setcolor(cr, 0.0, 0.0, 0.0); |
920 |
– |
return; |
921 |
– |
} |
922 |
– |
copycolor(cr, ap->val); |
923 |
– |
scalecolor(cr, d); |
924 |
– |
} |
925 |
– |
|
926 |
– |
|
927 |
– |
static void |
928 |
– |
avinsert( /* insert ambient value in our tree */ |
929 |
– |
AMBVAL *av |
930 |
– |
) |
931 |
– |
{ |
932 |
– |
AMBTREE *at; |
933 |
– |
AMBVAL *ap; |
934 |
– |
AMBVAL avh; |
935 |
– |
FVECT ck0; |
936 |
– |
double s; |
937 |
– |
int branch; |
938 |
– |
int i; |
939 |
– |
|
940 |
– |
if (av->rad <= FTINY) |
941 |
– |
error(CONSISTENCY, "zero ambient radius in avinsert"); |
942 |
– |
at = &atrunk; |
943 |
– |
VCOPY(ck0, thescene.cuorg); |
944 |
– |
s = thescene.cusize; |
945 |
– |
while (s*(OCTSCALE/2) > av->rad*ambacc) { |
946 |
– |
if (at->kid == NULL) |
947 |
– |
if ((at->kid = newambtree()) == NULL) |
948 |
– |
error(SYSTEM, "out of memory in avinsert"); |
949 |
– |
s *= 0.5; |
950 |
– |
branch = 0; |
951 |
– |
for (i = 0; i < 3; i++) |
952 |
– |
if (av->pos[i] > ck0[i] + s) { |
953 |
– |
ck0[i] += s; |
954 |
– |
branch |= 1 << i; |
955 |
– |
} |
956 |
– |
at = at->kid + branch; |
957 |
– |
} |
958 |
– |
avh.next = at->alist; /* order by increasing level */ |
959 |
– |
for (ap = &avh; ap->next != NULL; ap = ap->next) |
960 |
– |
if ( ap->next->lvl > av->lvl || |
961 |
– |
(ap->next->lvl == av->lvl) & |
962 |
– |
(ap->next->weight <= av->weight) ) |
963 |
– |
break; |
964 |
– |
av->next = ap->next; |
965 |
– |
ap->next = (AMBVAL*)av; |
966 |
– |
at->alist = avh.next; |
967 |
– |
} |
968 |
– |
|
969 |
– |
#endif /* ! NEWAMB */ |
970 |
– |
|
971 |
– |
/************* FOLLOWING ROUTINES SAME FOR NEW & OLD METHODS ***************/ |
972 |
– |
|
973 |
– |
static void |
657 |
|
initambfile( /* initialize ambient file */ |
658 |
|
int cre8 |
659 |
|
) |
975 |
|
|
976 |
|
if (typ == fls.l_type) /* already called? */ |
977 |
|
return; |
978 |
+ |
|
979 |
|
fls.l_type = typ; |
980 |
< |
if (fcntl(fileno(ambfp), F_SETLKW, &fls) < 0) |
981 |
< |
error(SYSTEM, "cannot (un)lock ambient file"); |
980 |
> |
do |
981 |
> |
if (fcntl(fileno(ambfp), F_SETLKW, &fls) != -1) |
982 |
> |
return; |
983 |
> |
while (errno == EINTR); |
984 |
> |
|
985 |
> |
error(SYSTEM, "cannot (un)lock ambient file"); |
986 |
|
} |
987 |
|
|
988 |
|
|
1001 |
|
if ((flen = lseek(fileno(ambfp), (off_t)0, SEEK_END)) < 0) |
1002 |
|
goto seekerr; |
1003 |
|
if ((n = flen - lastpos) > 0) { /* file has grown */ |
1004 |
< |
if (ambinp == NULL) { /* use duplicate filedes */ |
1005 |
< |
ambinp = fdopen(dup(fileno(ambfp)), "r"); |
1004 |
> |
if (ambinp == NULL) { /* get new file pointer */ |
1005 |
> |
ambinp = fopen(ambfile, "rb"); |
1006 |
|
if (ambinp == NULL) |
1007 |
< |
error(SYSTEM, "fdopen failed in ambsync"); |
1007 |
> |
error(SYSTEM, "fopen failed in ambsync"); |
1008 |
|
} |
1009 |
|
if (fseek(ambinp, lastpos, SEEK_SET) < 0) |
1010 |
|
goto seekerr; |
1019 |
|
avstore(&avs); |
1020 |
|
n -= AMBVALSIZ; |
1021 |
|
} |
1022 |
< |
lastpos = flen - n; |
1023 |
< |
/*** seek always as safety measure |
1024 |
< |
if (n) ***/ /* alignment */ |
1337 |
< |
if (lseek(fileno(ambfp), (off_t)lastpos, SEEK_SET) < 0) |
1338 |
< |
goto seekerr; |
1022 |
> |
lastpos = flen - n; /* check alignment */ |
1023 |
> |
if (n && lseek(fileno(ambfp), (off_t)lastpos, SEEK_SET) < 0) |
1024 |
> |
goto seekerr; |
1025 |
|
} |
1026 |
|
n = fflush(ambfp); /* calls write() at last */ |
1027 |
< |
if (n != EOF) |
1342 |
< |
lastpos += (long)nunflshed*AMBVALSIZ; |
1343 |
< |
else if ((lastpos = lseek(fileno(ambfp), (off_t)0, SEEK_CUR)) < 0) |
1344 |
< |
goto seekerr; |
1345 |
< |
|
1027 |
> |
lastpos += (long)nunflshed*AMBVALSIZ; |
1028 |
|
aflock(F_UNLCK); /* release file */ |
1029 |
|
nunflshed = 0; |
1030 |
|
return(n); |
1031 |
|
seekerr: |
1032 |
|
error(SYSTEM, "seek failed in ambsync"); |
1033 |
< |
return -1; /* pro forma return */ |
1033 |
> |
return(EOF); /* pro forma return */ |
1034 |
|
} |
1035 |
|
|
1036 |
|
#else /* ! F_SETLKW */ |