canvas+webgl实现鼠标交互变形动画效果代码-html代码-BFW代码库

代码语言：html
所属分类：动画
代码描述：canvas+webgl实现鼠标交互变形动画效果代码
下面为部分代码预览，完整代码请点击下载或在bfwstudio webide中打开
<!DOCTYPE html>
<html lang="en" >

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


  
  
<style>
body {
  background-color: #000;
  margin: 0;
  overflow: hidden;
  background-repeat: no-repeat;
}

canvas {
  position: absolute;
}
</style>


  
  
</head>

<body>
  
  
      <script >
"use strict";

let canv, gl;
let maxx, maxy;
let midx, midy;

let widthHandle, heightHandle;
let c0Handle;
let mousePos = {};
let algo, algoHandle;
let orb, orbHandle;
let auto = false,
autoLevel = 0; // 0: mouse driven, 1 : automatic motion
let timeLastMove;
let reqCoords;
let animState = 0;

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;

//-----------------------------------------------------------------------------
// miscellaneous functions
//-----------------------------------------------------------------------------

function alea(min, max) {
  // random number [min..max[ . If no max is provided, [0..min[

  if (typeof max == "undefined") return min * mrandom();
  return min + (max - min) * mrandom();
}

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

function intAlea(min, max) {
  // random integer number [min..max[ . If no max is provided, [0..min[

  if (typeof max == "undefined") {
    max = min;
    min = 0;
  }
  return mfloor(min + (max - min) * mrandom());
} // intAlea

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

} // function lerp

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

//************** Shader sources **************
const R = 0.2;
const A = -3.0; // < 0; heart tip  is at (0, A *R);
// values used by shader but easier to calculate in JS
// junction point between circle and straight line
const X0 = 2 * A * A / (A * A + 1) * R;
const Y0 = X0 / A;
const PA = 2 * A / (A * A - 1); // slope of perp. to straight line
const PB = -1 / PA; // slope of straight Line
const LNG = mhypot(X0, A * R - Y0); // length of straight line

let vertexSource = `
attribute vec2 position;

void main() {
  gl_Position = vec4(position, 0.0, 1.0);
}
`;

let fragmentSource = `

 precision mediump float;

 #define ITER_MAX 100

 uniform float width;
 uniform float height;
 uniform vec2 c0; // constant in Julia iterative formula
 uniform int algo;
 uniform vec2 orb;

 vec2 iResolution;
 vec2 z;

void main(){

  iResolution = vec2(width, height);

  float dist, thismin;

  float zoom = 1.0;     // defines width of displayed area in the complex plane
  float factor = 4.0;   // this factor changes the thickness of displayed patterns

  if (algo == 1) {
    /* it would be smarter to use uniforms for zoom and factor, and set their values in JS. */
    zoom = 1.5;
    factor = 5.0;
  } else if (algo == 2) {
    factor = 12.0;
  }

  dist = 10000.;

  z = (gl_FragCoord.xy - 0.5 * iResolution.xy  ) / min(width, height) * 2.0 * zoom ;

  int k = 0;

  for (int kk = 0; kk < ITER_MAX; ++kk) {

    z = vec2 (z.x * z.x - z.y * z.y, 2.0 * z.x * z.y) + c0; // Julia formula, normal
    // here comes the orbit trap algorithm, as descriped in Wikipedia : https://en.wikipedia.org/wiki/Orbit_trap
    // algo #0 uses point orb as a trap; algo #1 uses x and y axes
    if (algo == 0) {
      thismin = length(z - orb);
    } else if (algo == 1) {
      thismin = min(abs(z.x), abs(z.y));
    } else {
      float rx = abs(z.x);
      if ((z.y > 0.0) || (z.y > (rx - ${R}) * ${PA})) {
        thismin = abs(length(vec2(rx, z.y)-vec2(${R}, 0))-${R});
      } else {
        if (z.y < ${A * R} + rx * ${PA}) { // beyond heart tip
          thismin = length(z - vec2(0, ${A * R}));
        } else {
          thismin = abs(${X0} * (z.y - ${Y0}) - ${
Y0 - A * R
}*(rx - ${X0})) / ${LNG};
          thismin = min(thismin, length(z));
        }
      }
    }
    if (thismin < dist) {
      dist = thismin;
      k = kk  - (kk / 6) * 6;
    }
  };

  vec3 s;
  if (k == 0) s = vec3(1.0, 0.0, 0.0);
  else if (k == 1) s = vec3(1.0, 1.0, 0.0);
  else if (k == 2) s = vec3(0.0, 1.0, 0.0);
  else if (k == 3) s = vec3(0.0, 1.0, 1.0);
  else if (k == 4) s = vec3(0.0, 0.0, 1.0);
  else s = vec3(1.0, 0.0, 1.0);

  float lum = (1.0-clamp(dist * factor , 0.0, 1.0));
  lum = sqrt(lum);
  gl_FragColor = vec4(s*lum, 1.0);
}
`;

