123

Pen Settings

CSS Base

Vendor Prefixing

Add External Stylesheets/Pens

Any URL's added here will be added as <link>s in order, and before the CSS in the editor. If you link to another Pen, it will include the CSS from that Pen. If the preprocessor matches, it will attempt to combine them before processing.

+ add another resource

You're using npm packages, so we've auto-selected Babel for you here, which we require to process imports and make it all work. If you need to use a different JavaScript preprocessor, remove the packages in the npm tab.

Add External Scripts/Pens

Any URL's added here will be added as <script>s in order, and run before the JavaScript in the editor. You can use the URL of any other Pen and it will include the JavaScript from that Pen.

+ add another resource

Use npm Packages

We can make npm packages available for you to use in your JavaScript. We use webpack to prepare them and make them available to import. We'll also process your JavaScript with Babel.

⚠️ This feature can only be used by logged in users.

Code Indentation

     

Save Automatically?

If active, Pens will autosave every 30 seconds after being saved once.

Auto-Updating Preview

If enabled, the preview panel updates automatically as you code. If disabled, use the "Run" button to update.

HTML Settings

Here you can Sed posuere consectetur est at lobortis. Donec ullamcorper nulla non metus auctor fringilla. Maecenas sed diam eget risus varius blandit sit amet non magna. Donec id elit non mi porta gravida at eget metus. Praesent commodo cursus magna, vel scelerisque nisl consectetur et.

            
              <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/dat-gui/0.5/dat.gui.min.js"></script>
<script src="js/triangles.js"></script>

		<canvas id="playground" width="800" height="800"></canvas>

            
          
!
            
              body, html {
	margin: 0;
	padding: 0;
	background: #000;
}
            
          
!
            
              /* 
honestly not sure what I was going for here.  Still thinking of something cool to do with it

Thanks Ironwallaby for delaunay triangulation implementation
https://github.com/ironwallaby/delaunay
*/
$(function () {
	var sim = new Eng();

	var gui = new dat.GUI();
  	//gui.addColor(sim, 'nextLineColor');
  	gui.add(sim, 'edgeBounce', 0, 1);
  	gui.add(sim, 'acceleration', 0, 1);
  	gui.add(sim, 'maxSpeed', 0, 5);
  	gui.add(sim, 'maxArea', 0, 20000);
});

var Eng = function () {
  
  window.onresize = $.proxy(function(event) {
    this.canvas.width = window.innerWidth;
    this.canvas.height = window.innerHeight;
  }, this);
  
	this.canvas = document.getElementById('playground');

	this.c = document.getElementById('playground').getContext('2d');
	this.canvas.width = window.innerWidth;
	this.canvas.height = window.innerHeight;

	this.timestep = 16;
	this.updatePositionTimestep = 16;
	this.updatePositions = true;


	this.getRandomArbitrary = function (min, max) {
		return Math.floor(Math.random() * (max - min) + min);
	}
	this.maxArea = 1000;
	this.i = 1000;
	this.vertices = new Array(this.i);
	this.edgeBounce = 0.4;
	this.acceleration = 0.4;
	this.maxSpeed = 4;

	for(var tr = 0; tr < this.vertices.length; tr++) {
		var x, y;
		x = this.getRandomArbitrary(-10, this.canvas.width + 10);
		y = this.getRandomArbitrary(-10, this.canvas.height + 10);

		this.vertices[tr] = {x: x, y: y, velX: 0, velY: 0}
	}
	

	this.loop = function () {
		this.c.clearRect(0,0, this.canvas.width, this.canvas.height);

		if(this.updatePositions) {
			this.updatePositions = false;
			for(var tr = 0; tr < this.vertices.length; tr++) {
				this.vertices[tr].velX = this.vertices[tr].velX + (Math.random() - 0.499999) * this.acceleration;
				this.vertices[tr].velY = this.vertices[tr].velY + (Math.random() - 0.499999) * this.acceleration;
				if (this.vertices[tr].x > this.canvas.width + 20) {
					this.vertices[tr].velX = this.vertices[tr].velX - this.edgeBounce;
				} else if(this.vertices[tr].x < -20) {
					this.vertices[tr].velX = this.vertices[tr].velX + this.edgeBounce;
				}
				if (this.vertices[tr].y > this.canvas.height + 20) {
					this.vertices[tr].velY = this.vertices[tr].velY - this.edgeBounce;
				} else if(this.vertices[tr].y < -20) {
					this.vertices[tr].velY = this.vertices[tr].velY + this.edgeBounce;
				}
				if (this.vertices[tr].velY > this.maxSpeed) {
					this.vertices[tr].velY = this.maxSpeed;
				}
				if (this.vertices[tr].velX > this.maxSpeed) {
					this.vertices[tr].velX = this.maxSpeed;
				}
				this.vertices[tr].x = this.vertices[tr].x + this.vertices[tr].velX;
				this.vertices[tr].y = this.vertices[tr].y + this.vertices[tr].velY;
			}

			setTimeout($.proxy(function () {
				this.updatePositions = true;
			}, this), this.updatePositionTimestep);
		}

		var triangles = triangulate(this.vertices)

		i = triangles.length
		while(i)
			triangles[--i].draw(this)


		setTimeout($.proxy(function () {
			this.loop();
		}, this), this.timestep);
	}

	this.loop();
}

