this["exportedVariables"] =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__(1);


/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

//#region Requirements
var A = require('Animation')/*xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/;

var CI = require('CameraInfo')/*xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/;

var FT = require('FaceTracking')/*xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/;

var M = require('Materials')/*xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/;

var P = require('Patches')/*xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/;

var S = require('Scene')/*xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/;

var R = require('Reactive')/*xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/;

var T = require('Textures')/*xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/;

var Time = require('Time')/*xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/; //#endregion


var camera = S.root.find("Camera");
var focalPlane = camera.focalPlane;
var fpRatio = focalPlane.height.div(focalPlane.width);
var cpRatio = CI.previewSize.height.div(CI.previewSize.width);
var ratioFix = fpRatio.div(cpRatio); //

var faces = [FT.face(0), FT.face(1)];
var faceNulls = [S.root.find('f0_null'), S.root.find('f1_null')];
var trackers = [S.root.find('facetracker0'), S.root.find('facetracker1')];
var faceWarps = [S.root.find('faceWarp_f0'), S.root.find('faceWarp_f1')];
var noses = [faceNulls[0].find('nose_bunny_nose'), faceNulls[1].find('nose_bunny_nose')]; // Whisker Section

var isWiggling = [false, false];
var timeIntervalMin = 4000;
var randomIntervalRange = 3000;
var needAFace = true;
var keepCounting = true;
var twitchTime = 500; //

var mat = M.get('colorLut_mat');

for (var i = 0; i < faceNulls.length; i++) {
  var face = faces[i];
  var tracker = trackers[i];
  var ears = faceNulls[i].find("earsSmoothNull");
  var leftEarNull = faceNulls[i].find("earplacerL");
  var rightEarNull = faceNulls[i].find("earplacerR");
  faceNulls[i].transform = face.cameraTransform;
  faceNulls[i].hidden = face.isTracked.not();
  faceWarps[i].transform = face.cameraTransform;
  faceWarps[i].hidden = face.isTracked.not();
  var smoothedFace = face.cameraTransform.expSmooth(30);
  leftEarNull.transform.rotationY = smoothedFace.rotationY.neg().mul(1.5);
  rightEarNull.transform.rotationY = smoothedFace.rotationY.neg().mul(1.5);
  randomEventTimer(i);
  rotateEars(i);
}

function rotateEars(faceIndex) {
  var face = FT.face(faceIndex); // RotationZ note: positive radians to head-tilt-left, negative radians to head-tilt-right

  var rotationZ = face.cameraTransform.rotationZ.neg(); // Input Variables

  var firstFrame = 0; // first frame in sequence

  var lastFrame = 139; // last frame in sequence

  var pointOfIdle = 70; // point in sequence around which the sequence idles

  var leftIdleAmplitude = 14; // plus/minus value the idle oscillates (8 would be 16 frames, f'rex)

  var leftIdleFrequency = 1.5; // seconds of a full idle loop

  var rightIdleAmplitude = 8; // plus/minus value the idle oscillates (8 would be 16 frames, f'rex)

  var rightIdleFrequency = 1.7; // seconds of a full idle loop

  var maxHeadTilt = 15; // degrees right or left to extent of sequence on either side

  var perkBoundStart = 25; // maximum frame the sequence won't move past until triggered by mouth

  var perkBoundEnd = 115; // minimum frame ' '

  var amountOfSmoothing = 20; // Variable Adjustments

  var maxHeadRadians = maxHeadTilt * (Math.PI / 180); // Binary left-or-right multipliers

  var negBinary = R.neg(R.clamp(R.mul(rotationZ, 10000), -1, 0));
  var posBinary = R.clamp(R.mul(rotationZ, 10000), 0, 1); // Rangefinding Left and Right
  // Rangefinding Left and Right

  var fromIdleToPerkEnd = mapValueInRange(rotationZ, R.val(0), R.val(maxHeadRadians), R.val(0), R.val(perkBoundEnd - leftIdleAmplitude - pointOfIdle + 1), true);
  var fromPerkStartToIdle = mapValueInRange(rotationZ, R.val(0 - maxHeadRadians), R.val(0), R.val(perkBoundStart + rightIdleAmplitude), R.val(pointOfIdle), true); // idle Animation function

  var leftIdleScrubSampler = A.samplers.linear(-leftIdleAmplitude, leftIdleAmplitude);
  var rightIdleScrubSampler = A.samplers.linear(-rightIdleAmplitude, rightIdleAmplitude);
  var leftIdleScrubDriver = A.timeDriver({
    durationMilliseconds: leftIdleFrequency * 1000,
    loopCount: Infinity,
    mirror: true
  });
  var rightIdleScrubDriver = A.timeDriver({
    durationMilliseconds: rightIdleFrequency * 1000,
    loopCount: Infinity,
    mirror: true
  });
  leftIdleScrubDriver.start();
  rightIdleScrubDriver.start();
  var leftIdlingFrameScrub = R.sum(R.sum(fromPerkStartToIdle, fromIdleToPerkEnd), A.animate(leftIdleScrubDriver, leftIdleScrubSampler));
  var rightIdlingFrameScrub = R.sum(R.sum(fromPerkStartToIdle, fromIdleToPerkEnd), A.animate(rightIdleScrubDriver, rightIdleScrubSampler)); // Integrate mouth Openness

  var isPerky = false;
  var perkDuration = 1600;
  var leftPerkDriver = A.timeDriver({
    durationMilliseconds: perkDuration
  });
  var rightPerkDriver = A.timeDriver({
    durationMilliseconds: perkDuration
  });
  var leftPerkSampler = A.samplers.sequence({
    samplers: [A.samplers.linear(0, 100), A.samplers.linear(100, 100), A.samplers.linear(100, 0)],
    knots: [0, 2, 12, 20]
  });
  var rightPerkSampler = A.samplers.sequence({
    samplers: [A.samplers.linear(0, 100), A.samplers.linear(100, 100), A.samplers.linear(100, 0)],
    knots: [0, 2, 12, 20]
  });
  var leftPerk = A.animate(leftPerkDriver, leftPerkSampler);
  var rightPerk = A.animate(rightPerkDriver, rightPerkSampler);
  var mouthOpen = face.mouth.openness;
  mouthOpen.multiTrigger(0.5).subscribe(function () {
    wiggleTheNose(faceIndex);
    perky();
  });

  function perky() {
    if (!isPerky) {
      isPerky = true;
      leftPerkDriver.reset();
      leftPerkDriver.start();
      Time.setTimeout(function () {
        rightPerkDriver.reset();
        rightPerkDriver.start();
      }, 50);
      var callback = rightPerkDriver.onCompleted().subscribe(function (e) {
        isPerky = false;
        callback.unsubscribe();
      });
    }
  }

  var leftPerkPercentDriver = A.valueDriver(roundValue(leftPerk), 0, 100);
  var rightPerkPercentDriver = A.valueDriver(roundValue(rightPerk), 0, 100);
  var scrubSampler = A.samplers.linear(0, 100);
  var addPerk = mapValueInRange(A.animate(leftPerkPercentDriver, scrubSampler), 0, 100, 0, R.sub(lastFrame + leftIdleAmplitude, leftIdlingFrameScrub), true);
  var subPerk = mapValueInRange(A.animate(rightPerkPercentDriver, scrubSampler), 0, 100, 0, R.sub(firstFrame - rightIdleAmplitude, rightIdlingFrameScrub), true);
  var leftPerkFrameScrub = R.min(R.sum(leftIdlingFrameScrub, addPerk), lastFrame + 1);
  var rightPerkFrameScrub = R.sub(lastFrame, R.max(R.sum(rightIdlingFrameScrub, subPerk), firstFrame)); // Cut streams and put them together

  var leftCurrentFrame = roundValue(leftPerkFrameScrub.expSmooth(amountOfSmoothing));
  var rightCurrentFrame = roundValue(rightPerkFrameScrub.expSmooth(amountOfSmoothing));
  var leftEarRGBSequence = T.get("bunnyEars_v52-Fill-animation-L " + faceIndex);
  var leftEarAlphaSequence = T.get("bunnyEars_v52-Matte-animation-L " + faceIndex);
  var rightEarRGBSequence = T.get("bunnyEars_v52-Fill-animation-R " + faceIndex);
  var rightEarAlphaSequence = T.get("bunnyEars_v52-Matte-animation-R " + faceIndex);
  leftEarRGBSequence.currentFrame = leftCurrentFrame;
  leftEarAlphaSequence.currentFrame = leftCurrentFrame;
  rightEarRGBSequence.currentFrame = rightCurrentFrame;
  rightEarAlphaSequence.currentFrame = rightCurrentFrame;
}

function randomEventTimer(faceIndex) {
  var randomInterval;
  var isFaceThere = true;

  function startTimer(faceIndex) {
    randomInterval = Math.floor(Math.random() * randomIntervalRange) + timeIntervalMin;
    Time.setTimeout(function () {
      wiggleTheNose(faceIndex); //

      if (keepCounting == true && (isFaceThere == true || needAFace == false)) {
        startTimer(faceIndex);
      }
    }, randomInterval);
  }

  var scalarFaceThere = FT.count.gt(R.val(faceIndex));
  scalarFaceThere.monitor().subscribe(function (e) {
    isFaceThere = e.newValue; // if ( isFaceThere == true ) { Diagnostics.log('I see a face!') } else { Diagnostics.log('Woops, face gone.') };

    if (isFaceThere == true && needAFace == true) {
      startTimer(faceIndex);
    }
  });
  startTimer(faceIndex);
}

function wiggleTheNose(faceIndex) {
  var numOfTwitches = Math.round(Math.random() * 3) + 2;
  var noseNose = noses[faceIndex]; // Set up wiggling and idle drivers/samplers/animators

  var wiggleTimingDriver = A.timeDriver({
    durationMilliseconds: twitchTime
  });
  var noseWiggleDriver = A.timeDriver({
    durationMilliseconds: 125,
    loopCount: Infinity,
    mirror: true
  });
  var noseWiggleSampler = A.samplers.linear(0, -0.22);
  noseNose.transform.rotationX = A.animate(noseWiggleDriver, noseWiggleSampler).expSmooth(30);
  noseWiggleDriver.start();
  wiggleTimingDriver.start();
  var twitchCounter = 1;
  wiggleTimingDriver.onCompleted().subscribe(function (e) {
    if (twitchCounter < numOfTwitches) {
      twitchCounter = twitchCounter + 1;
      wiggleTimingDriver.reset();
      wiggleTimingDriver.start();
      noseWiggleDriver.reset();
      noseWiggleDriver.start();
      isWiggling[faceIndex] = true;
    } else {
      wiggleTimingDriver.reset();
      noseWiggleDriver.reset();
      noseWiggleDriver.stop();
      isWiggling[faceIndex] = false;
    }
  });
} // Utility Functions


function mapValueInRange(value, fromLow, fromHigh, toLow, toHigh, clip) {
  var fromRangeSize = R.sub(fromHigh, fromLow);
  var toRangeSize = R.sub(toHigh, toLow);
  var valueScale = R.div(value.sub(fromLow), fromRangeSize);
  var newValue = R.sum(toLow, valueScale.mul(toRangeSize));

  if (clip) {
    newValue = R.clamp(newValue, R.min(toLow, toHigh), R.max(toLow, toHigh));
  }

  return newValue;
}

function roundValue(value) {
  return R.sub(value, R.mod(value, R.val(1)));
}

P.setPoint2DValue("ratioFix", R.point2d(ratioFix, 1.0));

/***/ })
/******/ ]);
//# sourceMappingURL=script.js.map