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.47 by greg, Sun Mar 23 23:15:53 2014 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 420 | Line 423 | SDcacheFile(const char *fname)
423                  return NULL;
424          SDerrorDetail[0] = '\0';
425          if ((sd = SDgetCache(fname)) == NULL) {
426 <                SDreportEnglish(SDEmemory, stderr);
426 >                SDreportError(SDEmemory, stderr);
427                  return NULL;
428          }
429          if (!SDisLoaded(sd) && (ec = SDloadFile(sd, fname))) {
430 <                SDreportEnglish(ec, stderr);
430 >                SDreportError(ec, stderr);
431                  SDfreeCache(sd);
432                  return NULL;
433          }
# Line 485 | Line 488 | SDsampComponent(SDValue *sv, FVECT ioVec, double randX
488                  return SDEargument;
489                                          /* get cumulative distribution */
490          VCOPY(inVec, ioVec);
491 +        sv->cieY = 0;
492          cd = (*sdc->func->getCDist)(inVec, sdc);
493 <        if (cd == NULL)
494 <                return SDEmemory;
495 <        if (cd->cTotal <= 1e-6) {       /* anything to sample? */
493 >        if (cd != NULL)
494 >                sv->cieY = cd->cTotal;
495 >        if (sv->cieY <= 1e-6) {         /* nothing to sample? */
496                  sv->spec = c_dfcolor;
493 –                sv->cieY = .0;
497                  memset(ioVec, 0, 3*sizeof(double));
498                  return SDEnone;
499          }
497 –        sv->cieY = cd->cTotal;
500                                          /* compute sample direction */
501          ec = (*sdc->func->sampCDist)(ioVec, randX, cd);
502          if (ec)
# Line 616 | Line 618 | SDsizeBSDF(double *projSA, const FVECT v1, const RREAL
618                  projSA[0] = M_PI;
619                  if (qflags == SDqueryMin+SDqueryMax)
620                          projSA[1] = M_PI;
621 <        }
621 >        } else if (qflags == SDqueryMin+SDqueryMax && projSA[0] > projSA[1])
622 >                projSA[0] = projSA[1];
623          return SDEnone;
624   }
625  
# 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);
767 <                        return SDEmemory;
768 <                }
768 <                sv->cieY += cdarr[i]->cTotal;
765 >                if (cdarr[i] == NULL)
766 >                        cdarr[i] = &SDemptyCD;
767 >                else
768 >                        sv->cieY += cdarr[i]->cTotal;
769          }
770          if (sv->cieY <= 1e-6) {         /* anything to sample? */
771                  sv->cieY = .0;
# Line 790 | Line 790 | SDsampBSDF(SDValue *sv, FVECT ioVec, double randX, int
790                  randX -= sd->tLamb.cieY;
791          }
792                                          /* else one of cumulative dist. */
793 <        for (i = 0; i < n && randX < cdarr[i]->cTotal; i++)
793 >        for (i = 0; i < n && randX > cdarr[i]->cTotal; i++)
794                  randX -= cdarr[i]->cTotal;
795          if (i >= n)
796                  return SDEinternal;

Diff Legend

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