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

Comparing ray/src/common/xf.c (file contents):
Revision 1.7 by greg, Wed Oct 18 23:15:37 1989 UTC vs.
Revision 2.5 by greg, Tue Feb 25 02:47:22 2003 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   *  xf.c - routines to convert transform arguments into 4X4 matrix.
6   *
7 < *     1/28/86
7 > *  External symbols declared in standard.h
8   */
9  
10 + #include "copyright.h"
11  
12 < #define  PI             3.14159265358979323846
12 > #include  "standard.h"
13 >
14   #define  d2r(a)         ((PI/180.)*(a))
15  
16 < #define  checkarg(a,n)  if (av[i][a] || i+n >= ac) goto done
16 > #define  checkarg(a,l)  if (av[i][a] || badarg(ac-i-1,av+i+1,l)) goto done
17  
18  
19   int
20 < xf(retmat, retsca, ac, av)              /* get transform specification */
21 < double  retmat[4][4];
23 < double  *retsca;
20 > xf(ret, ac, av)                 /* get transform specification */
21 > register XF  *ret;
22   int  ac;
23   char  *av[];
24   {
25 <        double  atof(), sin(), cos();
28 <        double  xfmat[4][4], m4[4][4];
25 >        MAT4  xfmat, m4;
26          double  xfsca, dtmp;
27          int  i, icnt;
28  
29 <        setident4(retmat);
30 <        *retsca = 1.0;
29 >        setident4(ret->xfm);
30 >        ret->sca = 1.0;
31  
32 +        icnt = 1;
33          setident4(xfmat);
34          xfsca = 1.0;
35  
# Line 42 | Line 40 | char  *av[];
40                  switch (av[i][1]) {
41          
42                  case 't':                       /* translate */
43 <                        checkarg(2,3);
43 >                        checkarg(2,"fff");
44                          m4[3][0] = atof(av[++i]);
45                          m4[3][1] = atof(av[++i]);
46                          m4[3][2] = atof(av[++i]);
# Line 51 | Line 49 | char  *av[];
49                  case 'r':                       /* rotate */
50                          switch (av[i][2]) {
51                          case 'x':
52 <                                checkarg(3,1);
52 >                                checkarg(3,"f");
53                                  dtmp = d2r(atof(av[++i]));
54                                  m4[1][1] = m4[2][2] = cos(dtmp);
55                                  m4[2][1] = -(m4[1][2] = sin(dtmp));
56                                  break;
57                          case 'y':
58 <                                checkarg(3,1);
58 >                                checkarg(3,"f");
59                                  dtmp = d2r(atof(av[++i]));
60                                  m4[0][0] = m4[2][2] = cos(dtmp);
61                                  m4[0][2] = -(m4[2][0] = sin(dtmp));
62                                  break;
63                          case 'z':
64 <                                checkarg(3,1);
64 >                                checkarg(3,"f");
65                                  dtmp = d2r(atof(av[++i]));
66                                  m4[0][0] = m4[1][1] = cos(dtmp);
67                                  m4[1][0] = -(m4[0][1] = sin(dtmp));
68                                  break;
69                          default:
70 <                                return(i);
70 >                                goto done;
71                          }
72                          break;
73  
74                  case 's':                       /* scale */
75 <                        checkarg(2,1);
75 >                        checkarg(2,"f");
76                          dtmp = atof(av[i+1]);
77                          if (dtmp == 0.0) goto done;
78                          i++;
# Line 87 | Line 85 | char  *av[];
85                  case 'm':                       /* mirror */
86                          switch (av[i][2]) {
87                          case 'x':
88 <                                checkarg(3,0);
88 >                                checkarg(3,"");
89                                  xfsca *=
90                                  m4[0][0] = -1.0;
91                                  break;
92                          case 'y':
93 <                                checkarg(3,0);
93 >                                checkarg(3,"");
94                                  xfsca *=
95                                  m4[1][1] = -1.0;
96                                  break;
97                          case 'z':
98 <                                checkarg(3,0);
98 >                                checkarg(3,"");
99                                  xfsca *=
100                                  m4[2][2] = -1.0;
101                                  break;
102                          default:
103 <                                return(i);
103 >                                goto done;
104                          }
105                          break;
106  
107                  case 'i':                       /* iterate */
108 <                        checkarg(2,1);
111 <                        icnt = atoi(av[++i]);
108 >                        checkarg(2,"i");
109                          while (icnt-- > 0) {
110 <                                multmat4(retmat, retmat, xfmat);
111 <                                *retsca *= xfsca;
110 >                                multmat4(ret->xfm, ret->xfm, xfmat);
111 >                                ret->sca *= xfsca;
112                          }
113 +                        icnt = atoi(av[++i]);
114                          setident4(xfmat);
115                          xfsca = 1.0;
116 <                        break;
116 >                        continue;
117  
118                  default:
119 <                        return(i);
119 >                        goto done;
120  
121                  }
122                  multmat4(xfmat, xfmat, m4);
123          }
124   done:
125 <        multmat4(retmat, retmat, xfmat);
126 <        *retsca *= xfsca;
125 >        while (icnt-- > 0) {
126 >                multmat4(ret->xfm, ret->xfm, xfmat);
127 >                ret->sca *= xfsca;
128 >        }
129          return(i);
130   }
131  
132  
133 – #ifdef  INVXF
133   int
134 < invxf(retmat, retsca, ac, av)           /* invert transform specification */
135 < double  retmat[4][4];
137 < double  *retsca;
134 > invxf(ret, ac, av)              /* invert transform specification */
135 > register XF  *ret;
136   int  ac;
137   char  *av[];
138   {
139 <        double  atof(), sin(), cos();
142 <        double  xfmat[4][4], m4[4][4];
139 >        MAT4  xfmat, m4;
140          double  xfsca, dtmp;
141          int  i, icnt;
142  
143 <        setident4(retmat);
144 <        *retsca = 1.0;
143 >        setident4(ret->xfm);
144 >        ret->sca = 1.0;
145  
146 +        icnt = 1;
147          setident4(xfmat);
148          xfsca = 1.0;
149  
# Line 156 | Line 154 | char  *av[];
154                  switch (av[i][1]) {
155          
156                  case 't':                       /* translate */
157 <                        checkarg(2,3);
157 >                        checkarg(2,"fff");
158                          m4[3][0] = -atof(av[++i]);
159                          m4[3][1] = -atof(av[++i]);
160                          m4[3][2] = -atof(av[++i]);
# Line 165 | Line 163 | char  *av[];
163                  case 'r':                       /* rotate */
164                          switch (av[i][2]) {
165                          case 'x':
166 <                                checkarg(3,1);
166 >                                checkarg(3,"f");
167                                  dtmp = -d2r(atof(av[++i]));
168                                  m4[1][1] = m4[2][2] = cos(dtmp);
169                                  m4[2][1] = -(m4[1][2] = sin(dtmp));
170                                  break;
171                          case 'y':
172 <                                checkarg(3,1);
172 >                                checkarg(3,"f");
173                                  dtmp = -d2r(atof(av[++i]));
174                                  m4[0][0] = m4[2][2] = cos(dtmp);
175                                  m4[0][2] = -(m4[2][0] = sin(dtmp));
176                                  break;
177                          case 'z':
178 <                                checkarg(3,1);
178 >                                checkarg(3,"f");
179                                  dtmp = -d2r(atof(av[++i]));
180                                  m4[0][0] = m4[1][1] = cos(dtmp);
181                                  m4[1][0] = -(m4[0][1] = sin(dtmp));
182                                  break;
183                          default:
184 <                                return(i);
184 >                                goto done;
185                          }
186                          break;
187  
188                  case 's':                       /* scale */
189 <                        checkarg(2,1);
189 >                        checkarg(2,"f");
190                          dtmp = atof(av[i+1]);
191                          if (dtmp == 0.0) goto done;
192                          i++;
# Line 201 | Line 199 | char  *av[];
199                  case 'm':                       /* mirror */
200                          switch (av[i][2]) {
201                          case 'x':
202 <                                checkarg(3,0);
202 >                                checkarg(3,"");
203                                  xfsca *=
204                                  m4[0][0] = -1.0;
205                                  break;
206                          case 'y':
207 <                                checkarg(3,0);
207 >                                checkarg(3,"");
208                                  xfsca *=
209                                  m4[1][1] = -1.0;
210                                  break;
211                          case 'z':
212 <                                checkarg(3,0);
212 >                                checkarg(3,"");
213                                  xfsca *=
214                                  m4[2][2] = -1.0;
215                                  break;
216                          default:
217 <                                return(i);
217 >                                goto done;
218                          }
219                          break;
220  
221                  case 'i':                       /* iterate */
222 <                        checkarg(2,1);
225 <                        icnt = atoi(av[++i]);
222 >                        checkarg(2,"i");
223                          while (icnt-- > 0) {
224 <                                multmat4(retmat, xfmat, retmat);
225 <                                *retsca *= xfsca;
224 >                                multmat4(ret->xfm, xfmat, ret->xfm);
225 >                                ret->sca *= xfsca;
226                          }
227 +                        icnt = atoi(av[++i]);
228                          setident4(xfmat);
229                          xfsca = 1.0;
230                          break;
231  
232                  default:
233 <                        return(i);
233 >                        goto done;
234  
235                  }
236                  multmat4(xfmat, m4, xfmat);     /* left multiply */
237          }
238   done:
239 <        multmat4(retmat, xfmat, retmat);
240 <        *retsca *= xfsca;
239 >        while (icnt-- > 0) {
240 >                multmat4(ret->xfm, xfmat, ret->xfm);
241 >                ret->sca *= xfsca;
242 >        }
243          return(i);
244   }
245 < #endif
245 >
246 >
247 > int
248 > fullxf(fx, ac, av)                      /* compute both forward and inverse */
249 > FULLXF  *fx;
250 > int  ac;
251 > char  *av[];
252 > {
253 >        xf(&fx->f, ac, av);
254 >        return(invxf(&fx->b, ac, av));
255 > }

Diff Legend

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