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.2 by greg, Fri Mar 24 16:59:48 1989 UTC vs.
Revision 1.5 by greg, Fri Oct 6 09:39:42 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) return(i)
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, icnt;
30  
31 +        setident4(retmat);
32 +        *retsca = 1.0;
33 +
34 +        setident4(xfmat);
35 +        xfsca = 1.0;
36 +
37          for (i = 0; i < ac && av[i][0] == '-'; i++) {
38          
39                  setident4(m4);
# Line 51 | Line 57 | char  *av[];
57                                  break;
58                          case 'y':
59                                  checkarg("-ry",1);
60 <                                theta = PI/180 * atof(av[++i]);
60 >                                theta = PI/180.0 * atof(av[++i]);
61                                  m4[0][0] = m4[2][2] = cos(theta);
62                                  m4[0][2] = -(m4[2][0] = sin(theta));
63                                  break;
64                          case 'z':
65                                  checkarg("-rz",1);
66 <                                theta = PI/180 * atof(av[++i]);
66 >                                theta = PI/180.0 * atof(av[++i]);
67                                  m4[0][0] = m4[1][1] = cos(theta);
68                                  m4[1][0] = -(m4[0][1] = sin(theta));
69                                  break;
# Line 68 | Line 74 | char  *av[];
74  
75                  case 's':                       /* scale */
76                          checkarg("-s",1);
77 <                        *xfsca *=
77 >                        xfsca *=
78                          m4[0][0] =
79                          m4[1][1] =
80                          m4[2][2] = atof(av[++i]);
# Line 78 | Line 84 | char  *av[];
84                          switch (av[i][2]) {
85                          case 'x':
86                                  checkarg("-mx",0);
87 <                                *xfsca *=
87 >                                xfsca *=
88                                  m4[0][0] = -1.0;
89                                  break;
90                          case 'y':
91                                  checkarg("-my",0);
92 <                                *xfsca *=
92 >                                xfsca *=
93                                  m4[1][1] = -1.0;
94                                  break;
95                          case 'z':
96                                  checkarg("-mz",0);
97 <                                *xfsca *=
97 >                                xfsca *=
98                                  m4[2][2] = -1.0;
99                                  break;
100                          default:
# Line 96 | Line 102 | char  *av[];
102                          }
103                          break;
104  
105 +                case 'i':                       /* iterate */
106 +                        checkarg("-i",1);
107 +                        icnt = atoi(av[++i]);
108 +                        while (icnt-- > 0) {
109 +                                multmat4(retmat, retmat, xfmat);
110 +                                *retsca *= xfsca;
111 +                        }
112 +                        setident4(xfmat);
113 +                        xfsca = 1.0;
114 +                        break;
115 +
116                  default:
117                          return(i);
118  
119                  }
120                  multmat4(xfmat, xfmat, m4);
121          }
122 + done:
123 +        multmat4(retmat, retmat, xfmat);
124 +        *retsca *= xfsca;
125          return(i);
126   }
127  
128  
129   #ifdef  INVXF
130   int
131 < invxf(xfmat, xfsca, ac, av)             /* invert transform specification */
132 < double  xfmat[4][4];
133 < double  *xfsca;
131 > invxf(retmat, retsca, ac, av)           /* invert transform specification */
132 > double  retmat[4][4];
133 > double  *retsca;
134   int  ac;
135   char  *av[];
136   {
137          double  atof(), sin(), cos();
138 <        double  m4[4][4];
139 <        double  theta;
140 <        int  i;
138 >        double  xfmat[4][4], m4[4][4];
139 >        double  xfsca, theta;
140 >        int  i, icnt;
141  
142 +        setident4(retmat);
143 +        *retsca = 1.0;
144 +
145 +        setident4(xfmat);
146 +        xfsca = 1.0;
147 +
148          for (i = 0; i < ac && av[i][0] == '-'; i++) {
149          
150                  setident4(m4);
# Line 159 | Line 185 | char  *av[];
185  
186                  case 's':                       /* scale */
187                          checkarg("-s",1);
188 <                        *xfsca *=
188 >                        xfsca *=
189                          m4[0][0] =
190                          m4[1][1] =
191                          m4[2][2] = 1.0 / atof(av[++i]);
# Line 169 | Line 195 | char  *av[];
195                          switch (av[i][2]) {
196                          case 'x':
197                                  checkarg("-mx",0);
198 <                                *xfsca *=
198 >                                xfsca *=
199                                  m4[0][0] = -1.0;
200                                  break;
201                          case 'y':
202                                  checkarg("-my",0);
203 <                                *xfsca *=
203 >                                xfsca *=
204                                  m4[1][1] = -1.0;
205                                  break;
206                          case 'z':
207                                  checkarg("-mz",0);
208 <                                *xfsca *=
208 >                                xfsca *=
209                                  m4[2][2] = -1.0;
210                                  break;
211                          default:
# Line 187 | Line 213 | char  *av[];
213                          }
214                          break;
215  
216 +                case 'i':                       /* iterate */
217 +                        checkarg("-i",1);
218 +                        icnt = atoi(av[++i]);
219 +                        while (icnt-- > 0) {
220 +                                multmat4(retmat, xfmat, retmat);
221 +                                *retsca *= xfsca;
222 +                        }
223 +                        setident4(xfmat);
224 +                        xfsca = 1.0;
225 +                        break;
226 +
227                  default:
228                          return(i);
229  
230                  }
231                  multmat4(xfmat, m4, xfmat);     /* left multiply */
232          }
233 + done:
234 +        multmat4(retmat, xfmat, retmat);
235 +        *retsca *= xfsca;
236          return(i);
237   }
238   #endif

Diff Legend

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