//************** Utility functions **************

//Compile shader and combine with source
function compileShader(shaderSource, shaderType) {
  let shader = gl.createShader(shaderType);
  gl.shaderSource(shader, shaderSource);
  gl.compileShader(shader);
  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
    throw "Shader compile failed with: " + gl.getShaderInfoLog(shader);
  }
  return shader;
}

//From https://codepen.io/jlfwong/pen/GqmroZ
//Utility to complain loudly if we fail to find the attribute/uniform
function getAttribLocation(program, name) {
  let attributeLocation = gl.getAttribLocation(program, name);
  if (attributeLocation === -1) {
    throw "Cannot find attribute " + name + ".";
  }
  return attributeLocation;
}

function getUniformLocation(program, name) {
  let attributeLocation = gl.getUniformLocation(program, name);
  if (attributeLocation === null) {
    throw "Cannot find uniform " + name + ".";
  }
  return attributeLocation;
}

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

function initShadersStuff() {
  //************** Create shaders **************

  //Create vertex and fragment shaders
  let vertexShader = compileShader(vertexSource, gl.VERTEX_SHADER);
  let fragmentShader = compileShader(fragmentSource, gl.FRAGMENT_SHADER);

  //Create shader programs
  let program = gl.createProgram();
  gl.attachShader(program, vertexShader);
  gl.attachShader(program, fragmentShader);
  gl.linkProgram(program);

  gl.useProgram(program);

  //Set up rectangle covering entire canvas
  let vertexData = new Float32Array([
  -1.0,
  1.0, // top left
  -1.0,
  -1.0, // bottom left
  1.0,
  1.0, // top right
  1.0,
  -1.0 // bottom right
  ]);

  // Create vertex buffer
  let vertexDataBuffer = gl.createBuffer();
  gl.bindBuffer(gl.ARRAY_BUFFER, vertexDataBuffer);
  gl.bufferData(gl.ARRAY_BUFFER, vertexData, gl.STATIC_DRAW);
  // Layout of our data in the vertex buffer
  let positionHandle = getAttribLocation(program, "position");
  gl.enableVertexAttribArray(positionHandle);
  gl.vertexAttribPointer(
  positionHandle,
  2, // position is a vec2 (2 values per component)
  gl.FLOAT, // each component is a float
  false, // don't normalize values
  2 * 4, // two 4 byte float components per vertex (32 bit float is 4 bytes)
  0 // how many bytes inside the buffer to start from
  );

  //Get uniform handles

  widthHandle = getUniformLocation(program, "width");
  heightHandle = getUniformLocation(program, "height");
  c0Handle = getUniformLocation(program, "c0");
  algoHandle = getUniformLocation(program, "algo");
  orbHandle = getUniformLocation(program, "orb");
}

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

class Mover {
  constructor(poi) {
    this.poi = poi;
    this.tPrev = performance.now(); // time of previous move
    this.tRel = 0; // relative time, inside current step
    this.step = 0;
    this.lastP = poi.at(-1).p; // mimic we are starting from end of last movement
    this.speed = 1.0;
  }

  move() {
    /* returns current position of mover */

    let dt = performance.now() - this.tPrev;
    this.tPrev += dt;
    dt *= this.speed;
    this.tRel += dt; // time is running...
    while (this.tRel > this.poi[this.step].duration) {
      this.tRel -= this.poi[this.step].duration;
      this.lastP = this.poi[this.step].p;
      ++this.step;
      if (this.step >= this.poi.length) this.step = 0;
    }
    return lerp(
    this.lastP,
    this.poi[this.step].p,
    this.tRel / this.poi[this.step].duration);

  } // move
} // class Mover

const durl = 3000;
const durs = 1000;
const durss = 500;
const POI0 = [
// for algorithm #0
{ p: { x: -0.092357, y: -0.929936 }, duration: durl },
{ p: { x: -0.070064, y: -0.671974 }, duration: durs },
{ p: { x: -0.07962, y: -0.678344 }, duration: durs },
{ p: { x: -0.07962, y: -0.6656 }, duration: durs },
{ p: { x: -0.13057, y: -0.678344 }, duration: durl },
{ p: { x: -0.1465, y: -0.65637 }, duration: durs },
{ p: { x: -0.1793, y: -0.66669 }, duration: durs },
{ p: { x: -0.22293, y: -0.665605 }, duration: durs },
{ p: { x: -0.226115, y: -0.640127 }, duration: durs },
{ p: { x: -0.267516, y: -0.579618 }, duration: durs },
{ p: { x: -0.273885, y: -0.496815 }, duration: durs },
{ p: { x: 0.261146, y: -0.492675 }, duration: durl },
{ p: { x: 0.267516, y: -0.519108 }, duration: durs },
{ p: { .........完整代码请登录后点击上方下载按钮下载查看