Reddit's mobile app loading animation

[FellippeHeitor]

I am a bit obsessed with loading animations (one may have noticed at this point), be them fading dots, bouncing circles, or, in this case, little orbs orbiting a bigger orb.

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(400, 400, 32)
2.  
3. _TITLE "Reddit's mobile app loading animation"
4.  
5. COLOR _RGB32(39, 78, 177)
6. DO
7.     'LINE (0, 0)-(_WIDTH - 1, _HEIGHT - 1), _RGBA32(0, 0, 0, 30), BF
8.     CLS
9.  
10.     CircleFill _WIDTH / 2, _HEIGHT / 2, 35, _DEFAULTCOLOR
11.  
12.     a = a + .05
13.     b = b + .025
14.     IF a > _PI(2) THEN a = _PI(2) - a
15.     IF b > _PI(2) THEN b = _PI(2) - b
16.  
17.     c = 90
18.     FOR i = a TO a - _PI(.85) STEP -.001
19.         PSET (_WIDTH / 2 + COS(i - _PI) * c, _HEIGHT / 2 + SIN(i - _PI) * c)
20.         PSET (_WIDTH / 2 + COS(i) * c, _HEIGHT / 2 + SIN(i) * c)
21.     NEXT
22.     CircleFill _WIDTH / 2 + COS(a - _PI) * c, _HEIGHT / 2 + SIN(a - _PI) * c, 10, _DEFAULTCOLOR
23.     CircleFill _WIDTH / 2 + COS(a) * c, _HEIGHT / 2 + SIN(a) * c, 10, _DEFAULTCOLOR
24.  
25.     d = 180
26.     FOR i = b TO b - _PI(.85) STEP -.001
27.         PSET (_WIDTH / 2 + COS(i - _PI) * d, _HEIGHT / 2 + SIN(i - _PI) * d)
28.         PSET (_WIDTH / 2 + COS(i) * d, _HEIGHT / 2 + SIN(i) * d)
29.     NEXT
30.     CircleFill _WIDTH / 2 + COS(b - _PI) * d, _HEIGHT / 2 + SIN(b - _PI) * d, 20, _DEFAULTCOLOR
31.     CircleFill _WIDTH / 2 + COS(b) * d, _HEIGHT / 2 + SIN(b) * d, 20, _DEFAULTCOLOR
32.  
33.     _DISPLAY
34.     _LIMIT 30
35. LOOP
36.  
37. SUB CircleFill (x AS LONG, y AS LONG, R AS LONG, C AS _UNSIGNED LONG)
38.     DIM x0 AS SINGLE, y0 AS SINGLE
39.     DIM e AS SINGLE
40.  
41.     x0 = R
42.     y0 = 0
43.     e = -R
44.     DO WHILE y0 < x0
45.         IF e <= 0 THEN
46.             y0 = y0 + 1
47.             LINE (x - x0, y + y0)-(x + x0, y + y0), C, BF
48.             LINE (x - x0, y - y0)-(x + x0, y - y0), C, BF
49.             e = e + 2 * y0
50.         ELSE
51.             LINE (x - y0, y - x0)-(x + y0, y - x0), C, BF
52.             LINE (x - y0, y + x0)-(x + y0, y + x0), C, BF
53.             x0 = x0 - 1
54.             e = e - 2 * x0
55.         END IF
56.     LOOP
57.     LINE (x - R, y)-(x + R, y), C, BF
58. END SUB

I like to watch them align from time to time.

[Pete]

Look Mark, more balls. Go get 'em boy!

Pete :D

[STxAxTIC]

That CircleFill routine looks familiar - on the other hand I suppose it *should*, because like the irreducible mousetrap, there really are one, maybe two, correct ways to fill a circle in this language. The thing that interests me right now is the choice of of variable types:

Code: QB64: [Select]

1. SUB CircleFill (x AS LONG, y AS LONG, R AS LONG, C AS _UNSIGNED LONG)
2.     DIM x0 AS SINGLE, y0 AS SINGLE
3.     DIM e AS SINGLE

So the sub takes LONGs for coordinates, but then cooks up helper variables that are SINGLE. Shoudn't these types agree? When you go to compute x-x0 for instance, doesn't the result lose any LONGness that may have been intended? (Not to mention, as a pure numbers thing, LONG has way more precision than is necessary to put color on a screen only few thousand pixels wide at best.)

Not a critique, just wanna make a little smoke.

[FellippeHeitor]

I'll refer you to Vince on that one. He provided me with that code for our (mine and Ashish's) p5js.bas library, so I have no idea what goes there, except it works :-)

[_vince]

vince's circle fill

Code: QB64: [Select]

1. defint a-z
2. sub circlef (x, y, r, c as long)
3.         x0 = r
4.         y0 = 0
5.         e = -r
6.         do while y0 < x0
7.                 if e <= 0 then
8.                         y0 = y0 + 1
9.                         line (x-x0, y+y0)-(x+x0, y+y0), c, bf
10.                         line (x-x0, y-y0)-(x+x0, y-y0), c, bf
11.                         e = e + 2*y0
12.                 else
13.                         line (x-y0, y-x0)-(x+y0, y-x0), c, bf
14.                         line (x-y0, y+x0)-(x+y0, y+x0), c, bf
15.                         x0 = x0 - 1
16.                         e = e - 2*x0
17.                 end if
18.         loop
19.         line (x-r,y)-(x+r,y),c,bf
20. end sub
21.  

[bplus]

That CircleFill routine looks familiar - on the other hand I suppose it *should*, because like the irreducible mousetrap, there really are one, maybe two, correct ways to fill a circle in this language. The thing that interests me right now is the choice of of variable types:

Code: QB64: [Select]

1. SUB CircleFill (x AS LONG, y AS LONG, R AS LONG, C AS _UNSIGNED LONG)
2.     DIM x0 AS SINGLE, y0 AS SINGLE
3.     DIM e AS SINGLE

So the sub takes LONGs for coordinates, but then cooks up helper variables that are SINGLE. Shoudn't these types agree? When you go to compute x-x0 for instance, doesn't the result lose any LONGness that may have been intended? (Not to mention, as a pure numbers thing, LONG has way more precision than is necessary to put color on a screen only few thousand pixels wide at best.)

Not a critique, just wanna make a little smoke.

Smoke this:
IMO State of the art with Circle Fill is this:

Code: QB64: [Select]

1. ' with Steve's EllipseFill, who needs CircleFill?
2. ' Is this fast enough for general circle fill (June 2018):  https://www.qb64.org/forum/index.php?topic=298.msg1942#msg1942
3. '  EllipseFill SMcNeill (Nov 3, 2018) https://www.qb64.org/forum/index.php?topic=755.msg6506#msg6506
4. SUB EllipseFill (cx AS INTEGER, cy AS INTEGER, rx AS INTEGER, ry AS INTEGER, c AS _UNSIGNED LONG)
5.     DIM a AS LONG, b AS LONG
6.     DIM x AS LONG, y AS LONG
7.     DIM xx AS LONG, yy AS LONG
8.     DIM sx AS LONG, sy AS LONG
9.     DIM e AS LONG
10.  
11.     a = 2 * rx * rx
12.     b = 2 * ry * ry
13.     x = rx
14.     xx = ry * ry * (1 - rx - rx)
15.     yy = rx * rx
16.     sx = b * rx
17.  
18.     DO WHILE sx >= sy
19.         LINE (cx - x, cy - y)-(cx + x, cy - y), c, BF
20.         IF y <> 0 THEN LINE (cx - x, cy + y)-(cx + x, cy + y), c, BF
21.  
22.         y = y + 1
23.         sy = sy + a
24.         e = e + yy
25.         yy = yy + a
26.  
27.         IF (e + e + xx) > 0 THEN
28.             x = x - 1
29.             sx = sx - b
30.             e = e + xx
31.             xx = xx + b
32.         END IF
33.     LOOP
34.  
35.     x = 0
36.     y = ry
37.     xx = rx * ry
38.     yy = rx * rx * (1 - ry - ry)
39.     e = 0
40.     sx = 0
41.     sy = a * ry
42.  
43.     DO WHILE sx <= sy
44.         LINE (cx - x, cy - y)-(cx + x, cy - y), c, BF
45.         LINE (cx - x, cy + y)-(cx + x, cy + y), c, BF
46.  
47.         DO
48.             x = x + 1
49.             sx = sx + b
50.             e = e + xx
51.             xx = xx + b
52.         LOOP UNTIL (e + e + yy) > 0
53.  
54.         y = y - 1
55.         sy = sy - a
56.         e = e + yy
57.         yy = yy + a
58.  
59.     LOOP
60.  
61. END SUB

We had a conversation and tests for Circle Fill in June 2018 but then Steve comes up with an Ellipse Fill in November 2018 that turns out to be at least as fast and a more general solution to filled ellipse (including circles), see ref links in code above.

About typing, the parameters are integer but the working variables need to be long (at least) for mult and squaring integers.

Being a ball enthusiast I guess I am the only one that noticed?

[STxAxTIC]

Sure, ellipsefill is better than circlefill for ellipses that aren't tilted, if I read that code correctly. The circlefill codes are by that standard, more general by symmetry argument. Can that handle a rotated filled ellipse? I stand corrected if it can.

[_vince]

but then Steve comes up with an Ellipse Fill in November 2018 that turns out to be at least as fast and a more general solution to filled ellipse (including circles),

That Steve!!!

Some funny stuff:

Code: QB64: [Select]

1. xx = ry * ry * (1 - rx - rx)
2. IF (e + e + xx) > 0 THEN
3.  

That's on a Steve level of ultraoptimization

[bplus]

Sure, ellipsefill is better than circlefill for ellipses that aren't tilted, if I read that code correctly. The circlefill codes are by that standard, more general by symmetry argument. Can that handle a rotated filled ellipse? I stand corrected if it can.

? A circle is a special kind of ellipse, thus I say the ellipse is more general than a circle, like a square is a special case of rectangles which are special cases of quads. (EDIT: I guess I should have said a more general solution to filled circles, not filled ellipses.)

And yes, so far ellipses can't be tilted. Good challenge though!

[bplus]

Code: QB64: [Select]

1.  
2. SCREEN _NEWIMAGE(400, 400, 32)
3.  
4. _TITLE "Loading Animation Ellipse mod" 'B+ mod 2019-02-06
5. ' Fellipe's original: https://www.qb64.org/forum/index.php?topic=1042.0
6.  
7. COLOR _RGBA32(39, 78, 177, 10)
8. c = 100: c1 = 35
9. d = 140: d1 = 180
10. b = _PI(.25)
11. cx = 200: cy = 200
12. DIM k AS _UNSIGNED LONG
13. DO
14.     CLS
15.     FOR r = 20 TO 1 STEP -1
16.         EllipseFill cx, cy, r, r, _RGB32(12 * (25 - r), 12 * (25 - r), 12 * (25 - r))
17.     NEXT
18.  
19.     a = a + .05
20.     b = b + .025
21.     IF a > _PI(2) THEN a = _PI(2) - a
22.     IF b > _PI(2) THEN b = _PI(2) - b
23.  
24.     FOR i = a TO a - _PI(.85) STEP -.001
25.         PSET (cx + COS(i - _PI) * c, cy + SIN(i - _PI) * c1)
26.         PSET (cx + COS(i) * c, cy + SIN(i) * c1)
27.     NEXT
28.     FOR r = 10 TO 1 STEP -1
29.         k = (10 - r) * 25
30.         EllipseFill cx + COS(a - _PI) * c, cy + SIN(a - _PI) * c1, r, r, _RGB32(k, k, 0)
31.         EllipseFill cx + COS(a) * c, cy + SIN(a) * c1, r, r, _RGB32(k, 0, k)
32.     NEXT
33.     FOR i = b TO b - _PI(.85) STEP -.001
34.         PSET (cx + COS(i - _PI) * d, cy + SIN(i - _PI) * d1)
35.         PSET (cx + COS(i) * d, cy + SIN(i) * d1)
36.     NEXT
37.     FOR r = 20 TO 1 STEP -1
38.         k = (20 - r) * 6
39.         EllipseFill cx + COS(b - _PI) * d, cy + SIN(b - _PI) * d1, r, r, _RGB32(0, k, 0)
40.         EllipseFill cx + COS(b) * d, cy + SIN(b) * d1, r, r, _RGB32(k, 0, 0)
41.     NEXT
42.     _DISPLAY
43.     _LIMIT 30
44. LOOP
45.  
46.  
47. ' with Steve's EllipseFill, who needs CircleFill?
48. ' Is this fast enough for general circle fill (June 2018):  https://www.qb64.org/forum/index.php?topic=298.msg1942#msg1942
49. '  EllipseFill SMcNeill (Nov 3, 2018) https://www.qb64.org/forum/index.php?topic=755.msg6506#msg6506
50. SUB EllipseFill (cx AS INTEGER, cy AS INTEGER, rx AS INTEGER, ry AS INTEGER, c AS _UNSIGNED LONG)
51.     DIM a AS LONG, b AS LONG
52.     DIM x AS LONG, y AS LONG
53.     DIM xx AS LONG, yy AS LONG
54.     DIM sx AS LONG, sy AS LONG
55.     DIM e AS LONG
56.  
57.     a = 2 * rx * rx
58.     b = 2 * ry * ry
59.     x = rx
60.     xx = ry * ry * (1 - rx - rx)
61.     yy = rx * rx
62.     sx = b * rx
63.  
64.     DO WHILE sx >= sy
65.         LINE (cx - x, cy - y)-(cx + x, cy - y), c, BF
66.         IF y <> 0 THEN LINE (cx - x, cy + y)-(cx + x, cy + y), c, BF
67.  
68.         y = y + 1
69.         sy = sy + a
70.         e = e + yy
71.         yy = yy + a
72.  
73.         IF (e + e + xx) > 0 THEN
74.             x = x - 1
75.             sx = sx - b
76.             e = e + xx
77.             xx = xx + b
78.         END IF
79.     LOOP
80.  
81.     x = 0
82.     y = ry
83.     xx = rx * ry
84.     yy = rx * rx * (1 - ry - ry)
85.     e = 0
86.     sx = 0
87.     sy = a * ry
88.  
89.     DO WHILE sx <= sy
90.         LINE (cx - x, cy - y)-(cx + x, cy - y), c, BF
91.         LINE (cx - x, cy + y)-(cx + x, cy + y), c, BF
92.  
93.         DO
94.             x = x + 1
95.             sx = sx + b
96.             e = e + xx
97.             xx = xx + b
98.         LOOP UNTIL (e + e + yy) > 0
99.  
100.         y = y - 1
101.         sy = sy - a
102.         e = e + yy
103.         yy = yy + a
104.  
105.     LOOP
106.  
107. END SUB
108.  
109.  

 

