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: #000;
  margin: 0;
  padding: 0;
  border-width: 0;
  overflow: hidden;
}
</style>

  
  
  
</head>

<body translate="no">
  
  
      <script >
"use strict";

const LIMIT_FRACT = 5; // in pixels
const DURATION = 1500; // in ms, for each recursion level

let canv, ctx; // canvas and context
let maxx, maxy; // canvas dimensions

// for animation
let messages;
let dragon;
let baseline, basep;
let clear = false;

const b90 = 4 / 3 * (Math.sqrt(2) - 1); // to draw 1/4 circle with Bézier curves

// 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 mPIS3 = Math.PI / 3;
const m2PI = Math.PI * 2;
const m2PIS3 = Math.PI * 2 / 3;
const msin = Math.sin;
const mcos = Math.cos;
const matan2 = Math.atan2;

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

const rac2s2 = msqrt(2) / 2;

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

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 middle(p0, p1) {
  return { x: (p0.x + p1.x) / 2, y: (p0.y + p1.y) / 2 };
} // middle

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

function lerp(p0, p1, alpha) {
  return {
    x: p1.x * alpha + p0.x * (1 - alpha),
    y: p1.y * alpha + p0.y * (1 - alpha) };

} // lerp

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
function Noise1DOneShotModulo(period, modulo, step, random = Math.random) {
  /* returns a 1D single-shot noise generator.
         modulo must be > 0
         the (optional) random function must return a value between 0 and 1
        the returned function has no parameter, and will return a new number every time it is called.
        If the random function provides reproducible values (and is not used elsewhere), this
        one will return reproducible values too.
        period should be > 1. The bigger period is, the smoother output noise is
        All values between 0 and modulo have an equal probablilty. The values wrap from 0 to modulo and vice versa
        This makes the returned function suitable for directions or hues
      */

  let currx = 1 + random() * 0.5; // start with random offset
  let y0;
  let y1 = modulo * random(); // 'previous' value

  const dx = 1 / period;

  return function () {
    currx += dx;
    if (currx > 1) {
      currx -= 1;
      y0 = y1 % modulo;
      y1 = y0 + step * (2 * random() - 1); // 'next' value
      while (y1 < 0) {
        y0 += modulo;
        y1 += modulo;
      }
    }
    let z = (3 - 2 * currx) * currx * currx;
    return (z * y1 + (1 - z) * y0) % modulo;
  };
} // Noise1DOneShotModulo

//------------------------------------------------------------------------
function cutCubicIn2(bezier) {
  const pa = middle(bezier[0], bezier[1]);
  const pb = middle(bezier[1], bezier[2]);
  const pc = middle(bezier[2], bezier[3]);
  const pd = middle(pa, pb);
  const pe = middle(pb, pc);
  const pf = middle(pd, pe);
  return [
  [bezier[0], pa, pd, pf],
  [pf, pe, pc, bezier[3]]];

} // cutCubicIn2

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

function buildDragon(level) {
  // defined ona 1x1 rectangular grid. Will be rotated and scaled when drawn
  // dragon of level n (0 ..level) is just the 2^n first elements of the dragon array

  let turn;
  let turns = "";
  for (let k = 0; k < level; ++k) {
    turns += "0";
    for (let kc = turns.length - 2; kc >= 0; --kc)
    turns += turns.charAt(kc) == "0" ? "1" : "0";
  } // for k

  dragon = [
  { x: 0, y: 0 },
  { x: 1, y: 0 }];
  // begin with simple segment
  let dir = 0; // must be actual direction of segment above (0=E,1=S,2=W,3=N)
  let { x, y } = dragon[1];
  for (let k = 0; k < turns.length; ++k) {
    turn = turns.charAt(k) == "0" ? 1 : -1; // exchange 1 with -1 will exchange right and left turns
    dir = (dir - turn + 4) % 4;
    x += [1, 0, -1, 0][dir];
    y += [0, +1, 0, -1][dir];
    dragon.push({ x, y }); // new point
  }
} // buildDragon

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

function makeLevel(level) {
  // level must NOT be greater than the level provided in buildDragon
  /* for a baseline of 500, the whole curve fits in rectangle (-166,-333),(582,166) */
  let rot = -mPI / 4 * level;
  let scale = baseline / Math.pow(2, level / 2);
  let mat = new DOMMatrix([
  scale * mcos(rot),
  scale * msin(-rot),
  scale * msin(rot),
  scale * mcos(rot),
  0,
  0]);

  const nbPts = (1 << level) + 1;

  let drag = [];
  for (let k = 0; k < nbPts; ++k)
  drag[k] = DOMPointReadOnly.fromPoint(dragon[k]).matrixTransform(mat);

  let mid, pmid, p;
  let curve;
  curve = [];
  for (let k = 0; k < nbPts; ++k) {
    p = drag[k];
    if (k == nbPts - 1) {
      curve.push([pmid, lerp(pmid, p, 0.25), lerp(pmid, p, 0.75), p]); // final segment
    } else {
      mid = middle(p, drag[k + 1]);
      if (k == 0) {
        curve.push([p, lerp(p, mid, 0.25), lerp(p, mid, 0.75), mid]); // final segment
      } else {
        let p0 = lerp(pmid, p, b90);
        let p1 = lerp(mid, p, b90);
        curve.push([pmid, p0, p1, mid]);
      }
    }
    pmid = .........完整代码请登录后点击上方下载按钮下载查看