« previous next »
Pages: [1] 2   Go Down

Author Topic: Sanctum: Open world 3D engine using CIRCLE and LINE  (Read 8467 times)

0 Members and 1 Guest are viewing this topic.

Offline STxAxTIC

  • Library Staff
  • Forum Resident
  • Posts: 1091
  • he lives
    • View Profile
Sanctum: Open world 3D engine using CIRCLE and LINE
« on: February 01, 2019, 04:45:34 pm »
Compile to an EXE. Drag+drop the file below (level.txt) onto the EXE for a bonus.

You can do all kinds of things in this alpha version: ponder the big questions, discover heaven and hell, explore the fabric of digital spacetime itself...

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

Offline STxAxTIC

  • Library Staff
  • Forum Resident
  • Posts: 1091
  • he lives
    • View Profile
Re: Sanctum: Open world 3D engine using CIRCLE and LINE
« Reply #1 on: February 02, 2019, 12:51:43 am »
... And something tells me those members in our 60+ club who grew up without FPS games might need a hand... and so might the lazy people too.

Here is a three minute video of me flying around. My first youtube post btw.

https://youtu.be/Jgw4TX0f8NE
« Last Edit: February 02, 2019, 05:30:13 pm by STxAxTIC »
Logged
You're not done when it works, you're done when it's right.

Offline Pete

  • Forum Resident
  • Posts: 2361
  • Cuz I sez so, varmint!
    • View Profile
Re: Sanctum: Open world 3D engine using CIRCLE and LINE
« Reply #2 on: February 02, 2019, 11:07:50 am »
60+ Club? A hand, no, a liver... maybe. :D

I tried it, but it triggers my trip. I miss the days when the saying made more sense the other way around. Anyways, thanks the posting the 3-D effect in our 2-D universe, but since we are living in a Second-D World, and I'm a SCREEN 0 girl, I'll stick with the text stuff.

Pete
Logged
Want to learn how to write code on cave walls? https://www.tapatalk.com/groups/qbasic/qbasic-f1/

Offline STxAxTIC

  • Library Staff
  • Forum Resident
  • Posts: 1091
  • he lives
    • View Profile
Re: Sanctum: Open world 3D engine using CIRCLE and LINE (screen 0 version ready)
« Reply #3 on: February 02, 2019, 11:39:20 am »
Sigh.

