![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 4.i CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests|
Return to 4.i CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests |
1.1 root 1: extern struct _iobuf {
2: int _cnt;
3: char *_ptr;
4: char *_base;
5: short _flag;
6: char _file;
7: } _iob[20];
8: struct _iobuf *fopen();
9: struct _iobuf *fdopen();
10: struct _iobuf *freopen();
11: long ftell();
12: char *fgets();
13: typedef struct Triple{
14: float x;
15: float y;
16: float z;
17: }Triple;
18: typedef Triple Color;
19: typedef struct Point {
20: int type;
21: long stamp;
22: double x;
23: double y;
24: double z;
25: } Point;
26: typedef struct Plane {
27: int type;
28: long stamp;
29: double A;
30: double B;
31: double C;
32: double D;
33: } Plane;
34: typedef struct Conic {
35: int type;
36: long stamp;
37: double A;
38: double B;
39: double C;
40: double D;
41: double E;
42: double F;
43: double G;
44: double H;
45: double I;
46: double J;
47: } Conic;
48: typedef struct Transform {
49: double A, B, C, D;
50: double E, F, G, H;
51: double I, J, K, L;
52: } Transform;
53: typedef struct Tpair {
54: int type;
55: long stamp;
56: Transform t;
57: Transform tinv;
58: } Tpair;
59: typedef struct Ctree {
60: int type;
61: int (*test)();
62: struct Ctree *car;
63: struct Ctree *cdr;
64: } Ctree;
65: typedef struct Surface {
66: int type;
67: short flags;
68: Triple n;
69: short nfacet;
70: struct{
71: float m;
72: float frac;
73: }facet[5 ];
74: Triple *Dtab;
75: Color speccolor;
76: Color diffcolor;
77: Color ambcolor;
78: Color clearcolor;
79: } Surface;
80: typedef struct Object {
81: int type;
82: union {
83: Plane *plane;
84: Conic *conic;
85: } surface;
86: Conic *cover;
87: Point *center;
88: struct List *references;
89: Ctree *ctree;
90: Tpair *tpair;
91: Surface *srf;
92: float minrange1, minrange2;
93: float Q1, R1, S1, T1;
94: float Q2, R2, S2, T2;
95: int (*fun)();
96: } Object;
97: typedef struct View {
98: int type;
99: Tpair *tpair;
100: int style;
101: Color lightcolor;
102: Point *viewpoint;
103: Point *ul_corner, *ll_corner, *lr_corner;
104: Plane *screen;
105: struct List *bin[32 ][32 ];
106: } View;
107: typedef struct List {
108: int type;
109: union {
110: Point *point;
111: Object *object;
112: View *view;
113: struct List *list;
114: } car;
115: struct List *cdr;
116: } List;
117: typedef struct Symbol{
118: char *name;
119: short type;
120: union{
121: double val;
122: List *obj;
123: Tpair *tpair;
124: Triple *triple;
125: Surface *srf;
126: }u;
127: struct Symbol *next;
128: }Symbol;
129: extern double range1;
130: extern double range2;
131: extern long transform_stamp;
132: extern Color black;
133: extern Color fillcolor;
134: extern Color white;
135: extern List *scene;
136: extern Point testpoint;
137: extern Object *pobject;
138: extern Point dirnums;
139: extern Transform tnull;
140: extern View *camera;
141: extern List *lightsource;
142: extern char *progname;
143: char *emalloc();
144: double Pow();
145: double setvalue();
146: double value();
147: double fsqrt();
148: Color *create_color();
149: Color light();
150: Ctree *and();
151: Ctree *create_ctree();
152: Ctree *inside_list();
153: Ctree *outside_list();
154: List *cons_list();
155: Object *adddefn();
156: Object *boolean();
157: Object *copy();
158: Object *inside();
159: Object *outside();
160: Object *setobjvalue();
161: Object *unit_cone();
162: Object *unit_cube();
163: Object *unit_disc();
164: Object *unit_cylinder();
165: Object *unit_hyperboloid();
166: Object *unit_paraboloid();
167: Object *unit_paracylinder();
168: Object *unit_saddle();
169: Object *unit_sphere();
170: Object *unit_square();
171: Point intersect();
172: Point min_range();
173: Point trans_point();
174: Surface *create_surface();
175: Symbol *install();
176: Symbol *lookup();
177: Tpair *create_tpair();
178: Tpair *mulmat();
179: Tpair *matvalue();
180: Tpair *setmatvalue();
181: Transform trans_product();
182: Triple *trivalue();
183: Triple *settrivalue();
184: Triple *create_triple();
185: View *create_view();
186: long transform_stamp = 1;
187: extern double sin(), cos();
188: Transform tnull = {1.0, 0.0, 0.0, 0.0,
189: 0.0, 1.0, 0.0, 0.0,
190: 0.0, 0.0, 1.0, 0.0,};
191: Transform
192: trans_product(t1, t2)
193: register Transform *t1, *t2;
194: {
195: Transform t3;
196: t3.A = t1->A * t2->A + t1->B * t2->E + t1->C * t2->I;
197: t3.B = t1->A * t2->B + t1->B * t2->F + t1->C * t2->J;
198: t3.C = t1->A * t2->C + t1->B * t2->G + t1->C * t2->K;
199: t3.D = t1->A * t2->D + t1->B * t2->H + t1->C * t2->L + t1->D;
200: t3.E = t1->E * t2->A + t1->F * t2->E + t1->G * t2->I;
201: t3.F = t1->E * t2->B + t1->F * t2->F + t1->G * t2->J;
202: t3.G = t1->E * t2->C + t1->F * t2->G + t1->G * t2->K;
203: t3.H = t1->E * t2->D + t1->F * t2->H + t1->G * t2->L + t1->H;
204: t3.I = t1->I * t2->A + t1->J * t2->E + t1->K * t2->I;
205: t3.J = t1->I * t2->B + t1->J * t2->F + t1->K * t2->J;
206: t3.K = t1->I * t2->C + t1->J * t2->G + t1->K * t2->K;
207: t3.L = t1->I * t2->D + t1->J * t2->H + t1->K * t2->L + t1->L;
208: return t3;
209: }
210: Conic
211: trans_conic(t, c)
212: register Transform *t;
213: register Conic *c;
214: {
215: Conic nc;
216: nc.type = 3;
217: nc.A = (c->A*t->A*t->A + c->B*t->E*t->E + c->C*t->I*t->I) +
218: (c->D*t->A*t->E + c->E*t->E*t->I + c->F*t->A*t->I);
219: nc.B = (c->A*t->B*t->B + c->B*t->F*t->F + c->C*t->J*t->J) +
220: (c->D*t->B*t->F + c->E*t->F*t->J + c->F*t->B*t->J);
221: nc.C = (c->A*t->C*t->C + c->B*t->G*t->G + c->C*t->K*t->K) +
222: (c->D*t->C*t->G + c->E*t->G*t->K + c->F*t->C*t->K);
223: nc.D = (c->A*t->A*t->B + c->B*t->E*t->F + c->C*t->I*t->J)*2.0 +
224: c->D*(t->A*t->F + t->B*t->E) +
225: c->E*(t->E*t->J + t->F*t->I) +
226: c->F*(t->A*t->J + t->B*t->I);
227: nc.E = (c->A*t->B*t->C + c->B*t->F*t->G + c->C*t->J*t->K)*2.0 +
228: c->D*(t->B*t->G + t->C*t->F) +
229: c->E*(t->F*t->K + t->G*t->J) +
230: c->F*(t->B*t->K + t->C*t->J);
231: nc.F = (c->A*t->A*t->C + c->B*t->E*t->G + c->C*t->I*t->K)*2.0 +
232: c->D*(t->A*t->G + t->E*t->C) +
233: c->E*(t->E*t->K + t->G*t->I) +
234: c->F*(t->A*t->K + t->C*t->I);
235: nc.G = (c->A*t->A*t->D + c->B*t->E*t->H + c->C*t->I*t->L)*2.0 +
236: c->D*(t->A*t->H + t->D*t->E) +
237: c->E*(t->E*t->L + t->H*t->I) +
238: c->F*(t->A*t->L + t->D*t->I) +
239: c->G*t->A + c->H*t->E + c->I*t->I;
240: nc.H = (c->A*t->B*t->D + c->B*t->F*t->H + c->C*t->J*t->L)*2.0 +
241: c->D*(t->B*t->H + t->D*t->F) +
242: c->E*(t->F*t->L + t->H*t->J) +
243: c->F*(t->B*t->L + t->D*t->J) +
244: c->G*t->B + c->H*t->F + c->I*t->J;
245: nc.I = (c->A*t->C*t->D + c->B*t->G*t->H + c->C*t->K*t->L)*2.0 +
246: c->D*(t->C*t->H + t->D*t->G) +
247: c->E*(t->G*t->L + t->H*t->K) +
248: c->F*(t->C*t->L + t->D*t->K) +
249: c->G*t->C + c->H*t->G + c->I*t->K;
250: nc.J = (c->A*t->D*t->D + c->B*t->H*t->H + c->C*t->L*t->L) +
251: (c->D*t->D*t->H + c->E*t->H*t->L + c->F*t->D*t->L) +
252: c->G*t->D + c->H*t->H + c->I*t->L +
253: c->J;
254: return nc;
255: }
256: Plane
257: trans_plane(t, p)
258: register Transform *t;
259: register Plane *p;
260: {
261: Plane np;
262: np.type = 2;
263: np.A = p->A*t->A + p->B*t->E + p->C*t->I;
264: np.B = p->A*t->B + p->B*t->F + p->C*t->J;
265: np.C = p->A*t->C + p->B*t->G + p->C*t->K;
266: np.D = p->A*t->D + p->B*t->H + p->C*t->L + p->D;
267: return np;
268: }
269: Point
270: trans_point(t, p)
271: register Transform *t;
272: register Point *p;
273: {
274: Point np;
275: np.type = 1;
276: np.x = t->A*p->x + t->B*p->y + t->C*p->z + t->D;
277: np.y = t->E*p->x + t->F*p->y + t->G*p->z + t->H;
278: np.z = t->I*p->x + t->J*p->y + t->K*p->z + t->L;
279: return np;
280: }
281: do_transform(tp, list)
282: Tpair *tp;
283: register List *list;
284: {
285: if (!list)
286: return;
287: switch (list->type) {
288: case 1:
289: if (((Point *)list)->stamp == tp->stamp)
290: return;
291: *((Point *)list) = trans_point(&tp->t, ((Point *)list));
292: ((Point *)list)->stamp = tp->stamp;
293: return;
294: case 3:
295: if (((Conic *)list)->stamp == tp->stamp)
296: return;
297: *((Conic *)list) = trans_conic(&tp->tinv, ((Conic *)list));
298: ((Conic *)list)->stamp = tp->stamp;
299: return;
300: case 2:
301: if (((Plane *)list)->stamp == tp->stamp)
302: return;
303: *((Plane *)list) = trans_plane(&tp->tinv, ((Plane *)list));
304: ((Plane *)list)->stamp = tp->stamp;
305: return;
306: case 5:
307: do_transform(tp, list->car.list);
308: do_transform(tp, list->cdr);
309: return;
310: case 7:
311: do_transform(tp, ((Ctree *)list)->car);
312: do_transform(tp, ((Ctree *)list)->cdr);
313: return;
314: case 4:
315: do_transform(tp, ((View *)list)->viewpoint);
316: do_transform(tp, ((View *)list)->ul_corner);
317: do_transform(tp, ((View *)list)->ll_corner);
318: do_transform(tp, ((View *)list)->lr_corner);
319: do_transform(tp, ((View *)list)->screen);
320: do_transform(tp, ((View *)list)->tpair);
321: return;
322: case 6:
323: do_transform(tp, ((Object *)list)->surface);
324: do_transform(tp, ((Object *)list)->cover);
325: do_transform(tp, ((Object *)list)->references);
326: do_transform(tp, ((Object *)list)->ctree);
327: do_transform(tp, ((Object *)list)->tpair);
328: do_transform(tp, ((Object *)list)->center);
329: return;
330: case 8:
331: if (((Tpair *)list)->stamp == tp->stamp)
332: return;
333: ((Tpair *)list)->t = trans_product(&tp->t, &((Tpair *)list)->t);
334: ((Tpair *)list)->tinv = trans_product(&((Tpair *)list)->tinv, &tp->tinv);
335: ((Tpair *)list)->stamp = tp->stamp;
336: }
337: return;
338: }
339: translate(x, y, z, list)
340: double x, y, z;
341: List *list;
342: {
343: Tpair tp;
344: tp.stamp = transform_stamp++;
345: tp.type = 8;
346: tp.t = tnull;
347: tp.t.A = 1.0;
348: tp.t.F = 1.0;
349: tp.t.K = 1.0;
350: tp.t.D = x;
351: tp.t.H = y;
352: tp.t.L = z;
353: tp.tinv = tp.t;
354: tp.tinv.D = -x;
355: tp.tinv.H = -y;
356: tp.tinv.L = -z;
357: do_transform(&tp, list);
358: }
359: stretch(x, y, z, list)
360: double x, y, z;
361: List *list;
362: {
363: Tpair tp;
364: tp.stamp = transform_stamp++;
365: tp.type = 8;
366: tp.t = tnull;
367: tp.t.A = x;
368: tp.t.F = y;
369: tp.t.K = z;
370: tp.tinv = tnull;
371: tp.tinv.A = 1.0/x;
372: tp.tinv.F = 1.0/y;
373: tp.tinv.K = 1.0/z;
374: do_transform(&tp, list);
375: }
376: rotateX(theta, list)
377: double theta;
378: List *list;
379: {
380: Tpair tp;
381: tp.stamp = transform_stamp++;
382: tp.type = 8;
383: theta = theta * 0.0174532925199432957692 ;
384: tp.t = tnull;
385: tp.t.A = 1.0;
386: tp.t.F = cos(theta);
387: tp.t.G = -sin(theta);
388: tp.t.J = -tp.t.G;
389: tp.t.K = tp.t.F;
390: tp.tinv = tp.t;
391: tp.tinv.G = -tp.tinv.G;
392: tp.tinv.J = -tp.tinv.J;
393: do_transform(&tp, list);
394: }
395: rotateY(theta, list)
396: double theta;
397: List *list;
398: {
399: Tpair tp;
400:
401:
402: tp.stamp = transform_stamp++;
403: tp.type = 8;
404: theta = theta * 0.0174532925199432957692 ;
405: tp.t = tnull;
406: tp.t.F = 1.0;
407: tp.t.A = cos(theta);
408: tp.t.C = -sin(theta);
409: tp.t.I = -tp.t.C;
410: tp.t.K = tp.t.A;
411: tp.tinv = tp.t;
412: tp.tinv.C = -tp.tinv.C;
413: tp.tinv.I = -tp.tinv.I;
414: do_transform(&tp, list);
415: }
416: rotateZ(theta, list)
417: double theta;
418: List *list;
419: {
420: Tpair tp;
421:
422:
423: tp.stamp = transform_stamp++;
424: tp.type = 8;
425: theta = theta * 0.0174532925199432957692 ;
426: tp.t = tnull;
427: tp.t.K = 1.0;
428: tp.t.A = cos(theta);
429: tp.t.B = -sin(theta);
430: tp.t.E = -tp.t.B;
431: tp.t.F = tp.t.A;
432: tp.tinv = tp.t;
433: tp.tinv.B = -tp.tinv.B;
434: tp.tinv.E = -tp.tinv.E;
435: do_transform(&tp, list);
436: }
437: Conic
438: tangent_cone(p, c)
439: register Point *p;
440: register Conic *c;
441: {
442: Conic e;
443: double f4, fx, fy, fz, fw;
444:
445: f4 = (p->x*(c->A*p->x + c->D*p->y + c->F*p->z + c->G) +
446: p->y*(c->B*p->y + c->E*p->z + c->H) +
447: p->z*(c->C*p->z + c->I) + c->J) * 4.0;
448: e.A = f4*c->A;
449: e.B = f4*c->B;
450: e.C = f4*c->C;
451: e.D = f4*c->D;
452: e.E = f4*c->E;
453: e.F = f4*c->F;
454: e.G = f4*c->G;
455: e.H = f4*c->H;
456: e.I = f4*c->I;
457: e.J = f4*c->J;
458:
459: fx = 2.0*c->A*p->x + c->D*p->y + c->F*p->z + c->G;
460: fy = 2.0*c->B*p->y + c->D*p->x + c->E*p->z + c->H;
461: fz = 2.0*c->C*p->z + c->E*p->y + c->F*p->x + c->I;
462: fw = 2.0*c->J + c->G*p->x + c->H*p->y + c->I*p->z;
463:
464: e.A -= fx*fx;
465: e.B -= fy*fy;
466: e.C -= fz*fz;
467: e.J -= fw*fw;
468: e.D -= 2.0*fx*fy;
469: e.E -= 2.0*fy*fz;
470: e.F -= 2.0*fz*fx;
471: e.G -= 2.0*fx*fw;
472: e.H -= 2.0*fy*fw;
473: e.I -= 2.0*fz*fw;
474: return e;
475: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.