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 .........完整代码请登录后点击上方下载按钮下载查看