Just for Pete, here is the same program in SCREEN 0. (Where's Fluffrabbit by the way?)

Code: QB64: [Select]
  1. '#lang "qb"
  2.  
  3. ' Video.
  6. screenwidth = 640
  7. screenheight = 480
  8.  
  9. ' Memory.
  10. DIM bignumber AS LONG
  11. bignumber = 3000000
  12. DIM numparticleorig AS LONG
  13. numparticleorig = bignumber
  14. numparticlevisible = bignumber
  15.  
  16. ' Constant(s).
  17. pi = 3.1415926536
  18. ee = 2.7182818285
  19.  
  20. ' Camera orientation vectors.
  21. DIM uhat(1 TO 3), vhat(1 TO 3), nhat(1 TO 3)
  22.  
  23. ' Clipping planes.
  24. 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)
  25.  
  26. ' Basis vectors defined in xyz three-space.
  27. DIM xhat(1 TO 4), yhat(1 TO 4), zhat(1 TO 4)
  28. xhat(1) = 1: xhat(2) = 0: xhat(3) = 0: xhat(4) = 4
  29. yhat(1) = 0: yhat(2) = 1: yhat(3) = 0: yhat(4) = 2
  30. zhat(1) = 0: zhat(2) = 0: zhat(3) = 1: zhat(4) = 1
  31.  
  32. ' Basis vectors projected in uv two-space.
  33. DIM xhatp(1 TO 2), yhatp(1 TO 2), zhatp(1 TO 2)
  34.  
  35. ' Particle vectors defined in xyz three-space.
  36. DIM vecgroupname(bignumber / 10) AS STRING
  37. DIM vecaddress(bignumber / 10, 2) AS LONG
  38. DIM veccom(bignumber / 10, 3)
  39. DIM vecorig(numparticleorig, 3)
  40. DIM vecorigvel(numparticleorig, 3)
  41. DIM vecorigacc(numparticleorig, 3)
  42. DIM veccolor(numparticleorig)
  43. DIM vec(numparticleorig, 3)
  44. DIM vecvisible(numparticlevisible, 4)
  45.  
  46. ' Particle vectors projected in uv two-space.
  47. DIM vecpuv(numparticleorig, 1 TO 2)
  48. DIM vecvisiblepuv(numparticlevisible, 1 TO 2)
  49.  
  50. ' Particle projections adjusted for screen uv two-space.
  51. DIM vecpuvs(numparticleorig, 1 TO 2)
  52. DIM vecvisiblepuvs(numparticlevisible, 1 TO 2)
  53.  
  54. ' State.
  56. vecgroupcounter = 0
  57. numparticleorig = 0
  58. numparticlevisible = 0
  59. pcountparticleorig = 0
  60. fovd = -256 ' Field-of-view constant.
  61. nearplane(4) = 1
  62. farplane(4) = -100
  63. rightplane(4) = 0 '*' fovd * (nhat(1) * rightplane(1) + nhat(2) * rightplane(2) + nhat(3) * rightplane(3))
  64. leftplane(4) = 0
  65. topplane(4) = 0
  66. bottomplane(4) = 0
  67. centerx = screenwidth / 2
  68. centery = screenheight / 2
  69. speeddamp = 1 / 66 ' Rotation damper.
  70. speedboost = 1.5 ' Linear boost.
  71. timevar = 0
  72. uhat(1) = -.2078192: uhat(2) = -.9781672: uhat(3) = 0
  73. vhat(1) = 0: vhat(2) = 0: vhat(3) = 1
  74. camx = -42
  75. camy = 28
  76. camz = 40
  77. toggletimeanimate = 1
  78. toggleinvertmouse = -1
  79. togglehud = 1
  80.  
  81. ' Prime main loop.
  82. GOSUB initialize.objects
  83. numparticleorig = pcountparticleorig
  84. GOSUB redraw
  85.  
  86. ' Begin main loop.
  88.     IF toggletimeanimate = 1 THEN flagredraw = 1
  89.     IF flagredraw = 1 THEN
  90.         GOSUB redraw
  91.         flagredraw = -1
  92.     END IF
  93.     GOSUB mouseprocess
  94.     GOSUB keyprocess
  95.  
  96.     _DISPLAY
  97.     _KEYCLEAR
  98.     _LIMIT 30
  100.  
  102.  
  103. ' Gosubs.
  104.  
  105. mouseprocess:
  108.         GOSUB rotate.uhat.plus: GOSUB normalize.screen.vectors
  109.     END IF
  111.         GOSUB rotate.uhat.minus: GOSUB normalize.screen.vectors
  112.     END IF
  114.         IF toggleinvertmouse = -1 THEN
  115.             GOSUB rotate.vhat.plus: GOSUB normalize.screen.vectors
  116.         ELSE
  117.             GOSUB rotate.vhat.minus: GOSUB normalize.screen.vectors
  118.         END IF
  119.     END IF
  121.         IF toggleinvertmouse = -1 THEN
  122.             GOSUB rotate.vhat.minus: GOSUB normalize.screen.vectors
  123.         ELSE
  124.             GOSUB rotate.vhat.plus: GOSUB normalize.screen.vectors
  125.         END IF
  126.     END IF
  127.     IF _MOUSEWHEEL > 0 THEN GOSUB rotate.clockwise
  128.     IF _MOUSEWHEEL < 0 THEN GOSUB rotate.counterclockwise
  129.     'MouseLB = _MOUSEBUTTON(1)
  130.     'MouseRB = _MOUSEBUTTON(2)
  131.     flagredraw = 1
  134.  
  135. keyprocess:
  137. IF key$ <> "" THEN flagredraw = 1
  139.     CASE "8":
  140.         GOSUB rotate.vhat.plus
  141.     CASE "2":
  142.         GOSUB rotate.vhat.minus
  143.     CASE "4":
  144.         GOSUB rotate.uhat.minus
  145.     CASE "6":
  146.         GOSUB rotate.uhat.plus
  147.     CASE "7":
  148.         GOSUB rotate.clockwise
  149.     CASE "9":
  150.         GOSUB rotate.counterclockwise
  151.     CASE "1":
  152.         GOSUB rotate.uhat.minus: GOSUB normalize.screen.vectors: GOSUB rotate.clockwise
  153.     CASE "3":
  154.         GOSUB rotate.uhat.plus: GOSUB normalize.screen.vectors: GOSUB rotate.counterclockwise
  155.     CASE "s"
  156.         GOSUB strafe.camera.nhat.plus
  157.     CASE "w"
  158.         GOSUB strafe.camera.nhat.minus
  159.     CASE "d"
  160.         GOSUB strafe.camera.uhat.plus
  161.     CASE "a"
  162.         GOSUB strafe.camera.uhat.minus
  163.     CASE "e"
  164.         GOSUB strafe.camera.vhat.plus
  165.     CASE "q"
  166.         GOSUB strafe.camera.vhat.minus
  167.     CASE "x"
  168.         uhat(1) = 0: uhat(2) = 1: uhat(3) = 0
  169.         vhat(1) = 0: vhat(2) = 0: vhat(3) = 1
  170.     CASE "X"
  171.         uhat(1) = 0: uhat(2) = -1: uhat(3) = 0
  172.         vhat(1) = 0: vhat(2) = 0: vhat(3) = 1
  173.     CASE "y"
  174.         uhat(1) = -1: uhat(2) = 0: uhat(3) = 0
  175.         vhat(1) = 0: vhat(2) = 0: vhat(3) = 1
  176.     CASE "Y"
  177.         uhat(1) = 1: uhat(2) = 0: uhat(3) = 0
  178.         vhat(1) = 0: vhat(2) = 0: vhat(3) = 1
  179.     CASE "z"
  180.         uhat(1) = 1: uhat(2) = 0: uhat(3) = 0
  181.         vhat(1) = 0: vhat(2) = 1: vhat(3) = 0
  182.         GOSUB normalize.screen.vectors
  183.     CASE "Z"
  184.         uhat(1) = 0: uhat(2) = 1: uhat(3) = 0
  185.         vhat(1) = 1: vhat(2) = 0: vhat(3) = 0
  186.     CASE "]"
  187.         farplane(4) = farplane(4) - 1
  188.     CASE "["
  189.         farplane(4) = farplane(4) + 1
  190.     CASE " "
  191.         togglehud = -togglehud
  192.     CASE "t"
  193.         toggletimeanimate = -toggletimeanimate
  194.     CASE "i"
  195.         toggleinvertmouse = -toggleinvertmouse
  196.     CASE CHR$(27)
  197.         SYSTEM
  198.     CASE "f"
  199.         FOR k = 1 TO vecgroupcounter
  200.             IF vecgroupname(k) = "Sparks" THEN
  201.                 vgc = k
  202.                 FOR i = vecaddress(vgc, 1) TO vecaddress(vgc, 2)
  203.                     vecorig(i, 1) = camx + -nhat(1) * (1 - .1 * RND) * 60
  204.                     vecorig(i, 2) = camy + -nhat(2) * (1 - .1 * RND) * 60
  205.                     vecorig(i, 3) = camz + -nhat(3) * (1 - .1 * RND) * 60
  206.                     vecorigvel(i, 1) = (RND - .5) * 20
  207.                     vecorigvel(i, 2) = (RND - .5) * 20
  208.                     vecorigvel(i, 3) = (RND - .2) * 40
  209.                     vecorigacc(i, 3) = -30
  210.                     GOSUB calccom
  211.                 NEXT
  212.                 GOSUB adjustcom
  213.             END IF
  214.         NEXT
  217.  
  218. convert:
  219. ' Convert graphics from uv-cartesian coordinates to monitor coordinates.
  220. x0 = x: y0 = y
  221. x = x0 + centerx
  222. y = -y0 + centery
  224.  
  225. rotate.uhat.plus:
  226. uhat(1) = uhat(1) + nhat(1) * speeddamp
  227. uhat(2) = uhat(2) + nhat(2) * speeddamp
  228. uhat(3) = uhat(3) + nhat(3) * speeddamp
  230.  
  231. rotate.uhat.minus:
  232. uhat(1) = uhat(1) - nhat(1) * speeddamp
  233. uhat(2) = uhat(2) - nhat(2) * speeddamp
  234. uhat(3) = uhat(3) - nhat(3) * speeddamp
  236.  
  237. rotate.vhat.plus:
  238. vhat(1) = vhat(1) + nhat(1) * speeddamp
  239. vhat(2) = vhat(2) + nhat(2) * speeddamp
  240. vhat(3) = vhat(3) + nhat(3) * speeddamp
  242.  
  243. rotate.vhat.minus:
  244. vhat(1) = vhat(1) - nhat(1) * speeddamp
  245. vhat(2) = vhat(2) - nhat(2) * speeddamp
  246. vhat(3) = vhat(3) - nhat(3) * speeddamp
  248.  
  249. rotate.counterclockwise:
  250. v1 = vhat(1)
  251. v2 = vhat(2)
  252. v3 = vhat(3)
  253. vhat(1) = vhat(1) + uhat(1) * speeddamp
  254. vhat(2) = vhat(2) + uhat(2) * speeddamp
  255. vhat(3) = vhat(3) + uhat(3) * speeddamp
  256. uhat(1) = uhat(1) - v1 * speeddamp
  257. uhat(2) = uhat(2) - v2 * speeddamp
  258. uhat(3) = uhat(3) - v3 * speeddamp
  260.  
  261. rotate.clockwise:
  262. v1 = vhat(1)
  263. v2 = vhat(2)
  264. v3 = vhat(3)
  265. vhat(1) = vhat(1) - uhat(1) * speeddamp
  266. vhat(2) = vhat(2) - uhat(2) * speeddamp
  267. vhat(3) = vhat(3) - uhat(3) * speeddamp
  268. uhat(1) = uhat(1) + v1 * speeddamp
  269. uhat(2) = uhat(2) + v2 * speeddamp
  270. uhat(3) = uhat(3) + v3 * speeddamp
  272.  
  273. strafe.camera.uhat.plus:
  274. camx = camx + uhat(1) * speedboost
  275. camy = camy + uhat(2) * speedboost
  276. camz = camz + uhat(3) * speedboost
  278.  
  279. strafe.camera.uhat.minus:
  280. camx = camx - uhat(1) * speedboost
  281. camy = camy - uhat(2) * speedboost
  282. camz = camz - uhat(3) * speedboost
  284.  
  285. strafe.camera.vhat.plus:
  286. camx = camx + vhat(1) * speedboost
  287. camy = camy + vhat(2) * speedboost
  288. camz = camz + vhat(3) * speedboost
  290.  
  291. strafe.camera.vhat.minus:
  292. camx = camx - vhat(1) * speedboost
  293. camy = camy - vhat(2) * speedboost
  294. camz = camz - vhat(3) * speedboost
  296.  
  297. strafe.camera.nhat.plus:
  298. camx = camx + nhat(1) * speedboost
  299. camy = camy + nhat(2) * speedboost
  300. camz = camz + nhat(3) * speedboost
  302.  
  303. strafe.camera.nhat.minus:
  304. camx = camx - nhat(1) * speedboost
  305. camy = camy - nhat(2) * speedboost
  306. camz = camz - nhat(3) * speedboost
  308.  
  309. normalize.screen.vectors:
  310. uhatmag = SQR(uhat(1) ^ 2 + uhat(2) ^ 2 + uhat(3) ^ 2)
  311. uhat(1) = uhat(1) / uhatmag: uhat(2) = uhat(2) / uhatmag: uhat(3) = uhat(3) / uhatmag
  312. vhatmag = SQR(vhat(1) ^ 2 + vhat(2) ^ 2 + vhat(3) ^ 2)
  313. vhat(1) = vhat(1) / vhatmag: vhat(2) = vhat(2) / vhatmag: vhat(3) = vhat(3) / vhatmag
  314. uhatdotvhat = uhat(1) * vhat(1) + uhat(2) * vhat(2) + uhat(3) * vhat(3)
  315. IF SQR(uhatdotvhat ^ 2) > .0005 THEN
  316.     BEEP ' ... if vectors are somenow not normalized. This has never happened.
  317.     uhat(1) = 0.8251367: uhat(2) = -0.564903: uhat(3) = -0.005829525
  318.     vhat(1) = 0.065519: vhat(2) = 0.08544215: vhat(3) = 0.9941866
  320. ' The normal vector points toward the eye.
  321. nhat(1) = uhat(2) * vhat(3) - uhat(3) * vhat(2)
  322. nhat(2) = uhat(3) * vhat(1) - uhat(1) * vhat(3)
  323. nhat(3) = uhat(1) * vhat(2) - uhat(2) * vhat(1)
  324. nhatmag = SQR(nhat(1) ^ 2 + nhat(2) ^ 2 + nhat(3) ^ 2)
  325. nhat(1) = nhat(1) / nhatmag: nhat(2) = nhat(2) / nhatmag: nhat(3) = nhat(3) / nhatmag
  327.  
  328. redraw:
  329. GOSUB normalize.screen.vectors
  330. GOSUB calculate.clippingplanes
  331. ' Project the three-space basis vectors onto the screen plane.
  332. xhatp(1) = xhat(1) * uhat(1) + xhat(2) * uhat(2) + xhat(3) * uhat(3)
  333. xhatp(2) = xhat(1) * vhat(1) + xhat(2) * vhat(2) + xhat(3) * vhat(3)
  334. yhatp(1) = yhat(1) * uhat(1) + yhat(2) * uhat(2) + yhat(3) * uhat(3)
  335. yhatp(2) = yhat(1) * vhat(1) + yhat(2) * vhat(2) + yhat(3) * vhat(3)
  336. zhatp(1) = zhat(1) * uhat(1) + zhat(2) * uhat(2) + zhat(3) * uhat(3)
  337. zhatp(2) = zhat(1) * vhat(1) + zhat(2) * vhat(2) + zhat(3) * vhat(3)
  338. GOSUB compute.visible.particles
  339. GOSUB project.particles
  340. GOSUB draw.all.objects
  342.  
  343. compute.visible.particles:
  344. numparticlevisible = 0
  345. closestdist2 = 10000 ^ 2
  346. closestgroup = -1
  347. FOR k = 1 TO vecgroupcounter
  348.     dist2 = (camx - veccom(k, 1)) ^ 2 + (camy - veccom(k, 2)) ^ 2 + (camz - veccom(k, 3)) ^ 2
  349.  
  350.     IF dist2 < farplane(4) ^ 2 THEN
  351.  
  352.         groupinview = 1 ' Dsiable near plane group clipping to make things more interesting at zero distance.
  353.         IF (veccom(k, 1) - camx) * nearplane(1) + (veccom(k, 2) - camy) * nearplane(2) + (veccom(k, 3) - camz) * nearplane(3) - nearplane(4) < 0 THEN groupinview = 0
  354.         'IF (veccom(k, 1) - camx) * farplane(1) + (veccom(k, 2) - camy) * farplane(2) + (veccom(k, 3) - camz) * farplane(3) - farplane(4) < 0 THEN groupinview = 0
  355.         IF (veccom(k, 1) - camx) * rightplane(1) + (veccom(k, 2) - camy) * rightplane(2) + (veccom(k, 3) - camz) * rightplane(3) - rightplane(4) < 0 THEN groupinview = 0
  356.         IF (veccom(k, 1) - camx) * leftplane(1) + (veccom(k, 2) - camy) * leftplane(2) + (veccom(k, 3) - camz) * leftplane(3) - leftplane(4) < 0 THEN groupinview = 0
  357.         IF (veccom(k, 1) - camx) * topplane(1) + (veccom(k, 2) - camy) * topplane(2) + (veccom(k, 3) - camz) * topplane(3) - topplane(4) < 0 THEN groupinview = 0
  358.         IF (veccom(k, 1) - camx) * bottomplane(1) + (veccom(k, 2) - camy) * bottomplane(2) + (veccom(k, 3) - camz) * bottomplane(3) - bottomplane(4) < 0 THEN groupinview = 0
  359.         IF groupinview = 1 THEN
  360.  
  361.             FOR i = vecaddress(k, 1) TO vecaddress(k, 2)
  362.                 vec(i, 1) = vecorig(i, 1) - camx
  363.                 vec(i, 2) = vecorig(i, 2) - camy
  364.                 vec(i, 3) = vecorig(i, 3) - camz
  365.             NEXT
  366.  
  367.             IF toggletimeanimate = 1 THEN GOSUB timeanimate
  368.  
  369.             FOR i = vecaddress(k, 1) TO vecaddress(k, 2)
  370.                 GOSUB clip.particle.viewplanes
  371.             NEXT
  372.  
  373.         END IF
  374.  
  375.         IF dist2 < closestdist2 THEN
  376.             closestdist2 = dist2
  377.             closestgroup = k
  378.         END IF
  379.  
  380.     END IF
  383.  
  384. clip.particle.viewplanes:
  385. particleinview = 1
  386. fogswitch = -1
  387. ' Perform standard view plane clipping and implement fog effect.
  388. IF vec(i, 1) * nearplane(1) + vec(i, 2) * nearplane(2) + vec(i, 3) * nearplane(3) - nearplane(4) < 0 THEN particleinview = 0
  389. IF vec(i, 1) * farplane(1) + vec(i, 2) * farplane(2) + vec(i, 3) * farplane(3) - farplane(4) < 0 THEN particleinview = 0
  390. IF vec(i, 1) * farplane(1) + vec(i, 2) * farplane(2) + vec(i, 3) * farplane(3) - farplane(4) * .9 < 0 THEN fogswitch = 1
  391. IF vec(i, 1) * rightplane(1) + vec(i, 2) * rightplane(2) + vec(i, 3) * rightplane(3) - rightplane(4) < 0 THEN particleinview = 0
  392. IF vec(i, 1) * leftplane(1) + vec(i, 2) * leftplane(2) + vec(i, 3) * leftplane(3) - leftplane(4) < 0 THEN particleinview = 0
  393. IF vec(i, 1) * topplane(1) + vec(i, 2) * topplane(2) + vec(i, 3) * topplane(3) - topplane(4) < 0 THEN particleinview = 0
  394. IF vec(i, 1) * bottomplane(1) + vec(i, 2) * bottomplane(2) + vec(i, 3) * bottomplane(3) - bottomplane(4) < 0 THEN particleinview = 0
  395. IF particleinview = 1 THEN
  396.     numparticlevisible = numparticlevisible + 1
  397.     vecvisible(numparticlevisible, 1) = vec(i, 1)
  398.     vecvisible(numparticlevisible, 2) = vec(i, 2)
  399.     vecvisible(numparticlevisible, 3) = vec(i, 3)
  400.     vecvisible(numparticlevisible, 4) = veccolor(i)
  401.     IF fogswitch = 1 THEN vecvisible(numparticlevisible, 4) = 8
  404.  
  405. project.particles:
  406. ' Project vectors onto the screen plane.
  407. FOR i = 1 TO numparticlevisible
  408.     vecvisibledotnhat = vecvisible(i, 1) * nhat(1) + vecvisible(i, 2) * nhat(2) + vecvisible(i, 3) * nhat(3)
  409.     vecvisiblepuv(i, 1) = vecvisible(i, 1) * uhat(1) + vecvisible(i, 2) * uhat(2) + vecvisible(i, 3) * uhat(3)
  410.     vecvisiblepuv(i, 2) = vecvisible(i, 1) * vhat(1) + vecvisible(i, 2) * vhat(2) + vecvisible(i, 3) * vhat(3)
  411.     vecvisiblepuvs(i, 1) = vecvisiblepuv(i, 1) * fovd / vecvisibledotnhat
  412.     vecvisiblepuvs(i, 2) = vecvisiblepuv(i, 2) * fovd / vecvisibledotnhat
  415.  
  416. draw.all.objects:
  417. GOSUB plot.particles
  418. ' Redraw compass.
  419. x = 30 * xhatp(1): y = 30 * xhatp(2): GOSUB convert
  420. 'LINE (centerx, centery)-(x, y), xhat(4)
  421. x = 30 * yhatp(1): y = 30 * yhatp(2): GOSUB convert
  422. 'LINE (centerx, centery)-(x, y), yhat(4)
  423. x = 30 * zhatp(1): y = 30 * zhatp(2): GOSUB convert
  424. 'LINE (centerx, centery)-(x, y), zhat(4)
  425. IF togglehud = 1 THEN
  426.     COLOR 7
  427.     LOCATE 28, 26: PRINT "SPACE = toggle Info,  ESC = quit."
  428.     COLOR 14
  429.     LOCATE 26, 2: PRINT "- MOVE - ALIGN -"
  430.     COLOR 15
  431.     LOCATE 27, 2: PRINT " q w e - x y z"
  432.     LOCATE 28, 2: PRINT " a s d - X Y Z"
  433.     COLOR 14
  434.     LOCATE 25, 68: PRINT "-  ROTATE  -"
  435.     COLOR 7
  436.     LOCATE 26, 68: PRINT "7 8 9"
  437.     LOCATE 27, 68: PRINT "4 5 6"
  438.     LOCATE 28, 68: PRINT "1 2 3"
  439.     COLOR 7
  440.     LOCATE 26, 75: PRINT "Mouse"
  441.     LOCATE 27, 75: PRINT "  +  "
  442.     LOCATE 28, 75: PRINT "Wheel"
  443.     COLOR 7
  444.     LOCATE 1, 2: PRINT "- World Info -"
  445.     LOCATE 2, 2: PRINT "Particles:"; numparticleorig
  446.     LOCATE 3, 2: PRINT "Visible:"; numparticlevisible
  447.     LOCATE 5, 2: PRINT "- Player -"
  448.     LOCATE 6, 2: PRINT INT(camx); INT(camy); INT(camz)
  449.     LOCATE 8, 2: PRINT "- You see: -"
  450.     LOCATE 9, 2: PRINT vecgroupname(closestgroup)
  451.     'FOR k = 1 TO vecgroupcounter
  452.     '    IF vecgroupname(k) = "Sparks" THEN
  453.     '        LOCATE 10, 1: PRINT veccom(k, 1); veccom(k, 2); veccom(k, 3)
  454.     '        LOCATE 12, 1: PRINT SQR((camx - veccom(k, 1)) ^ 2 + (camy - veccom(k, 2)) ^ 2 + (camz - veccom(k, 3)) ^ 2)
  455.     '    END IF
  456.     'NEXT
  457.     LOCATE 1, 63: PRINT "- View Distance -"
  458.     LOCATE 2, 65: PRINT "Depth:"; -farplane(4)
  459.     LOCATE 3, 65: PRINT "Adjust via [ ]"
  460.     LOCATE 5, 63: PRINT "- Invert Mouse -"
  461.     LOCATE 6, 65: PRINT "Toggle via `i'"
  462.     LOCATE 1, 25: PRINT "Press `T' to toggle animation."
  464.     COLOR 7
  465.     LOCATE 28, 32: PRINT "You See: "; vecgroupname(closestgroup)
  468.  
  469. calculate.clippingplanes:
  470. ' Calculate normal vectors to all clipping planes.
  471. nearplane(1) = -nhat(1)
  472. nearplane(2) = -nhat(2)
  473. nearplane(3) = -nhat(3)
  474. farplane(1) = nhat(1)
  475. farplane(2) = nhat(2)
  476. farplane(3) = nhat(3)
  477. rightplane(1) = (screenheight / 2) * fovd * uhat(1) - (screenheight / 2) * (screenwidth / 2) * nhat(1)
  478. rightplane(2) = (screenheight / 2) * fovd * uhat(2) - (screenheight / 2) * (screenwidth / 2) * nhat(2)
  479. rightplane(3) = (screenheight / 2) * fovd * uhat(3) - (screenheight / 2) * (screenwidth / 2) * nhat(3)
  480. mag = SQR((rightplane(1)) ^ 2 + (rightplane(2)) ^ 2 + (rightplane(3)) ^ 2)
  481. rightplane(1) = rightplane(1) / mag
  482. rightplane(2) = rightplane(2) / mag
  483. rightplane(3) = rightplane(3) / mag
  484. leftplane(1) = -(screenheight / 2) * fovd * uhat(1) - (screenheight / 2) * (screenwidth / 2) * nhat(1)
  485. leftplane(2) = -(screenheight / 2) * fovd * uhat(2) - (screenheight / 2) * (screenwidth / 2) * nhat(2)
  486. leftplane(3) = -(screenheight / 2) * fovd * uhat(3) - (screenheight / 2) * (screenwidth / 2) * nhat(3)
  487. mag = SQR((leftplane(1)) ^ 2 + (leftplane(2)) ^ 2 + (leftplane(3)) ^ 2)
  488. leftplane(1) = leftplane(1) / mag
  489. leftplane(2) = leftplane(2) / mag
  490. leftplane(3) = leftplane(3) / mag
  491. topplane(1) = (screenwidth / 2) * fovd * vhat(1) - (screenheight / 2) * (screenwidth / 2) * nhat(1)
  492. topplane(2) = (screenwidth / 2) * fovd * vhat(2) - (screenheight / 2) * (screenwidth / 2) * nhat(2)
  493. topplane(3) = (screenwidth / 2) * fovd * vhat(3) - (screenheight / 2) * (screenwidth / 2) * nhat(3)
  494. mag = SQR((topplane(1)) ^ 2 + (topplane(2)) ^ 2 + (topplane(3)) ^ 2)
  495. topplane(1) = topplane(1) / mag
  496. topplane(2) = topplane(2) / mag
  497. topplane(3) = topplane(3) / mag
  498. bottomplane(1) = -(screenwidth / 2) * fovd * vhat(1) - (screenheight / 2) * (screenwidth / 2) * nhat(1)
  499. bottomplane(2) = -(screenwidth / 2) * fovd * vhat(2) - (screenheight / 2) * (screenwidth / 2) * nhat(2)
  500. bottomplane(3) = -(screenwidth / 2) * fovd * vhat(3) - (screenheight / 2) * (screenwidth / 2) * nhat(3)
  501. mag = SQR((bottomplane(1)) ^ 2 + (bottomplane(2)) ^ 2 + (bottomplane(3)) ^ 2)
  502. bottomplane(1) = bottomplane(1) / mag
  503. bottomplane(2) = bottomplane(2) / mag
  504. bottomplane(3) = bottomplane(3) / mag
  506.  
  507. plot.particles:
  509. FOR i = 1 TO numparticlevisible - 1
  510.     x = vecvisiblepuvs(i, 1): y = vecvisiblepuvs(i, 2) ': GOSUB convert
  511.     x1 = x: y1 = y
  512.     x = vecvisiblepuvs(i + 1, 1): y = vecvisiblepuvs(i + 1, 2) ': GOSUB convert
  513.     x2 = x: y2 = y
  514.     'IF ((x2 - x1) ^ 2 + (y2 - y1) ^ 2) < 15 ^ 2 THEN
  515.     '    LINE (x1, y1)-(x2, y2), vecvisible(i, 4) ', B
  516.     '    'PSET (x1, y1), vecvisible(i, 4)
  517.     'ELSE
  518.     '    CIRCLE (x1, y1), 1, vecvisible(i, 4)
  519.     '    'PSET (x1, y1), vecvisible(i, 4)
  520.     'END IF
  521.     xtext = (x1 + screenwidth / 2) * (80 / screenwidth)
  522.     ytext = (screenheight / 2 - y1) * (48 / screenheight) + 1
  523.     IF xtext < 1 THEN xtext = 1
  524.     IF xtext > 80 THEN xtext = 80
  525.     IF ytext < 1 THEN ytext = 1
  526.     IF ytext > 48 THEN ytext = 48
  527.     COLOR vecvisible(i, 4)
  528.     LOCATE ytext, xtext: PRINT "*"
  529.  
  532.  
  533. ' Data.
  534.  
  535. initialize.objects:
  536. pcountparticleorig = 0
  537.  
  538. gridsize = 550
  539. tilesize = 15
  540.  
  541. 'Waving Banner
  542. vecgroupcounter = vecgroupcounter + 1
  543. vgc = vecgroupcounter
  544. vecgroupname(vgc) = "Waving Banner"
  545. vecaddress(vgc, 1) = pcountparticleorig
  546. xl = -1.9: xr = 1.9: dx = .32
  547. yl = -1: yr = 1: dy = .32
  548. xl = xl * 4: xr = xr * 4: yl = yl * 4: yr = yr * 4
  549. xrange = 1 + INT((-xl + xr) / dx)
  550. yrange = 1 + INT((-yl + yr) / dy)
  551. t = 0
  552. FOR i = xl TO xr STEP dx
  553.     FOR j = yl TO yr STEP dy
  554.         pcountparticleorig = pcountparticleorig + 1
  555.         pn = pcountparticleorig
  556.         vecorig(pn, 1) = 70 + 1.25 * COS(i - 2 * t) ^ 2 - 1.25 * SIN(j - t) ^ 2
  557.         vecorig(pn, 2) = 30 + i
  558.         vecorig(pn, 3) = 40 + j
  559.         IF vecorig(pn, 1) < 70 THEN
  560.             veccolor(pn) = 11
  561.         ELSE
  562.             veccolor(pn) = 6
  563.         END IF
  564.         GOSUB calccom
  565.     NEXT
  567. vecaddress(vgc, 2) = pn
  568. GOSUB adjustcom
  569.  
  570. 'Clock Face (Rolex)
  571. vecgroupcounter = vecgroupcounter + 1
  572. vgc = vecgroupcounter
  573. vecgroupname(vgc) = "Clock Face (Rolex)"
  574. vecaddress(vgc, 1) = pcountparticleorig
  575. FOR q = 0 TO 2 * pi STEP (2 * pi / 12) / 25
  576.     FOR r = 10 TO 12 STEP .5
  577.         pcountparticleorig = pcountparticleorig + 1
  578.         pn = pcountparticleorig
  579.         vecorig(pn, 1) = 40 + r * COS(q)
  580.         vecorig(pn, 2) = -20 + r
  581.         vecorig(pn, 3) = 40 + r * SIN(q)
  582.         veccolor(pn) = 15
  583.         GOSUB calccom
  584.     NEXT
  586. vecaddress(vgc, 2) = pn
  587. GOSUB adjustcom
  588.  
  589. 'Clock Hands
  590. vecgroupcounter = vecgroupcounter + 1
  591. vgc = vecgroupcounter
  592. vecgroupname(vgc) = "Clock Hands"
  593. vecaddress(vgc, 1) = pcountparticleorig
  594. DIM hands(3, 2)
  595. hands(1, 1) = VAL(LEFT$(TIME$, 2)) * (2 * pi / 12)
  596. hands(2, 1) = VAL(MID$(TIME$, 4, 2)) * (2 * pi / 60)
  597. hands(3, 1) = VAL(RIGHT$(TIME$, 2)) * (2 * pi / 60)
  598. phase = pi / 2
  599. hands(1, 2) = 3
  600. hands(2, 2) = 5
  601. hands(3, 2) = 9
  602. FOR q = 1 TO 3
  603.     FOR r = 0 TO 5 + q STEP .1
  604.         pcountparticleorig = pcountparticleorig + 1
  605.         pn = pcountparticleorig
  606.         vecorig(pn, 1) = 40 + r * COS(hands(q, 1) + phase)
  607.         vecorig(pn, 2) = -10
  608.         vecorig(pn, 3) = 40 + r * SIN(hands(q, 1) + phase)
  609.         veccolor(pn) = hands(q, 2)
  610.         GOSUB calccom
  611.     NEXT
  613. vecaddress(vgc, 2) = pn
  614. GOSUB adjustcom
  615.  
  616. 'Dirt
  617. h = 5
  618. FOR w = 1 TO 5
  619.     FOR u = -gridsize TO gridsize STEP tilesize
  620.         FOR v = -gridsize TO gridsize STEP tilesize
  621.             vecgroupcounter = vecgroupcounter + 1
  622.             vgc = vecgroupcounter
  623.             vecgroupname(vgc) = "Dirt"
  624.             vecaddress(vgc, 1) = pcountparticleorig
  625.             FOR i = u TO u + tilesize STEP h
  626.                 FOR j = v TO v + tilesize STEP h
  627.                     IF RND > 1 - w / 5 THEN
  628.                         pcountparticleorig = pcountparticleorig + 1
  629.                         pn = pcountparticleorig
  630.                         vecorig(pn, 1) = i + RND * h - RND * h
  631.                         vecorig(pn, 2) = j + RND * h - RND * h
  632.                         vecorig(pn, 3) = -(w - 1) * 70 - RND * 70
  633.                         IF RND > .5 THEN
  634.                             veccolor(pn) = 6
  635.                         ELSE
  636.                             IF RND > .5 THEN
  637.                                 veccolor(pn) = 7
  638.                             ELSE
  639.                                 veccolor(pn) = 8
  640.                             END IF
  641.                         END IF
  642.                         GOSUB calccom
  643.                     END IF
  644.                 NEXT
  645.             NEXT
  646.             vecaddress(vgc, 2) = pn
  647.             GOSUB adjustcom
  648.         NEXT
  649.     NEXT
  651.  
  652. 'Grass and Puddles
  653. h = 2
  654. FOR u = -gridsize TO gridsize STEP tilesize
  655.     FOR v = -gridsize TO gridsize STEP tilesize
  656.         vecgroupcounter = vecgroupcounter + 1
  657.         vgc = vecgroupcounter
  658.         vecgroupname(vgc) = "Grass and Puddles"
  659.         vecaddress(vgc, 1) = pcountparticleorig
  660.         FOR i = u TO u + tilesize STEP h
  661.             FOR j = v TO v + tilesize STEP h
  662.                 pcountparticleorig = pcountparticleorig + 1
  663.                 pn = pcountparticleorig
  664.                 vecorig(pn, 1) = i + RND * h - RND * h
  665.                 vecorig(pn, 2) = j + RND * h - RND * h
  666.                 vecorig(pn, 3) = .5 + 1 * COS((i - 15) * .08) - 1 * COS((j - 6) * .12)
  667.                 IF vecorig(pn, 3) > 0 THEN
  668.                     veccolor(pn) = 2
  669.                 ELSE
  670.                     IF RND > .2 THEN
  671.                         veccolor(pn) = 9
  672.                     ELSE
  673.                         veccolor(pn) = 1
  674.                     END IF
  675.                 END IF
  676.                 GOSUB calccom
  677.             NEXT
  678.         NEXT
  679.         vecaddress(vgc, 2) = pn
  680.         GOSUB adjustcom
  681.     NEXT
  683.  
  684. 'Grave
  685. 'xloc = -90
  686. 'yloc = 0
  687. thickness = 2.5
  688. span = 20
  689. height = 30
  690. crux = 22
  691. FOR xloc = -90 TO -290 STEP -60
  692.     FOR yloc = 0 TO 180 STEP 45
  693.         FOR k = 0 TO height
  694.             vecgroupcounter = vecgroupcounter + 1
  695.             vgc = vecgroupcounter
  696.             vecgroupname(vgc) = "Grave"
  697.             vecaddress(vgc, 1) = pcountparticleorig
  698.             FOR i = -thickness TO thickness STEP thickness / 2
  699.                 FOR j = -thickness TO thickness STEP thickness / 2
  700.                     pcountparticleorig = pcountparticleorig + 1
  701.                     pn = pcountparticleorig
  702.                     vecorig(pn, 1) = xloc + i + (RND - .5) * 2
  703.                     vecorig(pn, 2) = yloc + j + (RND - .5) * 2
  704.                     vecorig(pn, 3) = k + (RND - .5) * 2
  705.                     IF RND > .5 THEN
  706.                         veccolor(pn) = 7
  707.                     ELSE
  708.                         veccolor(pn) = 8
  709.                     END IF
  710.                     GOSUB calccom
  711.                 NEXT
  712.             NEXT
  713.             vecaddress(vgc, 2) = pn
  714.             GOSUB adjustcom
  715.         NEXT
  716.         FOR j = -span / 2 TO -thickness
  717.             vecgroupcounter = vecgroupcounter + 1
  718.             vgc = vecgroupcounter
  719.             vecgroupname(vgc) = "Grave"
  720.             vecaddress(vgc, 1) = pcountparticleorig
  721.             FOR k = -thickness TO thickness STEP thickness / 2
  722.                 FOR i = -thickness TO thickness STEP thickness / 2
  723.                     pcountparticleorig = pcountparticleorig + 1
  724.                     pn = pcountparticleorig
  725.                     vecorig(pn, 1) = xloc + i + (RND - .5) * 2
  726.                     vecorig(pn, 2) = yloc + j + (RND - .5) * 2
  727.                     vecorig(pn, 3) = crux + k + (RND - .5) * 2
  728.                     IF RND > .5 THEN
  729.                         veccolor(pn) = 7
  730.                     ELSE
  731.                         veccolor(pn) = 8
  732.                     END IF
  733.                     GOSUB calccom
  734.                 NEXT
  735.             NEXT
  736.             vecaddress(vgc, 2) = pn
  737.             GOSUB adjustcom
  738.         NEXT
  739.         FOR j = thickness TO span / 2
  740.             vecgroupcounter = vecgroupcounter + 1
  741.             vgc = vecgroupcounter
  742.             vecgroupname(vgc) = "Grave"
  743.             vecaddress(vgc, 1) = pcountparticleorig
  744.             FOR k = -thickness TO thickness STEP thickness / 2
  745.                 FOR i = -thickness TO thickness STEP thickness / 2
  746.                     pcountparticleorig = pcountparticleorig + 1
  747.                     pn = pcountparticleorig
  748.                     vecorig(pn, 1) = xloc + i + (RND - .5) * 2
  749.                     vecorig(pn, 2) = yloc + j + (RND - .5) * 2
  750.                     vecorig(pn, 3) = crux + k + (RND - .5) * 2
  751.                     IF RND > .5 THEN
  752.                         veccolor(pn) = 7
  753.                     ELSE
  754.                         veccolor(pn) = 8
  755.                     END IF
  756.                     GOSUB calccom
  757.                 NEXT
  758.             NEXT
  759.             vecaddress(vgc, 2) = pn
  760.             GOSUB adjustcom
  761.         NEXT
  762.     NEXT
  764.  
  765. 'Heaven's Bottom Layer
  766. h = 2
  767. FOR u = -gridsize TO gridsize STEP tilesize
  768.     FOR v = -gridsize TO gridsize STEP tilesize
  769.         vecgroupcounter = vecgroupcounter + 1
  770.         vgc = vecgroupcounter
  771.         vecgroupname(vgc) = "Heaven's Bottom Layer"
  772.         vecaddress(vgc, 1) = pcountparticleorig
  773.         FOR i = u TO u + tilesize STEP h
  774.             FOR j = v TO v + tilesize STEP h
  775.                 pcountparticleorig = pcountparticleorig + 1
  776.                 pn = pcountparticleorig
  777.                 vecorig(pn, 1) = i + RND * h - RND * h
  778.                 vecorig(pn, 2) = j + RND * h - RND * h
  779.                 vecorig(pn, 3) = 420 - RND
  780.                 IF RND > .5 THEN
  781.                     veccolor(pn) = 3
  782.                 ELSE
  783.                     veccolor(pn) = 5
  784.                 END IF
  785.                 GOSUB calccom
  786.             NEXT
  787.         NEXT
  788.         vecaddress(vgc, 2) = pn
  789.         GOSUB adjustcom
  790.     NEXT
  792.  
  793. 'Hell Spawn
  794. FOR u = -gridsize TO gridsize STEP tilesize
  795.     FOR v = -gridsize TO gridsize STEP tilesize
  796.         vecgroupcounter = vecgroupcounter + 1
  797.         vgc = vecgroupcounter
  798.         vecgroupname(vgc) = "Hell Spawn"
  799.         vecaddress(vgc, 1) = pcountparticleorig
  800.         FOR i = u TO u + tilesize STEP tilesize / 5
  801.             FOR j = v TO v + tilesize STEP tilesize / 5
  802.                 pcountparticleorig = pcountparticleorig + 1
  803.                 pn = pcountparticleorig
  804.                 vecorig(pn, 1) = i + RND * tilesize / 5
  805.                 vecorig(pn, 2) = j + RND * tilesize / 5
  806.                 vecorig(pn, 3) = -350 - RND * 70
  807.                 IF RND > .2 THEN
  808.                     veccolor(pn) = 4
  809.                 ELSE
  810.                     veccolor(pn) = 10
  811.                 END IF
  812.                 GOSUB calccom
  813.             NEXT
  814.         NEXT
  815.         vecaddress(vgc, 2) = pn
  816.         GOSUB adjustcom
  817.     NEXT
  819.  
  820. 'Icewall East
  821. h = 2
  822. FOR u = -gridsize TO gridsize STEP tilesize
  823.     FOR v = 0 TO 70 STEP tilesize
  824.         vecgroupcounter = vecgroupcounter + 1
  825.         vgc = vecgroupcounter
  826.         vecgroupname(vgc) = "Icewall East"
  827.         vecaddress(vgc, 1) = pcountparticleorig
  828.         FOR i = u TO u + tilesize STEP h
  829.             FOR j = v TO v + tilesize STEP h
  830.                 pcountparticleorig = pcountparticleorig + 1
  831.                 pn = pcountparticleorig
  832.                 vecorig(pn, 1) = gridsize
  833.                 vecorig(pn, 2) = i + RND * h - RND * h
  834.                 vecorig(pn, 3) = j + RND * h - RND * h
  835.                 IF RND > .5 THEN
  836.                     veccolor(pn) = 15
  837.                 ELSE
  838.                     veccolor(pn) = 7
  839.                 END IF
  840.                 GOSUB calccom
  841.             NEXT
  842.         NEXT
  843.         vecaddress(vgc, 2) = pn
  844.         GOSUB adjustcom
  845.     NEXT
  847.  
  848. 'Icewall South
  849. h = 2
  850. FOR u = -gridsize TO gridsize STEP tilesize
  851.     FOR v = 0 TO 70 STEP tilesize
  852.         vecgroupcounter = vecgroupcounter + 1
  853.         vgc = vecgroupcounter
  854.         vecgroupname(vgc) = "Icewall South"
  855.         vecaddress(vgc, 1) = pcountparticleorig
  856.         FOR i = u TO u + tilesize STEP h
  857.             FOR j = v TO v + tilesize STEP h
  858.                 pcountparticleorig = pcountparticleorig + 1
  859.                 pn = pcountparticleorig
  860.                 vecorig(pn, 1) = -gridsize
  861.                 vecorig(pn, 2) = i + RND * h - RND * h
  862.                 vecorig(pn, 3) = j + RND * h - RND * h
  863.                 IF RND > .5 THEN
  864.                     veccolor(pn) = 15
  865.                 ELSE
  866.                     veccolor(pn) = 7
  867.                 END IF
  868.                 GOSUB calccom
  869.             NEXT
  870.         NEXT
  871.         vecaddress(vgc, 2) = pn
  872.         GOSUB adjustcom
  873.     NEXT
  875.  
  876. 'Icewall North
  877. h = 2
  878. FOR u = -gridsize TO gridsize STEP tilesize
  879.     FOR v = 0 TO 70 STEP tilesize
  880.         vecgroupcounter = vecgroupcounter + 1
  881.         vgc = vecgroupcounter
  882.         vecgroupname(vgc) = "Icewall North"
  883.         vecaddress(vgc, 1) = pcountparticleorig
  884.         FOR i = u TO u + tilesize STEP h
  885.             FOR j = v TO v + tilesize STEP h
  886.                 pcountparticleorig = pcountparticleorig + 1
  887.                 pn = pcountparticleorig
  888.                 vecorig(pn, 1) = i + RND * h - RND * h
  889.                 vecorig(pn, 2) = gridsize
  890.                 vecorig(pn, 3) = j + RND * h - RND * h
  891.                 IF RND > .5 THEN
  892.                     veccolor(pn) = 15
  893.                 ELSE
  894.                     veccolor(pn) = 7
  895.                 END IF
  896.                 GOSUB calccom
  897.             NEXT
  898.         NEXT
  899.         vecaddress(vgc, 2) = pn
  900.         GOSUB adjustcom
  901.     NEXT
  903.  
  904. 'Icewall West
  905. h = 2
  906. FOR u = -gridsize TO gridsize STEP tilesize
  907.     FOR v = 0 TO 70 STEP tilesize
  908.         vecgroupcounter = vecgroupcounter + 1
  909.         vgc = vecgroupcounter
  910.         vecgroupname(vgc) = "Icewall West"
  911.         vecaddress(vgc, 1) = pcountparticleorig
  912.         FOR i = u TO u + tilesize STEP h
  913.             FOR j = v TO v + tilesize STEP h
  914.                 pcountparticleorig = pcountparticleorig + 1
  915.                 pn = pcountparticleorig
  916.                 vecorig(pn, 1) = i + RND * h - RND * h
  917.                 vecorig(pn, 2) = -gridsize
  918.                 vecorig(pn, 3) = j + RND * h - RND * h
  919.                 IF RND > .5 THEN
  920.                     veccolor(pn) = 15
  921.                 ELSE
  922.                     veccolor(pn) = 7
  923.                 END IF
  924.                 GOSUB calccom
  925.             NEXT
  926.         NEXT
  927.         vecaddress(vgc, 2) = pn
  928.         GOSUB adjustcom
  929.     NEXT
  931.  
  932. 'Lake of Fire
  933. h = 2
  934. FOR u = -gridsize TO gridsize STEP tilesize
  935.     FOR v = -gridsize TO gridsize STEP tilesize
  936.         vecgroupcounter = vecgroupcounter + 1
  937.         vgc = vecgroupcounter
  938.         vecgroupname(vgc) = "Lake of Fire"
  939.         vecaddress(vgc, 1) = pcountparticleorig
  940.         FOR i = u TO u + tilesize STEP h
  941.             FOR j = v TO v + tilesize STEP h
  942.                 pcountparticleorig = pcountparticleorig + 1
  943.                 pn = pcountparticleorig
  944.                 vecorig(pn, 1) = i + RND * h - RND * h
  945.                 vecorig(pn, 2) = j + RND * h - RND * h
  946.                 vecorig(pn, 3) = -350 - 70 - RND
  947.                 IF RND > .2 THEN
  948.                     veccolor(pn) = 4
  949.                 ELSE
  950.                     veccolor(pn) = 11
  951.                 END IF
  952.                 GOSUB calccom
  953.             NEXT
  954.         NEXT
  955.         vecaddress(vgc, 2) = pn
  956.         GOSUB adjustcom
  957.     NEXT
  959.  
  960. 'Megalith
  961. ctrx = -90
  962. ctry = -320
  963. ctrz = 4
  964. w = 8
  965. h = 256
  966. dens = 100
  967. FOR k = 1 TO h STEP w
  968.     FOR i = -h / 20 + k / 20 TO h / 20 - k / 20 STEP w
  969.         FOR j = -h / 20 + k / 20 TO h / 20 - k / 20 STEP w
  970.             vecgroupcounter = vecgroupcounter + 1
  971.             vgc = vecgroupcounter
  972.             vecgroupname(vgc) = "Megalith"
  973.             vecaddress(vgc, 1) = pcountparticleorig
  974.             FOR q = 1 TO dens
  975.                 pcountparticleorig = pcountparticleorig + 1
  976.                 pn = pcountparticleorig
  977.                 vecorig(pn, 1) = ctrx + i + (RND - .5) * w
  978.                 vecorig(pn, 2) = ctry + j + (RND - .5) * w
  979.                 vecorig(pn, 3) = ctrz + k + (RND - .5) * w
  980.                 IF RND > .5 THEN
  981.                     veccolor(pn) = 11
  982.                 ELSE
  983.                     veccolor(pn) = 7
  984.                 END IF
  985.                 GOSUB calccom
  986.             NEXT
  987.             vecaddress(vgc, 2) = pn
  988.             GOSUB adjustcom
  989.         NEXT
  990.     NEXT
  992.  
  993. 'Moon
  994. vecgroupcounter = vecgroupcounter + 1
  995. vgc = vecgroupcounter
  996. vecgroupname(vgc) = "Moon"
  997. vecaddress(vgc, 1) = pcountparticleorig
  998. radius = 4
  999. au = 60
  1000. dx = (2 * pi / radius) * .05
  1001. dy = (2 * pi / radius) * .05
  1002. xl = 0: xr = 2 * pi
  1003. yl = 0: yr = pi
  1004. xrange = 1 + INT((-xl + xr) / dx)
  1005. yrange = 1 + INT((-yl + yr) / dy)
  1006. FOR i = 1 TO xrange
  1007.     FOR j = 1 TO yrange
  1008.         pcountparticleorig = pcountparticleorig + 1
  1009.         pn = pcountparticleorig
  1010.         theta = i * dx - dx
  1011.         phi = j * dy - dy
  1012.         vecorig(pn, 1) = au + radius * SIN(phi) * COS(theta)
  1013.         vecorig(pn, 2) = radius * SIN(phi) * SIN(theta)
  1014.         vecorig(pn, 3) = 90 + radius * COS(phi)
  1015.         IF RND > .5 THEN
  1016.             veccolor(pn) = 7
  1017.         ELSE
  1018.             veccolor(pn) = 8
  1019.         END IF
  1020.         GOSUB calccom
  1021.     NEXT
  1023. vecaddress(vgc, 2) = pn
  1024. GOSUB adjustcom
  1025.  
  1026. 'Rain
  1027. FOR u = -gridsize TO gridsize STEP tilesize
  1028.     FOR v = -gridsize TO gridsize STEP tilesize
  1029.         vecgroupcounter = vecgroupcounter + 1
  1030.         vgc = vecgroupcounter
  1031.         vecgroupname(vgc) = "Rain"
  1032.         vecaddress(vgc, 1) = pcountparticleorig
  1033.         FOR i = u TO u + tilesize STEP tilesize '/ 3
  1034.             FOR j = v TO v + tilesize STEP tilesize '/ 3
  1035.                 pcountparticleorig = pcountparticleorig + 1
  1036.                 pn = pcountparticleorig
  1037.                 vecorig(pn, 1) = i + RND * tilesize
  1038.                 vecorig(pn, 2) = j + RND * tilesize
  1039.                 vecorig(pn, 3) = RND * 70
  1040.                 IF RND > .66 THEN
  1041.                     veccolor(pn) = 9
  1042.                 ELSE
  1043.                     veccolor(pn) = 7
  1044.                 END IF
  1045.                 GOSUB calccom
  1046.             NEXT
  1047.         NEXT
  1048.         vecaddress(vgc, 2) = pn
  1049.         GOSUB adjustcom
  1050.     NEXT
  1052.  
  1053. 'Pyramid
  1054. ctrx = -90
  1055. ctry = -120
  1056. ctrz = 4
  1057. w = 8
  1058. h = 56
  1059. dens = 50
  1060. FOR k = 1 TO h STEP w
  1061.     FOR i = -h / 2 + k / 2 TO h / 2 - k / 2 STEP w
  1062.         FOR j = -h / 2 + k / 2 TO h / 2 - k / 2 STEP w
  1063.             vecgroupcounter = vecgroupcounter + 1
  1064.             vgc = vecgroupcounter
  1065.             vecgroupname(vgc) = "Pyramid"
  1066.             vecaddress(vgc, 1) = pcountparticleorig
  1067.             FOR q = 1 TO dens
  1068.                 pcountparticleorig = pcountparticleorig + 1
  1069.                 pn = pcountparticleorig
  1070.                 vecorig(pn, 1) = ctrx + i + (RND - .5) * w
  1071.                 vecorig(pn, 2) = ctry + j + (RND - .5) * w
  1072.                 vecorig(pn, 3) = ctrz + k + (RND - .5) * w
  1073.                 IF RND > .5 THEN
  1074.                     veccolor(pn) = 6
  1075.                 ELSE
  1076.                     veccolor(pn) = 12
  1077.                 END IF
  1078.                 GOSUB calccom
  1079.             NEXT
  1080.             vecaddress(vgc, 2) = pn
  1081.             GOSUB adjustcom
  1082.         NEXT
  1083.     NEXT
  1085.  
  1086. 'Sky
  1087. h = 2
  1088. FOR u = -gridsize TO gridsize STEP tilesize
  1089.     FOR v = -gridsize TO gridsize STEP tilesize
  1090.         vecgroupcounter = vecgroupcounter + 1
  1091.         vgc = vecgroupcounter
  1092.         vecgroupname(vgc) = "Sky"
  1093.         vecaddress(vgc, 1) = pcountparticleorig
  1094.         FOR i = u TO u + tilesize STEP h
  1095.             FOR j = v TO v + tilesize STEP h
  1096.                 pcountparticleorig = pcountparticleorig + 1
  1097.                 pn = pcountparticleorig
  1098.                 vecorig(pn, 1) = i + RND * h - RND * h
  1099.                 vecorig(pn, 2) = j + RND * h - RND * h
  1100.                 vecorig(pn, 3) = 70 + RND * h - RND * h
  1101.                 IF RND > .5 THEN
  1102.                     veccolor(pn) = 9
  1103.                 ELSE
  1104.                     veccolor(pn) = 15
  1105.                 END IF
  1106.                 GOSUB calccom
  1107.             NEXT
  1108.         NEXT
  1109.         vecaddress(vgc, 2) = pn
  1110.         GOSUB adjustcom
  1111.     NEXT
  1113.  
  1114. 'Snake?
  1115. vecgroupcounter = vecgroupcounter + 1
  1116. vgc = vecgroupcounter
  1117. vecgroupname(vgc) = "Snake?"
  1118. vecaddress(vgc, 1) = pcountparticleorig
  1119. FOR i = -pi TO pi STEP .005
  1120.     pcountparticleorig = pcountparticleorig + 1
  1121.     pn = pcountparticleorig
  1122.     vecorig(pn, 1) = -10 + 5 * COS(i)
  1123.     vecorig(pn, 2) = -20 + 5 * SIN(i)
  1124.     vecorig(pn, 3) = 25 - 3 * COS(6 * i) * SIN(3 * i)
  1125.     veccolor(pn) = 12
  1126.     GOSUB calccom
  1128. vecaddress(vgc, 2) = pn
  1129. GOSUB adjustcom
  1130.  
  1131. 'Sparks
  1132. u = 0
  1133. v = 0
  1134. vecgroupcounter = vecgroupcounter + 1
  1135. vgc = vecgroupcounter
  1136. vecgroupname(vgc) = "Sparks"
  1137. vecaddress(vgc, 1) = pcountparticleorig
  1138. FOR i = 1 TO 300
  1139.     pcountparticleorig = pcountparticleorig + 1
  1140.     pn = pcountparticleorig
  1141.     vecorig(pn, 1) = RND - .5
  1142.     vecorig(pn, 2) = RND - .5
  1143.     vecorig(pn, 3) = 20 + RND - .5
  1144.     vecorigvel(pn, 1) = 8 * (RND - .5)
  1145.     vecorigvel(pn, 2) = 8 * (RND - .5)
  1146.     vecorigvel(pn, 3) = 20 * RND
  1147.     vecorigacc(pn, 1) = 0
  1148.     vecorigacc(pn, 2) = 0
  1149.     vecorigacc(pn, 3) = -40
  1150.     veccolor(pn) = INT(RND * 14) + 1
  1151.     GOSUB calccom
  1153. vecaddress(vgc, 2) = pn
  1154. GOSUB adjustcom
  1155.  
  1156. 'Stars
  1157. h = 5
  1158. FOR w = 1 TO 5
  1159.     FOR u = -gridsize TO gridsize STEP tilesize
  1160.         FOR v = -gridsize TO gridsize STEP tilesize
  1161.             vecgroupcounter = vecgroupcounter + 1
  1162.             vgc = vecgroupcounter
  1163.             vecgroupname(vgc) = "Stars"
  1164.             vecaddress(vgc, 1) = pcountparticleorig
  1165.             FOR i = u TO u + tilesize STEP h
  1166.                 FOR j = v TO v + tilesize STEP h
  1167.                     IF RND > 1 - w / 5 THEN
  1168.                         pcountparticleorig = pcountparticleorig + 1
  1169.                         pn = pcountparticleorig
  1170.                         vecorig(pn, 1) = i + RND * h - RND * h
  1171.                         vecorig(pn, 2) = j + RND * h - RND * h
  1172.                         vecorig(pn, 3) = w * 70 + RND * 70
  1173.                         IF RND > .5 THEN
  1174.                             veccolor(pn) = 15
  1175.                         ELSE
  1176.                             IF RND > .5 THEN
  1177.                                 veccolor(pn) = 7
  1178.                             ELSE
  1179.                                 veccolor(pn) = 8
  1180.                             END IF
  1181.                         END IF
  1182.                         GOSUB calccom
  1183.                     END IF
  1184.                 NEXT
  1185.             NEXT
  1186.             vecaddress(vgc, 2) = pn
  1187.             GOSUB adjustcom
  1188.         NEXT
  1189.     NEXT
  1191.  
  1192. 'Sun
  1193. radius = 10
  1194. dx = .0628
  1195. dy = .0628
  1196. xl = 0: xr = 2 * pi
  1197. yl = 0: yr = pi
  1198. xrange = 1 + INT((-xl + xr) / dx)
  1199. yrange = 1 + INT((-yl + yr) / dy)
  1200. FOR i = 1 TO xrange STEP 10
  1201.     FOR j = 1 TO yrange STEP 10
  1202.         vecgroupcounter = vecgroupcounter + 1
  1203.         vgc = vecgroupcounter
  1204.         vecgroupname(vgc) = "Sun"
  1205.         vecaddress(vgc, 1) = pcountparticleorig
  1206.         FOR u = i TO i + 10 STEP 1
  1207.             FOR v = j TO j + 10 STEP 1
  1208.                 pcountparticleorig = pcountparticleorig + 1
  1209.                 pn = pcountparticleorig
  1210.                 theta = u * dx - dx
  1211.                 phi = v * dy - dy
  1212.                 vecorig(pn, 1) = radius * SIN(phi) * COS(theta)
  1213.                 vecorig(pn, 2) = radius * SIN(phi) * SIN(theta)
  1214.                 vecorig(pn, 3) = 90 + radius * COS(phi)
  1215.                 veccolor(pn) = 14
  1216.                 GOSUB calccom
  1217.             NEXT
  1218.         NEXT
  1219.         vecaddress(vgc, 2) = pn
  1220.         GOSUB adjustcom
  1221.     NEXT
  1223.  
  1224. 'UFO!!!
  1225. vecgroupcounter = vecgroupcounter + 1
  1226. vgc = vecgroupcounter
  1227. vecgroupname(vgc) = "UFO!!!"
  1228. vecaddress(vgc, 1) = pcountparticleorig
  1229. FOR q = 0 TO 2 * pi STEP (2 * pi / 12) / 25
  1230.     FOR r = 10 TO 12 STEP .5
  1231.         pcountparticleorig = pcountparticleorig + 1
  1232.         pn = pcountparticleorig
  1233.         vecorig(pn, 1) = -90 + r * COS(q)
  1234.         vecorig(pn, 2) = -120 + r * SIN(q)
  1235.         vecorig(pn, 3) = 100 + r - 12
  1236.         veccolor(pn) = 13
  1237.         GOSUB calccom
  1238.     NEXT
  1239.     FOR r = 12 TO 10 STEP -.5
  1240.         pcountparticleorig = pcountparticleorig + 1
  1241.         pn = pcountparticleorig
  1242.         vecorig(pn, 1) = -90 + r * COS(q)
  1243.         vecorig(pn, 2) = -120 + r * SIN(q)
  1244.         vecorig(pn, 3) = 100 - r + 12
  1245.         veccolor(pn) = 12
  1246.         GOSUB calccom
  1247.     NEXT
  1249. r = 5
  1250. h = 30
  1251. FOR w = 1 TO 400
  1252.     xx = (RND - .5) * 2 * r
  1253.     yy = (RND - .5) * 2 * r
  1254.     IF xx ^ 2 + yy ^ 2 < r ^ 2 THEN
  1255.         pcountparticleorig = pcountparticleorig + 1
  1256.         pn = pcountparticleorig
  1257.         vecorig(pn, 1) = -90 + xx
  1258.         vecorig(pn, 2) = -120 + yy
  1259.         vecorig(pn, 3) = 100 - RND * h
  1260.         IF RND > .5 THEN
  1261.             veccolor(pn) = 3
  1262.         ELSE
  1263.             veccolor(pn) = 11
  1264.         END IF
  1265.         GOSUB calccom
  1266.     END IF
  1268. vecaddress(vgc, 2) = pn
  1269. GOSUB adjustcom
  1270.  
  1271. 'Waves or Particles? (1)
  1272. FOR i = 1 TO 5 STEP 1
  1273.     FOR k = 1 TO 5 STEP 1
  1274.         vecgroupcounter = vecgroupcounter + 1
  1275.         vgc = vecgroupcounter
  1276.         vecgroupname(vgc) = "Particles or Waves?"
  1277.         vecaddress(vgc, 1) = pcountparticleorig
  1278.         FOR u = i TO i + 1 STEP .05
  1279.             FOR v = k TO k + 1 STEP .05
  1280.                 pcountparticleorig = pcountparticleorig + 1
  1281.                 pn = pcountparticleorig
  1282.                 vecorig(pn, 1) = 70 + 7 * u
  1283.                 vecorig(pn, 2) = 80 + 1 * COS((u ^ 2 - v ^ 2))
  1284.                 vecorig(pn, 3) = 10 + 7 * v
  1285.                 IF vecorig(pn, 2) < 80 THEN
  1286.                     veccolor(pn) = 2
  1287.                 ELSE
  1288.                     veccolor(pn) = 1
  1289.                 END IF
  1290.                 GOSUB calccom
  1291.             NEXT
  1292.         NEXT
  1293.         vecaddress(vgc, 2) = pn
  1294.         GOSUB adjustcom
  1295.     NEXT
  1297.  
  1298. 'Waves or Particles? (2)
  1299. FOR i = 1 TO 5 STEP 1
  1300.     FOR k = 1 TO 5 STEP 1
  1301.         vecgroupcounter = vecgroupcounter + 1
  1302.         vgc = vecgroupcounter
  1303.         vecgroupname(vgc) = "Waves or Particles?"
  1304.         vecaddress(vgc, 1) = pcountparticleorig
  1305.         FOR u = i TO i + 1 STEP .05
  1306.             FOR v = k TO k + 1 STEP .05
  1307.                 pcountparticleorig = pcountparticleorig + 1
  1308.                 pn = pcountparticleorig
  1309.                 vecorig(pn, 1) = -7 * u
  1310.                 vecorig(pn, 2) = 80 + 1 * COS(2 * ((u - 7) ^ 2 - (v - 5) ^ 2))
  1311.                 vecorig(pn, 3) = 10 + 7 * v
  1312.                 IF vecorig(pn, 2) < 80 THEN
  1313.                     veccolor(pn) = 13
  1314.                 ELSE
  1315.                     veccolor(pn) = 4
  1316.                 END IF
  1317.                 GOSUB calccom
  1318.             NEXT
  1319.         NEXT
  1320.         vecaddress(vgc, 2) = pn
  1321.         GOSUB adjustcom
  1322.     NEXT
  1324.  
  1325.  
  1326. 'File
  1329.     DO WHILE NOT EOF(1)
  1330.         INPUT #1, xx, yy, zz, co
  1331.         regularpoint = 1
  1332.         IF xx = -999999 AND yy = -999999 AND zz = -999999 AND co = -999999 THEN
  1333.             regularpoint = 0
  1334.             INPUT #1, n$
  1335.             vecgroupcounter = vecgroupcounter + 1
  1336.             vgc = vecgroupcounter
  1337.             vecgroupname(vgc) = n$
  1338.             vecaddress(vgc, 1) = pcountparticleorig
  1339.         END IF
  1340.         IF xx = -888888 AND yy = -888888 AND zz = -888888 AND co = -888888 THEN
  1341.             regularpoint = 0
  1342.             vecaddress(vgc, 2) = pn
  1343.             GOSUB adjustcom
  1344.         END IF
  1345.         IF regularpoint = 1 THEN
  1346.             pcountparticleorig = pcountparticleorig + 1
  1347.             pn = pcountparticleorig
  1348.             vecorig(pn, 1) = xx
  1349.             vecorig(pn, 2) = yy
  1350.             vecorig(pn, 3) = zz
  1351.             veccolor(pn) = co
  1352.             GOSUB calccom
  1353.         END IF
  1354.     LOOP
  1356.  
  1358.  
  1359. timeanimate:
  1360. timestep = .001
  1361. timevar = timevar + timestep
  1362. IF timevar > 10 ^ 6 THEN timevar = 0
  1363.  
  1364. IF vecgroupname(k) = "Clock Hands" THEN
  1365.     pn = vecaddress(k, 1)
  1366.     hands(1, 1) = VAL(LEFT$(TIME$, 2)) * (2 * pi / 12)
  1367.     hands(2, 1) = VAL(MID$(TIME$, 4, 2)) * (2 * pi / 60)
  1368.     hands(3, 1) = VAL(RIGHT$(TIME$, 2)) * (2 * pi / 60)
  1369.     phase = pi / 2
  1370.     FOR q = 1 TO 3
  1371.         FOR r = 0 TO 5 + q STEP .1
  1372.             pn = pn + 1
  1373.             vecorig(pn, 1) = 40 + r * COS(hands(q, 1) + phase)
  1374.             vecorig(pn, 2) = -10
  1375.             vecorig(pn, 3) = 40 + r * SIN(hands(q, 1) + phase)
  1376.         NEXT
  1377.     NEXT
  1379. IF vecgroupname(k) = "Waving Banner" THEN
  1380.     pn = vecaddress(k, 1)
  1381.     t = timevar / 50
  1382.     xl = -1.9: xr = 1.9: dx = .32
  1383.     yl = -1: yr = 1: dy = .32
  1384.     xl = xl * 4: xr = xr * 4: yl = yl * 4: yr = yr * 4
  1385.     FOR i = xl TO xr STEP dx
  1386.         FOR j = yl TO yr STEP dy
  1387.             pn = pn + 1
  1388.             vecorig(pn, 1) = 70 + 1.25 * COS(i - 2 * t) ^ 2 - 1.25 * SIN(j - t) ^ 2
  1389.             vecorig(pn, 2) = 30 + i
  1390.             vecorig(pn, 3) = 40 + j
  1391.             IF vecorig(pn, 1) < 70 THEN
  1392.                 veccolor(pn) = 11
  1393.             ELSE
  1394.                 veccolor(pn) = 6
  1395.             END IF
  1396.         NEXT
  1397.     NEXT
  1399. IF vecgroupname(k) = "Hell Spawn" THEN
  1400.     FOR i = vecaddress(k, 1) + 1 TO vecaddress(k, 2)
  1401.         vecorig(i, 3) = vecorig(i, 3) + .3
  1402.         IF vecorig(i, 3) > -350 THEN vecorig(i, 3) = -350 - 70
  1403.     NEXT
  1405. IF vecgroupname(k) = "Moon" THEN
  1406.     t = timevar * .000001
  1407.     FOR i = vecaddress(k, 1) + 1 TO vecaddress(k, 2)
  1408.         xx = vecorig(i, 1)
  1409.         yy = vecorig(i, 2)
  1410.         vecorig(i, 1) = xx * COS(t) - yy * SIN(t)
  1411.         vecorig(i, 2) = xx * SIN(t) + yy * COS(t)
  1412.         GOSUB calccom
  1413.     NEXT
  1414.     GOSUB adjustcom
  1416. IF vecgroupname(k) = "Rain" THEN
  1417.     FOR i = vecaddress(k, 1) + 1 TO vecaddress(k, 2)
  1418.         vecorig(i, 3) = vecorig(i, 3) - .3
  1419.         IF vecorig(i, 3) < 0 THEN vecorig(i, 3) = 70
  1420.     NEXT
  1422. IF vecgroupname(k) = "Snake?" THEN
  1423.     pn = vecaddress(k, 1) + 1
  1424.     t = timevar * .1
  1425.     FOR i = -pi TO pi STEP .005
  1426.         vecorig(pn, 1) = -10 + 5 * COS(i + t)
  1427.         vecorig(pn, 2) = -20 + 5 * SIN(i + t)
  1428.         vecorig(pn, 3) = 25 - 3 * COS(6 * i + t) * SIN(3 * i + t)
  1429.         pn = pn + 1
  1430.     NEXT
  1432. IF vecgroupname(k) = "Sparks" THEN
  1433.     vgc = k
  1434.     dt = timestep * 100
  1435.     FOR pn = vecaddress(vgc, 1) + 1 TO vecaddress(vgc, 2)
  1436.         vecorigvel(pn, 1) = vecorigvel(pn, 1) + vecorigacc(pn, 1) * timestep
  1437.         vecorigvel(pn, 2) = vecorigvel(pn, 2) + vecorigacc(pn, 2) * dt
  1438.         vecorigvel(pn, 3) = vecorigvel(pn, 3) + vecorigacc(pn, 3) * dt
  1439.         vecorig(pn, 1) = vecorig(pn, 1) + vecorigvel(pn, 1) * dt
  1440.         vecorig(pn, 2) = vecorig(pn, 2) + vecorigvel(pn, 2) * dt
  1441.         vecorig(pn, 3) = vecorig(pn, 3) + vecorigvel(pn, 3) * dt
  1442.         IF vecorig(pn, 3) < 0 THEN
  1443.             vecorig(pn, 3) = 0
  1444.             vecorigvel(pn, 1) = vecorigvel(pn, 1) * .75
  1445.             vecorigvel(pn, 2) = vecorigvel(pn, 2) * .75
  1446.             vecorigvel(pn, 3) = -vecorigvel(pn, 3) * .5
  1447.         END IF
  1448.         GOSUB calccom
  1449.     NEXT
  1450.     GOSUB adjustcom
  1452. IF vecgroupname(k) = "UFO!!!" THEN
  1453.     vgc = k
  1454.     dt = timestep
  1455.     FOR pn = vecaddress(vgc, 1) + 1 TO vecaddress(vgc, 2)
  1456.         xx = vecorig(pn, 1) - 150
  1457.         yy = vecorig(pn, 2) - 150
  1458.         vecorig(pn, 1) = xx * COS(dt) - yy * SIN(dt) + 150
  1459.         vecorig(pn, 2) = xx * SIN(dt) + yy * COS(dt) + 150
  1460.         GOSUB calccom
  1461.     NEXT
  1462.     GOSUB adjustcom
  1465.  
  1466. calccom:
  1467. veccom(vgc, 1) = vecorig(pn, 1) + veccom(vgc, 1)
  1468. veccom(vgc, 2) = vecorig(pn, 2) + veccom(vgc, 2)
  1469. veccom(vgc, 3) = vecorig(pn, 3) + veccom(vgc, 3)
  1471.  
  1472. adjustcom:
  1473. veccom(vgc, 1) = veccom(vgc, 1) / (vecaddress(vgc, 2) - vecaddress(vgc, 1))
  1474. veccom(vgc, 2) = veccom(vgc, 2) / (vecaddress(vgc, 2) - vecaddress(vgc, 1))
  1475. veccom(vgc, 3) = veccom(vgc, 3) / (vecaddress(vgc, 2) - vecaddress(vgc, 1))
  1477.  

