Particle fountain: Difference between revisions

Content added Content deleted

Inline

Revision as of 13:53, 27 September 2021

Implement a particle fountain.

Emulate a fountain of water droplets in a gravitational field being sprayed up and then falling back down.

The particle fountain should be generally ordered but individually chaotic; the particles should be going mostly in the same direction, but should have slightly different vectors.

Your fountain should have at least several hundred particles in motion at any one time, and ideally several thousand.

It is optional to have the individual particle interact with each other.

If at all possible, link to a short video clip of your fountain in action.

Off-site link to a demo video

Perl

<lang perl>#!/usr/bin/perl

use strict; # https://rosettacode.org/wiki/Particle_fountain use warnings; use Tk;

my $size = 900; my @particles; my $maxparticles = 500; my @colors = qw( red green blue yellow cyan magenta orange white );

my $mw = MainWindow->new; my $c = $mw->Canvas( -width => $size, -height => $size, -bg => 'black',

 )->pack;

$mw->Button(-text => 'Exit', -command => sub {$mw->destroy},

 )->pack(-fill => 'x');

step(); MainLoop; -M $0 < 0 and exec $0;

sub step

 {
 $c->delete('all');
 $c->createLine($size / 2 - 10, $size, $size / 2, $size - 10,
   $size / 2 + 10, $size, -fill => 'white' );
 for ( @particles )
   {
   my ($ox, $oy, $vx, $vy, $color) = @$_;
   my $x = $ox + $vx;
   my $y = $oy + $vy;
   $c->createRectangle($ox, $oy, $x, $y, -fill => $color, -outline => $color);
   if( $y < $size )
     {
     $_->[0] = $x;
     $_->[1] = $y;
     $_->[3] += 0.006; # gravity :)
     }
   else { $_ = undef }
   }
 @particles = grep defined, @particles;
 if( @particles < $maxparticles and --$| )
   {
   push @particles, [ $size >> 1, $size - 10,
     (1 - rand 2) / 2.5 , -3 - rand 0.05, $colors[rand @colors] ];
   }
 $mw->after(1 => \&step);
 }</lang>

Phix

Translation of: Raku

Library: Phix/pGUI

Library: Phix/online

You can run this online here.

--
-- demo\rosetta\Particle_fountain.exw
-- ==================================
--
with javascript_semantics
include pGUI.e

Ihandle dlg, canvas
cdCanvas cddbuffer, cdcanvas

constant title = "Particle fountain"
constant help_text = """
Uparrow increases the saturation of the particle colors,
downarrow decreases saturation until they all become white.
PageUp sprays the particles out at a wider angle/spread,
PageDown makes the jet narrower.
Space toggles reciprocation (wobble) on and off (straight up).
Left arrow decreases the angle range for reciprocation,
right arrow increases the angle range for reciprocation.
Press the "q" key to quit.
"""

constant particlenum = 3000
-- each particle is {x,y,color,life,dx,dy}
sequence particles = repeat({0,0,0,0,0,0},particlenum)
atom t1 = time()+1
integer fps = 0
bool reciprocate = true
atom range = 1.5,
     spread = 1.5,
     saturation = 0.4,
     start = time(),
     df = 0.0001

function redraw_cb(Ihandle /*ih*/, integer /*posx*/, /*posy*/)
    integer {w, h} = IupGetIntInt(canvas, "DRAWSIZE")
    cdCanvasActivate(cddbuffer)
    cdCanvasClear(cddbuffer)
    for i=1 to length(particles) do
        atom {x,y,color,life} = particles[i]
        if life>0 then
            cdCanvasPixel(cddbuffer, x, h/10-y, color) 
        end if
    end for
    cdCanvasFlush(cddbuffer)
    return IUP_DEFAULT
end function

function map_cb(Ihandle ih)
    cdcanvas = cdCreateCanvas(CD_IUP, ih)
    cddbuffer = cdCreateCanvas(CD_DBUFFER, cdcanvas)
    cdCanvasSetBackground(cddbuffer, CD_BLACK)
    return IUP_DEFAULT
