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.1 by greg, Thu Feb 2 10:34:41 1989 UTC vs.
Revision 1.4 by greg, Thu Oct 5 07:54:31 1989 UTC

# Line 13 | Line 13 | static char SCCSid[] = "$SunId$ LBL";
13  
14   #define  PI             3.14159265358979323846
15  
16 + #define  checkarg(a,n)  if (strcmp(av[i],a) || i+n >= ac) goto done
17  
18 +
19   int
20 < xf(xfmat, xfsca, ac, av)                /* get transform specification */
21 < double  xfmat[4][4];
22 < double  *xfsca;
20 > xf(retmat, retsca, ac, av)              /* get transform specification */
21 > double  retmat[4][4];
22 > double  *retsca;
23   int  ac;
24   char  *av[];
25   {
26          double  atof(), sin(), cos();
27 <        double  m4[4][4];
28 <        double  theta;
29 <        int  i;
27 >        double  xfmat[4][4], m4[4][4];
28 >        double  xfsca, theta;
29 >        int  i, j;
30 >        int  rept;
31  
32 +        setident4(retmat);
33 +        *retsca = 1.0;
34 +
35 +        rept = 1;
36 +        setident4(xfmat);
37 +        xfsca = 1.0;
38 +
39          for (i = 0; i < ac && av[i][0] == '-'; i++) {
40          
41                  setident4(m4);
# Line 33 | Line 43 | char  *av[];
43                  switch (av[i][1]) {
44          
45                  case 't':                       /* translate */
46 +                        checkarg("-t",3);
47                          m4[3][0] = atof(av[++i]);
48                          m4[3][1] = atof(av[++i]);
49                          m4[3][2] = atof(av[++i]);
# Line 41 | Line 52 | char  *av[];
52                  case 'r':                       /* rotate */
53                          switch (av[i][2]) {
54                          case 'x':
55 +                                checkarg("-rx",1);
56                                  theta = PI/180.0 * atof(av[++i]);
57                                  m4[1][1] = m4[2][2] = cos(theta);
58                                  m4[2][1] = -(m4[1][2] = sin(theta));
59                                  break;
60                          case 'y':
61 <                                theta = PI/180 * atof(av[++i]);
61 >                                checkarg("-ry",1);
62 >                                theta = PI/180.0 * atof(av[++i]);
63                                  m4[0][0] = m4[2][2] = cos(theta);
64                                  m4[0][2] = -(m4[2][0] = sin(theta));
65                                  break;
66                          case 'z':
67 <                                theta = PI/180 * atof(av[++i]);
67 >                                checkarg("-rz",1);
68 >                                theta = PI/180.0 * atof(av[++i]);
69                                  m4[0][0] = m4[1][1] = cos(theta);
70                                  m4[1][0] = -(m4[0][1] = sin(theta));
71                                  break;
# Line 61 | Line 75 | char  *av[];
75                          break;
76  
77                  case 's':                       /* scale */
78 <                        *xfsca *=
78 >                        checkarg("-s",1);
79 >                        xfsca *=
80                          m4[0][0] =
81                          m4[1][1] =
82                          m4[2][2] = atof(av[++i]);
# Line 70 | Line 85 | char  *av[];
85                  case 'm':                       /* mirror */
86                          switch (av[i][2]) {
87                          case 'x':
88 <                                *xfsca *=
88 >                                checkarg("-mx",0);
89 >                                xfsca *=
90                                  m4[0][0] = -1.0;
91                                  break;
92                          case 'y':
93 <                                *xfsca *=
93 >                                checkarg("-my",0);
94 >                                xfsca *=
95                                  m4[1][1] = -1.0;
96                                  break;
97                          case 'z':
98 <                                *xfsca *=
98 >                                checkarg("-mz",0);
99 >                                xfsca *=
100                                  m4[2][2] = -1.0;
101                                  break;
102                          default:
# Line 86 | Line 104 | char  *av[];
104                          }
105                          break;
106  
107 +                case 'i':                       /* iterate */
108 +                        checkarg("-i",1);
109 +                        for (j = 0; j < rept; j++) {
110 +                                multmat4(retmat, retmat, xfmat);
111 +                                *retsca *= xfsca;
112 +                        }
113 +                        rept = atoi(av[++i]);
114 +                        setident4(xfmat);
115 +                        xfsca = 1.0;
116 +                        break;
117 +
118                  default:
119                          return(i);
120  
121                  }
122                  multmat4(xfmat, xfmat, m4);
123          }
124 + done:
125 +        for (j = 0; j < rept; j++) {
126 +                multmat4(retmat, retmat, xfmat);
127 +                *retsca *= xfsca;
128 +        }
129          return(i);
130   }
131  
132  
133   #ifdef  INVXF
134   int
135 < invxf(xfmat, xfsca, ac, av)             /* invert transform specification */
136 < double  xfmat[4][4];
137 < double  *xfsca;
135 > invxf(retmat, retsca, ac, av)           /* invert transform specification */
136 > double  retmat[4][4];
137 > double  *retsca;
138   int  ac;
139   char  *av[];
140   {
141          double  atof(), sin(), cos();
142 <        double  m4[4][4];
143 <        double  theta;
144 <        int  i;
142 >        double  xfmat[4][4], m4[4][4];
143 >        double  xfsca, theta;
144 >        int  i, j;
145 >        int  rept;
146  
147 +        setident4(retmat);
148 +        *retsca = 1.0;
149 +
150 +        rept = 1;
151 +        setident4(xfmat);
152 +        xfsca = 1.0;
153 +
154          for (i = 0; i < ac && av[i][0] == '-'; i++) {
155          
156                  setident4(m4);
# Line 116 | Line 158 | char  *av[];
158                  switch (av[i][1]) {
159          
160                  case 't':                       /* translate */
161 +                        checkarg("-t",3);
162                          m4[3][0] = -atof(av[++i]);
163                          m4[3][1] = -atof(av[++i]);
164                          m4[3][2] = -atof(av[++i]);
# Line 124 | Line 167 | char  *av[];
167                  case 'r':                       /* rotate */
168                          switch (av[i][2]) {
169                          case 'x':
170 +                                checkarg("-rx",1);
171                                  theta = -PI/180.0 * atof(av[++i]);
172                                  m4[1][1] = m4[2][2] = cos(theta);
173                                  m4[2][1] = -(m4[1][2] = sin(theta));
174                                  break;
175                          case 'y':
176 +                                checkarg("-ry",1);
177                                  theta = -PI/180.0 * atof(av[++i]);
178                                  m4[0][0] = m4[2][2] = cos(theta);
179                                  m4[0][2] = -(m4[2][0] = sin(theta));
180                                  break;
181                          case 'z':
182 +                                checkarg("-rz",1);
183                                  theta = -PI/180.0 * atof(av[++i]);
184                                  m4[0][0] = m4[1][1] = cos(theta);
185                                  m4[1][0] = -(m4[0][1] = sin(theta));
# Line 144 | Line 190 | char  *av[];
190                          break;
191  
192                  case 's':                       /* scale */
193 +                        checkarg("-s",1);
194                          *xfsca *=
195                          m4[0][0] =
196                          m4[1][1] =
# Line 153 | Line 200 | char  *av[];
200                  case 'm':                       /* mirror */
201                          switch (av[i][2]) {
202                          case 'x':
203 +                                checkarg("-mx",0);
204                                  *xfsca *=
205                                  m4[0][0] = -1.0;
206                                  break;
207                          case 'y':
208 +                                checkarg("-my",0);
209                                  *xfsca *=
210                                  m4[1][1] = -1.0;
211                                  break;
212                          case 'z':
213 +                                checkarg("-mz",0);
214                                  *xfsca *=
215                                  m4[2][2] = -1.0;
216                                  break;
# Line 169 | Line 219 | char  *av[];
219                          }
220                          break;
221  
222 +                case 'i':                       /* iterate */
223 +                        checkarg("-i",1);
224 +                        for (j = 0; j < rept; j++) {
225 +                                multmat4(retmat, xfmat, retmat);
226 +                                *retsca *= xfsca;
227 +                        }
228 +                        rept = atoi(av[++i]);
229 +                        setident4(xfmat);
230 +                        xfsca = 1.0;
231 +                        break;
232 +
233                  default:
234                          return(i);
235  
236                  }
237                  multmat4(xfmat, m4, xfmat);     /* left multiply */
238 +        }
239 + done:
240 +        for (j = 0; j < rept; j++) {
241 +                multmat4(retmat, xfmat, retmat);
242 +                *retsca *= xfsca;
243          }
244          return(i);
245   }

Diff Legend

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