js实现可编辑的雪花效果代码-html代码-BFW代码库

代码语言：html
所属分类：其他
代码描述：js实现可编辑的雪花效果代码
下面为部分代码预览，完整代码请点击下载或在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;
}

button {
  display: block;
  z-index: 10;
  position: absolute;
  left: 1em;
  cursor: pointer;
}

#controls {
  top: 1em;
}

#setfern {
  top: 3em;
}

#setsierp {
  top: 5em;
}
</style>


  
</head>

<body translate="no">
  <button type="button" id="controls">edit</button>
<button type="button" id="setfern">fern</button>
<button type="button" id="setsierp">Sierpiński</button>
  
      <script >
let canv, ctx; // canvas and context
let fgCanv, fgCtx;
let maxx, maxy; // canvas dimensions
let fern;
let xc, yc, radius;
let controls = true;
let animFernState = 0;

const captureRadius = 10;

// for animation
let messages;

// 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 rac3 = msqrt(3);
const rac3s2 = rac3 / 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 randomSign() {
  // -1 or +1
  return mrandom > 0.5 ? -1 : 1;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
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 drawFigure(point, figureIndex, color, lineWidth) {
  fgCtx.beginPath();
  fgCtx.strokeStyle = color;
  fgCtx.lineWidth = lineWidth;
  switch (figureIndex) {
    case 0: // cross
      fgCtx.moveTo(point.x - 3, point.y);
      fgCtx.lineTo(point.x + 3, point.y);
      fgCtx.moveTo(point.x, point.y - 3);
      fgCtx.lineTo(point.x, point.y + 3);
      break;
    case 1: // x
      fgCtx.moveTo(point.x - 2, point.y - 2);
      fgCtx.lineTo(point.x + 2, point.y + 2);
      fgCtx.moveTo(point.x - 2, point.y + 2);
      fgCtx.lineTo(point.x + 2, point.y - 2);
      break;
    case 2: // o
      fgCtx.arc(point.x, point.y, 2, 0, m2PI);
      break;}

  fgCtx.stroke();
} // drawFigure

//------------------------------------------------------------------------
// POINT
//------------------------------------------------------------------------
// class Point
function Point(x, y) {
  this.x = x;
  this.y = y;
} // function Point

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

Point.prototype.draw = function (color) {
  // hope this.index has been defined!
  // black background (thick line)
  drawFigure(this, this.index, "#000", 4);
  // colored drawing (thin line)
  drawFigure(this, this.index, color, 2);
}; // Point.prototype.draw

//------------------------------------------------------------------------
// TRIANGLE
//------------------------------------------------------------------------

// class Triangle

// given array of 3 points
// /!\ : vertices order MATTERS

function Triangle(vertices, color) {
  this.vertices = vertices;
  // since here a point cannot belong to more than one triangle, we can create a backlink :
  vertices.forEach((vertex, k) => {
    vertex.triangle = this;
    vertex.index = k;
  }); // vertices.forEach
  this.color = color; // will be used for drawing
} // Triangle

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Triangle.prototype.surface = function () {
  const [v0, v1, v2] = this.vertices;

  return (
    0.5 *
    mabs(
    v1.x * v0.y -
    v0.x * v1.y +
    v2.x * v1.y -
    v1.x * v2.y +
    v0.x * v2.y -
    v2.x * v0.y));


}; // surface
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Triangle.prototype.draw = function () {
  fgCtx.beginPath();
  fgCtx.strokeStyle = this.color;
  fgCtx.lineWidth = 1; // thin line;
  fgCtx.moveTo(this.vertices[0].x, this.vertices[0].y);
  fgCtx.lineTo(this.vertices[1].x, this.vertices[1].y);
  fgCtx.lineTo(this.vertices[2].x, this.vertices[2].y);
  fgCtx.closePath();
  fgCtx.stroke();
  this.vertices.forEach(vertex => vertex.draw(this.color));
}; // Triangle.prototype.draw

//------------------------------------------------------------------------
//------------------------------------------------------------------------
function transform(a, b, c, d, e, f) {
  return function (x, y) {
    return [a * x + b * y + c, d * x + e * y + f];
  };
}

//------------------------------------------------------------------------
// FERN
//------------------------------------------------------------------------
class Fern {
  constructor() {
    // colors for triangles

    this.colors = ["#0f0", "#f80", "#0ff", "#ff0", "#80f"];
    this.setFern();
  } // Fern

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  setFern() {
    let p0 = new Point(xc, yc - 0.03 * radius); // center, top
    let p1 = new Point(xc, yc + radius); // bottom
    let p2 = new Point(xc + radius * 0.5, yc + radius * rac3s2); // bottom right
    this.primary = new Triangle([p0, p1, p2], this.colors[0]);
    //  this.primary.draw();
    // vertices of other triangles will be defined using p0p1 and p0p2 as a base
    let base = [
    new Point(p1.x - p0.x, p1.y - p0.y),
    new Point(p2.x - p0.x, p2.y - p0.y)];
    // vertors rather than points, but who cares ?

    // lower left leaflet
    this.tri1 = new Triangle(
    [
    basedPoint(0.6, 0.03),
    basedPoint(0.48, 0.49),
    basedPoint(0.48 * 0.8, 0.49 * 0.85)],

    this.colors[1]);


    // lower rightleaflet
    this.tri2 = new Triangle(
    [
    basedPoint(0.01, 0.97),
    basedPoint(0.49, 0.48),
    basedPoint(0.49 * 0.85, 0.48 * 0.9)],

    this.colors[2]);

    // reduced copy
    this.tri4 = new Triangle(
    [basedPoint(0, 0), basedPoint(0.85, 0), basedPoint(0, 0.85)],
    this.colors[4]);

    this.triangles = [this.tri1, this.tri2, this.tri4];
    this.allTriangles = [this.primary, ...this.triangles];

    this.draw();
    this.transfos();
    animFernState = 1;

    function basedPoint(c1, c2) {
      // returns point at p0 + c1 * base[0] + c2 * base[1]
      // point is inside base triangle if c1 >= 0, c2 >= 0 AND c1 + c2 <= 1

      return new Point(
      p0.x + c1 * base[0].x + c2 * base[1].x,
      p0.y + c1 * base[0].y + c2 * base[1].y);

    } // basedPoint
  }
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  setSierp() {
    let p0 = new Point(xc, yc - 0.03 * radius); // center, top
    let p1 = new Point(xc, yc + radius); // bottom
    let p2 = new Point(xc + radius * 0.5, yc + radius * rac3s2); // bottom right
    this.primary = new Triangle([p0, p1, p2], this.colors[0]);
    //  this.primary.draw();
    // vertices of other triangles will be defined using p0p1 and p0p2 as a base
    let base = [
    new Point(p1.x - p0.x, p1.y - p0.y),
    new Point(p2.x - p0.x, p2.y - p0.y)];
    // vertors rather than points, but who cares ?

    // lower left leaflet
    this.tri1 = new Triangle(
    [basedPoint(0.5, 0), basedPoint(1, 0), basedPoint(0.5, 0.5)],
    this.colors[1]);


    // lower rightleaflet
    this.tri2 = new Triangle(
    [basedPoint(0, 0.5), basedPoint(0.5, 0.5), basedPoint(0, 1)],
    this.colors[2]);

    // reduced copy
    this.tri4 = new Triangle(
    [basedPoint(0, 0), basedPoint(0.5, 0), basedPoint(0, 0.5)],
    this.colors[4]);

    this.triangles = [this.tri1, this.tri2, this.tri4];
    this.allTriangles = [this.primary, ...this.triangles];

    this.draw();
    this.transfos();
    animFernState = 1;

    function basedPoint(c1, c2) {
      // returns point at p0 + c1 * base[0] + c2 * base[1]
      // point is inside base triangle if c1 >= 0, c2 >= 0 AND c1 + c2 <= 1

      return new Point(
      p0.x + c1 * base[0].x + c2 * base[1].x,
      p0.y + c1 * base[0].y + c2 * base[1].y);

    } // basedPoint
  }
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  draw() {
    fgCtx.clearRect(0, 0, maxx, maxy);
    this.allTriangles.forEach(tri => tri.draw());
  }

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  closestPoint(event) {
    /* mouse position given in event
          returns a distance and a point
        */

    let minDist = 1e9; // distance of closest point
    let p; // closest point
    let dist;

    this.allTriangles.forEach(triangle => {
      triangle.vertices.forEach(v => {
        dist = mhypot(event.clientX - v.x, event.clientY - v.y);
        if (dist < minDist) {
          minDist = dist;
          p = v;
        }
      });
    });
    return { p, minDist };
  } // closestPoint

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  coeffsTransfo(tri1, tri2) {
    // returns coefficients for affine transformation which changes triangle tri1 into triangle tri2
    /* a,b,c,d,e, f satisfying :
          tri1.vertices[0].x * a + tri1.vertices[0].y * b + c = tri2.vertices [0].x
          tri1.vertices[0].x * d + tri1.vertices[0].y * d + f = tri2.vertices [0].y
          (plus same for vertices[1] and vertices[2]
        */

    const [s0, s1, s2] = tri1.vertices;

    let det = det3(s0.x, s0.y, 1, s1.x, s1.y, 1, s2.x, s2.y, 1);
    let deta = det3(
    tri2.vertices[0].x,
    s0.y,
    1,
    tri2.vertices[1].x,
    s1.y,
    1,
    tri2.vertices[2].x,
    s2.y,
    1);

    let detb = det3(
    s0.x,
    tri2.vertices[0].x,
    1,
    s1.x,
    tri2.vertices[1].x,
    1,
    s2.x,
    tri2.vertices[2].x,
    1);

    let detc = det3(
    s0.x,
    s0.y,
    tri2.vertices[0].x,
    s1.x,
    s1.y,
    tri2.vertices[1].x,
    s2.x,
    s2.y,
    tri2.vertices[2].x);


    const a = deta / det;
 .........完整代码请登录后点击上方下载按钮下载查看