end function

function timer_cb(Ihandle /*ih*/)
    integer {w, h} = IupGetIntInt(canvas, "DRAWSIZE")
    fps += 1
    df = time()-start
    start = time()
    for i=1 to particlenum do
        atom {x,y,color,life,dx,dy} = particles[i]
        if life<=0 then
            if rnd()<df then
                life = 2.5          -- time to live
                x = w/2             -- starting position x
                y = h/10            --               and y
                -- randomize velocity so points reach different heights:
                atom r = iff(reciprocate?range*sin(time()):0)
                dx = (spread*rnd()-spread/2+r)*50   -- starting velocity x
                dy = (rnd()-2.9) * h/20.5           --               and y 
                color = hsv_to_rgb(round(remainder(time(),5)/5,100), saturation, 1)
            end if
        else
            if y>h/10 and dy>0 then
                dy *= -0.3  -- "bounce"
            end if
            dy += (h/10)*df -- adjust velocity
            x += dx*df      -- adjust position x
            y += dy*df*8    --             and y
            life -= df
        end if
        particles[i] = {x,y,color,life,dx,dy}
    end for
    IupRedraw(canvas)
    if time()>t1 then
        IupSetStrAttribute(dlg,"TITLE","%s (%d, %d fps/s [%dx%d])",{title,particlenum,fps,w,h})
        t1 = time()+1
        fps = 0
    end if
    return IUP_DEFAULT
end function

function key_cb(Ihandle /*dlg*/, atom c)
    if c=K_ESC or lower(c)='q' then return IUP_CLOSE
    elsif c=K_F1 then   IupMessage(title,help_text)
    elsif c=K_UP then   saturation = min(saturation+0.1,1)
    elsif c=K_DOWN then saturation = max(saturation-0.1,0)
    elsif c=K_PGUP then spread = min(spread+0.1,5)
    elsif c=K_PGDN then spread = max(spread-0.1,0.2)
    elsif c=K_RIGHT then range = min(range+0.1,2)
    elsif c=K_LEFT then range = max(range-0.1,0.1)
    elsif c=K_SP then reciprocate = not reciprocate
    end if
    return IUP_CONTINUE
end function

procedure main()
    IupOpen()
    canvas = IupGLCanvas("RASTERSIZE=400x300")
    IupSetCallbacks({canvas}, {"ACTION", Icallback("redraw_cb"),
                               "MAP_CB", Icallback("map_cb")})
    dlg = IupDialog(canvas,`TITLE="%s"`,{title})
    IupSetCallback(dlg, "KEY_CB", Icallback("key_cb"))
    Ihandle timer = IupTimer(Icallback("timer_cb"), 1000/25)
    IupShowXY(dlg,IUP_CENTER,IUP_CENTER)
    IupSetAttribute(canvas, "RASTERSIZE", NULL)
    if platform()!=JS then
        IupMainLoop()
        IupClose()
    end if
end procedure

main()

say q:to/DOCS/; Use UP and DOWN arrow keys to modify the saturation of the particle colors. Use PAGE UP and PAGE DOWN keys to modify the "spread" of the particles. Toggle reciprocation off / on with the SPACE bar. Use LEFT and RIGHT arrow keys to modify angle range for reciprocation. Press the "q" key to quit. DOCS

my $event = SDL_Event.new;

my num $df = 0.0001e0;