EDIT

Decided to attach a sketch of what's going on mathematically. Don't mind the sloppy handwriting.
main idea picture.jpg
* main idea picture.jpg (Filesize: 836.94 KB, Dimensions: 3507x2550, Views: 202)
« Last Edit: February 02, 2019, 08:30:31 pm by STxAxTIC »
Logged
You're not done when it works, you're done when it's right.

Offline Pete

  • Forum Resident
  • Posts: 2361
  • Cuz I sez so, varmint!
    • View Profile
Re: Sanctum: Open world 3D engine using CIRCLE and LINE
« Reply #4 on: February 02, 2019, 12:58:16 pm »
This is the strangest word processor I've ever tried.

Pete :D
Logged
Want to learn how to write code on cave walls? https://www.tapatalk.com/groups/qbasic/qbasic-f1/

Offline Richard Frost

  • Seasoned Forum Regular
  • Posts: 316
  • Needle nardle noo. - Peter Sellers
    • View Profile
Re: Sanctum: Open world 3D engine using CIRCLE and LINE
« Reply #5 on: February 02, 2019, 04:39:59 pm »
Your long variable names - do you actually type them in, or use short ones and do a mass search/replace
once the program is done? 

p.s. I am a zombie.  I will eat your brain to acquire 3D skills.  Beware of man with salt shaker.

