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

Comparing ray/src/rt/normal.c (file contents):
Revision 2.38 by greg, Sat Feb 22 02:07:29 2003 UTC vs.
Revision 2.48 by greg, Mon Sep 20 17:32:04 2004 UTC

# Line 1 | Line 1
1   #ifndef lint
2 < static const char       RCSid[] = "$Id$";
2 > static const char RCSid[] = "$Id$";
3   #endif
4   /*
5   *  normal.c - shading function for normal materials.
# Line 11 | Line 11 | static const char      RCSid[] = "$Id$";
11   *     Later changes described in delta comments.
12   */
13  
14 < /* ====================================================================
15 < * The Radiance Software License, Version 1.0
16 < *
17 < * Copyright (c) 1990 - 2002 The Regents of the University of California,
18 < * through Lawrence Berkeley National Laboratory.   All rights reserved.
19 < *
20 < * Redistribution and use in source and binary forms, with or without
21 < * modification, are permitted provided that the following conditions
22 < * are met:
23 < *
24 < * 1. Redistributions of source code must retain the above copyright
25 < *         notice, this list of conditions and the following disclaimer.
26 < *
27 < * 2. Redistributions in binary form must reproduce the above copyright
28 < *       notice, this list of conditions and the following disclaimer in
29 < *       the documentation and/or other materials provided with the
30 < *       distribution.
31 < *
32 < * 3. The end-user documentation included with the redistribution,
33 < *           if any, must include the following acknowledgment:
34 < *             "This product includes Radiance software
35 < *                 (http://radsite.lbl.gov/)
36 < *                 developed by the Lawrence Berkeley National Laboratory
37 < *               (http://www.lbl.gov/)."
38 < *       Alternately, this acknowledgment may appear in the software itself,
39 < *       if and wherever such third-party acknowledgments normally appear.
40 < *
41 < * 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
42 < *       and "The Regents of the University of California" must
43 < *       not be used to endorse or promote products derived from this
44 < *       software without prior written permission. For written
45 < *       permission, please contact [email protected].
46 < *
47 < * 5. Products derived from this software may not be called "Radiance",
48 < *       nor may "Radiance" appear in their name, without prior written
49 < *       permission of Lawrence Berkeley National Laboratory.
50 < *
51 < * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
52 < * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
53 < * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
54 < * DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
55 < * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
56 < * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
57 < * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
58 < * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
59 < * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
60 < * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
61 < * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
62 < * SUCH DAMAGE.
63 < * ====================================================================
64 < *
65 < * This software consists of voluntary contributions made by many
66 < * individuals on behalf of Lawrence Berkeley National Laboratory.   For more
67 < * information on Lawrence Berkeley National Laboratory, please see
68 < * <http://www.lbl.gov/>.
69 < */
14 > #include "copyright.h"
15  
16   #include  "ray.h"
17 <
17 > #include  "ambient.h"
18 > #include  "source.h"
19   #include  "otypes.h"
20 <
20 > #include  "rtotypes.h"
21   #include  "random.h"
22  
23   #ifndef  MAXITER
24   #define  MAXITER        10              /* maximum # specular ray attempts */
25   #endif
26                                          /* estimate of Fresnel function */
27 < #define  FRESNE(ci)     (exp(-6.0*(ci)) - 0.00247875217)
27 > #define  FRESNE(ci)     (exp(-5.85*(ci)) - 0.00287989916)
28  
83 – static void  gaussamp();
29  
30   /*
31   *      This routine implements the isotropic Gaussian
# Line 119 | Line 64 | typedef struct {
64          double  pdot;           /* perturbed dot product */
65   }  NORMDAT;             /* normal material data */
66  
67 + static srcdirf_t dirnorm;
68 + static void gaussamp(RAY  *r, NORMDAT  *np);
69  
70 +
71   static void
72 < dirnorm(cval, np, ldir, omega)          /* compute source contribution */
73 < COLOR  cval;                    /* returned coefficient */
74 < register NORMDAT  *np;          /* material data */
75 < FVECT  ldir;                    /* light source direction */
76 < double  omega;                  /* light source size */
72 > dirnorm(                /* compute source contribution */
73 >        COLOR  cval,                    /* returned coefficient */
74 >        void  *nnp,             /* material data */
75 >        FVECT  ldir,                    /* light source direction */
76 >        double  omega                   /* light source size */
77 > )
78   {
79 +        register NORMDAT *np = nnp;
80          double  ldot;
81          double  ldiff;
82          double  dtmp, d2;
# Line 142 | Line 92 | double  omega;                 /* light source size */
92  
93                                  /* Fresnel estimate */
94          ldiff = np->rdiff;
95 <        if (np->specfl & SP_PURE && (np->rspec > FTINY & ldiff > FTINY))
95 >        if (np->specfl & SP_PURE && (np->rspec > FTINY) & (ldiff > FTINY))
96                  ldiff *= 1. - FRESNE(fabs(ldot));
97  
98          if (ldot > FTINY && ldiff > FTINY) {
# Line 152 | Line 102 | double  omega;                 /* light source size */
102                   *  modified by the color of the material.
103                   */
104                  copycolor(ctmp, np->mcolor);
105 <                dtmp = ldot * omega * ldiff / PI;
105 >                dtmp = ldot * omega * ldiff * (1.0/PI);
106                  scalecolor(ctmp, dtmp);
107                  addcolor(cval, ctmp);
108          }
# Line 165 | Line 115 | double  omega;                 /* light source size */
115                  dtmp = np->alpha2;
116                                                  /* + source if flat */
117                  if (np->specfl & SP_FLAT)
118 <                        dtmp += omega/(4.0*PI);
118 >                        dtmp += omega * (0.25/PI);
119                                                  /* half vector */
120                  vtmp[0] = ldir[0] - np->rp->rdir[0];
121                  vtmp[1] = ldir[1] - np->rp->rdir[1];
# Line 174 | Line 124 | double  omega;                 /* light source size */
124                  d2 *= d2;
125                  d2 = (DOT(vtmp,vtmp) - d2) / d2;
126                                                  /* gaussian */
127 <                dtmp = exp(-d2/dtmp)/(4.*PI*dtmp);
127 >                dtmp = exp(-d2/dtmp)/(4.*PI * np->pdot * dtmp);
128                                                  /* worth using? */
129                  if (dtmp > FTINY) {
130                          copycolor(ctmp, np->scolor);
131 <                        dtmp *= omega * sqrt(ldot/np->pdot);
131 >                        dtmp *= omega;
132                          scalecolor(ctmp, dtmp);
133                          addcolor(cval, ctmp);
134                  }
# Line 188 | Line 138 | double  omega;                 /* light source size */
138                   *  Compute diffuse transmission.
139                   */
140                  copycolor(ctmp, np->mcolor);
141 <                dtmp = -ldot * omega * np->tdiff / PI;
141 >                dtmp = -ldot * omega * np->tdiff * (1.0/PI);
142                  scalecolor(ctmp, dtmp);
143                  addcolor(cval, ctmp);
144          }
# Line 198 | Line 148 | double  omega;                 /* light source size */
148                   *  is always modified by material color.
149                   */
150                                                  /* roughness + source */
151 <                dtmp = np->alpha2 + omega/PI;
151 >                dtmp = np->alpha2 + omega*(1.0/PI);
152                                                  /* gaussian */
153 <                dtmp = exp((2.*DOT(np->prdir,ldir)-2.)/dtmp)/(PI*dtmp);
153 >                dtmp = exp((2.*DOT(np->prdir,ldir)-2.)/dtmp) /
154 >                                        (PI*np->pdot*dtmp);
155                                                  /* worth using? */
156                  if (dtmp > FTINY) {
157                          copycolor(ctmp, np->mcolor);
158 <                        dtmp *= np->tspec * omega * sqrt(-ldot/np->pdot);
158 >                        dtmp *= np->tspec * omega;
159                          scalecolor(ctmp, dtmp);
160                          addcolor(cval, ctmp);
161                  }
# Line 212 | Line 163 | double  omega;                 /* light source size */
163   }
164  
165  
166 < int
167 < m_normal(m, r)                  /* color a ray that hit something normal */
168 < register OBJREC  *m;
169 < register RAY  *r;
166 > extern int
167 > m_normal(                       /* color a ray that hit something normal */
168 >        register OBJREC  *m,
169 >        register RAY  *r
170 > )
171   {
172          NORMDAT  nd;
173          double  fest;
# Line 237 | Line 189 | register RAY  *r;
189                          raytrans(r);
190                          return(1);
191                  }
192 +                raytexture(r, m->omod);
193                  flipsurface(r);                 /* reorient if backvis */
194 <        }
194 >        } else
195 >                raytexture(r, m->omod);
196          nd.mp = m;
197          nd.rp = r;
198                                                  /* get material color */
# Line 250 | Line 204 | register RAY  *r;
204          nd.alpha2 = m->oargs.farg[4];
205          if ((nd.alpha2 *= nd.alpha2) <= FTINY)
206                  nd.specfl |= SP_PURE;
207 <        if (r->ro != NULL && isflat(r->ro->otype))
208 <                nd.specfl |= SP_FLAT;
255 <                                                /* get modifiers */
256 <        raytexture(r, m->omod);
257 <        if (hastexture = DOT(r->pert,r->pert) > FTINY*FTINY)
207 >
208 >        if ( (hastexture = (DOT(r->pert,r->pert) > FTINY*FTINY)) ) {
209                  nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
210 <        else {
210 >        } else {
211                  VCOPY(nd.pnorm, r->ron);
212                  nd.pdot = r->rod;
213          }
214 +        if (r->ro != NULL && isflat(r->ro->otype))
215 +                nd.specfl |= SP_FLAT;
216          if (nd.pdot < .001)
217                  nd.pdot = .001;                 /* non-zero for dirnorm() */
218          multcolor(nd.mcolor, r->pcol);          /* modify material color */
# Line 405 | Line 358 | register RAY  *r;
358  
359  
360   static void
361 < gaussamp(r, np)                 /* sample gaussian specular */
362 < RAY  *r;
363 < register NORMDAT  *np;
361 > gaussamp(                       /* sample gaussian specular */
362 >        RAY  *r,
363 >        register NORMDAT  *np
364 > )
365   {
366          RAY  sr;
367          FVECT  u, v, h;

Diff Legend

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