main: loop {

   my $start = now;

   while SDL_PollEvent($event) {
       my $casted_event = SDL_CastEvent($event);

       given $casted_event {
           when *.type == QUIT {
               last main;
           }
           when *.type == WINDOWEVENT {
               if .event == RESIZED {
                   $w = .data1;
                   $h = .data2;
               }
           }
           when *.type == KEYDOWN {
               if KEY_CODES(.scancode) -> $comm {
                   given $comm {
                       when 'K_UP'    { $saturation = (($saturation + .1) min 1e0) }
                       when 'K_DOWN'  { $saturation = (($saturation - .1) max 0e0) }
                       when 'K_PGUP'  { $spread = (($spread + .1) min 5e0) }
                       when 'K_PGDN'  { $spread = (($spread - .1) max 2e-1) }
                       when 'K_RIGHT' { $range = (($range + .1) min 2e0) }
                       when 'K_LEFT'  { $range = (($range - .1) max 1e-1) }
                       when 'K_SPACE' { &reciprocate = reciprocate() == 0 ?? sub { $range * sin(now) } !! sub { 0 } }
                       when 'K_Q'     { last main }
                   }
               }
           }
       }
   }

   update($df);

   render();

   $df = (now - $start).Num;

   print fps();

}

say ;

sub fps {

   state $fps-frames = 0;
   state $fps-now    = now;
   state $fps        = ;
   $fps-frames++;
   if now - $fps-now >= 1 {
       $fps = [~] "\r", ' ' x 20, "\r",
           sprintf "FPS: %5.1f  ", ($fps-frames / (now - $fps-now));
       $fps-frames = 0;
       $fps-now = now;
   }
   $fps

}

sub hsv2rgb ( $h, $s, $v ){

   state %cache;
   %cache{"$h|$s|$v"} //= do {
       my $c = $v * $s;
       my $x = $c * (1 - abs( (($h*6) % 2) - 1 ) );
       my $m = $v - $c;
       [(do given $h {
           when   0..^1/6 { $c, $x, 0 }
           when 1/6..^1/3 { $x, $c, 0 }
           when 1/3..^1/2 { 0, $c, $x }
           when 1/2..^2/3 { 0, $x, $c }
           when 2/3..^5/6 { $x, 0, $c }
           when 5/6..1    { $c, 0, $x }
       } ).map: ((*+$m) * 255).Int]
   }

}</lang>

Link to off-site .mp4 video

Wren

Translation of: Julia

Library: DOME

Library: Wren-dynamic

<lang ecmascript>import "dome" for Window, Platform, Process import "graphics" for Canvas, Color import "math" for Math, Point import "random" for Random import "input" for Keyboard import "./dynamic" for Struct

var Start = Platform.time var Rand = Random.new()

var fields = [

   "particleNum",
   "positions",
   "velocities",
   "lifetimes",
   "points",
   "numPoints",
   "saturation",
   "spread",
   "range",
   "reciprocate"

] var ParticleFountain = Struct.create("ParticleFountain", fields)

class ParticleDisplay {

   construct new(particleNum, width, height) {
       Window.resize(width, height)
       Canvas.resize(width, height)
       Window.title = "Wren Particle System!"
       _pn = particleNum
       _w = width
       _h = height
       _df = 1 / 200 // say
       _pf = ParticleFountain.new(
           _pn,                      // particleNum
           List.filled(_pn * 2, 0),  // positions
           List.filled(_pn * 2, 0),  // velocities
           List.filled(_pn, 0),      // lifetimes
           List.filled(_pn, null),   // points
           0,                        // numPoints
           0.4,                      // saturation
           1.5,                      // spread
           1.5,                      // range
           false                     // reciprocate
       )
       for (i in 0..._pn) _pf.points[i] = Point.new(0, 0)
   }

   init() {
       Canvas.cls()
       _frames = 0 
   }

