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 1.8 by greg, Sat Apr 7 16:12:56 1990 UTC vs.
Revision 1.21 by greg, Thu Aug 8 13:08:01 1991 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1986 Regents of the University of California */
1 > /* Copyright (c) 1991 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 15 | Line 15 | static char SCCSid[] = "$SunId$ LBL";
15   #include  "otypes.h"
16  
17  
18 < typedef struct {
19 <        double  xfm[4][4];              /* transform matrix */
20 <        double  sca;                    /* scalefactor */
21 < }  XF;
18 > #define  INITFILE       "rayinit.cal"
19 > #define  DEFVNAME       "FILE_LOADED`"
20  
21 < static OBJREC  *fobj;           /* current function object */
22 < static RAY  *fray;              /* current function ray */
23 < static XF  fxf;                 /* current transformation */
21 > XF  unitxf = {                  /* identity transform */
22 >        1.0, 0.0, 0.0, 0.0,
23 >        0.0, 1.0, 0.0, 0.0,
24 >        0.0, 0.0, 1.0, 0.0,
25 >        0.0, 0.0, 0.0, 1.0,
26 >        1.0
27 > };
28  
29 + XF  funcxf;                     /* current transformation */
30 + static OBJREC  *fobj = NULL;    /* current function object */
31 + static RAY  *fray = NULL;       /* current function ray */
32  
33 < setmap(m, r, xfm, sca)          /* set channels for function call */
33 >
34 > setmap(m, r, bx)                /* set channels for function call */
35   OBJREC  *m;
36   register RAY  *r;
37 < double  xfm[4][4];
32 < double  sca;
37 > XF  *bx;
38   {
34 –        extern double  l_noise3(), l_noise3a(), l_noise3b(), l_noise3c();
35 –        extern double  l_hermite(), l_fnoise3(), l_arg();
39          extern long  eclock;
40 <        static char  *initfile = "rayinit.cal";
41 <
42 <        if (initfile != NULL) {
43 <                loadfunc(initfile);
41 <                scompile(NULL, "Dx=$1;Dy=$2;Dz=$3;");
42 <                scompile(NULL, "Nx=$4;Ny=$5;Nz=$6;");
43 <                scompile(NULL, "Px=$7;Py=$8;Pz=$9;");
44 <                scompile(NULL, "T=$10;Rdot=$11;");
45 <                scompile(NULL, "S=$12;Tx=$13;Ty=$14;Tz=$15;");
46 <                scompile(NULL, "Ix=$16;Iy=$17;Iz=$18;");
47 <                scompile(NULL, "Jx=$19;Jy=$20;Jz=$21;");
48 <                scompile(NULL, "Kx=$22;Ky=$23;Kz=$24;");
49 <                funset("arg", 1, l_arg);
50 <                funset("noise3", 3, l_noise3);
51 <                funset("noise3a", 3, l_noise3a);
52 <                funset("noise3b", 3, l_noise3b);
53 <                funset("noise3c", 3, l_noise3c);
54 <                funset("hermite", 5, l_hermite);
55 <                funset("fnoise3", 3, l_fnoise3);
56 <                initfile = NULL;
57 <        }
40 >        static long  lastrno = -1;
41 >                                        /* check to see if already set */
42 >        if (m == fobj && r->rno == lastrno)
43 >                return(0);
44          fobj = m;
45          fray = r;
46 <        fxf.sca = r->robs * sca;
47 <        multmat4(fxf.xfm, r->robx, xfm);
46 >        if (r->rox != NULL)
47 >                if (bx != &unitxf) {
48 >                        funcxf.sca = r->rox->b.sca * bx->sca;
49 >                        multmat4(funcxf.xfm, r->rox->b.xfm, bx->xfm);
50 >                } else
51 >                        copystruct(&funcxf, &r->rox->b);
52 >        else
53 >                copystruct(&funcxf, bx);
54 >        lastrno = r->rno;
55          eclock++;               /* notify expression evaluator */
56 +        return(1);
57   }
58  
59  
# Line 76 | Line 70 | RAY  *r;
70                  for (n = m->oargs.nsargs, sa = m->oargs.sarg;
71                                  n > 0 && **sa != '-'; n--, sa++)
72                          ;
73 <                mxf = (XF *)malloc(sizeof(XF));
74 <                if (mxf == NULL)
75 <                        goto memerr;
76 <                if (invxf(mxf->xfm, &mxf->sca, n, sa) != n)
77 <                        objerror(m, USER, "bad transform");
78 <                if (mxf->sca < 0.0)
79 <                        mxf->sca = -mxf->sca;
73 >                if (n == 0)
74 >                        mxf = &unitxf;
75 >                else {
76 >                        mxf = (XF *)malloc(sizeof(XF));
77 >                        if (mxf == NULL)
78 >                                goto memerr;
79 >                        if (invxf(mxf, n, sa) != n)
80 >                                objerror(m, USER, "bad transform");
81 >                        if (mxf->sca < 0.0)
82 >                                mxf->sca = -mxf->sca;
83 >                }
84                  m->os = (char *)mxf;
85          }
86 <        setmap(m, r, mxf->xfm, mxf->sca);
89 <        return;
86 >        return(setmap(m, r, mxf));
87   memerr:
88          error(SYSTEM, "out of memory in setfunc");
92 – #undef  mxf
89   }
90  
91  
# Line 127 | Line 123 | l_arg()                                /* return nth real argument */
123  
124  
125   double
126 < chanvalue(n)                    /* return channel n to calcomp */
131 < register int  n;
126 > l_erf()                         /* error function */
127   {
128 <        double  sum;
134 <        register RAY  *r;
128 >        extern double  erf();
129  
130 <        n--;                            /* for convenience */
130 >        return(erf(argument(1)));
131 > }
132  
138 –        if (n < 0 || n > 23)
139 –                error(USER, "illegal channel number");
133  
134 <        if (n == 9) {                   /* distance */
134 > double
135 > l_erfc()                        /* cumulative error function */
136 > {
137 >        extern double  erfc();
138  
139 <                sum = fray->rot;
140 <                for (r = fray->parent; r != NULL; r = r->parent)
145 <                        sum += r->rot;
146 <                return(sum * fxf.sca);
139 >        return(erfc(argument(1)));
140 > }
141  
142 +
143 + funcfile(fname)                 /* set context, load file if necessary */
144 + char  *fname;
145 + {
146 +        extern char  *setcontext();
147 +        static char  initfile[] = INITFILE;
148 +
149 +        if (initfile[0]) {              /* initialize on first call */
150 +                setcontext("");
151 +                scompile("Dx=$1;Dy=$2;Dz=$3;", NULL, 0);
152 +                scompile("Nx=$4;Ny=$5;Nz=$6;", NULL, 0);
153 +                scompile("Px=$7;Py=$8;Pz=$9;", NULL, 0);
154 +                scompile("T=$10;Rdot=$11;", NULL, 0);
155 +                scompile("S=$12;Tx=$13;Ty=$14;Tz=$15;", NULL, 0);
156 +                scompile("Ix=$16;Iy=$17;Iz=$18;", NULL, 0);
157 +                scompile("Jx=$19;Jy=$20;Jz=$21;", NULL, 0);
158 +                scompile("Kx=$22;Ky=$23;Kz=$24;", NULL, 0);
159 +                funset("arg", 1, '=', l_arg);
160 +                funset("erf", 1, ':', l_erf);
161 +                funset("erfc", 1, ':', l_erfc);
162 +                setnoisefuncs();
163 +                loadfunc(initfile);
164 +                initfile[0] = '\0';
165          }
166 <        if (n == 10)                    /* dot product */
167 <                return(fray->rod);
166 >        setcontext(fname);
167 >        if (!vardefined(DEFVNAME)) {
168 >                loadfunc(fname);
169 >                varset(DEFVNAME, ':', 1.0);
170 >        }
171 > }
172  
173 +
174 + double
175 + chanvalue(n)                    /* return channel n to calcomp */
176 + register int  n;
177 + {
178 +        double  sum;
179 +        register RAY  *r;
180 +
181 +        if (--n < 0)
182 +                goto badchan;
183 +
184          if (n < 3)                      /* ray direction */
185  
186 <                return( (       fray->rdir[0]*fxf.xfm[0][n] +
187 <                                fray->rdir[1]*fxf.xfm[1][n] +
188 <                                fray->rdir[2]*fxf.xfm[2][n]     )
189 <                         / fxf.sca );
186 >                return( (       fray->rdir[0]*funcxf.xfm[0][n] +
187 >                                fray->rdir[1]*funcxf.xfm[1][n] +
188 >                                fray->rdir[2]*funcxf.xfm[2][n]  )
189 >                         / funcxf.sca );
190  
191          if (n < 6)                      /* surface normal */
192  
193 <                return( (       fray->ron[0]*fxf.xfm[0][n-3] +
194 <                                fray->ron[1]*fxf.xfm[1][n-3] +
195 <                                fray->ron[2]*fxf.xfm[2][n-3]    )
196 <                         / fxf.sca );
193 >                return( (       fray->ron[0]*funcxf.xfm[0][n-3] +
194 >                                fray->ron[1]*funcxf.xfm[1][n-3] +
195 >                                fray->ron[2]*funcxf.xfm[2][n-3] )
196 >                         / funcxf.sca );
197  
198          if (n < 9)                      /* intersection */
199  
200 <                return( fray->rop[0]*fxf.xfm[0][n-6] +
201 <                                fray->rop[1]*fxf.xfm[1][n-6] +
202 <                                fray->rop[2]*fxf.xfm[2][n-6] +
203 <                                             fxf.xfm[3][n-6] );
200 >                return( fray->rop[0]*funcxf.xfm[0][n-6] +
201 >                                fray->rop[1]*funcxf.xfm[1][n-6] +
202 >                                fray->rop[2]*funcxf.xfm[2][n-6] +
203 >                                             funcxf.xfm[3][n-6] );
204  
205 +        if (n == 9) {                   /* distance */
206 +
207 +                sum = fray->rot;
208 +                for (r = fray->parent; r != NULL; r = r->parent)
209 +                        sum += r->rot;
210 +                return(sum * funcxf.sca);
211 +
212 +        }
213 +        if (n == 10)                    /* dot product (range [-1,1]) */
214 +                return( fray->rod <= -1.0 ? -1.0 :
215 +                        fray->rod >= 1.0 ? 1.0 :
216 +                        fray->rod );
217 +
218          if (n == 11)                    /* scale */
219 <                return(fxf.sca);
219 >                return(funcxf.sca);
220  
221          if (n < 15)                     /* origin */
222 <                return(fxf.xfm[3][n-12]);
222 >                return(funcxf.xfm[3][n-12]);
223  
224          if (n < 18)                     /* i unit vector */
225 <                return(fxf.xfm[0][n-15] / fxf.sca);
225 >                return(funcxf.xfm[0][n-15] / funcxf.sca);
226  
227          if (n < 21)                     /* j unit vector */
228 <                return(fxf.xfm[1][n-15] / fxf.sca);
228 >                return(funcxf.xfm[1][n-15] / funcxf.sca);
229  
230          if (n < 24)                     /* k unit vector */
231 <                return(fxf.xfm[2][n-21] / fxf.sca);
231 >                return(funcxf.xfm[2][n-21] / funcxf.sca);
232 > badchan:
233 >        error(USER, "illegal channel number");
234   }

Diff Legend

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