ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/common/xf.c

Comparing ray/src/common/xf.c (file contents):
Revision 1.11 by greg, Wed Oct 23 15:19:25 1991 UTC vs.
Revision 2.9 by greg, Mon Jun 23 15:11:04 2025 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
20	<	xf(ret, ac, av)                 /* get transform specification */
22	<	register XF  *ret;
23	<	int  ac;
24	<	char  *av[];
20	>	isxfopt(char *p)        /* check whether option begins transform */
21		{
22	<	double  atof(), sin(), cos();
22	>	if (*p++ != '-')
23	>	return(0);
24	>
25	>	if ((p[0] == 't') | (p[0] == 's') | (p[0] == 'i') &&
26	>	!p[1])
27	>	return(1);
28	>
29	>	if ((p[0] == 'r') | (p[0] == 'm') &&
30	>	('x' <= p[1]) & (p[1] <= 'z') &&
31	>	!p[2])
32	>	return(1);
33	>
34	>	return(0);
35	>	}
36	>
37	>
38	>	int
39	>	xf(XF *ret, int ac, char *av[])         /* get transform specification */
40	>	{
41		MAT4  xfmat, m4;
42		double  xfsca, dtmp;
43		int  i, icnt;
#	Line 42 | Line 56 | char  *av[];
56		switch (av[i][1]) {
57
58		case 't':                       /* translate */
59	<	checkarg(2,3);
59	>	checkarg(2,"fff");
60		m4[3][0] = atof(av[++i]);
61		m4[3][1] = atof(av[++i]);
62		m4[3][2] = atof(av[++i]);
#	Line 51 | Line 65 | char  *av[];
65		case 'r':                       /* rotate */
66		switch (av[i][2]) {
67		case 'x':
68	<	checkarg(3,1);
68	>	checkarg(3,"f");
69		dtmp = d2r(atof(av[++i]));
70		m4[1][1] = m4[2][2] = cos(dtmp);
71		m4[2][1] = -(m4[1][2] = sin(dtmp));
72		break;
73		case 'y':
74	<	checkarg(3,1);
74	>	checkarg(3,"f");
75		dtmp = d2r(atof(av[++i]));
76		m4[0][0] = m4[2][2] = cos(dtmp);
77		m4[0][2] = -(m4[2][0] = sin(dtmp));
78		break;
79		case 'z':
80	<	checkarg(3,1);
80	>	checkarg(3,"f");
81		dtmp = d2r(atof(av[++i]));
82		m4[0][0] = m4[1][1] = cos(dtmp);
83		m4[1][0] = -(m4[0][1] = sin(dtmp));
84		break;
85		default:
86	<	return(i);
86	>	goto done;
87		}
88		break;
89
90		case 's':                       /* scale */
91	<	checkarg(2,1);
91	>	checkarg(2,"f");
92		dtmp = atof(av[i+1]);
93		if (dtmp == 0.0) goto done;
94		i++;
#	Line 87 | Line 101 | char  *av[];
101		case 'm':                       /* mirror */
102		switch (av[i][2]) {
103		case 'x':
104	<	checkarg(3,0);
104	>	checkarg(3,"");
105		xfsca *=
106		m4[0][0] = -1.0;
107		break;
108		case 'y':
109	<	checkarg(3,0);
109	>	checkarg(3,"");
110		xfsca *=
111		m4[1][1] = -1.0;
112		break;
113		case 'z':
114	<	checkarg(3,0);
114	>	checkarg(3,"");
115		xfsca *=
116		m4[2][2] = -1.0;
117		break;
118		default:
119	<	return(i);
119	>	goto done;
120		}
121		break;
122
123		case 'i':                       /* iterate */
124	<	checkarg(2,1);
124	>	checkarg(2,"i");
125		while (icnt-- > 0) {
126		multmat4(ret->xfm, ret->xfm, xfmat);
127		ret->sca *= xfsca;
#	Line 118 | Line 132 | char  *av[];
132		continue;
133
134		default:
135	<	return(i);
135	>	goto done;
136
137		}
138		multmat4(xfmat, xfmat, m4);
#	Line 133 | Line 147 | done:
147
148
149		int
150	<	invxf(ret, ac, av)              /* invert transform specification */
137	<	register XF  *ret;
138	<	int  ac;
139	<	char  *av[];
150	>	invxf(XF *ret, int ac, char *av[])      /* invert transform specification */
151		{
141	–	double  atof(), sin(), cos();
152		MAT4  xfmat, m4;
153		double  xfsca, dtmp;
154		int  i, icnt;
#	Line 157 | Line 167 | char  *av[];
167		switch (av[i][1]) {
168
169		case 't':                       /* translate */
170	<	checkarg(2,3);
170	>	checkarg(2,"fff");
171		m4[3][0] = -atof(av[++i]);
172		m4[3][1] = -atof(av[++i]);
173		m4[3][2] = -atof(av[++i]);
#	Line 166 | Line 176 | char  *av[];
176		case 'r':                       /* rotate */
177		switch (av[i][2]) {
178		case 'x':
179	<	checkarg(3,1);
179	>	checkarg(3,"f");
180		dtmp = -d2r(atof(av[++i]));
181		m4[1][1] = m4[2][2] = cos(dtmp);
182		m4[2][1] = -(m4[1][2] = sin(dtmp));
183		break;
184		case 'y':
185	<	checkarg(3,1);
185	>	checkarg(3,"f");
186		dtmp = -d2r(atof(av[++i]));
187		m4[0][0] = m4[2][2] = cos(dtmp);
188		m4[0][2] = -(m4[2][0] = sin(dtmp));
189		break;
190		case 'z':
191	<	checkarg(3,1);
191	>	checkarg(3,"f");
192		dtmp = -d2r(atof(av[++i]));
193		m4[0][0] = m4[1][1] = cos(dtmp);
194		m4[1][0] = -(m4[0][1] = sin(dtmp));
195		break;
196		default:
197	<	return(i);
197	>	goto done;
198		}
199		break;
200
201		case 's':                       /* scale */
202	<	checkarg(2,1);
202	>	checkarg(2,"f");
203		dtmp = atof(av[i+1]);
204		if (dtmp == 0.0) goto done;
205		i++;
#	Line 202 | Line 212 | char  *av[];
212		case 'm':                       /* mirror */
213		switch (av[i][2]) {
214		case 'x':
215	<	checkarg(3,0);
215	>	checkarg(3,"");
216		xfsca *=
217		m4[0][0] = -1.0;
218		break;
219		case 'y':
220	<	checkarg(3,0);
220	>	checkarg(3,"");
221		xfsca *=
222		m4[1][1] = -1.0;
223		break;
224		case 'z':
225	<	checkarg(3,0);
225	>	checkarg(3,"");
226		xfsca *=
227		m4[2][2] = -1.0;
228		break;
229		default:
230	<	return(i);
230	>	goto done;
231		}
232		break;
233
234		case 'i':                       /* iterate */
235	<	checkarg(2,1);
235	>	checkarg(2,"i");
236		while (icnt-- > 0) {
237		multmat4(ret->xfm, xfmat, ret->xfm);
238		ret->sca *= xfsca;
#	Line 233 | Line 243 | char  *av[];
243		break;
244
245		default:
246	<	return(i);
246	>	goto done;
247
248		}
249		multmat4(xfmat, m4, xfmat);     /* left multiply */
#	Line 248 | Line 258 | done:
258
259
260		int
261	<	fullxf(fx, ac, av)                      /* compute both forward and inverse */
252	<	FULLXF  *fx;
253	<	int  ac;
254	<	char  *av[];
261	>	fullxf(FULLXF *fx, int ac, char *av[])  /* compute both forward and inverse */
262		{
263		xf(&fx->f, ac, av);
264		return(invxf(&fx->b, ac, av));

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)