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

Comparing ray/src/common/bsdf.c (file contents):
Revision 2.43 by greg, Sat Oct 13 20:15:43 2012 UTC vs.
Revision 2.56 by greg, Fri Dec 7 07:38:15 2018 UTC

# Line 35 | Line 35 | const char             *SDerrorEnglish[] = {
35                                  "Unknown error"
36                          };
37  
38 + /* Pointer to error list in preferred language */
39 + const char              **SDerrorList = SDerrorEnglish;
40 +
41   /* Additional information on last error (ASCII English) */
42   char                    SDerrorDetail[256];
43  
# Line 47 | Line 50 | struct SDCache_s       *SDcacheList = NULL;
50   /* Retain BSDFs in cache list */
51   int                     SDretainSet = SDretainNone;
52  
53 < /* Report any error to the indicated stream (in English) */
53 > /* Report any error to the indicated stream */
54   SDError
55 < SDreportEnglish(SDError ec, FILE *fp)
55 > SDreportError(SDError ec, FILE *fp)
56   {
57          if (!ec)
58                  return SDEnone;
# Line 59 | Line 62 | SDreportEnglish(SDError ec, FILE *fp)
62          }
63          if (fp == NULL)
64                  return ec;
65 <        fputs(SDerrorEnglish[ec], fp);
65 >        fputs(SDerrorList[ec], fp);
66          if (SDerrorDetail[0]) {
67                  fputs(": ", fp);
68                  fputs(SDerrorDetail, fp);
# Line 196 | Line 199 | SDloadFile(SDData *sd, const char *fname)
199          }
200          wtl = ezxml_child(ezxml_child(fl, "Optical"), "Layer");
201          if (wtl == NULL) {
202 <                sprintf(SDerrorDetail, "BSDF \"%s\": no optical layers'",
202 >                sprintf(SDerrorDetail, "BSDF \"%s\": no optical layers",
203                                  sd->name);
204                  ezxml_free(fl);
205                  return SDEformat;
# Line 419 | Line 422 | SDcacheFile(const char *fname)
422          if (fname == NULL || !*fname)
423                  return NULL;
424          SDerrorDetail[0] = '\0';
425 +        /* PLACE MUTEX LOCK HERE FOR THREAD-SAFE */
426          if ((sd = SDgetCache(fname)) == NULL) {
427 <                SDreportEnglish(SDEmemory, stderr);
427 >                SDreportError(SDEmemory, stderr);
428                  return NULL;
429          }
430          if (!SDisLoaded(sd) && (ec = SDloadFile(sd, fname))) {
431 <                SDreportEnglish(ec, stderr);
431 >                SDreportError(ec, stderr);
432                  SDfreeCache(sd);
433 <                return NULL;
433 >                sd = NULL;
434          }
435 +        /* END MUTEX LOCK */
436          return sd;
437   }
438  
# Line 485 | Line 490 | SDsampComponent(SDValue *sv, FVECT ioVec, double randX
490                  return SDEargument;
491                                          /* get cumulative distribution */
492          VCOPY(inVec, ioVec);
493 +        sv->cieY = 0;
494          cd = (*sdc->func->getCDist)(inVec, sdc);
495 <        if (cd == NULL)
496 <                return SDEmemory;
497 <        if (cd->cTotal <= 1e-6) {       /* anything to sample? */
495 >        if (cd != NULL)
496 >                sv->cieY = cd->cTotal;
497 >        if (sv->cieY <= 1e-6) {         /* nothing to sample? */
498                  sv->spec = c_dfcolor;
499 <                sv->cieY = .0;
494 <                memset(ioVec, 0, 3*sizeof(double));
499 >                memset(ioVec, 0, sizeof(FVECT));
500                  return SDEnone;
501          }
497 –        sv->cieY = cd->cTotal;
502                                          /* compute sample direction */
503          ec = (*sdc->func->sampCDist)(ioVec, randX, cd);
504          if (ec)
# Line 511 | Line 515 | SDsampComponent(SDValue *sv, FVECT ioVec, double randX
515                  c_cmix(&sv->spec, d, &sv->spec, coef[n], &sdc->cspec[n]);
516                  d += coef[n];
517          }
518 <                                        /* make sure everything is set */
515 <        c_ccvt(&sv->spec, C_CSXY+C_CSSPEC);
518 >        c_ccvt(&sv->spec, C_CSXY);      /* make sure (x,y) is set */
519          return SDEnone;
520   }
521  
# Line 556 | Line 559 | SDdiffuseSamp(FVECT outVec, int outFront, double randX
559          SDmultiSamp(outVec, 2, randX);
560          SDsquare2disk(outVec, outVec[0], outVec[1]);
561          outVec[2] = 1. - outVec[0]*outVec[0] - outVec[1]*outVec[1];
562 <        if (outVec[2] > 0)              /* a bit of paranoia */
560 <                outVec[2] = sqrt(outVec[2]);
562 >        outVec[2] = sqrt(outVec[2]*(outVec[2]>0));
563          if (!outFront)                  /* going out back? */
564                  outVec[2] = -outVec[2];
565   }
# Line 594 | Line 596 | SDsizeBSDF(double *projSA, const FVECT v1, const RREAL
596                  rdf = sd->rb;
597                  tdf = (sd->tb != NULL) ? sd->tb : sd->tf;
598          }
599 <        if (v2 != NULL)                 /* bidirectional? */
599 >        if (v2 != NULL) {               /* bidirectional? */
600                  if (v1[2] > 0 ^ v2[2] > 0)
601                          rdf = NULL;
602                  else
603                          tdf = NULL;
604 +        }
605          ec = SDEdata;                   /* run through components */
606          for (i = (rdf==NULL) ? 0 : rdf->ncomp; i--; ) {
607                  ec = (*rdf->comp[i].func->queryProjSA)(projSA, v1, v2,
# Line 616 | Line 619 | SDsizeBSDF(double *projSA, const FVECT v1, const RREAL
619                  projSA[0] = M_PI;
620                  if (qflags == SDqueryMin+SDqueryMax)
621                          projSA[1] = M_PI;
622 <        }
622 >        } else if (qflags == SDqueryMin+SDqueryMax && projSA[0] > projSA[1])
623 >                projSA[0] = projSA[1];
624          return SDEnone;
625   }
626  
# Line 641 | Line 645 | SDevalBSDF(SDValue *sv, const FVECT outVec, const FVEC
645          } else if (!(inFront | outFront)) {
646                  *sv = sd->rLambBack;
647                  sdf = sd->rb;
648 <        } else if (inFront) {
648 >        } else if (outFront) {
649                  *sv = sd->tLamb;
650                  sdf = (sd->tf != NULL) ? sd->tf : sd->tb;
651 <        } else /* inBack */ {
651 >        } else /* inFront & !outFront */ {
652                  *sv = sd->tLamb;
653                  sdf = (sd->tb != NULL) ? sd->tb : sd->tf;
654          }
# Line 660 | Line 664 | SDevalBSDF(SDValue *sv, const FVECT outVec, const FVEC
664                          sv->cieY += coef[nch];
665                  }
666          }
667 <                                        /* make sure everything is set */
664 <        c_ccvt(&sv->spec, C_CSXY+C_CSSPEC);
667 >        c_ccvt(&sv->spec, C_CSXY);      /* make sure (x,y) is set */
668          return SDEnone;
669   }
670  
# Line 753 | Line 756 | SDsampBSDF(SDValue *sv, FVECT ioVec, double randX, int
756                  return SDEmemory;
757          while (j-- > 0) {               /* non-diffuse transmission */
758                  cdarr[i+j] = (*tdf->comp[j].func->getCDist)(inVec, &tdf->comp[j]);
759 <                if (cdarr[i+j] == NULL) {
760 <                        free(cdarr);
758 <                        return SDEmemory;
759 <                }
759 >                if (cdarr[i+j] == NULL)
760 >                        cdarr[i+j] = &SDemptyCD;
761                  sv->cieY += cdarr[i+j]->cTotal;
762          }
763          while (i-- > 0) {               /* non-diffuse reflection */
764                  cdarr[i] = (*rdf->comp[i].func->getCDist)(inVec, &rdf->comp[i]);
765 <                if (cdarr[i] == NULL) {
766 <                        free(cdarr);
766 <                        return SDEmemory;
767 <                }
765 >                if (cdarr[i] == NULL)
766 >                        cdarr[i] = &SDemptyCD;
767                  sv->cieY += cdarr[i]->cTotal;
768          }
769          if (sv->cieY <= 1e-6) {         /* anything to sample? */
770                  sv->cieY = .0;
771 <                memset(ioVec, 0, 3*sizeof(double));
771 >                memset(ioVec, 0, sizeof(FVECT));
772                  return SDEnone;
773          }
774                                          /* scale random variable */
# Line 790 | Line 789 | SDsampBSDF(SDValue *sv, FVECT ioVec, double randX, int
789                  randX -= sd->tLamb.cieY;
790          }
791                                          /* else one of cumulative dist. */
792 <        for (i = 0; i < n && randX < cdarr[i]->cTotal; i++)
792 >        for (i = 0; i < n && randX >= cdarr[i]->cTotal; i++)
793                  randX -= cdarr[i]->cTotal;
794          if (i >= n)
795                  return SDEinternal;
# Line 815 | Line 814 | SDsampBSDF(SDValue *sv, FVECT ioVec, double randX, int
814   done:
815          if (cdarr != NULL)
816                  free(cdarr);
817 <                                        /* make sure everything is set */
819 <        c_ccvt(&sv->spec, C_CSXY+C_CSSPEC);
817 >        c_ccvt(&sv->spec, C_CSXY);      /* make sure (x,y) is set */
818          return SDEnone;
819   }
820  

Diff Legend

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