![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sdraw.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / pmsdk / samples / shapes|
Return to sdraw.c CVS log | Up to [OS/2 SDKs] / pmsdk / samples / shapes |
1.1 root 1: /*--------------------------------------------------------*\
2: SDRAW.C - 3D to 2D transformations and draw routines
3: \*--------------------------------------------------------*/
4:
5: #include <stddef.h>
6: #include <os2.h>
7: #include <math.h>
8: #include "sstruct.h"
9:
10: extern SHAPE rgshape [];
11:
12: POINT3D pt3FillBuffer [MAX_POINTS];
13:
14: extern INT yPelAdjust;
15:
16:
17: /*
18: * ScalePoint:
19: * - replace destination point by source point after scaling
20: */
21:
22: VOID ScalePoint (
23: POINT3D *ppt3Source,
24: POINT3D *ppt3Dest,
25: LONG iScale )
26: {
27: ppt3Dest->x = (INT) ( ((LONG) ppt3Source->x * iScale) >> 6 );
28: ppt3Dest->y = (INT) ( ((LONG) ppt3Source->y * iScale) >> 6 );
29: ppt3Dest->z = (INT) ( ((LONG) ppt3Source->z * iScale) >> 6 );
30: }
31:
32:
33: /*
34: * ChangeScale:
35: * - to be called after a window changes size
36: * - scales a shape's appropriate variables for the new size
37: * - the centre of the window indicates the new window size
38: */
39:
40: extern VOID ChangeScale (
41: PSV psv )
42: {
43: LONG xScale = psv->ptCentre.x;
44: LONG yScale = (psv->ptCentre.y << 10) / yPelAdjust;
45: LONG iScale = (xScale > yScale) ? yScale : xScale;
46: INIT *pinit = rgshape [psv->iShape].pinit;
47:
48: if (iScale < MIN_SCALE)
49: {
50: /* set lower bound on the scale of a shape */
51:
52: iScale = MIN_SCALE;
53: }
54:
55: /* scale the initial size of the shape */
56:
57: ScalePoint (&pinit->pt3SizeMid, &psv->pt3Size, iScale);
58: psv->pt3SizeMid = psv->pt3Size;
59:
60: /* scale the magnitude of the sinusoidal size change */
61:
62: ScalePoint (&pinit->pt3SizeMag, &psv->pt3SizeMag, iScale);
63:
64: /* scale the viewing distance */
65: /* (so that perspective is independent of window size) */
66:
67: psv->zViewDist = pinit->zViewDist * iScale;
68: }
69:
70:
71: /*
72: * lSin:
73: * - fast integer sine function with granularity of 1 degree
74: * - constraint: -360 <= angle <= 360
75: * - returns the sine of an angle * 16384 (shifted left by 14)
76: */
77:
78: LONG lSin(
79: INT iAngle )
80: {
81: static INT iSinTable [91] =
82: { 0, 286, 572, 857, 1143, 1428, 1713, 1997, 2280, 2563, 2845, 3126,
83: 3406, 3686, 3964, 4240, 4516, 4790, 5063, 5334, 5604, 5872, 6138,
84: 6402, 6664, 6924, 7182, 7438, 7692, 7943, 8192, 8438, 8682, 8923,
85: 9162, 9397, 9630, 9860, 10087, 10311, 10531, 10749, 10963, 11174,
86: 11381, 11585, 11786, 11982, 12176, 12365, 12551, 12733, 12911, 13085,
87: 13255, 13421, 13583, 13741, 13894, 14044, 14189, 14330, 14466, 14598,
88: 14726, 14849, 14968, 15082, 15191, 15296, 15396, 15491, 15582, 15668,
89: 15749, 15826, 15897, 15964, 16026, 16083, 16135, 16182, 16225, 16262,
90: 16294, 16322, 16344, 16362, 16374, 16382, 16384 };
91:
92: if (iAngle < 0)
93: iAngle += 360;
94:
95: if (iAngle < 180)
96: if (iAngle < 90)
97: return( (LONG) iSinTable [iAngle] );
98: else
99: return( (LONG) iSinTable [180 - iAngle] );
100: else
101: if (iAngle < 270)
102: return( (LONG) -iSinTable [iAngle - 180] );
103: else
104: return( (LONG) -iSinTable [360 - iAngle] );
105: }
106:
107:
108: /*
109: * iAngleAdd (macro):
110: * - adds the second angle to first angle
111: * - stores result (which is in range 0 to 359) in the first angle
112: */
113:
114: #define iAngleAdd( iA1,iA2) \
115: if ( ((iA1) += (iA2)) < 0 ) (iA1) += 360; \
116: else if ( (iA1) >= 360 ) (iA1) -= 360;
117:
118:
119: /*
120: * AddToAngle:
121: * - adds the 3D angular velocity to the 3D angle
122: */
123:
124: VOID AddToAngle(
125: POINT3D *ppt3Angle,
126: POINT3D *ppt3AngVel )
127: {
128: iAngleAdd (ppt3Angle->x, ppt3AngVel->x)
129: iAngleAdd (ppt3Angle->y, ppt3AngVel->y)
130: iAngleAdd (ppt3Angle->z, ppt3AngVel->z)
131: }
132:
133:
134: /*
135: * CalcSize:
136: * - calculates the new size for sinusoidal size variation
137: * ie. <size> = <middle> + <magnitude> * SIN (<angle>)
138: */
139:
140: VOID CalcSize(
141: POINT3D *ppt3Size,
142: POINT3D *ppt3SizeMid,
143: POINT3D *ppt3SizeMag,
144: POINT3D *ppt3SizeAng )
145: {
146: ppt3Size->x = ppt3SizeMid->x +
147: (INT) (ppt3SizeMag->x * lSin( ppt3SizeAng->x ) >> 14);
148: ppt3Size->y = ppt3SizeMid->y +
149: (INT) (ppt3SizeMag->y * lSin( ppt3SizeAng->y ) >> 14);
150: ppt3Size->z = ppt3SizeMid->z +
151: (INT) (ppt3SizeMag->z * lSin( ppt3SizeAng->z ) >> 14);
152: }
153:
154:
155: /*
156: * CalcPoints:
157: * - transform the 3D points to 2D points
158: * - transformation includes:
159: * a) scaling points
160: * b) rotating points around x/y/z axis
161: * c) perspective transformation
162: * d) translating to centre of window
163: */
164:
165: VOID CalcPoints (
166: PSV psv,
167: INT cPoints,
168: POINT3D rgpt3 [],
169: POINTL rgpt [] )
170: {
171: LONG sinx = lSin( psv->pt3Angle.x );
172: LONG cosx = lSin((psv->pt3Angle.x + 90) % 360 );
173: LONG siny = lSin( psv->pt3Angle.y );
174: LONG cosy = lSin((psv->pt3Angle.y + 90) % 360 );
175: LONG sinz = lSin( psv->pt3Angle.z );
176: LONG cosz = lSin((psv->pt3Angle.z + 90) % 360 );
177: LONG x, y, z, x2, y2, z2;
178: LONG z0 = psv->zViewDist;
179: INT i;
180: LONG xSize = psv->pt3Size.x;
181: LONG ySize = psv->pt3Size.y;
182: LONG zSize = psv->pt3Size.z;
183:
184: for( i=0; i < cPoints; i++ )
185: {
186: /* scale points relative to x/y/z axis of shape */
187:
188: x = (LONG) rgpt3 [i].x * xSize;
189: y = (LONG) rgpt3 [i].y * ySize;
190: z = (LONG) rgpt3 [i].z * zSize;
191:
192: /* rotate around X axis */
193:
194: y2 = ( y * cosx - z * sinx ) >> 14;
195: z2 = ( z * cosx + y * sinx ) >> 14;
196:
197: /* rotate around Y axis */
198:
199: z = ( z2 * cosy - x * siny ) >> 14;
200: x2 = ( x * cosy + z2 * siny ) >> 14;
201:
202: /* rotate around Z axis */
203:
204: x = ( x2 * cosz - y2 * sinz ) >> 14;
205: y = ( y2 * cosz + x2 * sinz ) >> 14;
206:
207: if (psv->fShaded)
208: {
209: /* store points used for shading */
210: /* (before perspective - light source is at infinity) */
211:
212: pt3FillBuffer [i].x = (INT) (x >> 8);
213: pt3FillBuffer [i].y = (INT) (y >> 8);
214: pt3FillBuffer [i].z = (INT) (z >> 8);
215: }
216:
217: if (psv->fPerspective)
218: {
219: /* avoid overflow when doing perspective */
220:
221: x = (x * (z0 >> 6)) / ((z0 - z) >> 6);
222: y = (y * (z0 >> 6)) / ((z0 - z) >> 6);
223: }
224:
225: /* store translated points in 2D table */
226: /* note: points must be rescaled to fit in window */
227:
228: rgpt [i].x = (x >> 8) + psv->ptCentre.x;
229: rgpt [i].y = (( (y >> 8) * yPelAdjust ) >> 10) + psv->ptCentre.y;
230: }
231: }
232:
233:
234: /*
235: * DrawLines:
236: * - draws a shape using the lines of the object (clipping off)
237: */
238:
239: VOID DrawLines (
240: HPS hps,
241: LINE rgline [],
242: POINTL rgpt [] )
243: {
244: INT i;
245: INT iPoint1, iPoint2 = -1;
246:
247: for( i=0; (iPoint1 = rgline [i].p1) >= 0; i++ )
248: {
249: if (iPoint1 != iPoint2)
250: {
251: GpiSetCurrentPosition( hps, &rgpt [iPoint1] );
252: }
253: iPoint2 = rgline [i].p2;
254: GpiLine( hps, &rgpt [iPoint2] );
255: }
256: }
257:
258:
259: /*
260: * DrawFaces:
261: * - draws a shape using the faces of the object (clipping on)
262: */
263:
264: VOID DrawFaces (
265: HPS hps,
266: FACE rgface [],
267: POINTL rgpt [] )
268: {
269: INT i = 0;
270: INT iEndFace, cSpread;
271: INT iPoint1, iPoint2, iPoint3;
272: LONG xV1, yV1, xV2, yV2;
273: LONG zNormal;
274:
275: iPoint1 = rgface [i++];
276: do
277: {
278: /* get 3 points spread out on surface */
279:
280: iEndFace = i;
281: while (rgface [iEndFace++] >= 0)
282: ;
283: cSpread = iEndFace - i + 1;
284:
285: if (cSpread > 5)
286: {
287: cSpread /= 3;
288: iPoint2 = rgface [i - 1 + cSpread];
289: iPoint3 = rgface [i - 1 + 2 * cSpread];
290: }
291: else
292: {
293: iPoint2 = rgface [i];
294: iPoint3 = rgface [i + 1];
295: }
296:
297: /* calculate z coordinate of normal (using 3 points on surface) */
298:
299: xV1 = rgpt [iPoint3].x - rgpt [iPoint2].x;
300: yV1 = rgpt [iPoint3].y - rgpt [iPoint2].y;
301: xV2 = rgpt [iPoint1].x - rgpt [iPoint2].x;
302: yV2 = rgpt [iPoint1].y - rgpt [iPoint2].y;
303: zNormal = xV1 * yV2 - yV1 * xV2;
304:
305: if (zNormal > 0)
306: {
307: /* face is pointing towards the user */
308:
309: /* draw the perimeter of the face */
310:
311: GpiSetCurrentPosition( hps, &rgpt [iPoint1] );
312: while (( iPoint2 = rgface [i++] ) >= 0)
313: GpiLine( hps, &rgpt [iPoint2] );
314: GpiLine( hps, &rgpt [iPoint1] );
315:
316: while (iPoint2 == -1)
317: {
318: /* draw a pattern associated with the face */
319:
320: iPoint1 = rgface [i++];
321: GpiSetCurrentPosition( hps, &rgpt [iPoint1] );
322: while ((iPoint2 = rgface [i++] ) >= 0)
323: GpiLine( hps, &rgpt [iPoint2] );
324: }
325: }
326: else
327: /* face is not visible - skip over it */
328:
329: while (rgface [i++] >= -1)
330: ;
331: }
332: while (( iPoint1 = rgface [i++] ) >= 0);
333: }
334:
335:
336: /*
337: * ChangeShapePosition:
338: * - calculate 2D points for new position
339: * - blank out old position
340: * - draw in new position
341: */
342:
343: extern VOID ChangeShapePosition (
344: PSV psv )
345: {
346: HPS hps;
347: POINTL *pptTemp;
348: SHAPE *pshape = &rgshape [psv->iShape];
349: OBJECT *pobject = pshape->pobject;
350:
351: if (psv->fVarySize)
352: {
353: /* vary the size */
354:
355: AddToAngle (&psv->pt3SizeAng, &pshape->pinit->pt3SizeVel );
356: CalcSize (&psv->pt3Size, &psv->pt3SizeMid,
357: &psv->pt3SizeMag, &psv->pt3SizeAng );
358: }
359:
360: /* rotate */
361:
362: AddToAngle (&psv->pt3Angle, &psv->pt3AngVel );
363:
364: /* calculate new position */
365:
366: CalcPoints (psv, pobject->cPoints, pobject->rgpt3, psv->rgptNew );
367:
368: hps = psv->hpsClient;
369:
370: /* blank out old position */
371:
372: if (psv->fErased)
373: psv->fErased = FALSE;
374: else
375: {
376: GpiSetColor (hps, CLR_WHITE);
377: if (psv->fClipping)
378: DrawFaces (hps, pobject->rgface, psv->rgptOld );
379: else
380: DrawLines (hps, pobject->rgline, psv->rgptOld );
381: }
382:
383: /* draw at new position */
384:
385: GpiSetColor (hps, CLR_BLACK);
386: if (psv->fClipping)
387: DrawFaces (hps, pobject->rgface, psv->rgptNew );
388: else
389: DrawLines (hps, pobject->rgline, psv->rgptNew );
390:
391: /* swap 2D points buffers - new becomes old */
392:
393: pptTemp = psv->rgptOld;
394: psv->rgptOld = psv->rgptNew;
395: psv->rgptNew = pptTemp;
396: }
397:
398:
399: VOID DrawAndFill (
400: PSV psv )
401: {
402: HPS hps = psv->hpsClient;
403: OBJECT *pobject = rgshape [psv->iShape].pobject;
404: FACE *rgface = pobject->rgface;
405: POINTL *rgpt = psv->rgptNew;
406: INT i = 0;
407: INT iEndFace, cSpread;
408: INT iPoint1, iPoint2, iPoint3;
409: LONG xV1, yV1, zV1, xV2, yV2, zV2;
410: LONG iDiv;
411: LONG xN, yN, zN;
412: LONG zNormal;
413: LONG sinx = lSin( psv->pt2LightAng.x );
414: LONG cosx = lSin((psv->pt2LightAng.x + 90) % 360 );
415: LONG siny = lSin( psv->pt2LightAng.y );
416: LONG cosy = lSin((psv->pt2LightAng.y + 90) % 360 );
417: POINTL pt;
418:
419: CalcPoints (psv, pobject->cPoints, pobject->rgpt3, rgpt );
420:
421: GpiSavePS (hps);
422: GpiCreateLogColorTable (hps, LCOL_RESET, LCOLF_RGB, 0L, 0L, NULL);
423:
424: iPoint1 = rgface [i++];
425: do
426: {
427: /* get 3 points spread out on surface */
428:
429: iEndFace = i;
430: while (rgface [iEndFace++] >= 0)
431: ;
432: cSpread = iEndFace - i + 1;
433:
434: if (cSpread > 5)
435: {
436: cSpread /= 3;
437: iPoint2 = rgface [i - 1 + cSpread];
438: iPoint3 = rgface [i - 1 + 2 * cSpread];
439: }
440: else
441: {
442: iPoint2 = rgface [i];
443: iPoint3 = rgface [i + 1];
444: }
445:
446: /* calculate z coordinate of normal (using 3 points on surface) */
447:
448: xV1 = rgpt [iPoint3].x - rgpt [iPoint2].x;
449: yV1 = rgpt [iPoint3].y - rgpt [iPoint2].y;
450: xV2 = rgpt [iPoint1].x - rgpt [iPoint2].x;
451: yV2 = rgpt [iPoint1].y - rgpt [iPoint2].y;
452: zNormal = xV1 * yV2 - yV1 * xV2;
453:
454: if (zNormal > 0)
455: {
456: /* face is pointing towards the user */
457:
458: /* normalize vectors */
459:
460: xV1 = pt3FillBuffer [iPoint3].x - pt3FillBuffer [iPoint2].x;
461: yV1 = pt3FillBuffer [iPoint3].y - pt3FillBuffer [iPoint2].y;
462: zV1 = pt3FillBuffer [iPoint3].z - pt3FillBuffer [iPoint2].z;
463:
464: xV2 = pt3FillBuffer [iPoint1].x - pt3FillBuffer [iPoint2].x;
465: yV2 = pt3FillBuffer [iPoint1].y - pt3FillBuffer [iPoint2].y;
466: zV2 = pt3FillBuffer [iPoint1].z - pt3FillBuffer [iPoint2].z;
467:
468: iDiv = (LONG) sqrt ((double) (xV1 * xV1 + yV1 * yV1 + zV1 * zV1) );
469: xV1 = (xV1 << 10) / iDiv;
470: yV1 = (yV1 << 10) / iDiv;
471: zV1 = (zV1 << 10) / iDiv;
472:
473: iDiv = (LONG) sqrt ((double) (xV2 * xV2 + yV2 * yV2 + zV2 * zV2) );
474: xV2 = (xV2 << 10) / iDiv;
475: yV2 = (yV2 << 10) / iDiv;
476: zV2 = (zV2 << 10) / iDiv;
477:
478: /* calculate normal to surface */
479:
480: xN = (yV1 * zV2 - zV1 * yV2) >> 10;
481: yN = (zV1 * xV2 - xV1 * zV2) >> 10;
482: zN = (xV1 * yV2 - yV1 * xV2) >> 10;
483:
484: /* rotate normal around X and Y axes */
485:
486: zN = ( zN * cosx + xN * sinx ) >> 14;
487: zN = ( zN * cosy + yN * siny ) >> 14;
488:
489: /* change range of zNormal from [0,1023] to [128,255] */
490:
491: zNormal = zN >> 3;
492: if (zNormal < 0)
493: zNormal = 0;
494: else if (zNormal > 127)
495: zNormal = 127;
496: zNormal += 128;
497:
498: GpiSetColor (hps, zNormal);
499:
500: /* draw the perimeter of the face */
501:
502: GpiBeginArea (hps, BA_NOBOUNDARY | BA_ALTERNATE);
503:
504: GpiSetCurrentPosition( hps, &rgpt [iPoint1] );
505: while (( iPoint2 = rgface [i++] ) >= 0)
506: GpiLine( hps, &rgpt [iPoint2] );
507: GpiLine( hps, &rgpt [iPoint1] );
508:
509: GpiEndArea (hps);
510:
511: GpiSetColor (hps, zNormal << 16 );
512:
513: while (iPoint2 == -1)
514: {
515: /* draw a pattern associated with the face */
516:
517: iPoint1 = rgface [i++];
518: GpiSetCurrentPosition( hps, &rgpt [iPoint1] );
519: while ((iPoint2 = rgface [i++] ) >= 0)
520: GpiLine( hps, &rgpt [iPoint2] );
521: }
522: }
523: else
524: /* face is not visible - skip over it */
525:
526: while (rgface [i++] >= -1)
527: ;
528: }
529: while (( iPoint1 = rgface [i++] ) >= 0);
530:
531: GpiRestorePS (hps, -1L);
532: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.