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.8 by greg, Tue Feb 20 18:02:30 1990 UTC vs.
Revision 2.8 by greg, Thu Apr 2 20:44:15 2020 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 rtmath.h
8   */
9  
10 + #include  <stdlib.h>
11 + #include  "rtmath.h"
12 + #include  "rtio.h"
13  
14 – #define  PI             3.14159265358979323846
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 */
22 < double  retmat[4][4];
23 < double  *retsca;
24 < int  ac;
25 < char  *av[];
20 > xf(XF *ret, int ac, char *av[])         /* get transform specification */
21   {
22 <        double  atof(), sin(), cos();
28 <        double  xfmat[4][4], m4[4][4];
22 >        MAT4  xfmat, m4;
23          double  xfsca, dtmp;
24          int  i, icnt;
25  
26 <        setident4(retmat);
27 <        *retsca = 1.0;
26 >        setident4(ret->xfm);
27 >        ret->sca = 1.0;
28  
29          icnt = 1;
30          setident4(xfmat);
# Line 43 | Line 37 | char  *av[];
37                  switch (av[i][1]) {
38          
39                  case 't':                       /* translate */
40 <                        checkarg(2,3);
40 >                        checkarg(2,"fff");
41                          m4[3][0] = atof(av[++i]);
42                          m4[3][1] = atof(av[++i]);
43                          m4[3][2] = atof(av[++i]);
# Line 52 | Line 46 | char  *av[];
46                  case 'r':                       /* rotate */
47                          switch (av[i][2]) {
48                          case 'x':
49 <                                checkarg(3,1);
49 >                                checkarg(3,"f");
50                                  dtmp = d2r(atof(av[++i]));
51                                  m4[1][1] = m4[2][2] = cos(dtmp);
52                                  m4[2][1] = -(m4[1][2] = sin(dtmp));
53                                  break;
54                          case 'y':
55 <                                checkarg(3,1);
55 >                                checkarg(3,"f");
56                                  dtmp = d2r(atof(av[++i]));
57                                  m4[0][0] = m4[2][2] = cos(dtmp);
58                                  m4[0][2] = -(m4[2][0] = sin(dtmp));
59                                  break;
60                          case 'z':
61 <                                checkarg(3,1);
61 >                                checkarg(3,"f");
62                                  dtmp = d2r(atof(av[++i]));
63                                  m4[0][0] = m4[1][1] = cos(dtmp);
64                                  m4[1][0] = -(m4[0][1] = sin(dtmp));
65                                  break;
66                          default:
67 <                                return(i);
67 >                                goto done;
68                          }
69                          break;
70  
71                  case 's':                       /* scale */
72 <                        checkarg(2,1);
72 >                        checkarg(2,"f");
73                          dtmp = atof(av[i+1]);
74                          if (dtmp == 0.0) goto done;
75                          i++;
# Line 88 | Line 82 | char  *av[];
82                  case 'm':                       /* mirror */
83                          switch (av[i][2]) {
84                          case 'x':
85 <                                checkarg(3,0);
85 >                                checkarg(3,"");
86                                  xfsca *=
87                                  m4[0][0] = -1.0;
88                                  break;
89                          case 'y':
90 <                                checkarg(3,0);
90 >                                checkarg(3,"");
91                                  xfsca *=
92                                  m4[1][1] = -1.0;
93                                  break;
94                          case 'z':
95 <                                checkarg(3,0);
95 >                                checkarg(3,"");
96                                  xfsca *=
97                                  m4[2][2] = -1.0;
98                                  break;
99                          default:
100 <                                return(i);
100 >                                goto done;
101                          }
102                          break;
103  
104                  case 'i':                       /* iterate */
105 <                        checkarg(2,1);
105 >                        checkarg(2,"i");
106                          while (icnt-- > 0) {
107 <                                multmat4(retmat, retmat, xfmat);
108 <                                *retsca *= xfsca;
107 >                                multmat4(ret->xfm, ret->xfm, xfmat);
108 >                                ret->sca *= xfsca;
109                          }
110                          icnt = atoi(av[++i]);
111                          setident4(xfmat);
# Line 119 | Line 113 | char  *av[];
113                          continue;
114  
115                  default:
116 <                        return(i);
116 >                        goto done;
117  
118                  }
119                  multmat4(xfmat, xfmat, m4);
120          }
121   done:
122          while (icnt-- > 0) {
123 <                multmat4(retmat, retmat, xfmat);
124 <                *retsca *= xfsca;
123 >                multmat4(ret->xfm, ret->xfm, xfmat);
124 >                ret->sca *= xfsca;
125          }
126          return(i);
127   }
128  
129  
136 – #ifdef  INVXF
130   int
131 < invxf(retmat, retsca, ac, av)           /* invert transform specification */
139 < double  retmat[4][4];
140 < double  *retsca;
141 < int  ac;
142 < char  *av[];
131 > invxf(XF *ret, int ac, char *av[])      /* invert transform specification */
132   {
133 <        double  atof(), sin(), cos();
145 <        double  xfmat[4][4], m4[4][4];
133 >        MAT4  xfmat, m4;
134          double  xfsca, dtmp;
135          int  i, icnt;
136  
137 <        setident4(retmat);
138 <        *retsca = 1.0;
137 >        setident4(ret->xfm);
138 >        ret->sca = 1.0;
139  
140          icnt = 1;
141          setident4(xfmat);
# Line 160 | Line 148 | char  *av[];
148                  switch (av[i][1]) {
149          
150                  case 't':                       /* translate */
151 <                        checkarg(2,3);
151 >                        checkarg(2,"fff");
152                          m4[3][0] = -atof(av[++i]);
153                          m4[3][1] = -atof(av[++i]);
154                          m4[3][2] = -atof(av[++i]);
# Line 169 | Line 157 | char  *av[];
157                  case 'r':                       /* rotate */
158                          switch (av[i][2]) {
159                          case 'x':
160 <                                checkarg(3,1);
160 >                                checkarg(3,"f");
161                                  dtmp = -d2r(atof(av[++i]));
162                                  m4[1][1] = m4[2][2] = cos(dtmp);
163                                  m4[2][1] = -(m4[1][2] = sin(dtmp));
164                                  break;
165                          case 'y':
166 <                                checkarg(3,1);
166 >                                checkarg(3,"f");
167                                  dtmp = -d2r(atof(av[++i]));
168                                  m4[0][0] = m4[2][2] = cos(dtmp);
169                                  m4[0][2] = -(m4[2][0] = sin(dtmp));
170                                  break;
171                          case 'z':
172 <                                checkarg(3,1);
172 >                                checkarg(3,"f");
173                                  dtmp = -d2r(atof(av[++i]));
174                                  m4[0][0] = m4[1][1] = cos(dtmp);
175                                  m4[1][0] = -(m4[0][1] = sin(dtmp));
176                                  break;
177                          default:
178 <                                return(i);
178 >                                goto done;
179                          }
180                          break;
181  
182                  case 's':                       /* scale */
183 <                        checkarg(2,1);
183 >                        checkarg(2,"f");
184                          dtmp = atof(av[i+1]);
185                          if (dtmp == 0.0) goto done;
186                          i++;
# Line 205 | Line 193 | char  *av[];
193                  case 'm':                       /* mirror */
194                          switch (av[i][2]) {
195                          case 'x':
196 <                                checkarg(3,0);
196 >                                checkarg(3,"");
197                                  xfsca *=
198                                  m4[0][0] = -1.0;
199                                  break;
200                          case 'y':
201 <                                checkarg(3,0);
201 >                                checkarg(3,"");
202                                  xfsca *=
203                                  m4[1][1] = -1.0;
204                                  break;
205                          case 'z':
206 <                                checkarg(3,0);
206 >                                checkarg(3,"");
207                                  xfsca *=
208                                  m4[2][2] = -1.0;
209                                  break;
210                          default:
211 <                                return(i);
211 >                                goto done;
212                          }
213                          break;
214  
215                  case 'i':                       /* iterate */
216 <                        checkarg(2,1);
216 >                        checkarg(2,"i");
217                          while (icnt-- > 0) {
218 <                                multmat4(retmat, xfmat, retmat);
219 <                                *retsca *= xfsca;
218 >                                multmat4(ret->xfm, xfmat, ret->xfm);
219 >                                ret->sca *= xfsca;
220                          }
221                          icnt = atoi(av[++i]);
222                          setident4(xfmat);
# Line 236 | Line 224 | char  *av[];
224                          break;
225  
226                  default:
227 <                        return(i);
227 >                        goto done;
228  
229                  }
230                  multmat4(xfmat, m4, xfmat);     /* left multiply */
231          }
232   done:
233          while (icnt-- > 0) {
234 <                multmat4(retmat, xfmat, retmat);
235 <                *retsca *= xfsca;
234 >                multmat4(ret->xfm, xfmat, ret->xfm);
235 >                ret->sca *= xfsca;
236          }
237          return(i);
238   }
239 < #endif
239 >
240 >
241 > int
242 > fullxf(FULLXF *fx, int ac, char *av[])  /* compute both forward and inverse */
243 > {
244 >        xf(&fx->f, ac, av);
245 >        return(invxf(&fx->b, ac, av));
246 > }

Diff Legend

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