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

Comparing ray/src/rt/p_data.c (file contents):
Revision 1.1 by greg, Thu Feb 2 10:41:33 1989 UTC vs.
Revision 2.9 by greg, Tue Jul 8 18:25:00 2014 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1986 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   *  p_data.c - routine for stored patterns.
9 – *
10 – *     6/4/86
6   */
7  
8 < #include  "ray.h"
8 > #include "copyright.h"
9  
10 + #include  "ray.h"
11   #include  "data.h"
12 + #include  "func.h"
13 + #include  "rtotypes.h"
14  
15   /*
16   *      A stored pattern can either be brightness or
# Line 48 | Line 46 | static char SCCSid[] = "$SunId$ LBL";
46   */
47  
48  
49 < p_bdata(m, r)                   /* interpolate brightness data */
50 < register OBJREC  *m;
51 < RAY  *r;
49 > int
50 > p_bdata(                        /* interpolate brightness data */
51 >        OBJREC  *m,
52 >        RAY  *r
53 > )
54   {
55 –        extern double  varvalue(), funvalue(), datavalue();
56 –        extern int  errno;
57 –        int  nv;
55          double  bval;
56          double  pt[MAXDIM];
57          DATARRAY  *dp;
58 <        register char  **sa;
58 >        MFUNC  *mf;
59 >        int  i;
60  
63 –        setfunc(m, r);
64 –
65 –        sa = m->oargs.sarg;
66 –
61          if (m->oargs.nsargs < 4)
62                  objerror(m, USER, "bad # arguments");
63 <        if (!vardefined(sa[3]))
64 <                loadfunc(sa[2]);
65 <        for (nv = 0; nv+3 < m->oargs.nsargs &&
66 <                        sa[nv+3][0] != '-'; nv++) {
67 <                if (nv >= MAXDIM)
68 <                        goto dimerr;
69 <                errno = 0;
70 <                pt[nv] = varvalue(sa[nv+3]);
77 <                if (errno)
63 >        dp = getdata(m->oargs.sarg[1]);
64 >        i = (1 << dp->nd) - 1;
65 >        mf = getfunc(m, 2, i<<3, 0);
66 >        setfunc(m, r);
67 >        errno = 0;
68 >        for (i = dp->nd; i-- > 0; ) {
69 >                pt[i] = evalue(mf->ep[i]);
70 >                if (errno == EDOM || errno == ERANGE)
71                          goto computerr;
72          }
80 –        dp = getdata(sa[1]);
81 –        if (dp->nd != nv)
82 –                goto dimerr;
73          bval = datavalue(dp, pt);
74          errno = 0;
75 <        bval = funvalue(sa[0], 1, &bval);
76 <        if (errno)
75 >        bval = funvalue(m->oargs.sarg[0], 1, &bval);
76 >        if (errno == EDOM || errno == ERANGE)
77                  goto computerr;
78          scalecolor(r->pcol, bval);
79 <        return;
90 <
91 < dimerr:
92 <        objerror(m, USER, "dimension error");
93 <
79 >        return(0);
80   computerr:
81          objerror(m, WARNING, "compute error");
82 <        return;
82 >        return(0);
83   }
84  
85  
86 < p_cdata(m, r)                   /* interpolate color data */
87 < register OBJREC  *m;
88 < RAY  *r;
86 > int
87 > p_cdata(                        /* interpolate color data */
88 >        OBJREC  *m,
89 >        RAY  *r
90 > )
91   {
104 –        extern double  varvalue(), funvalue(), datavalue();
105 –        extern int  errno;
106 –        int  i, nv;
92          double  col[3];
93          COLOR  cval;
94          double  pt[MAXDIM];
95 +        int  nv;
96          DATARRAY  *dp;
97 <        register char  **sa;
97 >        MFUNC  *mf;
98 >        int  i;
99  
113 –        setfunc(m, r);
114 –
115 –        sa = m->oargs.sarg;
116 –
100          if (m->oargs.nsargs < 8)
101                  objerror(m, USER, "bad # arguments");
102 <        if (!vardefined(sa[7]))
103 <                loadfunc(sa[6]);
104 <        for (nv = 0; nv+7 < m->oargs.nsargs &&
105 <                        sa[nv+7][0] != '-'; nv++) {
106 <                if (nv >= MAXDIM)
107 <                        goto dimerr;
108 <                errno = 0;
109 <                pt[nv] = varvalue(sa[nv+7]);
127 <                if (errno)
102 >        dp = getdata(m->oargs.sarg[3]);
103 >        i = (1 << (nv = dp->nd)) - 1;
104 >        mf = getfunc(m, 6, i<<7, 0);
105 >        setfunc(m, r);
106 >        errno = 0;
107 >        for (i = 0; i < nv; i++) {
108 >                pt[i] = evalue(mf->ep[i]);
109 >                if (errno == EDOM || errno == ERANGE)
110                          goto computerr;
111          }
112 <        for (i = 0; i < 3; i++) {
113 <                dp = getdata(sa[i+3]);
112 >        col[0] = datavalue(dp, pt);
113 >        for (i = 1; i < 3; i++) {
114 >                dp = getdata(m->oargs.sarg[i+3]);
115                  if (dp->nd != nv)
116 <                        goto dimerr;
116 >                        objerror(m, USER, "dimension error");
117                  col[i] = datavalue(dp, pt);
118          }
119          errno = 0;
120 <        setcolor(cval,  funvalue(sa[0], 3, col),
121 <                        funvalue(sa[1], 3, col),
122 <                        funvalue(sa[2], 3, col));
123 <        if (errno)
120 >        for (i = 0; i < 3; i++)
121 >                if (fundefined(m->oargs.sarg[i]) < 3)
122 >                        colval(cval,i) = funvalue(m->oargs.sarg[i], 1, col+i);
123 >                else
124 >                        colval(cval,i) = funvalue(m->oargs.sarg[i], 3, col);
125 >        if (errno == EDOM || errno == ERANGE)
126                  goto computerr;
127          multcolor(r->pcol, cval);
128 <        return;
144 <
145 < dimerr:
146 <        objerror(m, USER, "dimension error");
147 <
128 >        return(0);
129   computerr:
130          objerror(m, WARNING, "compute error");
131 <        return;
131 >        return(0);
132   }
133  
134  
135 < p_pdata(m, r)                   /* interpolate picture data */
136 < register OBJREC  *m;
137 < RAY  *r;
135 > int
136 > p_pdata(                        /* interpolate picture data */
137 >        OBJREC  *m,
138 >        RAY  *r
139 > )
140   {
158 –        extern double  varvalue(), funvalue(), datavalue();
159 –        extern int  errno;
160 –        int  i;
141          double  col[3];
142          COLOR  cval;
143          double  pt[2];
144          DATARRAY  *dp;
145 <        register char  **sa;
145 >        MFUNC  *mf;
146 >        int  i;
147  
167 –        setfunc(m, r);
168 –
169 –        sa = m->oargs.sarg;
170 –
148          if (m->oargs.nsargs < 7)
149                  objerror(m, USER, "bad # arguments");
150 <        if (!vardefined(sa[5]))
151 <                loadfunc(sa[4]);
152 <        for (i = 0; i < 2; i++) {
153 <                errno = 0;
154 <                pt[i] = varvalue(sa[i+5]);
155 <                if (errno)
156 <                        goto computerr;
157 <        }
181 <        dp = getpict(sa[3]);
150 >        mf = getfunc(m, 4, 0x3<<5, 0);
151 >        setfunc(m, r);
152 >        errno = 0;
153 >        pt[1] = evalue(mf->ep[0]);      /* y major ordering */
154 >        pt[0] = evalue(mf->ep[1]);
155 >        if (errno == EDOM || errno == ERANGE)
156 >                goto computerr;
157 >        dp = getpict(m->oargs.sarg[3]);
158          for (i = 0; i < 3; i++)
159                  col[i] = datavalue(dp+i, pt);
160          errno = 0;
161 <        setcolor(cval,  funvalue(sa[0], 3, col),
162 <                        funvalue(sa[1], 3, col),
163 <                        funvalue(sa[2], 3, col));
164 <        if (errno)
161 >        for (i = 0; i < 3; i++)
162 >                if (fundefined(m->oargs.sarg[i]) < 3)
163 >                        colval(cval,i) = funvalue(m->oargs.sarg[i], 1, col+i);
164 >                else
165 >                        colval(cval,i) = funvalue(m->oargs.sarg[i], 3, col);
166 >        if (errno == EDOM || errno == ERANGE)
167                  goto computerr;
168          multcolor(r->pcol, cval);
169 <        return;
169 >        return(0);
170  
171   computerr:
172          objerror(m, WARNING, "compute error");
173 <        return;
173 >        return(0);
174   }

Diff Legend

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