Logged
It works better if you plug it in.

Offline Richard Frost

  • Seasoned Forum Regular
  • Posts: 316
  • Needle nardle noo. - Peter Sellers
    • View Profile
Re: Sanctum: Open world 3D engine using CIRCLE and LINE
« Reply #6 on: February 02, 2019, 04:49:35 pm »
Hardware for the 3D graphics engine...
circuit_diagram.png
* circuit_diagram.png (Filesize: 133.69 KB, Dimensions: 740x952, Views: 185)
Logged
It works better if you plug it in.

Offline STxAxTIC

  • Library Staff
  • Forum Resident
  • Posts: 1091
  • he lives
    • View Profile
Re: Sanctum: Open world 3D engine using CIRCLE and LINE
« Reply #7 on: February 02, 2019, 05:02:20 pm »
Sup Richard -

I type the long variable names typically. I'm all about code that doesn't need many comments - the code *is* the commentary when you name things right. Programmers convince themselves that they power-type all day and need all kinds of "++" esque shortcuts, but that's a myth. Clear code is better than unnecessarily tight code 100% of the time.

Nice hardware pic, haha. Now this site has 3 xkcd readers that I know about...
Logged
You're not done when it works, you're done when it's right.

Offline Petr

  • Forum Resident
  • Posts: 1720
  • The best code is the DNA of the hops.
    • View Profile
