![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to BoinkViewPart.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / Backspace|
Return to BoinkViewPart.m CVS log | Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / Backspace |
1.1 root 1: // BoinkViewPart.m
2: //
3: // implements a bouncing ball screen saver view
4: //
5: // You may freely copy, distribute, and reuse the code in this example.
6: // NeXT disclaims any warranty of any kind, expressed or implied, as to its
7: // fitness for any particular use.
8:
9:
10: #import "BoinkViewPart.h"
11: #import "SpaceView.h"
12: #import "Thinker.h"
13: #import "BoinkWraps.h"
14: #import <appkit/NXImage.h>
15: #import <math.h>
16: #import <libc.h>
17: #import <dpsclient/wraps.h>
18:
19: @implementation BoinkView
20:
21: // assumed interval in milliseconds
22: #define ASSUMED_INTERVAL 35
23:
24: #define WIDTH 100
25: #define HEIGHT 100
26: #define GAP 4
27: #define COUNT 10
28: #define ACCEL (-2)
29: #define REBOUND (-1.3)
30:
31: // This screen height value is not critical, though it will be used
32: // to determine how high the ball can go
33: #define SCREEN_HEIGHT 832
34: #define LAUNCH_SPEED (sqrt(fabs(2*ACCEL*(SCREEN_HEIGHT - HEIGHT))))
35: #define REAL_LAUNCH_SPEEd (sqrt(fabs(2*accel*(viewHeight - HEIGHT))))
36:
37: #define MIN_X_SPEED (3)
38: #define MAX_X_SPEED (6)
39: #define ABS_MAX_X_SPEED (6)
40: #define MAX_Y_SPEED (LAUNCH_SPEED + 20)
41:
42: #define BUFFER_WIDTH (WIDTH + ABS_MAX_X_SPEED + 1)
43: #define BUFFER_HEIGHT (HEIGHT + MAX_Y_SPEED + 1)
44:
45:
46:
47: /* move the ball to its new bounce position */
48: - oneStep
49: {
50: NXRect black = {0,0,0,0};
51: NXRect ballRect;
52: BRECT new;
53: float scaledTime, calcYpos;
54:
55: then = now;
56: now = currentTimeInMs();
57:
58: /* calculate new ball x position */
59: xpos += [self timeCorrectedXSpeed];
60:
61: if (xpos < 0) /* ball hit left edge */
62: { xspeed = -xspeed;
63: if (viewWidth > WIDTH)
64: { spinDir = -spinDir;
65: }
66: xpos = 0;
67: }
68: else if (xpos > (viewWidth - WIDTH)) /* ball hit right edge */
69: { if (viewWidth > WIDTH)
70: {
71: xspeed = -[self getRandomXspeed];
72: [self checkXspeed:&xspeed];
73: xpos = (viewWidth - WIDTH);
74: }
75: else
76: { xspeed = xpos = 0;
77: }
78: }
79:
80:
81: scaledTime = ((float)(now - then) / ASSUMED_INTERVAL);
82: if (scaledTime > 1) scaledTime = 1;
83:
84: // calculate new ball vertical position
85: calcYpos = ypos + (scaledTime*yspeed) + ((accel * scaledTime * scaledTime)/2);
86:
87: // change vertical ball speed to simulate gravity
88: yspeed += (accel * scaledTime);
89:
90: if (calcYpos < (ypos - MAX_Y_SPEED)) calcYpos = ypos - MAX_Y_SPEED;
91: else if (calcYpos > (ypos + MAX_Y_SPEED)) calcYpos = ypos + MAX_Y_SPEED;
92:
93: ypos = calcYpos;
94:
95: if (yspeed < -MAX_Y_SPEED) yspeed = -MAX_Y_SPEED;
96:
97:
98: if (ypos <= 0) /* ball hit bottom of window */
99: {
100: ypos = 0;
101:
102: if (viewHeight > HEIGHT)
103: {
104: if (reboundMode == DECREASING)
105: {
106: yspeed = lastLaunchSpeed = lastLaunchSpeed + rebound;
107: }
108: else
109: {
110: yspeed = lastLaunchSpeed = lastLaunchSpeed - (2*rebound);
111: }
112:
113: if (yspeed <= 0)
114: {
115: yspeed = 0;
116: reboundMode = INCREASING; /* bounce height increases every bounce */
117: }
118: else if (yspeed > MAX_Y_SPEED) yspeed = MAX_Y_SPEED - (3*accel);
119: }
120: else yspeed = 0;
121:
122: }
123: else if (ypos >= (viewHeight - HEIGHT)) /* ball hit top of window */
124: { if (viewHeight > HEIGHT)
125: {
126: yspeed = accel;
127: ypos = (viewHeight - HEIGHT);
128: reboundMode = DECREASING; /* bounce height decreases every bounce */
129: spinDir = -spinDir;
130: }
131: else
132: { yspeed = ypos = 0;
133: }
134: }
135:
136:
137: /* rotate the ball by selecting a new ball image to blit */
138: /* we have an image of the ball in 10 different stages of rotation */
139:
140: [self incrementBallNumber];
141:
142: new.l = floor(xpos);
143: new.b = floor(ypos);
144: new.r = new.l + WIDTH;
145: new.t = new.b + HEIGHT;
146:
147: ballRect.origin.x = (WIDTH+GAP) * ballNum;
148: ballRect.origin.y = 0;
149: ballRect.size.width = WIDTH;
150: ballRect.size.height = HEIGHT;
151:
152: redrawTo.x = MIN(new.l, old.l);
153: redrawTo.y = MIN(new.b, old.b);
154:
155: redraw.origin.x = 0;
156: redraw.origin.y = 0;
157: redraw.size.width = (MAX(new.r, old.r)) - redrawTo.x + 1;
158: redraw.size.height = (MAX(new.t, old.t)) - redrawTo.y + 1;
159:
160: black.size= redraw.size;
161:
162: [self updateGrid];
163:
164: [buffer lockFocus];
165: PSsetgray(0);
166: NXRectFill(&black);
167:
168: ballTo.x = new.l - redrawTo.x;
169: ballTo.y = new.b - redrawTo.y;
170:
171: [self drawLinesInBuffer];
172:
173: [balls composite:NX_SOVER fromRect:&ballRect toPoint:&ballTo];
174: [buffer unlockFocus];
175:
176:
177: // Now bring it onto the screen
178:
179: [buffer composite:NX_COPY fromRect:&redraw toPoint:&redrawTo];
180:
181: old = new;
182:
183: return self;
184: }
185:
186:
187:
188: /* calculate a vertical launch speed which will get the ball almost to */
189: /* the top of the window before gravity pulls it back down. Little bit */
190: /* of physics lesson here... */
191:
192: - newSpeed
193: {
194: lastLaunchSpeed = yspeed = REAL_LAUNCH_SPEEd;
195: if (yspeed > MAX_Y_SPEED) yspeed = MAX_Y_SPEED;
196: xpos = 0;
197: ypos = 0;
198:
199: if (viewWidth <= WIDTH) xspeed = 0;
200: else xspeed = [self getRandomXspeed];
201:
202: [self checkXspeed:&xspeed];
203: rebound = REBOUND;
204: return self;
205: }
206:
207:
208: - initFrame:(const NXRect *)frameRect
209: {
210: NXRect black = {0, 0, BUFFER_WIDTH, BUFFER_HEIGHT };
211:
212: [super initFrame:frameRect];
213: [self allocateGState]; // For faster lock/unlockFocus
214: [self setClipping:NO]; // even faster...
215:
216: accel = ACCEL;
217: spinDir = 1;
218:
219: //in this case, I only need one buffer for several Views
220: if (!(buffer = [NXImage findImageNamed:"boinkBuffer"]))
221: {
222: buffer = [[NXImage alloc] initSize:&black.size];
223: [buffer setName:"boinkBuffer"];
224: }
225:
226: if ([buffer lockFocus])
227: {
228: PSsetgray(0);
229: NXRectFill(&black);
230: [buffer unlockFocus];
231: }
232:
233: balls = [NXImage findImageNamed:"balls"];
234:
235: [self newViewSize];
236:
237: return self;
238: }
239:
240: - setAccel:(float)val
241: {
242: accel = val;
243: return self;
244: }
245:
246: - sizeTo:(NXCoord)width :(NXCoord)height
247: {
248: [super sizeTo:width :height];
249: [self newViewSize];
250: return self;
251: }
252:
253: - drawSelf:(const NXRect *)rects :(int)rectCount
254: {
255: if (!rects || !rectCount) return self;
256:
257: //PSsetgray(0);
258: //NXRectFill(rects);
259:
260: NXRectClip(rects);
261: [self drawGrid];
262:
263: return self;
264: }
265:
266: - newViewSize
267: {
268: int i;
269: //this is called every time View size changes
270: NXRect black = {0, 0, BUFFER_WIDTH, BUFFER_HEIGHT };
271:
272: then = now = currentTimeInMs();
273:
274: if (oldSize.width == bounds.size.width &&
275: oldSize.height == bounds.size.height)
276: return self;
277: else
278: {
279: oldSize.width = bounds.size.width;
280: oldSize.height = bounds.size.height;
281: }
282:
283: old.l = old.r = old.b = old.t = ballTo.x = ballTo.y = 0;
284:
285: viewWidth = bounds.size.width;
286: viewHeight = bounds.size.height;
287: if (viewHeight > SCREEN_HEIGHT) viewHeight = SCREEN_HEIGHT;
288:
289: nvert = viewWidth/130;
290: if (nvert > NVERT) nvert = NVERT;
291: nhoriz = viewHeight/130;
292: if (nhoriz > NHORIZ) nhoriz = NHORIZ;
293:
294: if (viewWidth < WIDTH) nvert = 0;
295: if (viewHeight < HEIGHT) nhoriz= 0;
296: vcount = hcount = 0;
297:
298: for (i=0; i<nvert; i++)
299: {
300: vertLines[i].hue = i * 0.17;
301: while (vertLines[i].hue > 1) vertLines[i].hue -= 1;
302: vertLines[i].pos = floor(i * (viewWidth/nvert));
303: }
304:
305: for (i=0; i<nhoriz; i++)
306: {
307: horizLines[i].hue = i * 0.17 + 0.1;
308: while (horizLines[i].hue > 1) horizLines[i].hue -= 1;
309: horizLines[i].pos = i * floor((viewHeight/nhoriz)) + 1;
310: }
311:
312: if ([buffer lockFocus])
313: {
314: PSsetgray(0);
315: NXRectFill(&black);
316: [buffer unlockFocus];
317: }
318:
319: [self newSpeed];
320: return self;
321: }
322:
323: - incrementBallNumber
324: {
325: if (now > nextRotationTime)
326: {
327: ballNum += spinDir;
328:
329: if (ballNum >= COUNT) ballNum = 0;
330: else if (ballNum < 0) ballNum = COUNT-1;
331: nextRotationTime = now + 24;
332: }
333:
334: return self;
335: }
336:
337: - (float) getRandomXspeed
338: {
339: return randBetween(MIN_X_SPEED, MAX_X_SPEED);
340: }
341:
342: - (float) timeCorrectedXSpeed
343: {
344: float ret = xspeed * ((float)(now - then) / ASSUMED_INTERVAL);
345: [self checkXspeed:&ret];
346: return ret;
347: }
348:
349: - checkXspeed:(float *)speed
350: {
351: if (*speed > MAX_X_SPEED) *speed = MAX_X_SPEED;
352: else if (*speed < -MAX_X_SPEED) *speed = -MAX_X_SPEED;
353: return self;
354: }
355:
356: - (const char *)windowTitle
357: {
358: return "Boink!";
359: }
360:
361:
362: - drawGrid
363: {
364: int i;
365: float *fp;
366:
367: for (i=0; i<nvert; i++)
368: {
369: fp = &vertLines[i].pos;
370: colorLine(*fp, 0, *fp, viewHeight, vertLines[i].hue, 1);
371: }
372:
373: for (i=0; i<nhoriz; i++)
374: {
375: fp = &horizLines[i].pos;
376: colorLine(0, *fp, viewWidth, *fp, horizLines[i].hue, 1);
377: }
378:
379: return self;
380: }
381:
382: - updateGrid
383: {
384: NXRect avoid;
385: float oldPos;
386: float *fp;
387:
388: if (!nvert && !nhoriz) return self;
389:
390: if (now < nextLineDrawTime) return self;
391:
392: nextLineDrawTime = now + 3300;
393:
394: avoid.origin = redrawTo;
395: avoid.size = redraw.size;
396:
397: if (++toggle & 1)
398: {
399: //advance vertical line
400:
401: if (!nvert) return self;
402:
403: fp = &vertLines[vcount].pos;
404: oldPos = *fp;
405: *fp += 1;
406: if (*fp > viewWidth) *fp = 0;
407: vertLines[vcount].hue += 0.005;
408: if (vertLines[vcount].hue > 1) vertLines[vcount].hue -= 1;
409:
410:
411: verticalLineWithAvoidance(*fp, 0, *fp, viewHeight, vertLines[vcount].hue, 1, &avoid);
412: verticalLineWithAvoidance(oldPos, 0, oldPos, viewHeight, 0, 0, &avoid);
413:
414: if (++vcount >= nvert) vcount = 0;
415: }
416: else
417: {
418: //advance horiz line
419:
420: if (!nhoriz) return self;
421:
422: fp = &horizLines[hcount].pos;
423: oldPos = *fp;
424: *fp += 1;
425: if (*fp > viewHeight) *fp = 0;
426: horizLines[hcount].hue += 0.005;
427: if (horizLines[hcount].hue > 1) horizLines[hcount].hue -= 1;
428:
429:
430: horizLineWithAvoidance(0, *fp, viewWidth, *fp, horizLines[hcount].hue, 1, &avoid);
431: horizLineWithAvoidance(0, oldPos, viewWidth, oldPos, 0, 0, &avoid);
432:
433: if (++hcount >= nhoriz) hcount = 0;
434: }
435:
436: return self;
437: }
438:
439: void horizLineWithAvoidance(float x1, float y1, float x2,float y2,
440: float hue,float brightness, const NXRect *r)
441: {
442: if (y1 <= r->origin.y || y1 >= r->origin.y+r->size.height)
443: colorLine(x1, y1, x2, y2, hue, brightness);
444: else
445: {
446: colorLine(x1, y1, r->origin.x, y2, hue, brightness);
447: colorLine(r->origin.x+r->size.width, y1, x2, y2, hue, brightness);
448: }
449: }
450:
451: void verticalLineWithAvoidance(float x1, float y1, float x2,float y2,
452: float hue,float brightness, const NXRect *r)
453: {
454: if (x1 <= r->origin.x || x1 >= r->origin.x+r->size.width)
455: colorLine(x1, y1, x2, y2, hue, brightness);
456: else
457: {
458: colorLine(x1, y1, x2, r->origin.y, hue, brightness);
459: colorLine(x1, r->origin.y+r->size.height, x2, y2, hue, brightness);
460: }
461: }
462:
463: - drawLinesInBuffer
464: {
465: NXRect avoid;
466: int i;
467:
468: avoid.origin = redrawTo;
469: avoid.size = redraw.size;
470:
471: for (i=0; i<nvert; i++)
472: {
473: float x = vertLines[i].pos;
474:
475: if (x >= avoid.origin.x && x <= avoid.origin.x + avoid.size.width)
476: {
477: colorLine(x-redrawTo.x, 0, x-redrawTo.x, avoid.size.height, vertLines[i].hue, 1);
478: }
479: }
480:
481: for (i=0; i<nhoriz; i++)
482: {
483: float y = horizLines[i].pos;
484:
485: if (y >= avoid.origin.y && y <= avoid.origin.y + avoid.size.height)
486: {
487: colorLine(0, y-redrawTo.y, avoid.size.width, y-redrawTo.y, horizLines[i].hue, 1);
488: }
489: }
490:
491: return self;
492: }
493:
494: - inspector:sender
495: {
496: return [sender boinkInspector];
497: }
498:
499:
500:
501: @end
502:
503:
504:
505:
506:
507:
508:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.