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

Comparing ray/src/rt/m_brdf.c (file contents):
Revision 2.13 by greg, Mon Nov 6 12:03:22 1995 UTC vs.
Revision 2.44 by greg, Wed Dec 18 17:57:06 2024 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1991 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   *  Shading for materials with arbitrary BRDF's
6   */
7  
8 < #include  "ray.h"
8 > #include "copyright.h"
9  
10 + #include  "ray.h"
11 + #include  "ambient.h"
12   #include  "data.h"
13 <
13 > #include  "source.h"
14   #include  "otypes.h"
15 <
15 > #include  "rtotypes.h"
16   #include  "func.h"
17 + #include  "pmapmat.h"
18  
19 – extern int  backvis;                    /* back faces visible? */
20 –
19   /*
20   *      Arguments to this material include the color and specularity.
21   *  String arguments include the reflection function and files.
# Line 41 | Line 39 | extern int  backvis;                   /* back faces visible? */
39   *  Arguments for MAT_TFUNC are:
40   *      2+      func    funcfile        transform
41   *      0
42 < *      4+      red     grn     blu     rspec   trans   tspec   A7 ..
42 > *      6+      red     grn     blu     rspec   trans   tspec   A7 ..
43   *
44   *  Arguments for MAT_TDATA are:
45   *      4+      func    datafile        funcfile        v0 ..   transform
46   *      0
47 < *      4+      red     grn     blu     rspec   trans   tspec   A7 ..
47 > *      6+      red     grn     blu     rspec   trans   tspec   A7 ..
48   *
49   *  Arguments for the more general MAT_BRTDF are:
50   *      10+     rrefl   grefl   brefl
# Line 69 | Line 67 | typedef struct {
67          OBJREC  *mp;            /* material pointer */
68          RAY  *pr;               /* intersected ray */
69          DATARRAY  *dp;          /* data array for PDATA, MDATA or TDATA */
70 <        COLOR  mcolor;          /* material (or pattern) color */
71 <        COLOR  rdiff;           /* diffuse reflection */
72 <        COLOR  tdiff;           /* diffuse transmission */
70 >        SCOLOR  mcolor;         /* material (or pattern) color */
71 >        SCOLOR  rdiff;          /* diffuse reflection */
72 >        SCOLOR  tdiff;          /* diffuse transmission */
73          double  rspec;          /* specular reflectance (1 for BRDTF) */
74          double  trans;          /* transmissivity (.5 for BRDTF) */
75          double  tspec;          /* specular transmittance (1 for BRDTF) */
# Line 80 | Line 78 | typedef struct {
78   }  BRDFDAT;             /* BRDF material data */
79  
80  
81 < dirbrdf(cval, np, ldir, omega)          /* compute source contribution */
82 < COLOR  cval;                    /* returned coefficient */
83 < register BRDFDAT  *np;          /* material data */
84 < FVECT  ldir;                    /* light source direction */
85 < double  omega;                  /* light source size */
81 > static int setbrdfunc(BRDFDAT *np);
82 >
83 >
84 > static void
85 > dirbrdf(                /* compute source contribution */
86 >        SCOLOR  scval,                  /* returned coefficient */
87 >        void  *nnp,                     /* material data */
88 >        FVECT  ldir,                    /* light source direction */
89 >        double  omega                   /* light source size */
90 > )
91   {
92 +        BRDFDAT *np = nnp;
93          double  ldot;
94          double  dtmp;
95 +        SCOLOR  sctmp;
96          COLOR  ctmp;
97          FVECT  ldx;
98 <        static double  vldx[5], pt[MAXDIM];
99 <        register char   **sa;
100 <        register int    i;
98 >        static double  vldx[5], pt[MAXDDIM];
99 >        char    **sa;
100 >        int     i;
101   #define lddx (vldx+1)
102  
103 <        setcolor(cval, 0.0, 0.0, 0.0);
103 >        scolorblack(scval);
104          
105          ldot = DOT(np->pnorm, ldir);
106  
# Line 111 | Line 116 | double  omega;                 /* light source size */
116                   *  color.  The diffuse reflected component will always be
117                   *  modified by the color of the material.
118                   */
119 <                copycolor(ctmp, np->rdiff);
119 >                copyscolor(sctmp, np->rdiff);
120                  dtmp = ldot * omega / PI;
121 <                scalecolor(ctmp, dtmp);
122 <                addcolor(cval, ctmp);
121 >                scalescolor(sctmp, dtmp);
122 >                saddscolor(scval, sctmp);
123          } else {
124                  /*
125                   *  Diffuse transmitted component.
126                   */
127 <                copycolor(ctmp, np->tdiff);
127 >                copyscolor(sctmp, np->tdiff);
128                  dtmp = -ldot * omega / PI;
129 <                scalecolor(ctmp, dtmp);
130 <                addcolor(cval, ctmp);
129 >                scalescolor(sctmp, dtmp);
130 >                saddscolor(scval, sctmp);
131          }
132 <        if (ldot > 0.0 ? np->rspec <= FTINY : np->tspec <= FTINY)
133 <                return;         /* no specular component */
132 >        if ((ldot > 0.0 ? np->rspec <= FTINY : np->tspec <= FTINY) ||
133 >                        ambRayInPmap(np->pr))
134 >                return;         /* diffuse only */
135                                          /* set up function */
136          setbrdfunc(np);
137          sa = np->mp->oargs.sarg;
# Line 137 | Line 143 | double  omega;                 /* light source size */
143          lddx[3] = omega;
144                                          /* compute BRTDF */
145          if (np->mp->otype == MAT_BRTDF) {
146 <                if (sa[6][0] == '0')            /* special case */
146 >                if (sa[6][0] == '0' && !sa[6][1])       /* special case */
147                          colval(ctmp,RED) = 0.0;
148                  else
149                          colval(ctmp,RED) = funvalue(sa[6], 4, lddx);
150 <                if (!strcmp(sa[7],sa[6]))
150 >                if (sa[7][0] == '0' && !sa[7][1])
151 >                        colval(ctmp,GRN) = 0.0;
152 >                else if (!strcmp(sa[7],sa[6]))
153                          colval(ctmp,GRN) = colval(ctmp,RED);
154                  else
155                          colval(ctmp,GRN) = funvalue(sa[7], 4, lddx);
156 <                if (!strcmp(sa[8],sa[6]))
156 >                if (sa[8][0] == '0' && !sa[8][1])
157 >                        colval(ctmp,BLU) = 0.0;
158 >                else if (!strcmp(sa[8],sa[6]))
159                          colval(ctmp,BLU) = colval(ctmp,RED);
160                  else if (!strcmp(sa[8],sa[7]))
161                          colval(ctmp,BLU) = colval(ctmp,GRN);
# Line 162 | Line 172 | double  omega;                 /* light source size */
172                  dtmp = funvalue(sa[0], 5, vldx);
173                  setcolor(ctmp, dtmp, dtmp, dtmp);
174          }
175 <        if (errno) {
175 >        if ((errno == EDOM) | (errno == ERANGE)) {
176                  objerror(np->mp, WARNING, "compute error");
177                  return;
178          }
179          if (dtmp <= FTINY)
180                  return;
181 +        setscolor(sctmp, colval(ctmp,RED), colval(ctmp,GRN), colval(ctmp,BLU));
182          if (ldot > 0.0) {
183                  /*
184                   *  Compute reflected non-diffuse component.
185                   */
186 <                if (np->mp->otype == MAT_MFUNC | np->mp->otype == MAT_MDATA)
187 <                        multcolor(ctmp, np->mcolor);
186 >                if ((np->mp->otype == MAT_MFUNC) | (np->mp->otype == MAT_MDATA))
187 >                        smultscolor(sctmp, np->mcolor);
188                  dtmp = ldot * omega * np->rspec;
189 <                scalecolor(ctmp, dtmp);
190 <                addcolor(cval, ctmp);
189 >                scalescolor(sctmp, dtmp);
190 >                saddscolor(scval, sctmp);
191          } else {
192                  /*
193                   *  Compute transmitted non-diffuse component.
194                   */
195 <                if (np->mp->otype == MAT_TFUNC | np->mp->otype == MAT_TDATA)
196 <                        multcolor(ctmp, np->mcolor);
195 >                if ((np->mp->otype == MAT_TFUNC) | (np->mp->otype == MAT_TDATA))
196 >                        smultscolor(sctmp, np->mcolor);
197                  dtmp = -ldot * omega * np->tspec;
198 <                scalecolor(ctmp, dtmp);
199 <                addcolor(cval, ctmp);
198 >                scalescolor(sctmp, dtmp);
199 >                saddscolor(scval, sctmp);
200          }
201   #undef lddx
202   }
203  
204  
205 < m_brdf(m, r)                    /* color a ray which hit a BRDTfunc material */
206 < register OBJREC  *m;
207 < register RAY  *r;
205 > int
206 > m_brdf(                 /* color a ray that hit a BRDTfunc material */
207 >        OBJREC  *m,
208 >        RAY  *r
209 > )
210   {
211          BRDFDAT  nd;
212          RAY  sr;
200 –        double  transtest, transdist;
213          int  hasrefl, hastrans;
214 <        COLOR  ctmp;
215 <        register MFUNC  *mf;
216 <        register int  i;
214 >        int  hastexture;
215 >        SCOLOR  sctmp;
216 >        FVECT  vtmp;
217 >        double  d;
218 >        MFUNC  *mf;
219 >        int  i;
220                                                  /* check arguments */
221 <        if (m->oargs.nsargs < 10 | m->oargs.nfargs < 9)
221 >        if ((m->oargs.nsargs < 10) | (m->oargs.nfargs < 9))
222                  objerror(m, USER, "bad # arguments");
223          nd.mp = m;
224          nd.pr = r;
# Line 212 | Line 227 | register RAY  *r;
227          nd.trans = 0.5;
228                                                  /* diffuse reflectance */
229          if (r->rod > 0.0)
230 <                setcolor(nd.rdiff, m->oargs.farg[0],
230 >                setscolor(nd.rdiff, m->oargs.farg[0],
231                                  m->oargs.farg[1],
232                                  m->oargs.farg[2]);
233          else
234 <                setcolor(nd.rdiff, m->oargs.farg[3],
234 >                setscolor(nd.rdiff, m->oargs.farg[3],
235                                  m->oargs.farg[4],
236                                  m->oargs.farg[5]);
237                                                  /* diffuse transmittance */
238 <        setcolor(nd.tdiff, m->oargs.farg[6],
238 >        setscolor(nd.tdiff, m->oargs.farg[6],
239                          m->oargs.farg[7],
240                          m->oargs.farg[8]);
241 <                                        /* get modifiers */
241 >                                                /* get modifiers */
242          raytexture(r, m->omod);
243 <        nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
243 >        hastexture = (DOT(r->pert,r->pert) > FTINY*FTINY);
244 >        if (hastexture) {                       /* perturb normal */
245 >                nd.pdot = raynormal(nd.pnorm, r);
246 >        } else {
247 >                VCOPY(nd.pnorm, r->ron);
248 >                nd.pdot = r->rod;
249 >        }
250          if (r->rod < 0.0) {                     /* orient perturbed values */
251                  nd.pdot = -nd.pdot;
252                  for (i = 0; i < 3; i++) {
# Line 233 | Line 254 | register RAY  *r;
254                          r->pert[i] = -r->pert[i];
255                  }
256          }
257 <        copycolor(nd.mcolor, r->pcol);          /* get pattern color */
258 <        multcolor(nd.rdiff, nd.mcolor);         /* modify diffuse values */
259 <        multcolor(nd.tdiff, nd.mcolor);
260 <        hasrefl = bright(nd.rdiff) > FTINY;
261 <        hastrans = bright(nd.tdiff) > FTINY;
257 >        copyscolor(nd.mcolor, r->pcol);         /* get pattern color */
258 >        smultscolor(nd.rdiff, nd.mcolor);       /* modify diffuse values */
259 >        smultscolor(nd.tdiff, nd.mcolor);
260 >        hasrefl = (sintens(nd.rdiff) > FTINY);
261 >        hastrans = (sintens(nd.tdiff) > FTINY);
262                                                  /* load cal file */
263          nd.dp = NULL;
264 <        mf = getfunc(m, 9, 0x3f, 0);
264 >        mf = getfunc(m, 9, 0x3F, 0);
265                                                  /* compute transmitted ray */
266          setbrdfunc(&nd);
246 –        transtest = 0;
247 –        transdist = r->rot;
267          errno = 0;
268 <        setcolor(ctmp, evalue(mf->ep[3]),
268 >        setscolor(sctmp, evalue(mf->ep[3]),
269                          evalue(mf->ep[4]),
270                          evalue(mf->ep[5]));
271 <        if (errno)
271 >        if ((errno == EDOM) | (errno == ERANGE))
272                  objerror(m, WARNING, "compute error");
273 <        else if (rayorigin(&sr, r, TRANS, bright(ctmp)) == 0) {
274 <                if (!(r->crtype & SHADOW) &&
275 <                                DOT(r->pert,r->pert) > FTINY*FTINY) {
276 <                        for (i = 0; i < 3; i++) /* perturb direction */
258 <                                sr.rdir[i] = r->rdir[i] - .75*r->pert[i];
273 >        else if (rayorigin(&sr, TRANS, r, sctmp) == 0) {
274 >                if (hastexture && !(r->crtype & (SHADOW|AMBIENT))) {
275 >                                                /* perturb direction */
276 >                        VSUB(sr.rdir, r->rdir, r->pert);
277                          if (normalize(sr.rdir) == 0.0) {
278                                  objerror(m, WARNING, "illegal perturbation");
279                                  VCOPY(sr.rdir, r->rdir);
280                          }
281                  } else {
282                          VCOPY(sr.rdir, r->rdir);
265 –                        transtest = 2;
283                  }
284                  rayvalue(&sr);
285 <                multcolor(sr.rcol, ctmp);
286 <                addcolor(r->rcol, sr.rcol);
287 <                transtest *= bright(sr.rcol);
288 <                transdist = r->rot + sr.rt;
285 >                smultscolor(sr.rcol, sr.rcoef);
286 >                saddscolor(r->rcol, sr.rcol);
287 >                if ((!hastexture || r->crtype & (SHADOW|AMBIENT)) &&
288 >                                nd.tspec > pbright(nd.tdiff) + pbright(nd.rdiff))
289 >                        r->rxt = r->rot + raydistance(&sr);
290          }
291          if (r->crtype & SHADOW)                 /* the rest is shadow */
292                  return(1);
293 +
294                                                  /* compute reflected ray */
295          setbrdfunc(&nd);
296          errno = 0;
297 <        setcolor(ctmp, evalue(mf->ep[0]),
297 >        setscolor(sctmp, evalue(mf->ep[0]),
298                          evalue(mf->ep[1]),
299                          evalue(mf->ep[2]));
300 <        if (errno)
300 >        if ((errno == EDOM) | (errno == ERANGE))
301                  objerror(m, WARNING, "compute error");
302 <        else if (rayorigin(&sr, r, REFLECTED, bright(ctmp)) == 0) {
303 <                for (i = 0; i < 3; i++)
304 <                        sr.rdir[i] = r->rdir[i] + 2.0*nd.pdot*nd.pnorm[i];
302 >        else if (rayorigin(&sr, REFLECTED, r, sctmp) == 0) {
303 >                VSUM(sr.rdir, r->rdir, nd.pnorm, 2.*nd.pdot);
304 >                checknorm(sr.rdir);
305                  rayvalue(&sr);
306 <                multcolor(sr.rcol, ctmp);
307 <                addcolor(r->rcol, sr.rcol);
306 >                smultscolor(sr.rcol, sr.rcoef);
307 >                copyscolor(r->mcol, sr.rcol);
308 >                saddscolor(r->rcol, sr.rcol);
309 >                r->rmt = r->rot;
310 >                if (r->ro != NULL && isflat(r->ro->otype) &&
311 >                                !hastexture | (r->crtype & AMBIENT))
312 >                        r->rmt += raydistance(&sr);
313          }
314                                                  /* compute ambient */
315          if (hasrefl) {
316 <                if (nd.pdot < 0.0)
317 <                        flipsurface(r);
318 <                ambient(ctmp, r, nd.pnorm);
295 <                multcolor(ctmp, nd.rdiff);
296 <                addcolor(r->rcol, ctmp);        /* add to returned color */
297 <                if (nd.pdot < 0.0)
298 <                        flipsurface(r);
316 >                copyscolor(sctmp, nd.rdiff);
317 >                multambient(sctmp, r, nd.pnorm);
318 >                saddscolor(r->rcol, sctmp);     /* add to returned color */
319          }
320          if (hastrans) {                         /* from other side */
321 <                if (nd.pdot > 0.0)
322 <                        flipsurface(r);
323 <                ambient(ctmp, r, nd.pnorm);
324 <                multcolor(ctmp, nd.tdiff);
325 <                addcolor(r->rcol, ctmp);
326 <                if (nd.pdot > 0.0)
307 <                        flipsurface(r);
321 >                vtmp[0] = -nd.pnorm[0];
322 >                vtmp[1] = -nd.pnorm[1];
323 >                vtmp[2] = -nd.pnorm[2];
324 >                copyscolor(sctmp, nd.tdiff);
325 >                multambient(sctmp, r, vtmp);
326 >                saddscolor(r->rcol, sctmp);
327          }
328          if (hasrefl | hastrans || m->oargs.sarg[6][0] != '0')
329                  direct(r, dirbrdf, &nd);        /* add direct component */
311 –                                                /* check distance */
312 –        if (transtest > bright(r->rcol))
313 –                r->rt = transdist;
330  
331          return(1);
332   }
333  
334  
335  
336 < m_brdf2(m, r)                   /* color a ray which hit a BRDF material */
337 < register OBJREC  *m;
338 < register RAY  *r;
336 > int
337 > m_brdf2(                        /* color a ray that hit a BRDF material */
338 >        OBJREC  *m,
339 >        RAY  *r
340 > )
341   {
342          BRDFDAT  nd;
343 <        COLOR  ctmp;
343 >        SCOLOR  sctmp;
344 >        FVECT  vtmp;
345          double  dtmp;
346                                                  /* always a shadow */
347          if (r->crtype & SHADOW)
348                  return(1);
349 +                                                /* check for back side */
350 +        if (r->rod < 0.0) {
351 +                if (!backvis) {
352 +                        raytrans(r);
353 +                        return(1);
354 +                }
355 +                raytexture(r, m->omod);
356 +                flipsurface(r);                 /* reorient if backvis */
357 +        } else
358 +                raytexture(r, m->omod);
359                                                  /* check arguments */
360 <        if (m->oargs.nsargs < (hasdata(m->otype)?4:2) | m->oargs.nfargs <
361 <                        (m->otype==MAT_TFUNC|m->otype==MAT_TDATA?6:4))
360 >        if ((m->oargs.nsargs < (hasdata(m->otype)?4:2)) | (m->oargs.nfargs <
361 >                        ((m->otype==MAT_TFUNC)|(m->otype==MAT_TDATA)?6:4)))
362                  objerror(m, USER, "bad # arguments");
363 +
364          nd.mp = m;
365          nd.pr = r;
366                                                  /* get material color */
367 <        setcolor(nd.mcolor, m->oargs.farg[0],
367 >        setscolor(nd.mcolor, m->oargs.farg[0],
368                          m->oargs.farg[1],
369                          m->oargs.farg[2]);
370                                                  /* get specular component */
371          nd.rspec = m->oargs.farg[3];
372                                                  /* compute transmittance */
373 <        if (m->otype == MAT_TFUNC | m->otype == MAT_TDATA) {
373 >        if ((m->otype == MAT_TFUNC) | (m->otype == MAT_TDATA)) {
374                  nd.trans = m->oargs.farg[4]*(1.0 - nd.rspec);
375                  nd.tspec = nd.trans * m->oargs.farg[5];
376                  dtmp = nd.trans - nd.tspec;
377 <                setcolor(nd.tdiff, dtmp, dtmp, dtmp);
377 >                setscolor(nd.tdiff, dtmp, dtmp, dtmp);
378          } else {
379                  nd.tspec = nd.trans = 0.0;
380 <                setcolor(nd.tdiff, 0.0, 0.0, 0.0);
380 >                scolorblack(nd.tdiff);
381          }
382                                                  /* compute reflectance */
383          dtmp = 1.0 - nd.trans - nd.rspec;
384 <        setcolor(nd.rdiff, dtmp, dtmp, dtmp);
355 <                                                /* check for back side */
356 <        if (r->rod < 0.0) {
357 <                if (!backvis && m->otype != MAT_TFUNC
358 <                                && m->otype != MAT_TDATA) {
359 <                        raytrans(r);
360 <                        return(1);
361 <                }
362 <                flipsurface(r);                 /* reorient if backvis */
363 <        }
364 <                                                /* get modifiers */
365 <        raytexture(r, m->omod);
384 >        setscolor(nd.rdiff, dtmp, dtmp, dtmp);
385          nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
386 <        multcolor(nd.mcolor, r->pcol);          /* modify material color */
387 <        multcolor(nd.rdiff, nd.mcolor);
388 <        multcolor(nd.tdiff, nd.mcolor);
386 >        smultscolor(nd.mcolor, r->pcol);        /* modify material color */
387 >        smultscolor(nd.rdiff, nd.mcolor);
388 >        smultscolor(nd.tdiff, nd.mcolor);
389                                                  /* load auxiliary files */
390          if (hasdata(m->otype)) {
391                  nd.dp = getdata(m->oargs.sarg[1]);
# Line 377 | Line 396 | register RAY  *r;
396          }
397                                                  /* compute ambient */
398          if (nd.trans < 1.0-FTINY) {
399 <                ambient(ctmp, r, nd.pnorm);
400 <                scalecolor(ctmp, 1.0-nd.trans);
401 <                multcolor(ctmp, nd.mcolor);     /* modified by material color */
402 <                addcolor(r->rcol, ctmp);        /* add to returned color */
399 >                copyscolor(sctmp, nd.mcolor);   /* modified by material color */
400 >                scalescolor(sctmp, 1.0-nd.trans);
401 >                multambient(sctmp, r, nd.pnorm);
402 >                saddscolor(r->rcol, sctmp);     /* add to returned color */
403          }
404 <        if (nd.trans > FTINY) {         /* from other side */
405 <                flipsurface(r);
406 <                ambient(ctmp, r, nd.pnorm);
407 <                scalecolor(ctmp, nd.trans);
408 <                multcolor(ctmp, nd.mcolor);
409 <                addcolor(r->rcol, ctmp);
410 <                flipsurface(r);
404 >        if (nd.trans > FTINY) {                 /* from other side */
405 >                vtmp[0] = -nd.pnorm[0];
406 >                vtmp[1] = -nd.pnorm[1];
407 >                vtmp[2] = -nd.pnorm[2];
408 >                copyscolor(sctmp, nd.mcolor);
409 >                scalescolor(sctmp, nd.trans);
410 >                multambient(sctmp, r, vtmp);
411 >                saddscolor(r->rcol, sctmp);
412          }
413                                                  /* add direct component */
414          direct(r, dirbrdf, &nd);
# Line 397 | Line 417 | register RAY  *r;
417   }
418  
419  
420 < setbrdfunc(np)                  /* set up brdf function and variables */
421 < register BRDFDAT  *np;
420 > static int
421 > setbrdfunc(                     /* set up brdf function and variables */
422 >        BRDFDAT  *np
423 > )
424   {
425          FVECT  vec;
426 +        COLOR  ctmp;
427  
428          if (setfunc(np->mp, np->pr) == 0)
429                  return(0);      /* it's OK, setfunc says we're done */
430                                  /* else (re)assign special variables */
431          multv3(vec, np->pnorm, funcxf.xfm);
432 <        varset("NxP", '=', vec[0]/funcxf.sca);
433 <        varset("NyP", '=', vec[1]/funcxf.sca);
434 <        varset("NzP", '=', vec[2]/funcxf.sca);
435 <        varset("RdotP", '=', np->pdot <= -1.0 ? -1.0 :
436 <                        np->pdot >= 1.0 ? 1.0 : np->pdot);
437 <        varset("CrP", '=', colval(np->mcolor,RED));
438 <        varset("CgP", '=', colval(np->mcolor,GRN));
439 <        varset("CbP", '=', colval(np->mcolor,BLU));
432 >        varset("NxP`", '=', vec[0]/funcxf.sca);
433 >        varset("NyP`", '=', vec[1]/funcxf.sca);
434 >        varset("NzP`", '=', vec[2]/funcxf.sca);
435 >        varset("RdotP`", '=', np->pdot);
436 >        scolor_color(ctmp, np->mcolor);         /* should use scolor_rgb()? */
437 >        varset("CrP", '=', colval(ctmp,RED));
438 >        varset("CgP", '=', colval(ctmp,GRN));
439 >        varset("CbP", '=', colval(ctmp,BLU));
440          return(1);
441   }

Diff Legend

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