Re: Sanctum: Open world 3D engine using CIRCLE and LINE
« Reply #8 on: February 03, 2019, 04:21:34 am »
Richard Frost,

The beautiful connection of the MAA 555, which has Satanic designation MAA 666 :-D, that bat in the circuit and those coils and diodes, chachacha, yeah, that's a really good scheme. The transistor with two emitters :-D, that's fine. Thanks for this beautiful scheme :-D On one side cooled by water, on the other side powered by the sun :-D That's really great!
Logged

Offline Pete

  • Forum Resident
  • Posts: 2361
  • Cuz I sez so, varmint!
    • View Profile
Re: Sanctum: Open world 3D engine using CIRCLE and LINE
« Reply #9 on: February 03, 2019, 04:43:35 pm »
I got burned with that circuit many times, but then I discovered the secret... stop using Holy Water.

Hey Bill, check out what this guy posted! https://www.tapatalk.com/groups/qbasic/viewtopic.php?f=648955&t=39427

Pete :D
Logged
Want to learn how to write code on cave walls? https://www.tapatalk.com/groups/qbasic/qbasic-f1/

Offline STxAxTIC

  • Library Staff
  • Forum Resident
  • Posts: 1091
  • he lives
    • View Profile
Re: Sanctum: Open world 3D engine using CIRCLE and LINE
« Reply #10 on: February 03, 2019, 08:19:22 pm »
Aw, publicity! Where are my star-shaped sunglasses?