Append: Oh! I should report: While creating this mod, I learned that EllipseFill can't take a radius of 0, the routine needs a fix.

[FellippeHeitor]

Cool mod, bplus!

[STxAxTIC]

... and if you want to blow your balls up, run this thing. Download both attachments, and load data-reddit.txt as an argument. (Drop onto Sanctum.exe). While running, press (and hold if you wish) n to witness some destruction. Things don't just blow up and disappear when you do that. They dismantle, particle-by-particle, into a puddle at z=0. If you've got the pilot skills, go blow up the moon and the UFO afterward.

Code: QB64: [Select]

1. $EXEICON:'sanctum.ico'
2. REM $include:'Color32.BI'
3.  
4. ' Video.
5. SCREEN _NEWIMAGE(640, 480, 32)
6. 'SCREEN _NEWIMAGE(800, 600, 32)
7. 'SCREEN _NEWIMAGE(1024, 768, 32)
8. _FULLSCREEN
9. _MOUSEHIDE
10. screenwidth = _WIDTH
11. screenheight = _HEIGHT
12. plotmode = 1
13.  
14. ' Memory.
15. DIM bignumber AS LONG
16. bignumber = 3000000
17. DIM numparticleorig AS LONG
18. numparticleorig = bignumber
19. numparticlevisible = bignumber
20. numgroupvisible = 0
21.  
22. ' Structure to store groups of particles.
23. TYPE GroupElement
24.     Identity AS LONG
25.     Pointer AS LONG
26.     Lagger AS LONG
27.     ContentName AS STRING * 25
28.     FirstParticle AS LONG
29.     LastParticle AS LONG
30.     EventTimer AS LONG
31.     COMx AS SINGLE
32.     COMy AS SINGLE
33.     COMz AS SINGLE
34.     CORx AS SINGLE
35.     CORy AS SINGLE
36.     CORz AS SINGLE
37. END TYPE
38. DIM VectorGroup(bignumber / 10) AS GroupElement
39.  
40. ' Constant(s).
41. pi = 3.1415926536
42. ee = 2.7182818285
43.  
44. ' Camera orientation vectors.
45. DIM uhat(1 TO 3), vhat(1 TO 3), nhat(1 TO 3)
46.  
47. ' Clipping planes.
48. DIM nearplane(1 TO 4), farplane(1 TO 4), rightplane(1 TO 4), leftplane(1 TO 4), topplane(1 TO 4), bottomplane(1 TO 4)
49.  
50. ' Basis vectors defined in xyz three-space.
51. DIM xhat(1 TO 3), yhat(1 TO 3), zhat(1 TO 3)
52. xhat(1) = 1: xhat(2) = 0: xhat(3) = 0
53. yhat(1) = 0: yhat(2) = 1: yhat(3) = 0
54. zhat(1) = 0: zhat(2) = 0: zhat(3) = 1
55.  
56. ' Basis vectors projected in uv two-space.
57. DIM xhatp(1 TO 2), yhatp(1 TO 2), zhatp(1 TO 2)
58.  
59. ' Particle vectors defined in xyz three-space.
60. DIM vecgroupname(bignumber / 10) AS STRING
61. DIM vecorig(numparticleorig, 3)
62. DIM vecorigvel(numparticleorig, 3)
63. DIM vecorigrot(numparticleorig, 3)
64. DIM vecorigacc(numparticleorig, 3)
65. DIM veccolor(numparticleorig) AS LONG
66. DIM vec(numparticleorig, 3)
67. DIM vecvisible(numparticlevisible, 3)
68. DIM vecvisiblecolor(numparticlevisible) AS LONG
69.  
70. ' Particle vectors projected in uv two-space.
71. DIM vecpuv(numparticleorig, 1 TO 2)
72. DIM vecvisiblepuv(numparticlevisible, 1 TO 2)
73.  
74. ' Particle projections adjusted for screen uv two-space.
75. DIM vecpuvs(numparticleorig, 1 TO 2)
76. DIM vecvisiblepuvs(numparticlevisible, 1 TO 2)
77.  
78. ' State.
79. RANDOMIZE TIMER
80. nearplane(4) = 1
81. farplane(4) = -100
82. rightplane(4) = 0 '*' fovd * (nhat(1) * rightplane(1) + nhat(2) * rightplane(2) + nhat(3) * rightplane(3))
83. leftplane(4) = 0
84. topplane(4) = 0
85. bottomplane(4) = 0
86. centerx = screenwidth / 2
87. centery = screenheight / 2
88. fovd = -256
89. numparticleorig = 0
90. numparticlevisible = 0
91. particleindex = 0
92. vecgroupcounter = 0
93. vecgroupindex = 0
94. speeddamp = 1 / 66 ' Rotation damper.
95. speedboost = 1.5 ' Linear boost.
96. timevar = 0
97. 'camx = -42
98. 'camy = 28
99. 'camz = 40
100. camx = 18.69336: camy = 24.12129: camz = 20.24639
101. uhat(1) = -1: uhat(2) = 0: uhat(3) = 0
102. vhat(1) = 0: vhat(2) = 0: vhat(3) = 1
103. 'uhat(1) = -.2078192: uhat(2) = -.9781672: uhat(3) = 0
104. 'vhat(1) = 0: vhat(2) = 0: vhat(3) = 1
105. toggleanimatestandard = 1
106. toggleanimateforced = 1
107. toggleinvertmouse = -1
108. togglehud = -1
109.  
110. ' Prime main loop.
111. GOSUB initialize.objects
112. GOSUB redraw
113.  
114. ' Begin main loop.
115. DO
116.     IF toggleanimatestandard = 1 THEN flagredraw = 1
117.     IF flagredraw = 1 THEN
118.         GOSUB redraw
119.         flagredraw = -1
120.     END IF
121.     GOSUB mouseprocess
122.     GOSUB keyprocess
123.  
124.     _DISPLAY
125.     _KEYCLEAR
126.     _LIMIT 60
127. LOOP
128.  
129. SYSTEM
130.  
131. ' Gosubs.
132.  
133. mouseprocess:
134. mx = 0
135. my = 0
136. DO WHILE _MOUSEINPUT
137.     mx = mx + _MOUSEMOVEMENTX
138.     my = my + _MOUSEMOVEMENTY
139.  
140.     IF _MOUSEWHEEL > 0 THEN GOSUB rotate.clockwise
141.     IF _MOUSEWHEEL < 0 THEN GOSUB rotate.counterclockwise
142.     IF mx > 0 THEN
143.         GOSUB rotate.uhat.plus: GOSUB normalize.screen.vectors
144.     END IF
145.     IF mx < 0 THEN
146.         GOSUB rotate.uhat.minus: GOSUB normalize.screen.vectors
147.     END IF
148.     IF my > 0 THEN
149.         IF toggleinvertmouse = -1 THEN
150.             GOSUB rotate.vhat.plus: GOSUB normalize.screen.vectors
151.         ELSE
152.             GOSUB rotate.vhat.minus: GOSUB normalize.screen.vectors
153.         END IF
154.     END IF
155.     IF my < 0 THEN
156.         IF toggleinvertmouse = -1 THEN
157.             GOSUB rotate.vhat.minus: GOSUB normalize.screen.vectors
158.         ELSE
159.             GOSUB rotate.vhat.plus: GOSUB normalize.screen.vectors
160.         END IF
161.     END IF
162.     mx = 0
163.     my = 0
164. LOOP
165.  
166. 'MouseLB = _MOUSEBUTTON(1)
167. 'MouseRB = _MOUSEBUTTON(2)
168. flagredraw = 1
169. RETURN
170.  
171. keyprocess:
172. key$ = INKEY$
173. IF key$ <> "" THEN flagredraw = 1
174. SELECT CASE key$
175.     CASE "8", CHR$(0) + CHR$(73)
176.         GOSUB rotate.vhat.plus
177.     CASE "2", CHR$(0) + CHR$(81)
178.         GOSUB rotate.vhat.minus
179.     CASE "4", CHR$(0) + CHR$(75)
180.         GOSUB rotate.uhat.minus
181.     CASE "6", CHR$(0) + CHR$(77)
182.         GOSUB rotate.uhat.plus
183.     CASE "7"
184.         GOSUB rotate.clockwise
185.     CASE "9"
186.         GOSUB rotate.counterclockwise
187.     CASE "1"
188.         GOSUB rotate.uhat.minus: GOSUB normalize.screen.vectors: GOSUB rotate.clockwise
189.     CASE "3"
190.         GOSUB rotate.uhat.plus: GOSUB normalize.screen.vectors: GOSUB rotate.counterclockwise
191.     CASE "s", CHR$(0) + CHR$(80)
192.         GOSUB strafe.camera.nhat.plus
193.     CASE "w", CHR$(0) + CHR$(72)
194.         GOSUB strafe.camera.nhat.minus
195.     CASE "d"
196.         GOSUB strafe.camera.uhat.plus
197.     CASE "a"
198.         GOSUB strafe.camera.uhat.minus
199.     CASE "e"
200.         GOSUB strafe.camera.vhat.plus
201.     CASE "q"
202.         GOSUB strafe.camera.vhat.minus
203.     CASE "x"
204.         uhat(1) = 0: uhat(2) = 1: uhat(3) = 0
205.         vhat(1) = 0: vhat(2) = 0: vhat(3) = 1
206.     CASE "X"
207.         uhat(1) = 0: uhat(2) = -1: uhat(3) = 0
208.         vhat(1) = 0: vhat(2) = 0: vhat(3) = 1
209.     CASE "y"
210.         uhat(1) = -1: uhat(2) = 0: uhat(3) = 0
211.         vhat(1) = 0: vhat(2) = 0: vhat(3) = 1
212.     CASE "Y"
213.         uhat(1) = 1: uhat(2) = 0: uhat(3) = 0
214.         vhat(1) = 0: vhat(2) = 0: vhat(3) = 1
215.     CASE "z"
216.         uhat(1) = 1: uhat(2) = 0: uhat(3) = 0
217.         vhat(1) = 0: vhat(2) = 1: vhat(3) = 0
218.         GOSUB normalize.screen.vectors
219.     CASE "Z"
220.         uhat(1) = 0: uhat(2) = 1: uhat(3) = 0
221.         vhat(1) = 1: vhat(2) = 0: vhat(3) = 0
222.     CASE "]"
223.         farplane(4) = farplane(4) - 1
224.     CASE "["
225.         farplane(4) = farplane(4) + 1
226.     CASE " "
227.         togglehud = -togglehud
228.     CASE "t"
229.         toggleanimatestandard = -toggleanimatestandard
230.     CASE "i"
231.         toggleinvertmouse = -toggleinvertmouse
232.     CASE "p"
233.         plotmode = -plotmode
234.     CASE "v"
235.         OPEN "snapshot-camera.txt" FOR OUTPUT AS #1
236.         PRINT #1, camx, camy, camz
237.         PRINT #1, uhat(1), uhat(2), uhat(3)
238.         PRINT #1, vhat(1), vhat(2), vhat(3)
239.         CLOSE #1
240.     CASE CHR$(27)
241.         SYSTEM
242.     CASE "f"
243.         explodex = camx - nhat(1) * (1 - .1 * RND) * 60
244.         explodey = camy - nhat(2) * (1 - .1 * RND) * 60
245.         explodez = camz - nhat(3) * (1 - .1 * RND) * 60
246.         GOSUB explode
247.     CASE "n"
248.         VectorGroup(closestgroup).ContentName = "Newtonian"
249.         FOR particleindex = VectorGroup(closestgroup).FirstParticle TO VectorGroup(closestgroup).LastParticle
250.             vecorigvel(particleindex, 1) = (RND - .5) * 20
251.             vecorigvel(particleindex, 2) = (RND - .5) * 20
252.             vecorigvel(particleindex, 3) = (RND - .5) * 20
253.             vecorigacc(particleindex, 3) = -30
254.         NEXT
255.         VectorGroup(closestgroup).EventTimer = INT(TIMER)
256.     CASE "k"
257.         'IF LTRIM$(RTRIM$(VectorGroup(closestgroup).ContentName)) <> "Sparks" THEN
258.         explodex = VectorGroup(closestgroup).COMx
259.         explodey = VectorGroup(closestgroup).COMy
260.         explodez = VectorGroup(closestgroup).COMz
261.         GOSUB explode
262.         p = VectorGroup(closestgroup).Pointer
263.         l = VectorGroup(closestgroup).Lagger
264.         VectorGroup(l).Pointer = p
265.         IF p <> -999 THEN
266.             VectorGroup(p).Lagger = l
267.         ELSE
268.             'determine last object id
269.             p = 1
270.             DO
271.                 k = VectorGroup(p).Identity
272.                 p = VectorGroup(k).Pointer
273.                 IF p = -999 THEN EXIT DO
274.             LOOP
275.             lastobjectid = k
276.             VectorGroup(lastobjectid).Pointer = -999
277.         END IF
278.         'END IF
279.     CASE "b"
280.         'determine last object id
281.         p = 1
282.         DO
283.             k = VectorGroup(p).Identity
284.             p = VectorGroup(k).Pointer
285.             IF p = -999 THEN EXIT DO
286.         LOOP
287.         lastobjectid = k
288.         particleindex = VectorGroup(lastobjectid).LastParticle
289.         'create new group
290.         vecgroupcounter = vecgroupcounter + 1
291.         vecgroupindex = vecgroupcounter
292.         VectorGroup(vecgroupindex).Identity = vecgroupindex
293.         VectorGroup(vecgroupindex).Pointer = -999
294.         VectorGroup(vecgroupindex).Lagger = lastobjectid
295.         VectorGroup(vecgroupindex).ContentName = "Block"
296.         VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
297.         FOR r = 1 TO 400
298.             particleindex = particleindex + 1
299.             vecorig(particleindex, 1) = camx + -40 * nhat(1) + RND * tilesize / 2
300.             vecorig(particleindex, 2) = camy + -40 * nhat(2) + RND * tilesize / 2
301.             vecorig(particleindex, 3) = camz + -40 * nhat(3) + RND * tilesize / 2
302.             IF RND > .5 THEN
303.                 veccolor(particleindex) = Lime
304.             ELSE
305.                 veccolor(particleindex) = Purple
306.             END IF
307.             GOSUB calccom
308.         NEXT
309.         VectorGroup(vecgroupindex).LastParticle = particleindex
310.         GOSUB adjustcom
311.         'connect new group to last group
312.         VectorGroup(lastobjectid).Pointer = vecgroupindex
313. END SELECT
314. RETURN
315.  
316. convert:
317. ' Convert graphics from uv-cartesian coordinates to monitor coordinates.
318. x0 = x: y0 = y
319. x = x0 + centerx
320. y = -y0 + centery
321. RETURN
322.  
323. rotate.uhat.plus:
324. uhat(1) = uhat(1) + nhat(1) * speeddamp
325. uhat(2) = uhat(2) + nhat(2) * speeddamp
326. uhat(3) = uhat(3) + nhat(3) * speeddamp
327. RETURN
328.  
329. rotate.uhat.minus:
330. uhat(1) = uhat(1) - nhat(1) * speeddamp
331. uhat(2) = uhat(2) - nhat(2) * speeddamp
332. uhat(3) = uhat(3) - nhat(3) * speeddamp
333. RETURN
334.  
335. rotate.vhat.plus:
336. vhat(1) = vhat(1) + nhat(1) * speeddamp
337. vhat(2) = vhat(2) + nhat(2) * speeddamp
338. vhat(3) = vhat(3) + nhat(3) * speeddamp
339. RETURN
340.  
341. rotate.vhat.minus:
342. vhat(1) = vhat(1) - nhat(1) * speeddamp
343. vhat(2) = vhat(2) - nhat(2) * speeddamp
344. vhat(3) = vhat(3) - nhat(3) * speeddamp
345. RETURN
346.  
347. rotate.counterclockwise:
348. v1 = vhat(1)
349. v2 = vhat(2)
350. v3 = vhat(3)
351. vhat(1) = vhat(1) + uhat(1) * speeddamp
352. vhat(2) = vhat(2) + uhat(2) * speeddamp
353. vhat(3) = vhat(3) + uhat(3) * speeddamp
354. uhat(1) = uhat(1) - v1 * speeddamp
355. uhat(2) = uhat(2) - v2 * speeddamp
356. uhat(3) = uhat(3) - v3 * speeddamp
357. RETURN
358.  
359. rotate.clockwise:
360. v1 = vhat(1)
361. v2 = vhat(2)
362. v3 = vhat(3)
363. vhat(1) = vhat(1) - uhat(1) * speeddamp
364. vhat(2) = vhat(2) - uhat(2) * speeddamp
365. vhat(3) = vhat(3) - uhat(3) * speeddamp
366. uhat(1) = uhat(1) + v1 * speeddamp
367. uhat(2) = uhat(2) + v2 * speeddamp
368. uhat(3) = uhat(3) + v3 * speeddamp
369. RETURN
370.  
371. strafe.camera.uhat.plus:
372. camx = camx + uhat(1) * speedboost
373. camy = camy + uhat(2) * speedboost
374. camz = camz + uhat(3) * speedboost
375. RETURN
376.  
377. strafe.camera.uhat.minus:
378. camx = camx - uhat(1) * speedboost
379. camy = camy - uhat(2) * speedboost
380. camz = camz - uhat(3) * speedboost
381. RETURN
382.  
383. strafe.camera.vhat.plus:
384. camx = camx + vhat(1) * speedboost
385. camy = camy + vhat(2) * speedboost
386. camz = camz + vhat(3) * speedboost
387. RETURN
388.  
389. strafe.camera.vhat.minus:
390. camx = camx - vhat(1) * speedboost
391. camy = camy - vhat(2) * speedboost
392. camz = camz - vhat(3) * speedboost
393. RETURN
394.  
395. strafe.camera.nhat.plus:
396. camx = camx + nhat(1) * speedboost
397. camy = camy + nhat(2) * speedboost
398. camz = camz + nhat(3) * speedboost
399. RETURN
400.  
401. strafe.camera.nhat.minus:
402. camx = camx - nhat(1) * speedboost
403. camy = camy - nhat(2) * speedboost
404. camz = camz - nhat(3) * speedboost
405. RETURN
406.  
407. normalize.screen.vectors:
408. uhatmag = SQR(uhat(1) ^ 2 + uhat(2) ^ 2 + uhat(3) ^ 2)
409. uhat(1) = uhat(1) / uhatmag: uhat(2) = uhat(2) / uhatmag: uhat(3) = uhat(3) / uhatmag
410. vhatmag = SQR(vhat(1) ^ 2 + vhat(2) ^ 2 + vhat(3) ^ 2)
411. vhat(1) = vhat(1) / vhatmag: vhat(2) = vhat(2) / vhatmag: vhat(3) = vhat(3) / vhatmag
412. uhatdotvhat = uhat(1) * vhat(1) + uhat(2) * vhat(2) + uhat(3) * vhat(3)
413. IF SQR(uhatdotvhat ^ 2) > .0005 THEN
414.     BEEP ' ... if vectors are somenow not normalized. This has never happened.
415.     uhat(1) = 0.8251367: uhat(2) = -0.564903: uhat(3) = -0.005829525
416.     vhat(1) = 0.065519: vhat(2) = 0.08544215: vhat(3) = 0.9941866
417. END IF
418. ' The normal vector points toward the eye.
419. nhat(1) = uhat(2) * vhat(3) - uhat(3) * vhat(2)
420. nhat(2) = uhat(3) * vhat(1) - uhat(1) * vhat(3)
421. nhat(3) = uhat(1) * vhat(2) - uhat(2) * vhat(1)
422. nhatmag = SQR(nhat(1) ^ 2 + nhat(2) ^ 2 + nhat(3) ^ 2)
423. nhat(1) = nhat(1) / nhatmag: nhat(2) = nhat(2) / nhatmag: nhat(3) = nhat(3) / nhatmag
424. RETURN
425.  
426. redraw:
427. GOSUB normalize.screen.vectors
428. GOSUB calculate.clippingplanes
429. ' Project the three-space basis vectors onto the screen plane.
430. xhatp(1) = xhat(1) * uhat(1) + xhat(2) * uhat(2) + xhat(3) * uhat(3)
431. xhatp(2) = xhat(1) * vhat(1) + xhat(2) * vhat(2) + xhat(3) * vhat(3)
432. yhatp(1) = yhat(1) * uhat(1) + yhat(2) * uhat(2) + yhat(3) * uhat(3)
433. yhatp(2) = yhat(1) * vhat(1) + yhat(2) * vhat(2) + yhat(3) * vhat(3)
434. zhatp(1) = zhat(1) * uhat(1) + zhat(2) * uhat(2) + zhat(3) * uhat(3)
435. zhatp(2) = zhat(1) * vhat(1) + zhat(2) * vhat(2) + zhat(3) * vhat(3)
436. GOSUB compute.visible.groups
437. GOSUB project.particles
438. GOSUB draw.all.objects
439. RETURN
440.  
441. compute.visible.groups:
442. numparticlevisible = 0
443. numgroupvisible = 0
444. closestdist2 = 10000 ^ 2
445. closestgroup = 1
446. ci = -1
447. cf = -1
448.  
449. k = 1
450. k = VectorGroup(k).Identity
451. DO
452.  
453.     xcom = VectorGroup(k).COMx
454.     ycom = VectorGroup(k).COMy
455.     zcom = VectorGroup(k).COMz
456.     thename$ = LTRIM$(RTRIM$(VectorGroup(k).ContentName))
457.  
458.     ' Force animation regardless of distance from camera.
459.     IF thename$ = "Rotor" THEN
460.         vecgroupindex = k
461.         GOSUB animateforced
462.     END IF
463.  
464.     dist2 = (camx - xcom) ^ 2 + (camy - ycom) ^ 2 + (camz - zcom) ^ 2
465.  
466.     IF dist2 < farplane(4) ^ 2 THEN
467.  
468.         groupinview = 1 ' Disable near plane group clipping to make things more interesting at zero distance.
469.         'IF (xcom - camx) * nearplane(1) + (ycom - camy) * nearplane(2) + (zcom - camz) * nearplane(3) - nearplane(4) < 0 THEN groupinview = 0
470.         'IF (xcom - camx) * farplane(1) + (ycom - camy) * farplane(2) + (zcom - camz) * farplane(3) - farplane(4) < 0 THEN groupinview = 0
471.         IF (xcom - camx) * rightplane(1) + (ycom - camy) * rightplane(2) + (zcom - camz) * rightplane(3) - rightplane(4) < 0 THEN groupinview = 0
472.         IF (xcom - camx) * leftplane(1) + (ycom - camy) * leftplane(2) + (zcom - camz) * leftplane(3) - leftplane(4) < 0 THEN groupinview = 0
473.         IF (xcom - camx) * topplane(1) + (ycom - camy) * topplane(2) + (zcom - camz) * topplane(3) - topplane(4) < 0 THEN groupinview = 0
474.         IF (xcom - camx) * bottomplane(1) + (ycom - camy) * bottomplane(2) + (zcom - camz) * bottomplane(3) - bottomplane(4) < 0 THEN groupinview = 0
475.         IF groupinview = 1 THEN
476.  
477.             numgroupvisible = numgroupvisible + 1
478.  
479.             IF toggleanimatestandard = 1 THEN
480.                 vecgroupindex = k
481.                 GOSUB animatestandard
482.             END IF
483.  
484.             IF dist2 < closestdist2 AND thename$ <> "Sparks" AND thename$ <> "Newtonian" THEN
485.                 closestdist2 = dist2
486.                 closestgroup = k
487.             END IF
488.  
489.             IF k = closestgroup THEN ci = numparticlevisible
490.  
491.             FOR i = VectorGroup(k).FirstParticle TO VectorGroup(k).LastParticle
492.                 vec(i, 1) = vecorig(i, 1) - camx
493.                 vec(i, 2) = vecorig(i, 2) - camy
494.                 vec(i, 3) = vecorig(i, 3) - camz
495.                 GOSUB clip.particle.viewplanes
496.             NEXT
497.  
498.             IF k = closestgroup THEN cf = numparticlevisible
499.  
500.         END IF
501.  
502.     END IF
503.  
504.     k = VectorGroup(k).Pointer
505.     IF k = -999 THEN EXIT DO
506.     k = VectorGroup(k).Identity
507.  
508. LOOP
509.  
510. IF ci <> -1 AND cf <> -1 THEN
511.     FOR i = ci TO cf
512.         vecvisiblecolor(i) = Yellow
513.     NEXT
514. END IF
515.  
516. RETURN
517.  
518. clip.particle.viewplanes:
519. ' requires i
520. particleinview = 1
521. fogswitch = -1
522. ' Perform standard view plane clipping and implement fog effect.
523. IF vec(i, 1) * nearplane(1) + vec(i, 2) * nearplane(2) + vec(i, 3) * nearplane(3) - nearplane(4) < 0 THEN particleinview = 0
524. IF vec(i, 1) * farplane(1) + vec(i, 2) * farplane(2) + vec(i, 3) * farplane(3) - farplane(4) < 0 THEN particleinview = 0
525. IF vec(i, 1) * farplane(1) + vec(i, 2) * farplane(2) + vec(i, 3) * farplane(3) - farplane(4) * .9 < 0 THEN fogswitch = 1
526. IF vec(i, 1) * rightplane(1) + vec(i, 2) * rightplane(2) + vec(i, 3) * rightplane(3) - rightplane(4) < 0 THEN particleinview = 0
527. IF vec(i, 1) * leftplane(1) + vec(i, 2) * leftplane(2) + vec(i, 3) * leftplane(3) - leftplane(4) < 0 THEN particleinview = 0
528. IF vec(i, 1) * topplane(1) + vec(i, 2) * topplane(2) + vec(i, 3) * topplane(3) - topplane(4) < 0 THEN particleinview = 0
529. IF vec(i, 1) * bottomplane(1) + vec(i, 2) * bottomplane(2) + vec(i, 3) * bottomplane(3) - bottomplane(4) < 0 THEN particleinview = 0
530. IF particleinview = 1 THEN
531.     numparticlevisible = numparticlevisible + 1
532.     vecvisible(numparticlevisible, 1) = vec(i, 1)
533.     vecvisible(numparticlevisible, 2) = vec(i, 2)
534.     vecvisible(numparticlevisible, 3) = vec(i, 3)
535.     'IF closestgroup = k THEN
536.     'vecvisiblecolor(numparticlevisible) = Yellow
537.     'ELSE
538.     vecvisiblecolor(numparticlevisible) = veccolor(i)
539.     'END IF
540.     IF fogswitch = 1 THEN vecvisiblecolor(numparticlevisible) = Gray
541. END IF
542. RETURN
543.  
544. project.particles:
545. ' Project vectors onto the screen plane.
546. FOR i = 1 TO numparticlevisible
547.     vecvisibledotnhat = vecvisible(i, 1) * nhat(1) + vecvisible(i, 2) * nhat(2) + vecvisible(i, 3) * nhat(3)
548.     vecvisiblepuv(i, 1) = vecvisible(i, 1) * uhat(1) + vecvisible(i, 2) * uhat(2) + vecvisible(i, 3) * uhat(3)
549.     vecvisiblepuv(i, 2) = vecvisible(i, 1) * vhat(1) + vecvisible(i, 2) * vhat(2) + vecvisible(i, 3) * vhat(3)
550.     vecvisiblepuvs(i, 1) = vecvisiblepuv(i, 1) * fovd / vecvisibledotnhat
551.     vecvisiblepuvs(i, 2) = vecvisiblepuv(i, 2) * fovd / vecvisibledotnhat
552. NEXT
553. RETURN
554.  
555. draw.all.objects:
556. GOSUB plot.particles
557. ' Redraw compass.
558. x = 30 * xhatp(1): y = 30 * xhatp(2): GOSUB convert
559. LINE (centerx, centery)-(x, y), Red
560. x = 30 * yhatp(1): y = 30 * yhatp(2): GOSUB convert
561. LINE (centerx, centery)-(x, y), Green
562. x = 30 * zhatp(1): y = 30 * zhatp(2): GOSUB convert
563. LINE (centerx, centery)-(x, y), Blue
564. IF togglehud = 1 THEN
565.  
566.     COLOR LimeGreen
567.     LOCATE 2, 2: PRINT "- View Info -"
568.     COLOR DarkKhaki
569.     LOCATE 3, 2: PRINT "Particles:"; numparticlevisible
570.     LOCATE 4, 2: PRINT "Groups:"; numgroupvisible
571.     LOCATE 5, 2: PRINT "Depth:"; -farplane(4)
572.     LOCATE 6, 2: PRINT "Adjust via [ ]"
573.     COLOR LimeGreen
574.     LOCATE 8, 2: PRINT "- Camera -"
575.     COLOR DarkKhaki
576.     LOCATE 9, 2: PRINT INT(camx); INT(camy); INT(camz)
577.     COLOR LimeGreen
578.     LOCATE 11, 2: PRINT "- Closest: -"
579.     COLOR DarkKhaki
580.     dist = INT(SQR((camx - VectorGroup(closestgroup).COMx) ^ 2 + (camy - VectorGroup(closestgroup).COMy) ^ 2 + (camz - VectorGroup(closestgroup).COMz) ^ 2))
581.     LOCATE 12, 2: PRINT LTRIM$(RTRIM$(VectorGroup(closestgroup).ContentName)) + " (" + LTRIM$(RTRIM$(STR$(dist))) + ")"
582.     COLOR LimeGreen
583.     a$ = "MOVE - ALIGN": LOCATE 2, screenwidth / 8 - LEN(a$): PRINT a$
584.     COLOR DarkKhaki
585.     a$ = "q w e - x y z": LOCATE 3, screenwidth / 8 - LEN(a$): PRINT a$
586.     a$ = "a s d - X Y Z": LOCATE 4, screenwidth / 8 - LEN(a$): PRINT a$
587.     a$ = "i = invert ms": LOCATE 5, screenwidth / 8 - LEN(a$): PRINT a$
588.     COLOR LimeGreen
589.     a$ = "- ROTATE -": LOCATE 7, screenwidth / 8 - LEN(a$): PRINT a$
590.     COLOR DarkKhaki
591.     a$ = "7 8 9 Mouse": LOCATE 8, screenwidth / 8 - LEN(a$): PRINT a$
592.     a$ = "4 5 6   +  ": LOCATE 9, screenwidth / 8 - LEN(a$): PRINT a$
593.     a$ = "1 2 3 Wheel": LOCATE 10, screenwidth / 8 - LEN(a$): PRINT a$
594.     COLOR LimeGreen
595.     a$ = "- CONTROL -": LOCATE 12, screenwidth / 8 - LEN(a$): PRINT a$
596.     COLOR DarkKhaki
597.     a$ = "b = Create": LOCATE 13, screenwidth / 8 - LEN(a$): PRINT a$
598.     a$ = "k = Destroy": LOCATE 14, screenwidth / 8 - LEN(a$): PRINT a$
599.     a$ = "f = Fireworks": LOCATE 15, screenwidth / 8 - LEN(a$): PRINT a$
600.     a$ = "t = Stop time": LOCATE 16, screenwidth / 8 - LEN(a$): PRINT a$
601.     COLOR LimeGreen
602.     a$ = "SPACE = Hide Info": LOCATE (screenheight / 16) - 3, (screenwidth / 8) / 2 - LEN(a$) / 2: PRINT a$
603. ELSE
604.     COLOR LimeGreen
605.     a$ = "You See: " + LTRIM$(RTRIM$(VectorGroup(closestgroup).ContentName)): LOCATE (screenheight / 16) - 3, (screenwidth / 8) / 2 - LEN(a$) / 2: PRINT a$
606. END IF
607. RETURN
608.  
609. calculate.clippingplanes:
610. ' Calculate normal vectors to all clipping planes.
611. nearplane(1) = -nhat(1)
612. nearplane(2) = -nhat(2)
613. nearplane(3) = -nhat(3)
614. farplane(1) = nhat(1)
615. farplane(2) = nhat(2)
616. farplane(3) = nhat(3)
617. rightplane(1) = (screenheight / 2) * fovd * uhat(1) - (screenheight / 2) * (screenwidth / 2) * nhat(1)
618. rightplane(2) = (screenheight / 2) * fovd * uhat(2) - (screenheight / 2) * (screenwidth / 2) * nhat(2)
619. rightplane(3) = (screenheight / 2) * fovd * uhat(3) - (screenheight / 2) * (screenwidth / 2) * nhat(3)
620. mag = SQR((rightplane(1)) ^ 2 + (rightplane(2)) ^ 2 + (rightplane(3)) ^ 2)
621. rightplane(1) = rightplane(1) / mag
622. rightplane(2) = rightplane(2) / mag
623. rightplane(3) = rightplane(3) / mag
624. leftplane(1) = -(screenheight / 2) * fovd * uhat(1) - (screenheight / 2) * (screenwidth / 2) * nhat(1)
625. leftplane(2) = -(screenheight / 2) * fovd * uhat(2) - (screenheight / 2) * (screenwidth / 2) * nhat(2)
626. leftplane(3) = -(screenheight / 2) * fovd * uhat(3) - (screenheight / 2) * (screenwidth / 2) * nhat(3)
627. mag = SQR((leftplane(1)) ^ 2 + (leftplane(2)) ^ 2 + (leftplane(3)) ^ 2)
628. leftplane(1) = leftplane(1) / mag
629. leftplane(2) = leftplane(2) / mag
630. leftplane(3) = leftplane(3) / mag
631. topplane(1) = (screenwidth / 2) * fovd * vhat(1) - (screenheight / 2) * (screenwidth / 2) * nhat(1)
632. topplane(2) = (screenwidth / 2) * fovd * vhat(2) - (screenheight / 2) * (screenwidth / 2) * nhat(2)
633. topplane(3) = (screenwidth / 2) * fovd * vhat(3) - (screenheight / 2) * (screenwidth / 2) * nhat(3)
634. mag = SQR((topplane(1)) ^ 2 + (topplane(2)) ^ 2 + (topplane(3)) ^ 2)
635. topplane(1) = topplane(1) / mag
636. topplane(2) = topplane(2) / mag
637. topplane(3) = topplane(3) / mag
638. bottomplane(1) = -(screenwidth / 2) * fovd * vhat(1) - (screenheight / 2) * (screenwidth / 2) * nhat(1)
639. bottomplane(2) = -(screenwidth / 2) * fovd * vhat(2) - (screenheight / 2) * (screenwidth / 2) * nhat(2)
640. bottomplane(3) = -(screenwidth / 2) * fovd * vhat(3) - (screenheight / 2) * (screenwidth / 2) * nhat(3)
641. mag = SQR((bottomplane(1)) ^ 2 + (bottomplane(2)) ^ 2 + (bottomplane(3)) ^ 2)
642. bottomplane(1) = bottomplane(1) / mag
643. bottomplane(2) = bottomplane(2) / mag
644. bottomplane(3) = bottomplane(3) / mag
645. RETURN
646.  
647. plot.particles:
648. CLS
649. FOR i = 1 TO numparticlevisible - 1
650.     x = vecvisiblepuvs(i, 1): y = vecvisiblepuvs(i, 2): GOSUB convert: x1 = x: y1 = y
651.     x = vecvisiblepuvs(i + 1, 1): y = vecvisiblepuvs(i + 1, 2): GOSUB convert: x2 = x: y2 = y
652.     IF ((x2 - x1) ^ 2 + (y2 - y1) ^ 2) < 15 ^ 2 THEN
653.         IF plotmode = 1 THEN
654.             LINE (x1, y1)-(x2, y2), vecvisiblecolor(i)
655.         ELSE
656.             LINE (x1, y1)-(x2, y2), vecvisiblecolor(i), B
657.         END IF
658.     ELSE
659.         CIRCLE (x1, y1), 1, vecvisiblecolor(i)
660.     END IF
661. NEXT
662. RETURN
663.  
664. ' Data.
665.  
666. initialize.objects:
667. particleindex = 0
668. vecgroupcounter = 0
669. gridsize = 550
670. tilesize = 15
671.  
672. '__AAA
673. vecgroupcounter = vecgroupcounter + 1
674. vecgroupindex = vecgroupcounter
675. VectorGroup(vecgroupindex).Identity = vecgroupindex
676. VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
677. VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
678. VectorGroup(vecgroupindex).ContentName = "__AAA"
679. VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
680. FOR r = 1 TO 5
681.     particleindex = particleindex + 1
682.     vecorig(particleindex, 1) = -1000
683.     vecorig(particleindex, 2) = -1000
684.     vecorig(particleindex, 3) = -1000
685.     veccolor(particleindex) = White
686.     GOSUB calccom
687. NEXT
688. VectorGroup(vecgroupindex).LastParticle = particleindex
689. GOSUB adjustcom
690.  
691. 'Banner
692. vecgroupcounter = vecgroupcounter + 1
693. vecgroupindex = vecgroupcounter
694. VectorGroup(vecgroupindex).Identity = vecgroupindex
695. VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
696. VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
697. VectorGroup(vecgroupindex).ContentName = "Banner"
698. VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
699. xl = -1.9: xr = 1.9: dx = .32
700. yl = -1: yr = 1: dy = .32
701. xl = xl * 4: xr = xr * 4: yl = yl * 4: yr = yr * 4
702. xrange = 1 + INT((-xl + xr) / dx)
703. yrange = 1 + INT((-yl + yr) / dy)
704. t = 0
705. FOR i = xl TO xr STEP dx
706.     FOR j = yl TO yr STEP dy
707.         particleindex = particleindex + 1
708.         vecorig(particleindex, 1) = 70 + 1.25 * COS(i - 2 * t) ^ 2 - 1.25 * SIN(j - t) ^ 2
709.         vecorig(particleindex, 2) = 30 + i
710.         vecorig(particleindex, 3) = 40 + j
711.         IF vecorig(particleindex, 1) < 70 THEN
712.             veccolor(particleindex) = Red
713.         ELSE
714.             veccolor(particleindex) = DarkOrange
715.         END IF
716.         GOSUB calccom
717.     NEXT
718. NEXT
719. VectorGroup(vecgroupindex).LastParticle = particleindex
720. GOSUB adjustcom
721.  
722. 'Clock Face (Rolex)
723. vecgroupcounter = vecgroupcounter + 1
724. vecgroupindex = vecgroupcounter
725. VectorGroup(vecgroupindex).Identity = vecgroupindex
726. VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
727. VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
728. VectorGroup(vecgroupindex).ContentName = "Clock Face (Rolex)"
729. VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
730. FOR q = 0 TO 2 * pi STEP (2 * pi / 12) / 25
731.     FOR r = 10 TO 12 STEP .5
732.         particleindex = particleindex + 1
733.         vecorig(particleindex, 1) = 40 + r * COS(q)
734.         vecorig(particleindex, 2) = -20 + r
735.         vecorig(particleindex, 3) = 40 + r * SIN(q)
736.         veccolor(particleindex) = DarkSlateGray
737.         GOSUB calccom
738.     NEXT
739. NEXT
740. VectorGroup(vecgroupindex).LastParticle = particleindex
741. GOSUB adjustcom
742.  
743. 'Clock Hands
744. vecgroupcounter = vecgroupcounter + 1
745. vecgroupindex = vecgroupcounter
746. VectorGroup(vecgroupindex).Identity = vecgroupindex
747. VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
748. VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
749. VectorGroup(vecgroupindex).ContentName = "Clock Hands"
750. VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
751. DIM hand(3)
752. DIM hcol(3) AS LONG
753. hand(1) = VAL(LEFT$(TIME$, 2)) * (2 * pi / 12)
754. hand(2) = VAL(MID$(TIME$, 4, 2)) * (2 * pi / 60)
755. hand(3) = VAL(RIGHT$(TIME$, 2)) * (2 * pi / 60)
756. phase = pi / 2
757. hcol(1) = Gold
758. hcol(2) = Lime
759. hcol(3) = OrangeRed
760. FOR q = 1 TO 3
761.     FOR r = 0 TO 5 + q STEP .1
762.         particleindex = particleindex + 1
763.         vecorig(particleindex, 1) = 40 + r * COS(hand(q) + phase)
764.         vecorig(particleindex, 2) = -10
765.         vecorig(particleindex, 3) = 40 + r * SIN(hand(q) + phase)
766.         veccolor(particleindex) = hcol(q)
767.         GOSUB calccom
768.     NEXT
769. NEXT
770. VectorGroup(vecgroupindex).LastParticle = particleindex
771. GOSUB adjustcom
772.  
773. 'Dirt
774. h = 5
775. FOR w = 1 TO 5
776.     FOR u = -gridsize TO gridsize STEP tilesize
777.         FOR v = -gridsize TO gridsize STEP tilesize
778.             vecgroupcounter = vecgroupcounter + 1
779.             vecgroupindex = vecgroupcounter
780.             VectorGroup(vecgroupindex).Identity = vecgroupindex
781.             VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
782.             VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
783.             VectorGroup(vecgroupindex).ContentName = "Dirt"
784.             VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
785.             FOR i = u TO u + tilesize STEP h
786.                 FOR j = v TO v + tilesize STEP h
787.                     IF RND > 1 - w / 5 THEN
788.                         particleindex = particleindex + 1
789.                         vecorig(particleindex, 1) = i + RND * h - RND * h
790.                         vecorig(particleindex, 2) = j + RND * h - RND * h
791.                         vecorig(particleindex, 3) = -(w - 1) * 70 - RND * 70
792.                         IF RND > .5 THEN
793.                             veccolor(particleindex) = DarkGoldenRod
794.                         ELSE
795.                             IF RND > .5 THEN
796.                                 veccolor(particleindex) = SaddleBrown
797.                             ELSE
798.                                 veccolor(particleindex) = Sienna
799.                             END IF
800.                         END IF
801.                         GOSUB calccom
802.                     END IF
803.                 NEXT
804.             NEXT
805.             VectorGroup(vecgroupindex).LastParticle = particleindex
806.             GOSUB adjustcom
807.         NEXT
808.     NEXT
809. NEXT
810.  
811. 'Grass and Puddles
812. h = 2
813. FOR u = -gridsize TO gridsize STEP tilesize
814.     FOR v = -gridsize TO gridsize STEP tilesize
815.         vecgroupcounter = vecgroupcounter + 1
816.         vecgroupindex = vecgroupcounter
817.         VectorGroup(vecgroupindex).Identity = vecgroupindex
818.         VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
819.         VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
820.         VectorGroup(vecgroupindex).ContentName = "Grass and Puddles"
821.         VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
822.         FOR i = u TO u + tilesize STEP h
823.             FOR j = v TO v + tilesize STEP h
824.                 particleindex = particleindex + 1
825.                 vecorig(particleindex, 1) = i + RND * h - RND * h
826.                 vecorig(particleindex, 2) = j + RND * h - RND * h
827.                 vecorig(particleindex, 3) = .5 + 1 * COS((i - 15) * .08) - 1 * COS((j - 6) * .12)
828.                 IF vecorig(particleindex, 3) > 0 THEN
829.                     IF RND > .5 THEN
830.                         veccolor(particleindex) = Green
831.                     ELSE
832.                         veccolor(particleindex) = ForestGreen
833.                     END IF
834.                 ELSE
835.                     IF RND > .2 THEN
836.                         veccolor(particleindex) = LightSeaGreen
837.                     ELSE
838.                         veccolor(particleindex) = Blue
839.                     END IF
840.                 END IF
841.                 GOSUB calccom
842.             NEXT
843.         NEXT
844.         VectorGroup(vecgroupindex).LastParticle = particleindex
845.         GOSUB adjustcom
846.     NEXT
847. NEXT
848.  
849. 'Grave
850. 'xloc = -90
851. 'yloc = 0
852. thickness = 2.5
853. span = 20
854. height = 30
855. crux = 22
856. FOR xloc = -90 TO -290 STEP -60
857.     FOR yloc = 0 TO 180 STEP 45
858.         FOR k = 0 TO height
859.             vecgroupcounter = vecgroupcounter + 1
860.             vecgroupindex = vecgroupcounter
861.             VectorGroup(vecgroupindex).Identity = vecgroupindex
862.             VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
863.             VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
864.             VectorGroup(vecgroupindex).ContentName = "Grave"
865.             VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
866.             FOR i = -thickness TO thickness STEP thickness / 2
867.                 FOR j = -thickness TO thickness STEP thickness / 2
868.                     particleindex = particleindex + 1
869.                     vecorig(particleindex, 1) = xloc + i + (RND - .5) * 2
870.                     vecorig(particleindex, 2) = yloc + j + (RND - .5) * 2
871.                     vecorig(particleindex, 3) = k + (RND - .5) * 2
872.                     IF RND > .5 THEN
873.                         veccolor(particleindex) = SlateGray
874.                     ELSE
875.                         veccolor(particleindex) = DarkGray
876.                     END IF
877.                     GOSUB calccom
878.                 NEXT
879.             NEXT
880.             VectorGroup(vecgroupindex).LastParticle = particleindex
881.             GOSUB adjustcom
882.         NEXT
883.         FOR j = -span / 2 TO -thickness
884.             vecgroupcounter = vecgroupcounter + 1
885.             vecgroupindex = vecgroupcounter
886.             VectorGroup(vecgroupindex).Identity = vecgroupindex
887.             VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
888.             VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
889.             VectorGroup(vecgroupindex).ContentName = "Grave"
890.             VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
891.             FOR k = -thickness TO thickness STEP thickness / 2
892.                 FOR i = -thickness TO thickness STEP thickness / 2
893.                     particleindex = particleindex + 1
894.                     vecorig(particleindex, 1) = xloc + i + (RND - .5) * 2
895.                     vecorig(particleindex, 2) = yloc + j + (RND - .5) * 2
896.                     vecorig(particleindex, 3) = crux + k + (RND - .5) * 2
897.                     IF RND > .5 THEN
898.                         veccolor(particleindex) = SlateGray
899.                     ELSE
900.                         veccolor(particleindex) = DarkGray
901.                     END IF
902.                     GOSUB calccom
903.                 NEXT
904.             NEXT
905.             VectorGroup(vecgroupindex).LastParticle = particleindex
906.             GOSUB adjustcom
907.         NEXT
908.         FOR j = thickness TO span / 2
909.             vecgroupcounter = vecgroupcounter + 1
910.             vecgroupindex = vecgroupcounter
911.             VectorGroup(vecgroupindex).Identity = vecgroupindex
912.             VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
913.             VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
914.             VectorGroup(vecgroupindex).ContentName = "Grave"
915.             VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
916.             FOR k = -thickness TO thickness STEP thickness / 2
917.                 FOR i = -thickness TO thickness STEP thickness / 2
918.                     particleindex = particleindex + 1
919.                     vecorig(particleindex, 1) = xloc + i + (RND - .5) * 2
920.                     vecorig(particleindex, 2) = yloc + j + (RND - .5) * 2
921.                     vecorig(particleindex, 3) = crux + k + (RND - .5) * 2
922.                     IF RND > .5 THEN
923.                         veccolor(particleindex) = SlateGray
924.                     ELSE
925.                         veccolor(particleindex) = DarkGray
926.                     END IF
927.                     GOSUB calccom
928.                 NEXT
929.             NEXT
930.             VectorGroup(vecgroupindex).LastParticle = particleindex
931.             GOSUB adjustcom
932.         NEXT
933.     NEXT
934. NEXT
935.  
936. 'Heaven's Bottom Layer
937. h = 2
938. FOR u = -gridsize TO gridsize STEP tilesize
939.     FOR v = -gridsize TO gridsize STEP tilesize
940.         vecgroupcounter = vecgroupcounter + 1
941.         vecgroupindex = vecgroupcounter
942.         VectorGroup(vecgroupindex).Identity = vecgroupindex
943.         VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
944.         VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
945.         VectorGroup(vecgroupindex).ContentName = "Heaven's Bottom Layer"
946.         VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
947.         FOR i = u TO u + tilesize STEP h
948.             FOR j = v TO v + tilesize STEP h
949.                 particleindex = particleindex + 1
950.                 vecorig(particleindex, 1) = i + RND * h - RND * h
951.                 vecorig(particleindex, 2) = j + RND * h - RND * h
952.                 vecorig(particleindex, 3) = 420 - RND
953.                 IF RND > .5 THEN
954.                     veccolor(particleindex) = BlueViolet
955.                 ELSE
956.                     veccolor(particleindex) = Cyan
957.                 END IF
958.                 GOSUB calccom
959.             NEXT
960.         NEXT
961.         VectorGroup(vecgroupindex).LastParticle = particleindex
962.         GOSUB adjustcom
963.     NEXT
964. NEXT
965.  
966. 'Hell Spawn
967. FOR u = -gridsize TO gridsize STEP tilesize
968.     FOR v = -gridsize TO gridsize STEP tilesize
969.         vecgroupcounter = vecgroupcounter + 1
970.         vecgroupindex = vecgroupcounter
971.         VectorGroup(vecgroupindex).Identity = vecgroupindex
972.         VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
973.         VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
974.         VectorGroup(vecgroupindex).ContentName = "Hell Spawn"
975.         VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
976.         FOR i = u TO u + tilesize STEP tilesize / 5
977.             FOR j = v TO v + tilesize STEP tilesize / 5
978.                 particleindex = particleindex + 1
979.                 vecorig(particleindex, 1) = i + RND * tilesize / 5
980.                 vecorig(particleindex, 2) = j + RND * tilesize / 5
981.                 vecorig(particleindex, 3) = -350 - RND * 70
982.                 IF RND > .2 THEN
983.                     veccolor(particleindex) = Red
984.                 ELSE
985.                     veccolor(particleindex) = DarkGoldenRod
986.                 END IF
987.                 GOSUB calccom
988.             NEXT
989.         NEXT
990.         VectorGroup(vecgroupindex).LastParticle = particleindex
991.         GOSUB adjustcom
992.     NEXT
993. NEXT
994.  
995. 'Icewall East
996. h = 2
997. FOR u = -gridsize TO gridsize STEP tilesize
998.     FOR v = 0 TO 70 STEP tilesize
999.         vecgroupcounter = vecgroupcounter + 1
1000.         vecgroupindex = vecgroupcounter
1001.         VectorGroup(vecgroupindex).Identity = vecgroupindex
1002.         VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1003.         VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1004.         VectorGroup(vecgroupindex).ContentName = "Icewall East"
1005.         VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1006.         FOR i = u TO u + tilesize STEP h
1007.             FOR j = v TO v + tilesize STEP h
1008.                 particleindex = particleindex + 1
1009.                 vecorig(particleindex, 1) = gridsize
1010.                 vecorig(particleindex, 2) = i + RND * h - RND * h
1011.                 vecorig(particleindex, 3) = j + RND * h - RND * h
1012.                 IF RND > .5 THEN
1013.                     veccolor(particleindex) = White
1014.                 ELSE
1015.                     veccolor(particleindex) = Ivory
1016.                 END IF
1017.                 GOSUB calccom
1018.             NEXT
1019.         NEXT
1020.         VectorGroup(vecgroupindex).LastParticle = particleindex
1021.         GOSUB adjustcom
1022.     NEXT
1023. NEXT
1024.  
1025. 'Icewall South
1026. h = 2
1027. FOR u = -gridsize TO gridsize STEP tilesize
1028.     FOR v = 0 TO 70 STEP tilesize
1029.         vecgroupcounter = vecgroupcounter + 1
1030.         vecgroupindex = vecgroupcounter
1031.         VectorGroup(vecgroupindex).Identity = vecgroupindex
1032.         VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1033.         VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1034.         VectorGroup(vecgroupindex).ContentName = "Icewall South"
1035.         VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1036.         FOR i = u TO u + tilesize STEP h
1037.             FOR j = v TO v + tilesize STEP h
1038.                 particleindex = particleindex + 1
1039.                 vecorig(particleindex, 1) = -gridsize
1040.                 vecorig(particleindex, 2) = i + RND * h - RND * h
1041.                 vecorig(particleindex, 3) = j + RND * h - RND * h
1042.                 IF RND > .5 THEN
1043.                     veccolor(particleindex) = White
1044.                 ELSE
1045.                     veccolor(particleindex) = Ivory
1046.                 END IF
1047.                 GOSUB calccom
1048.             NEXT
1049.         NEXT
1050.         VectorGroup(vecgroupindex).LastParticle = particleindex
1051.         GOSUB adjustcom
1052.     NEXT
1053. NEXT
1054.  
1055. 'Icewall North
1056. h = 2
1057. FOR u = -gridsize TO gridsize STEP tilesize
1058.     FOR v = 0 TO 70 STEP tilesize
1059.         vecgroupcounter = vecgroupcounter + 1
1060.         vecgroupindex = vecgroupcounter
1061.         VectorGroup(vecgroupindex).Identity = vecgroupindex
1062.         VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1063.         VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1064.         VectorGroup(vecgroupindex).ContentName = "Icewall North"
1065.         VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1066.         FOR i = u TO u + tilesize STEP h
1067.             FOR j = v TO v + tilesize STEP h
1068.                 particleindex = particleindex + 1
1069.                 vecorig(particleindex, 1) = i + RND * h - RND * h
1070.                 vecorig(particleindex, 2) = gridsize
1071.                 vecorig(particleindex, 3) = j + RND * h - RND * h
1072.                 IF RND > .5 THEN
1073.                     veccolor(particleindex) = White
1074.                 ELSE
1075.                     veccolor(particleindex) = Ivory
1076.                 END IF
1077.                 GOSUB calccom
1078.             NEXT
1079.         NEXT
1080.         VectorGroup(vecgroupindex).LastParticle = particleindex
1081.         GOSUB adjustcom
1082.     NEXT
1083. NEXT
1084.  
1085. 'Icewall West
1086. h = 2
1087. FOR u = -gridsize TO gridsize STEP tilesize
1088.     FOR v = 0 TO 70 STEP tilesize
1089.         vecgroupcounter = vecgroupcounter + 1
1090.         vecgroupindex = vecgroupcounter
1091.         VectorGroup(vecgroupindex).Identity = vecgroupindex
1092.         VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1093.         VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1094.         VectorGroup(vecgroupindex).ContentName = "Icewall West"
1095.         VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1096.         FOR i = u TO u + tilesize STEP h
1097.             FOR j = v TO v + tilesize STEP h
1098.                 particleindex = particleindex + 1
1099.                 vecorig(particleindex, 1) = i + RND * h - RND * h
1100.                 vecorig(particleindex, 2) = -gridsize
1101.                 vecorig(particleindex, 3) = j + RND * h - RND * h
1102.                 IF RND > .5 THEN
1103.                     veccolor(particleindex) = White
1104.                 ELSE
1105.                     veccolor(particleindex) = Ivory
1106.                 END IF
1107.                 GOSUB calccom
1108.             NEXT
1109.         NEXT
1110.         VectorGroup(vecgroupindex).LastParticle = particleindex
1111.         GOSUB adjustcom
1112.     NEXT
1113. NEXT
1114.  
1115. 'Lake of Fire
1116. h = 2
1117. FOR u = -gridsize TO gridsize STEP tilesize
1118.     FOR v = -gridsize TO gridsize STEP tilesize
1119.         vecgroupcounter = vecgroupcounter + 1
1120.         vecgroupindex = vecgroupcounter
1121.         VectorGroup(vecgroupindex).Identity = vecgroupindex
1122.         VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1123.         VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1124.         VectorGroup(vecgroupindex).ContentName = "Lake of Fire"
1125.         VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1126.         FOR i = u TO u + tilesize STEP h
1127.             FOR j = v TO v + tilesize STEP h
1128.                 particleindex = particleindex + 1
1129.                 vecorig(particleindex, 1) = i + RND * h - RND * h
1130.                 vecorig(particleindex, 2) = j + RND * h - RND * h
1131.                 vecorig(particleindex, 3) = -350 - 70 - RND
1132.                 IF RND > .2 THEN
1133.                     veccolor(particleindex) = Red
1134.                 ELSE
1135.                     veccolor(particleindex) = Indigo
1136.                 END IF
1137.                 GOSUB calccom
1138.             NEXT
1139.         NEXT
1140.         VectorGroup(vecgroupindex).LastParticle = particleindex
1141.         GOSUB adjustcom
1142.     NEXT
1143. NEXT
1144.  
1145. 'Megalith
1146. ctrx = -90
1147. ctry = -320
1148. ctrz = 4
1149. w = 8
1150. h = 256
1151. dens = 100
1152. FOR k = 1 TO h STEP w
1153.     FOR i = -h / 20 + k / 20 TO h / 20 - k / 20 STEP w
1154.         FOR j = -h / 20 + k / 20 TO h / 20 - k / 20 STEP w
1155.             vecgroupcounter = vecgroupcounter + 1
1156.             vecgroupindex = vecgroupcounter
1157.             VectorGroup(vecgroupindex).Identity = vecgroupindex
1158.             VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1159.             VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1160.             VectorGroup(vecgroupindex).ContentName = "Megalith"
1161.             VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1162.             FOR q = 1 TO dens
1163.                 particleindex = particleindex + 1
1164.                 vecorig(particleindex, 1) = ctrx + i + (RND - .5) * w
1165.                 vecorig(particleindex, 2) = ctry + j + (RND - .5) * w
1166.                 vecorig(particleindex, 3) = ctrz + k + (RND - .5) * w
1167.                 IF RND > .5 THEN
1168.                     veccolor(particleindex) = Cyan
1169.                 ELSE
1170.                     veccolor(particleindex) = Teal
1171.                 END IF
1172.                 GOSUB calccom
1173.             NEXT
1174.             VectorGroup(vecgroupindex).LastParticle = particleindex
1175.             GOSUB adjustcom
1176.         NEXT
1177.     NEXT
1178. NEXT
1179.  
1180. 'Moon
1181. vecgroupcounter = vecgroupcounter + 1
1182. vecgroupindex = vecgroupcounter
1183. VectorGroup(vecgroupindex).Identity = vecgroupindex
1184. VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1185. VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1186. VectorGroup(vecgroupindex).ContentName = "Moon"
1187. VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1188. radius = 4
1189. au = 60
1190. dx = (2 * pi / radius) * .05
1191. dy = (2 * pi / radius) * .05
1192. xl = 0: xr = 2 * pi
1193. yl = 0: yr = pi
1194. xrange = 1 + INT((-xl + xr) / dx)
1195. yrange = 1 + INT((-yl + yr) / dy)
1196. FOR i = 1 TO xrange
1197.     FOR j = 1 TO yrange
1198.         particleindex = particleindex + 1
1199.         theta = i * dx - dx
1200.         phi = j * dy - dy
1201.         vecorig(particleindex, 1) = au + radius * SIN(phi) * COS(theta)
1202.         vecorig(particleindex, 2) = radius * SIN(phi) * SIN(theta)
1203.         vecorig(particleindex, 3) = 90 + radius * COS(phi)
1204.         IF RND > .5 THEN
1205.             veccolor(particleindex) = Gray
1206.         ELSE
1207.             veccolor(particleindex) = PaleGoldenRod
1208.         END IF
1209.         GOSUB calccom
1210.     NEXT
1211. NEXT
1212. VectorGroup(vecgroupindex).LastParticle = particleindex
1213. GOSUB adjustcom
1214.  
1215. 'Pyramid
1216. ctrx = -90
1217. ctry = -120
1218. ctrz = 4
1219. w = 8
1220. h = 56
1221. dens = 50
1222. FOR k = 1 TO h STEP w
1223.     FOR i = -h / 2 + k / 2 TO h / 2 - k / 2 STEP w
1224.         FOR j = -h / 2 + k / 2 TO h / 2 - k / 2 STEP w
1225.             vecgroupcounter = vecgroupcounter + 1
1226.             vecgroupindex = vecgroupcounter
1227.             VectorGroup(vecgroupindex).Identity = vecgroupindex
1228.             VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1229.             VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1230.             VectorGroup(vecgroupindex).ContentName = "Pyramid"
1231.             VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1232.             FOR q = 1 TO dens
1233.                 particleindex = particleindex + 1
1234.                 vecorig(particleindex, 1) = ctrx + i + (RND - .5) * w
1235.                 vecorig(particleindex, 2) = ctry + j + (RND - .5) * w
1236.                 vecorig(particleindex, 3) = ctrz + k + (RND - .5) * w
1237.                 IF RND > .5 THEN
1238.                     veccolor(particleindex) = DarkGoldenRod
1239.                 ELSE
1240.                     veccolor(particleindex) = GoldenRod
1241.                 END IF
1242.                 GOSUB calccom
1243.             NEXT
1244.             VectorGroup(vecgroupindex).LastParticle = particleindex
1245.             GOSUB adjustcom
1246.         NEXT
1247.     NEXT
1248. NEXT
1249.  
1250. 'Rain
1251. FOR u = -gridsize TO gridsize STEP tilesize
1252.     FOR v = -gridsize TO gridsize STEP tilesize
1253.         vecgroupcounter = vecgroupcounter + 1
1254.         vecgroupindex = vecgroupcounter
1255.         VectorGroup(vecgroupindex).Identity = vecgroupindex
1256.         VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1257.         VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1258.         VectorGroup(vecgroupindex).ContentName = "Rain"
1259.         VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1260.         FOR i = u TO u + tilesize STEP tilesize '/ 3
1261.             FOR j = v TO v + tilesize STEP tilesize '/ 3
1262.                 particleindex = particleindex + 1
1263.                 vecorig(particleindex, 1) = i + RND * tilesize
1264.                 vecorig(particleindex, 2) = j + RND * tilesize
1265.                 vecorig(particleindex, 3) = RND * 70
1266.                 IF RND > 5 THEN
1267.                     veccolor(particleindex) = Aquamarine
1268.                 ELSE
1269.                     veccolor(particleindex) = DodgerBlue
1270.                 END IF
1271.                 GOSUB calccom
1272.             NEXT
1273.         NEXT
1274.         VectorGroup(vecgroupindex).LastParticle = particleindex
1275.         GOSUB adjustcom
1276.     NEXT
1277. NEXT
1278.  
1279. ''Rotor
1280. 'vecgroupcounter = vecgroupcounter + 1
1281. 'vecgroupindex = vecgroupcounter
1282. 'VectorGroup(vecgroupindex).Identity = vecgroupindex
1283. 'VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1284. 'VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1285. 'VectorGroup(vecgroupindex).ContentName = "Rotor"
1286. 'VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1287. 'xc = 5
1288. 'yc = 5
1289. 'zc = 40
1290. 'rad = 20
1291. 'FOR k = 1 TO 600
1292. '    xx = RND * 2 * rad - rad
1293. '    yy = 0
1294. '    zz = RND * 2 * rad - rad
1295. '    IF xx ^ 2 + yy ^ 2 + zz ^ 2 < rad ^ 2 THEN
1296. '        particleindex = particleindex + 1
1297. '        vecorig(particleindex, 1) = xc + xx
1298. '        vecorig(particleindex, 2) = yc + yy
1299. '        vecorig(particleindex, 3) = zc + zz
1300. '        vecorigrot(particleindex, 1) = 50
1301. '        vecorigrot(particleindex, 2) = 50
1302. '        vecorigrot(particleindex, 3) = 50
1303. '        GOSUB calccom
1304. '        veccolor(particleindex) = _RGB(INT(RND * 255), INT(RND * 255), INT(RND * 255))
1305. '    END IF
1306. 'NEXT
1307. 'VectorGroup(vecgroupindex).LastParticle = particleindex
1308. 'GOSUB adjustcom
1309. 'VectorGroup(vecgroupindex).CORx = VectorGroup(vecgroupindex).COMx
1310. 'VectorGroup(vecgroupindex).CORy = VectorGroup(vecgroupindex).COMy
1311. 'VectorGroup(vecgroupindex).CORz = VectorGroup(vecgroupindex).COMz
1312.  
1313. 'Sky
1314. h = 2
1315. FOR u = -gridsize TO gridsize STEP tilesize
1316.     FOR v = -gridsize TO gridsize STEP tilesize
1317.         vecgroupcounter = vecgroupcounter + 1
1318.         vecgroupindex = vecgroupcounter
1319.         VectorGroup(vecgroupindex).Identity = vecgroupindex
1320.         VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1321.         VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1322.         VectorGroup(vecgroupindex).ContentName = "Sky"
1323.         VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1324.         FOR i = u TO u + tilesize STEP h
1325.             FOR j = v TO v + tilesize STEP h
1326.                 particleindex = particleindex + 1
1327.                 vecorig(particleindex, 1) = i + RND * h - RND * h
1328.                 vecorig(particleindex, 2) = j + RND * h - RND * h
1329.                 vecorig(particleindex, 3) = 70 + RND * h - RND * h
1330.                 IF RND > .5 THEN
1331.                     veccolor(particleindex) = Snow
1332.                 ELSE
1333.                     veccolor(particleindex) = RoyalBlue
1334.                 END IF
1335.                 GOSUB calccom
1336.             NEXT
1337.         NEXT
1338.         VectorGroup(vecgroupindex).LastParticle = particleindex
1339.         GOSUB adjustcom
1340.     NEXT
1341. NEXT
1342.  
1343. 'Snake?
1344. vecgroupcounter = vecgroupcounter + 1
1345. vecgroupindex = vecgroupcounter
1346. VectorGroup(vecgroupindex).Identity = vecgroupindex
1347. VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1348. VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1349. VectorGroup(vecgroupindex).ContentName = "Snake?"
1350. VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1351. FOR i = -pi TO pi STEP .005
1352.     particleindex = particleindex + 1
1353.     vecorig(particleindex, 1) = -10 + 5 * COS(i)
1354.     vecorig(particleindex, 2) = -20 + 5 * SIN(i)
1355.     vecorig(particleindex, 3) = 25 - 3 * COS(6 * i) * SIN(3 * i)
1356.     veccolor(particleindex) = Coral
1357.     GOSUB calccom
1358. NEXT
1359. VectorGroup(vecgroupindex).LastParticle = particleindex
1360. GOSUB adjustcom
1361.  
1362. 'Sparks
1363. vecgroupcounter = vecgroupcounter + 1
1364. vecgroupindex = vecgroupcounter
1365. VectorGroup(vecgroupindex).Identity = vecgroupindex
1366. VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1367. VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1368. VectorGroup(vecgroupindex).ContentName = "Sparks"
1369. VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1370. u = 0
1371. v = 0
1372. FOR i = 1 TO 300
1373.     particleindex = particleindex + 1
1374.     vecorig(particleindex, 1) = RND - .5
1375.     vecorig(particleindex, 2) = RND - .5
1376.     vecorig(particleindex, 3) = 20 + RND - .5
1377.     vecorigvel(particleindex, 1) = 8 * (RND - .5)
1378.     vecorigvel(particleindex, 2) = 8 * (RND - .5)
1379.     vecorigvel(particleindex, 3) = 20 * RND
1380.     vecorigacc(particleindex, 1) = 0
1381.     vecorigacc(particleindex, 2) = 0
1382.     vecorigacc(particleindex, 3) = -40
1383.     veccolor(particleindex) = _RGB(INT(RND * 255), INT(RND * 255), INT(RND * 255))
1384.     GOSUB calccom
1385. NEXT
1386. VectorGroup(vecgroupindex).LastParticle = particleindex
1387. GOSUB adjustcom
1388.  
1389. 'Stars
1390. h = 5
1391. FOR w = 1 TO 5
1392.     FOR u = -gridsize TO gridsize STEP tilesize
1393.         FOR v = -gridsize TO gridsize STEP tilesize
1394.             vecgroupcounter = vecgroupcounter + 1
1395.             vecgroupindex = vecgroupcounter
1396.             VectorGroup(vecgroupindex).Identity = vecgroupindex
1397.             VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1398.             VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1399.             VectorGroup(vecgroupindex).ContentName = "Stars"
1400.             VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1401.             FOR i = u TO u + tilesize STEP h
1402.                 FOR j = v TO v + tilesize STEP h
1403.                     IF RND > 1 - w / 5 THEN
1404.                         particleindex = particleindex + 1
1405.                         vecorig(particleindex, 1) = i + RND * h - RND * h
1406.                         vecorig(particleindex, 2) = j + RND * h - RND * h
1407.                         vecorig(particleindex, 3) = w * 70 + RND * 70
1408.                         IF RND > .5 THEN
1409.                             veccolor(particleindex) = GhostWhite
1410.                         ELSE
1411.                             IF RND > .5 THEN
1412.                                 veccolor(particleindex) = White
1413.                             ELSE
1414.                                 veccolor(particleindex) = DarkGray
1415.                             END IF
1416.                         END IF
1417.                         GOSUB calccom
1418.                     END IF
1419.                 NEXT
1420.             NEXT
1421.             VectorGroup(vecgroupindex).LastParticle = particleindex
1422.             GOSUB adjustcom
1423.         NEXT
1424.     NEXT
1425. NEXT
1426.  
1427. 'Sun
1428. radius = 10
1429. dx = .0628
1430. dy = .0628
1431. xl = 0: xr = 2 * pi
1432. yl = 0: yr = pi
1433. xrange = 1 + INT((-xl + xr) / dx)
1434. yrange = 1 + INT((-yl + yr) / dy)
1435. FOR i = 1 TO xrange STEP 10
1436.     FOR j = 1 TO yrange STEP 10
1437.         vecgroupcounter = vecgroupcounter + 1
1438.         vecgroupindex = vecgroupcounter
1439.         VectorGroup(vecgroupindex).Identity = vecgroupindex
1440.         VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1441.         VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1442.         VectorGroup(vecgroupindex).ContentName = "Sun"
1443.         VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1444.         FOR u = i TO i + 10 STEP 1
1445.             FOR v = j TO j + 10 STEP 1
1446.                 particleindex = particleindex + 1
1447.                 theta = u * dx - dx
1448.                 phi = v * dy - dy
1449.                 vecorig(particleindex, 1) = radius * SIN(phi) * COS(theta)
1450.                 vecorig(particleindex, 2) = radius * SIN(phi) * SIN(theta)
1451.                 vecorig(particleindex, 3) = 90 + radius * COS(phi)
1452.                 IF RND > .5 THEN
1453.                     veccolor(particleindex) = Sunglow
1454.                 ELSE
1455.                     veccolor(particleindex) = SunsetOrange
1456.                 END IF
1457.                 GOSUB calccom
1458.             NEXT
1459.         NEXT
1460.         VectorGroup(vecgroupindex).LastParticle = particleindex
1461.         GOSUB adjustcom
1462.     NEXT
1463. NEXT
1464.  
1465. 'UFO!!!
1466. vecgroupcounter = vecgroupcounter + 1
1467. vecgroupindex = vecgroupcounter
1468. VectorGroup(vecgroupindex).Identity = vecgroupindex
1469. VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1470. VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1471. VectorGroup(vecgroupindex).ContentName = "UFO!!!"
1472. VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1473. FOR q = 0 TO 2 * pi STEP (2 * pi / 12) / 25
1474.     FOR r = 10 TO 12 STEP .5
1475.         particleindex = particleindex + 1
1476.         vecorig(particleindex, 1) = -90 + r * COS(q)
1477.         vecorig(particleindex, 2) = -120 + r * SIN(q)
1478.         vecorig(particleindex, 3) = 100 + r - 12
1479.         veccolor(particleindex) = HotPink
1480.         GOSUB calccom
1481.     NEXT
1482.     FOR r = 12 TO 10 STEP -.5
1483.         particleindex = particleindex + 1
1484.         vecorig(particleindex, 1) = -90 + r * COS(q)
1485.         vecorig(particleindex, 2) = -120 + r * SIN(q)
1486.         vecorig(particleindex, 3) = 100 - r + 12
1487.         veccolor(particleindex) = Red
1488.         GOSUB calccom
1489.     NEXT
1490. NEXT
1491. r = 5
1492. h = 30
1493. FOR w = 1 TO 400
1494.     xx = (RND - .5) * 2 * r
1495.     yy = (RND - .5) * 2 * r
1496.     IF xx ^ 2 + yy ^ 2 < r ^ 2 THEN
1497.         particleindex = particleindex + 1
1498.         vecorig(particleindex, 1) = -90 + xx
1499.         vecorig(particleindex, 2) = -120 + yy
1500.         vecorig(particleindex, 3) = 100 - RND * h
1501.         IF RND > .5 THEN
1502.             veccolor(particleindex) = Aquamarine
1503.         ELSE
1504.             veccolor(particleindex) = Lime
1505.         END IF
1506.         GOSUB calccom
1507.     END IF
1508. NEXT
1509. VectorGroup(vecgroupindex).LastParticle = particleindex
1510. GOSUB adjustcom
1511.  
1512. 'Waves or Particles? (1)
1513. FOR i = 1 TO 5 STEP 1
1514.     FOR k = 1 TO 5 STEP 1
1515.         vecgroupcounter = vecgroupcounter + 1
1516.         vecgroupindex = vecgroupcounter
1517.         VectorGroup(vecgroupindex).Identity = vecgroupindex
1518.         VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1519.         VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1520.         VectorGroup(vecgroupindex).ContentName = "Waves or Particles?"
1521.         VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1522.         FOR u = i TO i + 1 STEP .05
1523.             FOR v = k TO k + 1 STEP .05
1524.                 particleindex = particleindex + 1
1525.                 vecorig(particleindex, 1) = 70 + 7 * u
1526.                 vecorig(particleindex, 2) = 80 + 1 * COS((u ^ 2 - v ^ 2))
1527.                 vecorig(particleindex, 3) = 10 + 7 * v
1528.                 IF vecorig(particleindex, 2) < 80 THEN
1529.                     veccolor(particleindex) = DarkBlue
1530.                 ELSE
1531.                     veccolor(particleindex) = DeepPink
1532.                 END IF
1533.                 GOSUB calccom
1534.             NEXT
1535.         NEXT
1536.         VectorGroup(vecgroupindex).LastParticle = particleindex
1537.         GOSUB adjustcom
1538.     NEXT
1539. NEXT
1540.  
1541. 'Waves or Particles? (2)
1542. FOR i = 1 TO 5 STEP 1
1543.     FOR k = 1 TO 5 STEP 1
1544.         vecgroupcounter = vecgroupcounter + 1
1545.         vecgroupindex = vecgroupcounter
1546.         VectorGroup(vecgroupindex).Identity = vecgroupindex
1547.         VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1548.         VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1549.         VectorGroup(vecgroupindex).ContentName = "Waves or Particles?"
1550.         VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1551.         FOR u = i TO i + 1 STEP .05
1552.             FOR v = k TO k + 1 STEP .05
1553.                 particleindex = particleindex + 1
1554.                 vecorig(particleindex, 1) = -7 * u
1555.                 vecorig(particleindex, 2) = 80 + 1 * COS(2 * ((u - 7) ^ 2 - (v - 5) ^ 2))
1556.                 vecorig(particleindex, 3) = 10 + 7 * v
1557.                 IF vecorig(particleindex, 2) < 80 THEN
1558.                     veccolor(particleindex) = Magenta
1559.                 ELSE
1560.                     veccolor(particleindex) = Chocolate
1561.                 END IF
1562.                 GOSUB calccom
1563.             NEXT
1564.         NEXT
1565.         VectorGroup(vecgroupindex).LastParticle = particleindex
1566.         GOSUB adjustcom
1567.     NEXT
1568. NEXT
1569.  
1570. 'File
1571. IF COMMAND$ <> "" THEN
1572.     OPEN COMMAND$ FOR INPUT AS #1
1573.     DO WHILE NOT EOF(1)
1574.         INPUT #1, xx, yy, zz, co
1575.         recordtype = 0
1576.         IF xx = -111111 AND yy = -111111 AND zz = -111111 AND co = -111111 THEN ' Next record begins a group.
1577.             recordtype = 111111
1578.             INPUT #1, n$
1579.             vecgroupcounter = vecgroupcounter + 1
1580.             vecgroupindex = vecgroupcounter
1581.             VectorGroup(vecgroupindex).Identity = vecgroupindex
1582.             VectorGroup(vecgroupindex).Pointer = vecgroupindex + 1
1583.             VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1584.             VectorGroup(vecgroupindex).ContentName = n$
1585.             VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1586.         END IF
1587.         IF xx = -222222 AND yy = -222222 AND zz = -222222 AND co = -222222 THEN ' Next record is position offset for entire group.
1588.             recordtype = 222222
1589.             INPUT #1, xx, yy, zz
1590.             vecorigvel(particleindex, 1) = 0 'xx
1591.             vecorigvel(particleindex, 2) = 0 'yy
1592.             vecorigvel(particleindex, 3) = 0 'zz
1593.         END IF
1594.  
1595.         IF xx = -333333 AND yy = -333333 AND zz = -333333 AND co = -333333 THEN ' Next record is previous particle's linear velocity vector.
1596.             recordtype = 333333
1597.             INPUT #1, xx, yy, zz
1598.             vecorigvel(particleindex, 1) = xx
1599.             vecorigvel(particleindex, 2) = yy
1600.             vecorigvel(particleindex, 3) = zz
1601.         END IF
1602.         IF xx = -444444 AND yy = -444444 AND zz = -444444 AND co = -444444 THEN ' Next record is previous particle's linear acceleration vector.
1603.             recordtype = 444444
1604.             INPUT #1, xx, yy, zz
1605.             vecorigacc(particleindex, 1) = xx
1606.             vecorigacc(particleindex, 2) = yy
1607.             vecorigacc(particleindex, 3) = zz
1608.         END IF
1609.         IF xx = -555555 AND yy = -555555 AND zz = -555555 AND co = -555555 THEN ' Next record is rotation point for entire group.
1610.             recordtype = 555555
1611.             INPUT #1, xx, yy, zz
1612.             VectorGroup(vecgroupindex).CORx = xx
1613.             VectorGroup(vecgroupindex).CORy = yy
1614.             VectorGroup(vecgroupindex).CORz = zz
1615.         END IF
1616.         IF xx = -666666 AND yy = -666666 AND zz = -666666 AND co = -666666 THEN ' Next record is previous particle's angular velocity vector.
1617.             recordtype = 666666
1618.             INPUT #1, xx, yy, zz
1619.             vecorigrot(particleindex, 1) = xx
1620.             vecorigrot(particleindex, 2) = yy
1621.             vecorigrot(particleindex, 3) = zz
1622.         END IF
1623.  
1624.         IF xx = -999999 AND yy = -999999 AND zz = -999999 AND co = -999999 THEN ' Previous record was last in group.
1625.             recordtype = 999999
1626.             VectorGroup(vecgroupindex).LastParticle = particleindex
1627.             GOSUB adjustcom
1628.         END IF
1629.         IF recordtype = 0 THEN ' Not a special record. Store position and color.
1630.             particleindex = particleindex + 1
1631.             vecorig(particleindex, 1) = xx
1632.             vecorig(particleindex, 2) = yy
1633.             vecorig(particleindex, 3) = zz
1634.             SELECT CASE co
1635.                 CASE 0
1636.                     veccolor(particleindex) = Black
1637.                 CASE 1
1638.                     veccolor(particleindex) = Blue
1639.                 CASE 2
1640.                     veccolor(particleindex) = Green
1641.                 CASE 3
1642.                     veccolor(particleindex) = Cyan
1643.                 CASE 4
1644.                     veccolor(particleindex) = Red
1645.                 CASE 5
1646.                     veccolor(particleindex) = Purple
1647.                 CASE 6
1648.                     veccolor(particleindex) = Orange
1649.                 CASE 7
1650.                     veccolor(particleindex) = LightGray
1651.                 CASE 8
1652.                     veccolor(particleindex) = DarkGray
1653.                 CASE 9
1654.                     veccolor(particleindex) = LightBlue
1655.                 CASE 10
1656.                     veccolor(particleindex) = LightGreen
1657.                 CASE 11
1658.                     veccolor(particleindex) = LightCyan
1659.                 CASE 12
1660.                     veccolor(particleindex) = OrangeRed 'lightred
1661.                 CASE 13
1662.                     veccolor(particleindex) = Violet 'lightpurple
1663.                 CASE 14
1664.                     veccolor(particleindex) = Yellow
1665.                 CASE 15
1666.                     veccolor(particleindex) = White
1667.                 CASE ELSE
1668.                     veccolor(particleindex) = White
1669.             END SELECT
1670.             GOSUB calccom
1671.         END IF
1672.     LOOP
1673.     CLOSE #1
1674. END IF
1675.  
1676. '__ZZZ
1677. vecgroupcounter = vecgroupcounter + 1
1678. vecgroupindex = vecgroupcounter
1679. VectorGroup(vecgroupindex).Identity = vecgroupindex
1680. VectorGroup(vecgroupindex).Pointer = -999
1681. VectorGroup(vecgroupindex).Lagger = vecgroupindex - 1
1682. VectorGroup(vecgroupindex).ContentName = "__ZZZ"
1683. VectorGroup(vecgroupindex).FirstParticle = particleindex + 1
1684. FOR r = 1 TO 5
1685.     particleindex = particleindex + 1
1686.     vecorig(particleindex, 1) = -1000
1687.     vecorig(particleindex, 2) = -1000
1688.     vecorig(particleindex, 3) = -1000
1689.     veccolor(particleindex) = White
1690.     GOSUB calccom
1691. NEXT
1692. VectorGroup(vecgroupindex).LastParticle = particleindex
1693. GOSUB adjustcom
1694.  
1695. numparticleorig = particleindex
1696. RETURN
1697.  
1698. animateforced:
1699. ' requires vecgroupindex
1700. ' protects timevar
1701. IF thename$ = "Rotor" THEN
1702.     GOSUB resetcom
1703.     FOR particleindex = VectorGroup(vecgroupindex).FirstParticle TO VectorGroup(vecgroupindex).LastParticle
1704.         x = vecorig(particleindex, 1) - VectorGroup(vecgroupindex).CORx
1705.         y = vecorig(particleindex, 2) - VectorGroup(vecgroupindex).CORy
1706.         z = vecorig(particleindex, 3) - VectorGroup(vecgroupindex).CORz
1707.         ax = vecorigrot(particleindex, 1)
1708.         ay = vecorigrot(particleindex, 2)
1709.         az = vecorigrot(particleindex, 3)
1710.         IF az <> 0 THEN
1711.             da = timestep * az
1712.             xx = x
1713.             yy = y
1714.             x = xx * COS(da) - yy * SIN(da)
1715.             y = xx * SIN(da) + yy * COS(da)
1716.         END IF
1717.         IF ay <> 0 THEN
1718.             da = timestep * ay
1719.             xx = x
1720.             zz = z
1721.             x = xx * COS(da) + zz * SIN(da)
1722.             z = -xx * SIN(da) + zz * COS(da)
1723.         END IF
1724.         IF ax <> 0 THEN
1725.             da = timestep * ax
1726.             yy = y
1727.             zz = z
1728.             y = yy * COS(da) - zz * SIN(da)
1729.             z = yy * SIN(da) + zz * COS(da)
1730.         END IF
1731.         vecorig(particleindex, 1) = x + VectorGroup(vecgroupindex).CORx
1732.         vecorig(particleindex, 2) = y + VectorGroup(vecgroupindex).CORy
1733.         vecorig(particleindex, 3) = z + VectorGroup(vecgroupindex).CORz
1734.         GOSUB calccom
1735.     NEXT
1736.     GOSUB adjustcom
1737. END IF
1738.  
1739. RETURN
1740.  
1741. animatestandard:
1742. ' requires vecgroupindex
1743. ' protects timevar
1744. timestep = .001
1745. timevar = timevar + timestep
1746. IF timevar > 10 ^ 6 THEN timevar = 0
1747. thename$ = LTRIM$(RTRIM$(VectorGroup(vecgroupindex).ContentName))
1748. IF thename$ = "Clock Hands" THEN
1749.     pin = VectorGroup(vecgroupindex).FirstParticle
1750.     hands(1, 1) = VAL(LEFT$(TIME$, 2)) * (2 * pi / 12)
1751.     hands(2, 1) = VAL(MID$(TIME$, 4, 2)) * (2 * pi / 60)
1752.     hands(3, 1) = VAL(RIGHT$(TIME$, 2)) * (2 * pi / 60)
1753.     FOR q = 1 TO 3
1754.         FOR r = 0 TO 5 + q STEP .1
1755.             pin = pin + 1
1756.             vecorig(pin, 1) = 40 + r * COS(hands(q, 1) + pi / 2)
1757.             vecorig(pin, 2) = -10
1758.             vecorig(pin, 3) = 40 + r * SIN(hands(q, 1) + pi / 2)
1759.         NEXT
1760.     NEXT
1761. END IF
1762. IF thename$ = "Banner" THEN
1763.     pin = VectorGroup(vecgroupindex).FirstParticle
1764.     t = timevar / 50
1765.     xl = -1.9: xr = 1.9: dx = .32
1766.     yl = -1: yr = 1: dy = .32
1767.     xl = xl * 4: xr = xr * 4: yl = yl * 4: yr = yr * 4
1768.     FOR i = xl TO xr STEP dx
1769.         FOR j = yl TO yr STEP dy
1770.             pin = pin + 1
1771.             vecorig(pin, 1) = 70 + 1.25 * COS(i - 2 * t) ^ 2 - 1.25 * SIN(j - t) ^ 2
1772.             vecorig(pin, 2) = 30 + i
1773.             vecorig(pin, 3) = 40 + j
1774.             IF vecorig(pin, 1) < 70 THEN
1775.                 veccolor(pin) = Red
1776.             ELSE
1777.                 veccolor(pin) = DarkOrange
1778.             END IF
1779.         NEXT
1780.     NEXT
1781. END IF
1782. IF thename$ = "Hell Spawn" THEN
1783.     FOR i = VectorGroup(vecgroupindex).FirstParticle TO VectorGroup(vecgroupindex).LastParticle
1784.         vecorig(i, 3) = vecorig(i, 3) + .3
1785.         IF vecorig(i, 3) > -350 THEN vecorig(i, 3) = -350 - 70
1786.     NEXT
1787. END IF
1788. IF thename$ = "Moon" THEN
1789.     t = timevar * .00001
1790.     GOSUB resetcom
1791.     FOR particleindex = VectorGroup(vecgroupindex).FirstParticle TO VectorGroup(vecgroupindex).LastParticle
1792.         xx = vecorig(particleindex, 1)
1793.         yy = vecorig(particleindex, 2)
1794.         vecorig(particleindex, 1) = xx * COS(t) - yy * SIN(t)
1795.         vecorig(particleindex, 2) = xx * SIN(t) + yy * COS(t)
1796.         GOSUB calccom
1797.     NEXT
1798.     GOSUB adjustcom
1799. END IF
1800. IF thename$ = "Rain" THEN
1801.     FOR i = VectorGroup(vecgroupindex).FirstParticle TO VectorGroup(vecgroupindex).LastParticle
1802.         vecorig(i, 3) = vecorig(i, 3) - .3
1803.         IF vecorig(i, 3) < 0 THEN vecorig(i, 3) = 70
1804.     NEXT
1805. END IF
1806. IF thename$ = "Snake?" THEN
1807.     pin = VectorGroup(vecgroupindex).FirstParticle
1808.     t = timevar * .1
1809.     FOR i = -pi TO pi STEP .005
1810.         vecorig(pin, 1) = -10 + 5 * COS(i + t)
1811.         vecorig(pin, 2) = -20 + 5 * SIN(i + t)
1812.         vecorig(pin, 3) = 25 - 3 * COS(6 * i + t) * SIN(3 * i + t)
1813.         pin = pin + 1
1814.     NEXT
1815. END IF
1816. IF thename$ = "Sparks" THEN
1817.     GOSUB resetcom
1818.     dt = timestep * 100
1819.     FOR particleindex = VectorGroup(vecgroupindex).FirstParticle TO VectorGroup(vecgroupindex).LastParticle
1820.         vecorigvel(particleindex, 1) = vecorigvel(particleindex, 1) + vecorigacc(particleindex, 1) * dt
1821.         vecorigvel(particleindex, 2) = vecorigvel(particleindex, 2) + vecorigacc(particleindex, 2) * dt
1822.         vecorigvel(particleindex, 3) = vecorigvel(particleindex, 3) + vecorigacc(particleindex, 3) * dt
1823.         vecorig(particleindex, 1) = vecorig(particleindex, 1) + vecorigvel(particleindex, 1) * dt
1824.         vecorig(particleindex, 2) = vecorig(particleindex, 2) + vecorigvel(particleindex, 2) * dt
1825.         vecorig(particleindex, 3) = vecorig(particleindex, 3) + vecorigvel(particleindex, 3) * dt
1826.         IF vecorig(particleindex, 3) < 0 THEN
1827.             vecorig(particleindex, 3) = 0
1828.             vecorigvel(particleindex, 1) = vecorigvel(particleindex, 1) * .75
1829.             vecorigvel(particleindex, 2) = vecorigvel(particleindex, 2) * .75
1830.             vecorigvel(particleindex, 3) = -vecorigvel(particleindex, 3) * .5
1831.         END IF
1832.         GOSUB calccom
1833.     NEXT
1834.     GOSUB adjustcom
1835. END IF
1836. IF thename$ = "Newtonian" THEN
1837.     GOSUB resetcom
1838.     dt = timestep * 100
1839.     FOR particleindex = VectorGroup(vecgroupindex).FirstParticle TO VectorGroup(vecgroupindex).LastParticle
1840.         vecorigvel(particleindex, 1) = vecorigvel(particleindex, 1) + vecorigacc(particleindex, 1) * dt
1841.         vecorigvel(particleindex, 2) = vecorigvel(particleindex, 2) + vecorigacc(particleindex, 2) * dt
1842.         vecorigvel(particleindex, 3) = vecorigvel(particleindex, 3) + vecorigacc(particleindex, 3) * dt
1843.         vecorig(particleindex, 1) = vecorig(particleindex, 1) + vecorigvel(particleindex, 1) * dt
1844.         vecorig(particleindex, 2) = vecorig(particleindex, 2) + vecorigvel(particleindex, 2) * dt
1845.         vecorig(particleindex, 3) = vecorig(particleindex, 3) + vecorigvel(particleindex, 3) * dt
1846.         IF vecorig(particleindex, 3) < 0 THEN
1847.             vecorig(particleindex, 3) = 0
1848.             vecorigvel(particleindex, 1) = vecorigvel(particleindex, 1) * .75
1849.             vecorigvel(particleindex, 2) = vecorigvel(particleindex, 2) * .75
1850.             vecorigvel(particleindex, 3) = -vecorigvel(particleindex, 3) * .5
1851.         END IF
1852.         GOSUB calccom
1853.     NEXT
1854.     GOSUB adjustcom
1855.     IF INT(TIMER) - VectorGroup(vecgroupindex).EventTimer > 20000 THEN
1856.         PRINT VectorGroup(vecgroupindex).EventTimer
1857.         END
1858.  
1859.         VectorGroup(vecgroupindex).ContentName = "Destroyed"
1860.     END IF
1861. END IF
1862. IF thename$ = "UFO!!!" THEN
1863.     GOSUB resetcom
1864.     dt = timestep
1865.     FOR particleindex = VectorGroup(vecgroupindex).FirstParticle TO VectorGroup(vecgroupindex).LastParticle
1866.         xx = vecorig(particleindex, 1) - 150
1867.         yy = vecorig(particleindex, 2) - 150
1868.         vecorig(particleindex, 1) = xx * COS(dt) - yy * SIN(dt) + 150
1869.         vecorig(particleindex, 2) = xx * SIN(dt) + yy * COS(dt) + 150
1870.         GOSUB calccom
1871.     NEXT
1872.     GOSUB adjustcom
1873. END IF
1874.  
1875. RETURN
1876.  
1877. explode:
1878. GOSUB resetcom
1879. vecgroupindex = VectorGroup(1).Identity
1880. DO
1881.     IF LTRIM$(RTRIM$(VectorGroup(vecgroupindex).ContentName)) = "Sparks" THEN
1882.         FOR particleindex = VectorGroup(vecgroupindex).FirstParticle TO VectorGroup(vecgroupindex).LastParticle
1883.             vecorig(particleindex, 1) = explodex
1884.             vecorig(particleindex, 2) = explodey
1885.             vecorig(particleindex, 3) = explodez
1886.             vecorigvel(particleindex, 1) = (RND - .5) * 20
1887.             vecorigvel(particleindex, 2) = (RND - .5) * 20
1888.             vecorigvel(particleindex, 3) = (RND - .2) * 40
1889.             vecorigacc(particleindex, 3) = -30
1890.             GOSUB calccom
1891.         NEXT
1892.         GOSUB adjustcom
1893.         EXIT DO
1894.     END IF
1895.     vecgroupindex = VectorGroup(vecgroupindex).Pointer
1896.     IF vecgroupindex = -999 THEN EXIT DO
1897.     vecgroupindex = VectorGroup(vecgroupindex).Identity
1898. LOOP
1899. RETURN
1900.  
1901. calccom:
1902. VectorGroup(vecgroupindex).COMx = vecorig(particleindex, 1) + VectorGroup(vecgroupindex).COMx
1903. VectorGroup(vecgroupindex).COMy = vecorig(particleindex, 2) + VectorGroup(vecgroupindex).COMy
1904. VectorGroup(vecgroupindex).COMz = vecorig(particleindex, 3) + VectorGroup(vecgroupindex).COMz
1905. RETURN
1906.  
1907. adjustcom:
1908. f = 1 + VectorGroup(vecgroupindex).LastParticle - VectorGroup(vecgroupindex).FirstParticle
1909. VectorGroup(vecgroupindex).COMx = VectorGroup(vecgroupindex).COMx / f
1910. VectorGroup(vecgroupindex).COMy = VectorGroup(vecgroupindex).COMy / f
1911. VectorGroup(vecgroupindex).COMz = VectorGroup(vecgroupindex).COMz / f
1912. RETURN
1913.  
1914. resetcom:
1915. VectorGroup(vecgroupindex).COMx = 0
1916. VectorGroup(vecgroupindex).COMy = 0
1917. VectorGroup(vecgroupindex).COMz = 0
1918. RETURN