   updatePF() {
       var xidx = 0
       var yidx = 1
       var pointIdx = 0
       var recip = Fn.new { _pf.reciprocate ? _pf.range * Math.sin(Platform.time/1000) : 0 }
       for (idx in 0..._pf.particleNum) {
           var willDraw = false
           if (_pf.lifetimes[idx] <= 0) {
               if (Rand.float() < _df) {
                   _pf.lifetimes[idx]  = 2.5       // time to live
                   _pf.positions[xidx] = _w / 20   // starting position x
                   _pf.positions[yidx] = _h / 10   // and y

                    // starting velocities x and y
                    // randomized slightly so points reach different heights
                   _pf.velocities[xidx] = 10 * (_pf.spread * Rand.float() - _pf.spread / 2 + recip.call())
                   _pf.velocities[yidx] = (Rand.float() - 2.9) * _h / 20.5
                   _willDraw = true
               }
           } else {
               if (_pf.positions[yidx] > _h/10 && _pf.velocities[yidx] > 0) {
                   _pf.velocities[yidx] = _pf.velocities[yidx] * (-0.3)   // bounce
               }
               _pf.velocities[yidx] = _pf.velocities[yidx] + _df * _h / 10             // adjust velocity
               _pf.positions[xidx]  = _pf.positions[xidx] + _pf.velocities[xidx] * _df // adjust position x
               _pf.positions[yidx]  = _pf.positions[yidx] + _pf.velocities[yidx] * _df // and y
               _pf.lifetimes[idx]   = _pf.lifetimes[idx] - _df
               willDraw = true
           }
           if (willDraw) {  // gather all the points that are going to be rendered
               _pf.points[pointIdx] = Point.new((_pf.positions[xidx] * 10).floor,
                                                (_pf.positions[yidx] * 10).floor)
                pointIdx = pointIdx + 1
           }
           xidx = xidx + 2
           yidx = xidx + 1
           _pf.numPoints = pointIdx
       }
   }

   update() {
       if (Keyboard["Up"].justPressed) {
           _pf.saturation = Math.min(_pf.saturation + 0.1, 1)
       } else if (Keyboard["Down"].justPressed) {
           _pf.saturation = Math.max(_pf.saturation - 0.1, 0)
       } else if (Keyboard["PageUp"].justPressed) {
           _pf.spread = Math.min(_pf.spread + 1, 50)
       } else if (Keyboard["PageDown"].justPressed) {
           _pf.spread = Math.max(_pf.spread - 0.1, 0.2)
       } else if (Keyboard["Left"].justPressed) {
           _pf.range = Math.min(_pf.range + 0.1, 12)
       } else if (Keyboard["Right"].justPressed) {
           _pf.range = Math.max(_pf.range - 0.1, 0.1)
       } else if (Keyboard["Space"].justPressed) {
           _pf.reciprocate = !_pf.reciprocate
       } else if (Keyboard["Q"].justPressed) {
           Process.exit()
       }
       updatePF()
   }

   draw(alpha) {
       var c = Color.hsv((Platform.time % 5) * 72, _pf.saturation, 0.5, 0x7f)
       for (i in 0..._pf.numPoints) {
           Canvas.pset(_pf.points[i].x, _pf.points[i].y, c)
       }
       _frames = _frames + 1
       var now = Platform.time
       if (now - Start >= 1) {
           Start = now
           Window.title = "Wren Particle System!    (FPS = %(_frames))"
           _frames = 0
       }
   }

}

System.print("""

   Use UP and DOWN arrow keys to modify the saturation of the particle colors.
   Use PAGE UP and PAGE DOWN keys to modify the "spread" of the particles.
   Toggle reciprocation off / on with the SPACE bar.
   Use LEFT and RIGHT arrow keys to modify angle range for reciprocation.
   Press the "q" key to quit.

""")

var Game = ParticleDisplay.new(3000, 800, 800)</lang>

@@ Line 100: / Line 100: @@
     int width_;
     int height_;
-    int particles_;
     std::vector<PointInfo> point_info_;
     std::vector<SDL_Point> points_;
@@ Line 113: / Line 112: @@
 ParticleFountain::ParticleFountain(int n, int width, int height)
-    : width_(width), height_(height), particles_(n), point_info_(n),
+    : width_(width), height_(height), point_info_(n), points_(n, {0, 0}),
-      points_(n, {0, 0}), rng_(std::random_device{}()), dist_(0.0, 1.0) {
+      rng_(std::random_device{}()), dist_(0.0, 1.0) {
     window_.reset(SDL_CreateWindow(
         "C++ Particle System!", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,