function Triangle(a, b, c) {
  this.a = a
  this.b = b
  this.c = c

  var A = b.x - a.x,
      B = b.y - a.y,
      C = c.x - a.x,
      D = c.y - a.y,
      E = A * (a.x + b.x) + B * (a.y + b.y),
      F = C * (a.x + c.x) + D * (a.y + c.y),
      G = 2 * (A * (c.y - b.y) - B * (c.x - b.x)),
      minx, miny, dx, dy

  /* If the points of the triangle are collinear, then just find the
   * extremes and use the midpoint as the center of the circumcircle. */
  if(Math.abs(G) < 0.000001) {
    minx = Math.min(a.x, b.x, c.x)
    miny = Math.min(a.y, b.y, c.y)
    dx   = (Math.max(a.x, b.x, c.x) - minx) * 0.5
    dy   = (Math.max(a.y, b.y, c.y) - miny) * 0.5

    this.x = minx + dx
    this.y = miny + dy
    this.r = dx * dx + dy * dy
  }

  else {
    this.x = (D*E - B*F) / G
    this.y = (A*F - C*E) / G
    dx = this.x - a.x
    dy = this.y - a.y
    this.r = dx * dx + dy * dy
  }
}

Triangle.prototype.draw = function(eng) {
  eng.c.beginPath()
	var area = Math.abs((this.a.x * (this.b.y - this.c.y) + this.b.x*(this.c.y-this.a.y) + this.c.x * (this.a.y - this.b.y))/2);
  eng.c.moveTo(this.a.x, this.a.y)
  eng.c.lineTo(this.b.x, this.b.y)
  eng.c.lineTo(this.c.x, this.c.y)
  //eng.c.fillStyle = 'rgba(0, ' + eng.getRandomArbitrary(150, 200) + ', 0, 1)';
  eng.c.fillStyle = 'rgba(22, 141, 217, ' + area/eng.maxArea + ')';
  eng.c.fill()
  eng.c.closePath()
}

function byX(a, b) {
  return b.x - a.x
}

function dedup(edges) {
  var j = edges.length,
      a, b, i, m, n

  outer: while(j) {
    b = edges[--j]
    a = edges[--j]
    i = j
    while(i) {
      n = edges[--i]
      m = edges[--i]
      if((a === m && b === n) || (a === n && b === m)) {
        edges.splice(j, 2)
        edges.splice(i, 2)
        j -= 2
        continue outer
      }
    }
  }
}

function triangulate(vertices) {
  /* Bail if there aren't enough vertices to form any triangles. */
  if(vertices.length < 3)
    return []

  /* Ensure the vertex array is in order of descending X coordinate
   * (which is needed to ensure a subquadratic runtime), and then find
   * the bounding box around the points. */
  vertices.sort(byX)

  var i    = vertices.length - 1,
      xmin = vertices[i].x,
      xmax = vertices[0].x,
      ymin = vertices[i].y,
      ymax = ymin

  while(i--) {
    if(vertices[i].y < ymin) ymin = vertices[i].y
    if(vertices[i].y > ymax) ymax = vertices[i].y
  }

  /* Find a supertriangle, which is a triangle that surrounds all the
   * vertices. This is used like something of a sentinel value to remove
   * cases in the main algorithm, and is removed before we return any
   * results.
   *
   * Once found, put it in the "open" list. (The "open" list is for
   * triangles who may still need to be considered; the "closed" list is
   * for triangles which do not.) */
  var dx     = xmax - xmin,
      dy     = ymax - ymin,
      dmax   = (dx > dy) ? dx : dy,
      xmid   = (xmax + xmin) * 0.5,
      ymid   = (ymax + ymin) * 0.5,
      open   = [
        new Triangle(
          {x: xmid - 20 * dmax, y: ymid -      dmax, __sentinel: true},
          {x: xmid            , y: ymid + 20 * dmax, __sentinel: true},
          {x: xmid + 20 * dmax, y: ymid -      dmax, __sentinel: true}
        )
      ],
      closed = [],
      edges = [],
      j, a, b

  /* Incrementally add each vertex to the mesh. */
  i = vertices.length
  while(i--) {
    /* For each open triangle, check to see if the current point is
     * inside it's circumcircle. If it is, remove the triangle and add
     * it's edges to an edge list. */
    edges.length = 0
    j = open.length
    while(j--) {
      /* If this point is to the right of this triangle's circumcircle,
       * then this triangle should never get checked again. Remove it
       * from the open list, add it to the closed list, and skip. */
      dx = vertices[i].x - open[j].x
      if(dx > 0 && dx * dx > open[j].r) {
        closed.push(open[j])
        open.splice(j, 1)
        continue
      }

      /* If not, skip this triangle. */
      dy = vertices[i].y - open[j].y
      if(dx * dx + dy * dy > open[j].r)
        continue

      /* Remove the triangle and add it's edges to the edge list. */
      edges.push(
        open[j].a, open[j].b,
        open[j].b, open[j].c,
        open[j].c, open[j].a
      )
      open.splice(j, 1)
    }

    /* Remove any doubled edges. */
    dedup(edges)

    /* Add a new triangle for each edge. */
    j = edges.length
    while(j) {
      b = edges[--j]
      a = edges[--j]
      open.push(new Triangle(a, b, vertices[i]))
    }
  }

  /* Copy any remaining open triangles to the closed list, and then
   * remove any triangles that share a vertex with the supertriangle. */
  Array.prototype.push.apply(closed, open)

  i = closed.length
  while(i--)
    if(closed[i].a.__sentinel ||
       closed[i].b.__sentinel ||
       closed[i].c.__sentinel)
      closed.splice(i, 1)

  /* Yay, we're done! */
  return closed
}

if (typeof module !== 'undefined') {
    module.exports = {
        Triangle: Triangle,
        triangulate: triangulate
    }
}
            
          
!
999px
🕑 One or more of the npm packages you are using needs to be built. You're the first person to ever need it! We're building it right now and your preview will start updating again when it's ready.

Console