[FellippeHeitor]

This is very satisfying to watch, STx! Destroying the rotor piece by piece was even more satisfying, I must say!

[_vince]

another variant, might be faster might be slower, needs a test.  Should be much faster for larger circles and possibly slower for smaller circles.  It draws the majority of the circle as a single LINE BF using Steve's algorithm

Code: QB64: [Select]

1. 'vince's implementation of bresenham circles using steve-like optimizations
2. sub circlef(x, y, r, c as long)
3.         x0 = r
4.         y0 = 0
5.         e = -r
6.     rr = r/sqr(2)
7.         do while y0 < x0
8.                 if e <= 0 then
9.                         y0 = y0 + 1
10.             line (x-x0, y+y0)-(x-rr, y+y0), c, bf
11.             line (x+x0, y+y0)-(x+rr, y+y0), c, bf
12.                         line (x-x0, y-y0)-(x-rr, y-y0), c, bf
13.             line (x+x0, y-y0)-(x+rr, y-y0), c, bf
14.                         e = e + 2*y0
15.                 else
16.                         line (x-y0, y-x0)-(x+y0, y-x0), c, bf
17.                         line (x-y0, y+x0)-(x+y0, y+x0), c, bf
18.                         x0 = x0 - 1
19.                         e = e - 2*x0
20.                 end if
21.         loop
22.         line (x-r,y)-(x-rr,y),c,bf
23.     line (x+r,y)-(x+rr,y),c,bf
24.     line (x-rr+1, y-rr)-(x+rr-1,y+rr),c,bf
25. end sub
26.