js实现canvas黑客帝国文字矩阵动画效果代码-html代码-BFW代码库

代码语言：html
所属分类：动画
代码描述：js实现canvas黑客帝国文字矩阵动画效果代码
下面为部分代码预览，完整代码请点击下载或在bfwstudio webide中打开
<!DOCTYPE html>
<html>

<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <script>
        "use strict";
    (function() {
    
    Error.stackTraceLimit = Infinity;
    
    var $global, $module;
    if (typeof window !== "undefined") { /* web page */
      $global = window;
    } else if (typeof self !== "undefined") { /* web worker */
      $global = self;
    } else if (typeof global !== "undefined") { /* Node.js */
      $global = global;
      $global.require = require;
    } else { /* others (e.g. Nashorn) */
      $global = this;
    }
    
    if ($global === undefined || $global.Array === undefined) {
      throw new Error("no global object found");
    }
    if (typeof module !== "undefined") {
      $module = module;
    }
    
    var $packages = {}, $idCounter = 0;
    var $keys = function(m) { return m ? Object.keys(m) : []; };
    var $flushConsole = function() {};
    var $throwRuntimeError; /* set by package "runtime" */
    var $throwNilPointerError = function() { $throwRuntimeError("invalid memory address or nil pointer dereference"); };
    var $call = function(fn, rcvr, args) { return fn.apply(rcvr, args); };
    var $makeFunc = function(fn) { return function() { return $externalize(fn(this, new ($sliceType($jsObjectPtr))($global.Array.prototype.slice.call(arguments, []))), $emptyInterface); }; };
    var $unused = function(v) {};
    
    var $mapArray = function(array, f) {
      var newArray = new array.constructor(array.length);
      for (var i = 0; i < array.length; i++) {
        newArray[i] = f(array[i]);
      }
      return newArray;
    };
    
    var $methodVal = function(recv, name) {
      var vals = recv.$methodVals || {};
      recv.$methodVals = vals; /* noop for primitives */
      var f = vals[name];
      if (f !== undefined) {
        return f;
      }
      var method = recv[name];
      f = function() {
        $stackDepthOffset--;
        try {
          return method.apply(recv, arguments);
        } finally {
          $stackDepthOffset++;
        }
      };
      vals[name] = f;
      return f;
    };
    
    var $methodExpr = function(typ, name) {
      var method = typ.prototype[name];
      if (method.$expr === undefined) {
        method.$expr = function() {
          $stackDepthOffset--;
          try {
            if (typ.wrapped) {
              arguments[0] = new typ(arguments[0]);
            }
            return Function.call.apply(method, arguments);
          } finally {
            $stackDepthOffset++;
          }
        };
      }
      return method.$expr;
    };
    
    var $ifaceMethodExprs = {};
    var $ifaceMethodExpr = function(name) {
      var expr = $ifaceMethodExprs["$" + name];
      if (expr === undefined) {
        expr = $ifaceMethodExprs["$" + name] = function() {
          $stackDepthOffset--;
          try {
            return Function.call.apply(arguments[0][name], arguments);
          } finally {
            $stackDepthOffset++;
          }
        };
      }
      return expr;
    };
    
    var $subslice = function(slice, low, high, max) {
      if (low < 0 || high < low || max < high || high > slice.$capacity || max > slice.$capacity) {
        $throwRuntimeError("slice bounds out of range");
      }
      var s = new slice.constructor(slice.$array);
      s.$offset = slice.$offset + low;
      s.$length = slice.$length - low;
      s.$capacity = slice.$capacity - low;
      if (high !== undefined) {
        s.$length = high - low;
      }
      if (max !== undefined) {
        s.$capacity = max - low;
      }
      return s;
    };
    
    var $substring = function(str, low, high) {
      if (low < 0 || high < low || high > str.length) {
        $throwRuntimeError("slice bounds out of range");
      }
      return str.substring(low, high);
    };
    
    var $sliceToArray = function(slice) {
      if (slice.$array.constructor !== Array) {
        return slice.$array.subarray(slice.$offset, slice.$offset + slice.$length);
      }
      return slice.$array.slice(slice.$offset, slice.$offset + slice.$length);
    };
    
    var $decodeRune = function(str, pos) {
      var c0 = str.charCodeAt(pos);
    
      if (c0 < 0x80) {
        return [c0, 1];
      }
    
      if (c0 !== c0 || c0 < 0xC0) {
        return [0xFFFD, 1];
      }
    
      var c1 = str.charCodeAt(pos + 1);
      if (c1 !== c1 || c1 < 0x80 || 0xC0 <= c1) {
        return [0xFFFD, 1];
      }
    
      if (c0 < 0xE0) {
        var r = (c0 & 0x1F) << 6 | (c1 & 0x3F);
        if (r <= 0x7F) {
          return [0xFFFD, 1];
        }
        return [r, 2];
      }
    
      var c2 = str.charCodeAt(pos + 2);
      if (c2 !== c2 || c2 < 0x80 || 0xC0 <= c2) {
        return [0xFFFD, 1];
      }
    
      if (c0 < 0xF0) {
        var r = (c0 & 0x0F) << 12 | (c1 & 0x3F) << 6 | (c2 & 0x3F);
        if (r <= 0x7FF) {
          return [0xFFFD, 1];
        }
        if (0xD800 <= r && r <= 0xDFFF) {
          return [0xFFFD, 1];
        }
        return [r, 3];
      }
    
      var c3 = str.charCodeAt(pos + 3);
      if (c3 !== c3 || c3 < 0x80 || 0xC0 <= c3) {
        return [0xFFFD, 1];
      }
    
      if (c0 < 0xF8) {
        var r = (c0 & 0x07) << 18 | (c1 & 0x3F) << 12 | (c2 & 0x3F) << 6 | (c3 & 0x3F);
        if (r <= 0xFFFF || 0x10FFFF < r) {
          return [0xFFFD, 1];
        }
        return [r, 4];
      }
    
      return [0xFFFD, 1];
    };
    
    var $encodeRune = function(r) {
      if (r < 0 || r > 0x10FFFF || (0xD800 <= r && r <= 0xDFFF)) {
        r = 0xFFFD;
      }
      if (r <= 0x7F) {
        return String.fromCharCode(r);
      }
      if (r <= 0x7FF) {
        return String.fromCharCode(0xC0 | r >> 6, 0x80 | (r & 0x3F));
      }
      if (r <= 0xFFFF) {
        return String.fromCharCode(0xE0 | r >> 12, 0x80 | (r >> 6 & 0x3F), 0x80 | (r & 0x3F));
      }
      return String.fromCharCode(0xF0 | r >> 18, 0x80 | (r >> 12 & 0x3F), 0x80 | (r >> 6 & 0x3F), 0x80 | (r & 0x3F));
    };
    
    var $stringToBytes = function(str) {
      var array = new Uint8Array(str.length);
      for (var i = 0; i < str.length; i++) {
        array[i] = str.charCodeAt(i);
      }
      return array;
    };
    
    var $bytesToString = function(slice) {
      if (slice.$length === 0) {
        return "";
      }
      var str = "";
      for (var i = 0; i < slice.$length; i += 10000) {
        str += String.fromCharCode.apply(undefined, slice.$array.subarray(slice.$offset + i, slice.$offset + Math.min(slice.$length, i + 10000)));
      }
      return str;
    };
    
    var $stringToRunes = function(str) {
      var array = new Int32Array(str.length);
      var rune, j = 0;
      for (var i = 0; i < str.length; i += rune[1], j++) {
        rune = $decodeRune(str, i);
        array[j] = rune[0];
      }
      return array.subarray(0, j);
    };
    
    var $runesToString = function(slice) {
      if (slice.$length === 0) {
        return "";
      }
      var str = "";
      for (var i = 0; i < slice.$length; i++) {
        str += $encodeRune(slice.$array[slice.$offset + i]);
      }
      return str;
    };
    
    var $copyString = function(dst, src) {
      var n = Math.min(src.length, dst.$length);
      for (var i = 0; i < n; i++) {
        dst.$array[dst.$offset + i] = src.charCodeAt(i);
      }
      return n;
    };
    
    var $copySlice = function(dst, src) {
      var n = Math.min(src.$length, dst.$length);
      $copyArray(dst.$array, src.$array, dst.$offset, src.$offset, n, dst.constructor.elem);
      return n;
    };
    
    var $copyArray = function(dst, src, dstOffset, srcOffset, n, elem) {
      if (n === 0 || (dst === src && dstOffset === srcOffset)) {
        return;
      }
    
      if (src.subarray) {
        dst.set(src.subarray(srcOffset, srcOffset + n), dstOffset);
        return;
      }
    
      switch (elem.kind) {
      case $kindArray:
      case $kindStruct:
        if (dst === src && dstOffset > srcOffset) {
          for (var i = n - 1; i >= 0; i--) {
            elem.copy(dst[dstOffset + i], src[srcOffset + i]);
          }
          return;
        }
        for (var i = 0; i < n; i++) {
          elem.copy(dst[dstOffset + i], src[srcOffset + i]);
        }
        return;
      }
    
      if (dst === src && dstOffset > srcOffset) {
        for (var i = n - 1; i >= 0; i--) {
          dst[dstOffset + i] = src[srcOffset + i];
        }
        return;
      }
      for (var i = 0; i < n; i++) {
        dst[dstOffset + i] = src[srcOffset + i];
      }
    };
    
    var $clone = function(src, type) {
      var clone = type.zero();
      type.copy(clone, src);
      return clone;
    };
    
    var $pointerOfStructConversion = function(obj, type) {
      if(obj.$proxies === undefined) {
        obj.$proxies = {};
        obj.$proxies[obj.constructor.string] = obj;
      }
      var proxy = obj.$proxies[type.string];
      if (proxy === undefined) {
        var properties = {};
        for (var i = 0; i < type.elem.fields.length; i++) {
          (function(fieldProp) {
            properties[fieldProp] = {
              get: function() { return obj[fieldProp]; },
              set: function(value) { obj[fieldProp] = value; }
            };
          })(type.elem.fields[i].prop);
        }
        proxy = Object.create(type.prototype, properties);
        proxy.$val = proxy;
        obj.$proxies[type.string] = proxy;
        proxy.$proxies = obj.$proxies;
      }
      return proxy;
    };
    
    var $append = function(slice) {
      return $internalAppend(slice, arguments, 1, arguments.length - 1);
    };
    
    var $appendSlice = function(slice, toAppend) {
      if (toAppend.constructor === String) {
        var bytes = $stringToBytes(toAppend);
        return $internalAppend(slice, bytes, 0, bytes.length);
      }
      return $internalAppend(slice, toAppend.$array, toAppend.$offset, toAppend.$length);
    };
    
    var $internalAppend = function(slice, array, offset, length) {
      if (length === 0) {
        return slice;
      }
    
      var newArray = slice.$array;
      var newOffset = slice.$offset;
      var newLength = slice.$length + length;
      var newCapacity = slice.$capacity;
    
      if (newLength > newCapacity) {
        newOffset = 0;
        newCapacity = Math.max(newLength, slice.$capacity < 1024 ? slice.$capacity * 2 : Math.floor(slice.$capacity * 5 / 4));
    
        if (slice.$array.constructor === Array) {
          newArray = slice.$array.slice(slice.$offset, slice.$offset + slice.$length);
          newArray.length = newCapacity;
          var zero = slice.constructor.elem.zero;
          for (var i = slice.$length; i < newCapacity; i++) {
            newArray[i] = zero();
          }
        } else {
          newArray = new slice.$array.constructor(newCapacity);
          newArray.set(slice.$array.subarray(slice.$offset, slice.$offset + slice.$length));
        }
      }
    
      $copyArray(newArray, array, newOffset + slice.$length, offset, length, slice.constructor.elem);
    
      var newSlice = new slice.constructor(newArray);
      newSlice.$offset = newOffset;
      newSlice.$length = newLength;
      newSlice.$capacity = newCapacity;
      return newSlice;
    };
    
    var $equal = function(a, b, type) {
      if (type === $jsObjectPtr) {
        return a === b;
      }
      switch (type.kind) {
      case $kindComplex64:
      case $kindComplex128:
        return a.$real === b.$real && a.$imag === b.$imag;
      case $kindInt64:
      case $kindUint64:
        return a.$high === b.$high && a.$low === b.$low;
      case $kindArray:
        if (a.length !== b.length) {
          return false;
        }
        for (var i = 0; i < a.length; i++) {
          if (!$equal(a[i], b[i], type.elem)) {
            return false;
          }
        }
        return true;
      case $kindStruct:
        for (var i = 0; i < type.fields.length; i++) {
          var f = type.fields[i];
          if (!$equal(a[f.prop], b[f.prop], f.typ)) {
            return false;
          }
        }
        return true;
      case $kindInterface:
        return $interfaceIsEqual(a, b);
      default:
        return a === b;
      }
    };
    
    var $interfaceIsEqual = function(a, b) {
      if (a === $ifaceNil || b === $ifaceNil) {
        return a === b;
      }
      if (a.constructor !== b.constructor) {
        return false;
      }
      if (a.constructor === $jsObjectPtr) {
        return a.object === b.object;
      }
      if (!a.constructor.comparable) {
        $throwRuntimeError("comparing uncomparable type " + a.constructor.string);
      }
      return $equal(a.$val, b.$val, a.constructor);
    };
    
    var $min = Math.min;
    var $mod = function(x, y) { return x % y; };
    var $parseInt = parseInt;
    var $parseFloat = function(f) {
      if (f !== undefined && f !== null && f.constructor === Number) {
        return f;
      }
      return parseFloat(f);
    };
    
    var $froundBuf = new Float32Array(1);
    var $fround = Math.fround || function(f) {
      $froundBuf[0] = f;
      return $froundBuf[0];
    };
    
    var $imul = Math.imul || function(a, b) {
      var ah = (a >>> 16) & 0xffff;
      var al = a & 0xffff;
      var bh = (b >>> 16) & 0xffff;
      var bl = b & 0xffff;
      return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0) >> 0);
    };
    
    var $floatKey = function(f) {
      if (f !== f) {
        $idCounter++;
        return "NaN$" + $idCounter;
      }
      return String(f);
    };
    
    var $flatten64 = function(x) {
      return x.$high * 4294967296 + x.$low;
    };
    
    var $shiftLeft64 = function(x, y) {
      if (y === 0) {
        return x;
      }
      if (y < 32) {
        return new x.constructor(x.$high << y | x.$low >>> (32 - y), (x.$low << y) >>> 0);
      }
      if (y < 64) {
        return new x.constructor(x.$low << (y - 32), 0);
      }
      return new x.constructor(0, 0);
    };
    
    var $shiftRightInt64 = function(x, y) {
      if (y === 0) {
        return x;
      }
      if (y < 32) {
        return new x.constructor(x.$high >> y, (x.$low >>> y | x.$high << (32 - y)) >>> 0);
      }
      if (y < 64) {
        return new x.constructor(x.$high >> 31, (x.$high >> (y - 32)) >>> 0);
      }
      if (x.$high < 0) {
        return new x.constructor(-1, 4294967295);
      }
      return new x.constructor(0, 0);
    };
    
    var $shiftRightUint64 = function(x, y) {
      if (y === 0) {
        return x;
      }
      if (y < 32) {
        return new x.constructor(x.$high >>> y, (x.$low >>> y | x.$high << (32 - y)) >>> 0);
      }
      if (y < 64) {
        return new x.constructor(0, x.$high >>> (y - 32));
      }
      return new x.constructor(0, 0);
    };
    
    var $mul64 = function(x, y) {
      var high = 0, low = 0;
      if ((y.$low & 1) !== 0) {
        high = x.$high;
        low = x.$low;
      }
      for (var i = 1; i < 32; i++) {
        if ((y.$low & 1<<i) !== 0) {
          high += x.$high << i | x.$low >>> (32 - i);
          low += (x.$low << i) >>> 0;
        }
      }
      for (var i = 0; i < 32; i++) {
        if ((y.$high & 1<<i) !== 0) {
          high += x.$low << i;
        }
      }
      return new x.constructor(high, low);
    };
    
    var $div64 = function(x, y, returnRemainder) {
      if (y.$high === 0 && y.$low === 0) {
        $throwRuntimeError("integer divide by zero");
      }
    
      var s = 1;
      var rs = 1;
    
      var xHigh = x.$high;
      var xLow = x.$low;
      if (xHigh < 0) {
        s = -1;
        rs = -1;
        xHigh = -xHigh;
        if (xLow !== 0) {
          xHigh--;
          xLow = 4294967296 - xLow;
        }
      }
    
      var yHigh = y.$high;
      var yLow = y.$low;
      if (y.$high < 0) {
        s *= -1;
        yHigh = -yHigh;
        if (yLow !== 0) {
          yHigh--;
          yLow = 4294967296 - yLow;
        }
      }
    
      var high = 0, low = 0, n = 0;
      while (yHigh < 2147483648 && ((xHigh > yHigh) || (xHigh === yHigh && xLow > yLow))) {
        yHigh = (yHigh << 1 | yLow >>> 31) >>> 0;
        yLow = (yLow << 1) >>> 0;
        n++;
      }
      for (var i = 0; i <= n; i++) {
        high = high << 1 | low >>> 31;
        low = (low << 1) >>> 0;
        if ((xHigh > yHigh) || (xHigh === yHigh && xLow >= yLow)) {
          xHigh = xHigh - yHigh;
          xLow = xLow - yLow;
          if (xLow < 0) {
            xHigh--;
            xLow += 4294967296;
          }
          low++;
          if (low === 4294967296) {
            high++;
            low = 0;
          }
        }
        yLow = (yLow >>> 1 | yHigh << (32 - 1)) >>> 0;
        yHigh = yHigh >>> 1;
      }
    
      if (returnRemainder) {
        return new x.constructor(xHigh * rs, xLow * rs);
      }
      return new x.constructor(high * s, low * s);
    };
    
    var $divComplex = function(n, d) {
      var ninf = n.$real === Infinity || n.$real === -Infinity || n.$imag === Infinity || n.$imag === -Infinity;
      var dinf = d.$real === Infinity || d.$real === -Infinity || d.$imag === Infinity || d.$imag === -Infinity;
      var nnan = !ninf && (n.$real !== n.$real || n.$imag !== n.$imag);
      var dnan = !dinf && (d.$real !== d.$real || d.$imag !== d.$imag);
      if(nnan || dnan) {
        return new n.constructor(NaN, NaN);
      }
      if (ninf && !dinf) {
        return new n.constructor(Infinity, Infinity);
      }
      if (!ninf && dinf) {
        return new n.constructor(0, 0);
      }
      if (d.$real === 0 && d.$imag === 0) {
        if (n.$real === 0 && n.$imag === 0) {
          return new n.constructor(NaN, NaN);
        }
        return new n.constructor(Infinity, Infinity);
      }
      var a = Math.abs(d.$real);
      var b = Math.abs(d.$imag);
      if (a <= b) {
        var ratio = d.$real / d.$imag;
        var denom = d.$real * ratio + d.$imag;
        return new n.constructor((n.$real * ratio + n.$imag) / denom, (n.$imag * ratio - n.$real) / denom);
      }
      var ratio = d.$imag / d.$real;
      var denom = d.$imag * ratio + d.$real;
      return new n.constructor((n.$imag * ratio + n.$real) / denom, (n.$imag - n.$real * ratio) / denom);
    };
    
    va.........完整代码请登录后点击上方下载按钮下载查看