canvas多彩条纹效果代码-html代码-BFW代码库

代码语言：html

所属分类：其他

代码描述：canvas多彩条纹效果代码

下面为部分代码预览，完整代码请点击下载或在bfwstudio webide中打开

<!DOCTYPE html>
<html lang="en" >

<head>
  <meta charset="UTF-8">
  

  
  
<style>
body {
  font-family: Arial, Helvetica, "Liberation Sans", FreeSans, sans-serif;
  background-color: #fff;
  margin: 0;
  padding: 0;
  border-width: 0;
}
</style>

  
</head>

<body >
  

  
      <script >
"use strict";

window.addEventListener("load", function () {
  let triWidth, triHeight; // length of triangle side and altitude

  let canv, ctx; // canvas and context

  let maxx, maxy; // canvas dimensions

  let grid;
  let nbx, nby;
  let hnbx, hnby; // number of triangles in the half of the width, height of the canvas
  let nbLines;

  let events;

  // shortcuts for Math.
  const mrandom = Math.random;
  const mfloor = Math.floor;
  const mround = Math.round;
  const mceil = Math.ceil;
  const mabs = Math.abs;
  const mmin = Math.min;
  const mmax = Math.max;

  const mPI = Math.PI;
  const mPIS2 = Math.PI / 2;
  const m2PI = Math.PI * 2;
  const msin = Math.sin;
  const mcos = Math.cos;
  const matan2 = Math.atan2;

  const mhypot = Math.hypot;
  const msqrt = Math.sqrt;

  const rac3 = msqrt(3);
  const rac3s2 = rac3 / 2;
  const mPIS3 = Math.PI / 3;

  const sinPIS6 = 0.5;
  const cosPIS6 = rac3s2;
  const sinPIS3 = cosPIS6;
  const cosPIS3 = sinPIS6;

  //------------------------------------------------------------------------

  function alea(mini, maxi) {
    // random number in given range

    if (typeof maxi == "undefined") return mini * mrandom(); // range 0..mini

    return mini + mrandom() * (maxi - mini); // range mini..maxi
  }
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  function intAlea(mini, maxi) {
    // random integer in given range (mini..maxi - 1 or 0..mini - 1)
    //
    if (typeof maxi == "undefined") return mfloor(mini * mrandom()); // range 0..mini - 1
    return mini + mfloor(mrandom() * (maxi - mini)); // range mini .. maxi - 1
  }
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  function removeElement(array, element) {
    let idx = array.indexOf(element);
    array.splice(idx, 1);
  } // removeElement

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  function randomElement(array) {
    return array[intAlea(0, array.length)];
  }
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  function arrayShuffle(array) {
    /* randomly changes the order of items in an array
           only the order is modified, not the elements
        */
    let k1, temp;
    for (let k = array.length - 1; k >= 1; --k) {
      k1 = intAlea(0, k + 1);
      temp = array[k];
      array[k] = array[k1];
      array[k1] = temp;
    } // for k
    return array;
  } // arrayShuffle

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  /* returns lerp point between p0 and p1,
        alpha = 0 will return p0, alpha = 1 will return p1
        values of alpha outside [0,1] may be used to compute points outside the p0-p1 segment
      */
  function lerp(p0, p1, alpha) {
    return {
      x: (1 - alpha) * p0.x + alpha * p1.x,
      y: (1 - alpha) * p0.y + alpha * p1.y };

  } // function lerp

  //------------------------------------------------------------------------

  class Triangle {
    constructor(kx, ky) {
      /* numbering of vertices / edges
               0                        2---1---1
             / \                        \     /
            2   0                        2   0
           /     \                        \ /
          2---1---1                        0
      */


      /* constructor */

      this.kx = kx;
      this.ky = ky;
      this.kxc = kx - hnbx;
      this.kyc = ky - hnby;
      this.upsideDown = this.kxc + this.kyc & 1; // 0 or 1

      this.setXY();
    } // constructor

    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    setBase(side) {
      // where side is 0,1,2
      this.base = side; // which side is the base ?
      this.dirBase = [
      [0, 1, 2],
      [2, 1, 0]][
      this.upsideDown][this.base]; // orientation of base (== base side number for normally oriented triangle)
    }
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    getNeighbors() {
      /* must be called once - and only once - after the grid has been created */
      let kx, ky;
      this.neighbors = [];
      for (let k = 0; k < 3; ++k) {
        kx = this.kx + [1, 0, -1][k];
        ky =
        this.ky +
        [
        [0, 1, 0],
        [0, -1, 0]][
        this.upsideDown][k];
        this.neighbors[k] =
        kx < 0 || kx >= nbx || ky < 0 || ky >= nby ? false : grid[ky][kx];
      } // for k
    }

    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    setXY() {
      let xa, ya, vertices, deltay, upsideDown;
      // centre of this triangle (middle of height, not gravity centre)
      this.ya = ya = maxy / 2 + this.kyc * triHeight;
      this.xa = xa = maxx / 2 + this.kxc * triWidth / 2;

      this.vertices = vertices = [];
      deltay = triHeight / 2;
      if (this.upsideDown) deltay = -deltay;

      vertices[0] = { x: xa, y: ya - deltay };
      vertices[1] = { x: xa + triWidth / 2, y: ya + deltay };
      vertices[2] = { x: xa - triWidth / 2, y: ya + deltay };
    } // setXY
  } // class Triangle

  //------------------------------------------------------------------------
  function rndColor() {
    return `hsl(${intAlea(360)},${intAlea(80, 100)}%,${intAlea(35, 65)}%)`;
  }

  //------------------------------------------------------------------------

  function createBlock(tri) {
    let ntri, nside;

    if (tri.block) throw "wtf ???"; // already involved in a block, ignore
    // set base and exit side
    let choice = [
    [
    [1, 2],
    [2, 1]],

    [
    [0, 2],
    [2, 0]],

    [
    [1, 0],
    [0, 1]]][

    tri.entry][intAlea(2)];
    tri.exit = choice[0];
    tri.setBase(choice[1]);
    let block = [tri]; // create block with 1st segment
    tri.block = block;
    while (true) {
      ntri = tri.neighbors[tri.exit]; // next triangle, on exit side
      if (ntri === false) return block; // no neighbor => reached a side, finished
      nside = 2 - tri.exit; // neighbor sides are 0-2 or 1-1 pairs, so 2 - x is suitable to pick other side of pair
      if (ntri.block && ntri.base == nside) return block; // reached base of a .........完整代码请登录后点击上方下载按钮下载查看