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.10 by greg, Mon Jul 15 11:28:41 1991 UTC vs.
Revision 2.7 by greg, Fri Jun 27 22:27:45 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1990 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  "standard.h"
10 > #include  <stdlib.h>
11 > #include  "rtmath.h"
12 > #include  "rtio.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
# Line 23 | Line 22 | register XF  *ret;
22   int  ac;
23   char  *av[];
24   {
25 <        double  atof(), sin(), cos();
27 <        double  xfmat[4][4], m4[4][4];
25 >        MAT4  xfmat, m4;
26          double  xfsca, dtmp;
27          int  i, icnt;
28  
# 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);
108 >                        checkarg(2,"i");
109                          while (icnt-- > 0) {
110                                  multmat4(ret->xfm, ret->xfm, xfmat);
111                                  ret->sca *= xfsca;
# Line 118 | Line 116 | char  *av[];
116                          continue;
117  
118                  default:
119 <                        return(i);
119 >                        goto done;
120  
121                  }
122                  multmat4(xfmat, xfmat, m4);
# Line 138 | Line 136 | 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  
# Line 157 | 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 166 | 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 202 | 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);
222 >                        checkarg(2,"i");
223                          while (icnt-- > 0) {
224                                  multmat4(ret->xfm, xfmat, ret->xfm);
225                                  ret->sca *= xfsca;
# Line 233 | Line 230 | char  *av[];
230                          break;
231  
232                  default:
233 <                        return(i);
233 >                        goto done;
234  
235                  }
236                  multmat4(xfmat, m4, xfmat);     /* left multiply */

Diff Legend

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