In exchange for this lovely cross-pollination of ideas, I will start hitting that forum way more often! (It's actually really encouraging to know that not *all* QB64 discussion happens exclusively here. That would be sad.)
Logged
You're not done when it works, you're done when it's right.

Offline bplus

  • Global Moderator
  • Forum Resident
  • Posts: 8053
  • b = b + ...
    • View Profile
Re: Sanctum: Open world 3D engine using CIRCLE and LINE
« Reply #11 on: February 03, 2019, 09:17:57 pm »
I have to say the video clip demo of this is much better than my little exploration.

Following Richard Frost idea to include music with Sierpinski Circled, I found all sorts of stuff that would go with the clip for Sanctum.

It would be cool if you could change the music according to the directions you go in space travel.
Logged

Offline Pete

  • Forum Resident
  • Posts: 2361
  • Cuz I sez so, varmint!
    • View Profile
Re: Sanctum: Open world 3D engine using CIRCLE and LINE
« Reply #12 on: February 04, 2019, 02:11:46 am »
Quote from: STxAxTIC on February 03, 2019, 08:19:22 pm
Aw, publicity! Where are my star-shaped sunglasses?

In exchange for this lovely cross-pollination of ideas, I will start hitting that forum way more often! (It's actually really encouraging to know that not *all* QB64 discussion happens exclusively here. That would be sad.)

I added user name from the old N54 QB Forum: STxAxTIK, in the posting group. You should be able to post when you want by logging in with your old Network54 password. If you forgot that password, just re-register and I will add your new user name to the posting group. I miss the old boards but the video embedding and some other features are a nice addition.

Pete
Logged
Want to learn how to write code on cave walls? https://www.tapatalk.com/groups/qbasic/qbasic-f1/

Offline STxAxTIC

  • Library Staff
  • Forum Resident
  • Posts: 1091
  • he lives
    • View Profile
Re: Sanctum: Open world 3D engine using CIRCLE and LINE
« Reply #13 on: February 04, 2019, 06:20:25 am »
Hello all, made a major update to the mechanism (data-wise, not the geometry) behind the Sanctum engine. For those who follow this...

The question that motivated the update is: How do you make changes to any element in the 3D world while the program is running? Thinking about this for a second, certain elements in games tend be immutable. You can try blowing up the walls in Doom, CounterStrike, or Tetris all day long, and it'll never happen - the engine just treats the environment differently than the stuff you can move around... but then along came Minecraft, which broke that barrier. So in that same spirit, I introduce a new direction for this project, and at this point I realize I should have waited and named this "PixelCraft". You can now create and destroy little blocks to build stuff. Very primitive for now, but it works.

The "major update" is how the particles are stored. When you boot the program as of now, the world is made of several million particles. How then, do we create and delete select chunks of the environment without befuddling arrays? With so many millions, we can't waste any time... So it is Linked List to the rescue. (That's what all the "pointer/lagger" stuff in there means.)

The code is updated at the top post. The "level.txt" attachment has also been replaced. Be sure to grab it too.

Instructions for creating and destroying blocks will be on screen. Its still rudimentary.
« Last Edit: February 04, 2019, 06:33:46 am by STxAxTIC »
Logged
You're not done when it works, you're done when it's right.

Offline Pete

  • Forum Resident
  • Posts: 2361
  • Cuz I sez so, varmint!
    • View Profile
Re: Sanctum: Open world 3D engine using CIRCLE and LINE
« Reply #14 on: February 04, 2019, 10:29:11 am »
Destroying blocks? As in we can blow stuff up? Now you've got my attention.

Pete
Logged
Want to learn how to write code on cave walls? https://www.tapatalk.com/groups/qbasic/qbasic-f1/
Pages: [1] 2   Go Up
« previous next »