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

Comparing ray/src/rt/func.c (file contents):
Revision 2.10 by greg, Tue Aug 3 12:04:58 1993 UTC vs.
Revision 2.25 by greg, Thu Jun 7 18:56:06 2012 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1992 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   *  func.c - interface to calcomp functions.
9 – *
10 – *     4/7/86
6   */
7  
8 < #include  "ray.h"
8 > #include "copyright.h"
9  
10 + #include  "ray.h"
11 + #include  "paths.h"
12   #include  "otypes.h"
16 –
13   #include  "func.h"
14  
15  
# Line 34 | Line 30 | XF  funcxf;                    /* current transformation */
30   static OBJREC  *fobj = NULL;    /* current function object */
31   static RAY  *fray = NULL;       /* current function ray */
32  
33 < static double  l_erf(), l_erfc(), l_arg();
33 > static double  l_erf(char *), l_erfc(char *), l_arg(char *);
34  
35  
36   MFUNC *
37 < getfunc(m, ff, ef, dofwd)       /* get function for this modifier */
38 < OBJREC  *m;
39 < int  ff;
40 < unsigned  ef;
41 < int  dofwd;
37 > getfunc(        /* get function for this modifier */
38 >        OBJREC  *m,
39 >        int  ff,
40 >        unsigned int  ef,
41 >        int  dofwd
42 > )
43   {
47 –        extern EPNODE  *curfunc;
44          static char  initfile[] = INITFILE;
45          char  sbuf[MAXSTR];
46 <        register char  **arg;
47 <        register MFUNC  *f;
46 >        char  **arg;
47 >        MFUNC  *f;
48          int  ne, na;
49 <        register int  i;
49 >        int  i;
50                                          /* check to see if done already */
51          if ((f = (MFUNC *)m->os) != NULL)
52                  return(f);
53          fobj = NULL; fray = NULL;
54          if (initfile[0]) {              /* initialize on first call */
55 +                esupport |= E_VARIABLE|E_FUNCTION|E_INCHAN|E_RCONST|E_REDEFW;
56 +                esupport &= ~(E_OUTCHAN);
57                  setcontext("");
58                  scompile("Dx=$1;Dy=$2;Dz=$3;", NULL, 0);
59                  scompile("Nx=$4;Ny=$5;Nz=$6;", NULL, 0);
# Line 65 | Line 63 | int  dofwd;
63                  scompile("Ix=$16;Iy=$17;Iz=$18;", NULL, 0);
64                  scompile("Jx=$19;Jy=$20;Jz=$21;", NULL, 0);
65                  scompile("Kx=$22;Ky=$23;Kz=$24;", NULL, 0);
66 +                scompile("Lu=$26;Lv=$27;", NULL, 0);
67                  funset("arg", 1, '=', l_arg);
68                  funset("erf", 1, ':', l_erf);
69                  funset("erfc", 1, ':', l_erfc);
70                  setnoisefuncs();
71 +                setprismfuncs();
72                  loadfunc(initfile);
73                  initfile[0] = '\0';
74          }
# Line 81 | Line 81 | int  dofwd;
81          if (i == 1 && arg[ff][0] == '.')
82                  setcontext(f->ctx = "");        /* "." means no file */
83          else {
84 <                strcpy(sbuf,arg[ff]);   /* file name is context */
84 >                strcpy(sbuf,arg[ff]);           /* file name is context */
85                  if (i > LCALSUF && !strcmp(sbuf+i-LCALSUF, CALSUF))
86                          sbuf[i-LCALSUF] = '\0'; /* remove suffix */
87                  setcontext(f->ctx = savestr(sbuf));
# Line 131 | Line 131 | toofew:
131          objerror(m, USER, "too few string arguments");
132   memerr:
133          error(SYSTEM, "out of memory in getfunc");
134 +        return NULL; /* pro forma return */
135   }
136  
137  
138 < freefunc(m)                     /* free memory associated with modifier */
139 < OBJREC  *m;
138 > void
139 > freefunc(                       /* free memory associated with modifier */
140 >        OBJREC  *m
141 > )
142   {
143 <        register MFUNC  *f;
144 <        register int  i;
143 >        MFUNC  *f;
144 >        int  i;
145  
146          if ((f = (MFUNC *)m->os) == NULL)
147                  return;
# Line 154 | Line 157 | OBJREC  *m;
157                  freestr(f->ctx);
158          }
159          if (f->b != &unitxf)
160 <                free((char *)f->b);
161 <        if (f->f != NULL && f->f != &unitxf)
162 <                free((char *)f->f);
163 <        free((char *)f);
160 >                free((void *)f->b);
161 >        if ((f->f != NULL) & (f->f != &unitxf))
162 >                free((void *)f->f);
163 >        free((void *)f);
164          m->os = NULL;
165   }
166  
167  
168 < setfunc(m, r)                   /* set channels for function call */
169 < OBJREC  *m;
170 < register RAY  *r;
168 > int
169 > setfunc(                        /* set channels for function call */
170 >        OBJREC  *m,                     /* can be NULL */
171 >        RAY  *r
172 > )
173   {
174 <        static unsigned long  lastrno = ~0;
175 <        register MFUNC  *f;
176 <                                        /* get function */
177 <        if ((f = (MFUNC *)m->os) == NULL)
178 <                error(m, CONSISTENCY, "setfunc called before getfunc");
179 <                                        /* set evaluator context */
180 <        setcontext(f->ctx);
174 >        static RNUMBER  lastrno = ~0;
175 >        MFUNC  *f;
176 >                                        /* get function if any */
177 >        if (m != NULL) {
178 >                if ((f = (MFUNC *)m->os) == NULL)
179 >                        objerror(m, CONSISTENCY, "setfunc called before getfunc");
180 >                setcontext(f->ctx);     /* set evaluator context */
181 >        } else
182 >                setcontext("");
183                                          /* check to see if matrix set */
184 <        if (m == fobj && r->rno == lastrno)
184 >        if ((m == fobj) & (r->rno == lastrno))
185                  return(0);
186          fobj = m;
187          fray = r;
# Line 183 | Line 190 | register RAY  *r;
190                          funcxf.sca = r->rox->b.sca * f->b->sca;
191                          multmat4(funcxf.xfm, r->rox->b.xfm, f->b->xfm);
192                  } else
193 <                        copystruct(&funcxf, &r->rox->b);
193 >                        funcxf = r->rox->b;
194          else
195 <                copystruct(&funcxf, f->b);
195 >                funcxf = *(f->b);
196          lastrno = r->rno;
197          eclock++;               /* notify expression evaluator */
198          return(1);
199   }
200  
201  
202 < loadfunc(fname)                 /* load definition file */
203 < char  *fname;
202 > void
203 > loadfunc(                       /* load definition file */
204 >        char  *fname
205 > )
206   {
198 –        extern char  *libpath;          /* library search path */
207          char  *ffname;
208  
209 <        if ((ffname = getpath(fname, libpath, R_OK)) == NULL) {
209 >        if ((ffname = getpath(fname, getrlibpath(), R_OK)) == NULL) {
210                  sprintf(errmsg, "cannot find function file \"%s\"", fname);
211                  error(USER, errmsg);
212          }
# Line 207 | Line 215 | char  *fname;
215  
216  
217   static double
218 < l_arg()                         /* return nth real argument */
218 > l_arg(char *nm)                 /* return nth real argument */
219   {
220 <        extern double  argument();
213 <        register int  n;
220 >        int  n;
221  
222          if (fobj == NULL)
223 <                syntax("arg(n) used in constant expression");
223 >                error(USER, "arg(n) called without a context");
224  
225          n = argument(1) + .5;           /* round to integer */
226  
# Line 229 | Line 236 | l_arg()                                /* return nth real argument */
236  
237  
238   static double
239 < l_erf()                         /* error function */
239 > l_erf(char *nm)                 /* error function */
240   {
234 –        extern double  erf();
235 –
241          return(erf(argument(1)));
242   }
243  
244  
245   static double
246 < l_erfc()                        /* cumulative error function */
246 > l_erfc(char *nm)                /* cumulative error function */
247   {
243 –        extern double  erfc();
244 –
248          return(erfc(argument(1)));
249   }
250  
251  
252   double
253 < chanvalue(n)                    /* return channel n to calcomp */
254 < register int  n;
253 > chanvalue(                      /* return channel n to calcomp */
254 >        int  n
255 > )
256   {
253 –        double  sum;
254 –        register RAY  *r;
255 –
257          if (fray == NULL)
258                  syntax("ray parameter used in constant expression");
259  
260          if (--n < 0)
261                  goto badchan;
262  
263 <        if (n < 3)                      /* ray direction */
263 >        if (n <= 2)                     /* ray direction */
264  
265                  return( (       fray->rdir[0]*funcxf.xfm[0][n] +
266                                  fray->rdir[1]*funcxf.xfm[1][n] +
267                                  fray->rdir[2]*funcxf.xfm[2][n]  )
268                           / funcxf.sca );
269  
270 <        if (n < 6)                      /* surface normal */
270 >        if (n <= 5)                     /* surface normal */
271  
272                  return( (       fray->ron[0]*funcxf.xfm[0][n-3] +
273                                  fray->ron[1]*funcxf.xfm[1][n-3] +
274                                  fray->ron[2]*funcxf.xfm[2][n-3] )
275                           / funcxf.sca );
276  
277 <        if (n < 9)                      /* intersection */
277 >        if (n <= 8)                     /* intersection */
278  
279                  return( fray->rop[0]*funcxf.xfm[0][n-6] +
280                                  fray->rop[1]*funcxf.xfm[1][n-6] +
281                                  fray->rop[2]*funcxf.xfm[2][n-6] +
282                                               funcxf.xfm[3][n-6] );
283  
284 <        if (n == 9) {                   /* total distance */
285 <                sum = fray->rot;
285 <                for (r = fray->parent; r != NULL; r = r->parent)
286 <                        sum += r->rot;
287 <                return(sum * funcxf.sca);
284 >        if (n == 9)                     /* total distance */
285 >                return(raydist(fray,PRIMARY) * funcxf.sca);
286  
289 –        }
290 –
287          if (n == 10)                    /* dot product (range [-1,1]) */
288                  return( fray->rod <= -1.0 ? -1.0 :
289                          fray->rod >= 1.0 ? 1.0 :
# Line 296 | Line 292 | register int  n;
292          if (n == 11)                    /* scale */
293                  return(funcxf.sca);
294  
295 <        if (n < 15)                     /* origin */
295 >        if (n <= 14)                    /* origin */
296                  return(funcxf.xfm[3][n-12]);
297  
298 <        if (n < 18)                     /* i unit vector */
298 >        if (n <= 17)                    /* i unit vector */
299                  return(funcxf.xfm[0][n-15] / funcxf.sca);
300  
301 <        if (n < 21)                     /* j unit vector */
302 <                return(funcxf.xfm[1][n-15] / funcxf.sca);
301 >        if (n <= 20)                    /* j unit vector */
302 >                return(funcxf.xfm[1][n-18] / funcxf.sca);
303  
304 <        if (n < 24)                     /* k unit vector */
304 >        if (n <= 23)                    /* k unit vector */
305                  return(funcxf.xfm[2][n-21] / funcxf.sca);
306  
307 <        if (n == 24) {                  /* single ray (shadow) distance */
308 <                sum = fray->rot;
309 <                for (r = fray->parent; r != NULL && r->crtype&SHADOW;
310 <                                r = r->parent)
311 <                        sum += r->rot;
316 <                return(sum * funcxf.sca);
317 <        }
307 >        if (n == 24)                    /* single ray (shadow) distance */
308 >                return((fray->rot+raydist(fray->parent,SHADOW)) * funcxf.sca);
309 >
310 >        if (n <= 26)                    /* local (u,v) coordinates */
311 >                return(fray->uv[n-25]);
312   badchan:
313          error(USER, "illegal channel number");
314 +        return(0.0);
315   }

Diff Legend

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