@lumen5/lottie-web 5.14.0

package/player/js/utils/expressions/Expressions.js

@@ -0,0 +1,48 @@
+import CompExpressionInterface from './CompInterface';
+import ExpressionManager from './ExpressionManager';
+
+const Expressions = (function () {
+  var ob = {};
+  ob.initExpressions = initExpressions;
+  ob.resetFrame = ExpressionManager.resetFrame;
+
+  function initExpressions(animation) {
+    var stackCount = 0;
+    var registers = [];
+
+    function pushExpression() {
+      stackCount += 1;
+    }
+
+    function popExpression() {
+      stackCount -= 1;
+      if (stackCount === 0) {
+        releaseInstances();
+      }
+    }
+
+    function registerExpressionProperty(expression) {
+      if (registers.indexOf(expression) === -1) {
+        registers.push(expression);
+      }
+    }
+
+    function releaseInstances() {
+      var i;
+      var len = registers.length;
+      for (i = 0; i < len; i += 1) {
+        registers[i].release();
+      }
+      registers.length = 0;
+    }
+
+    animation.renderer.compInterface = CompExpressionInterface(animation.renderer);
+    animation.renderer.globalData.projectInterface.registerComposition(animation.renderer);
+    animation.renderer.globalData.pushExpression = pushExpression;
+    animation.renderer.globalData.popExpression = popExpression;
+    animation.renderer.globalData.registerExpressionProperty = registerExpressionProperty;
+  }
+  return ob;
+}());
+
+export default Expressions;

package/player/js/utils/expressions/FootageInterface.js

@@ -0,0 +1,60 @@
+const FootageInterface = (function () {
+  var outlineInterfaceFactory = (function (elem) {
+    var currentPropertyName = '';
+    var currentProperty = elem.getFootageData();
+    function init() {
+      currentPropertyName = '';
+      currentProperty = elem.getFootageData();
+      return searchProperty;
+    }
+    function searchProperty(value) {
+      if (currentProperty[value]) {
+        currentPropertyName = value;
+        currentProperty = currentProperty[value];
+        if (typeof currentProperty === 'object') {
+          return searchProperty;
+        }
+        return currentProperty;
+      }
+      var propertyNameIndex = value.indexOf(currentPropertyName);
+      if (propertyNameIndex !== -1) {
+        var index = parseInt(value.substr(propertyNameIndex + currentPropertyName.length), 10);
+        currentProperty = currentProperty[index];
+        if (typeof currentProperty === 'object') {
+          return searchProperty;
+        }
+        return currentProperty;
+      }
+      return '';
+    }
+    return init;
+  });
+
+  var dataInterfaceFactory = function (elem) {
+    function interfaceFunction(value) {
+      if (value === 'Outline') {
+        return interfaceFunction.outlineInterface();
+      }
+      return null;
+    }
+
+    interfaceFunction._name = 'Outline';
+    interfaceFunction.outlineInterface = outlineInterfaceFactory(elem);
+    return interfaceFunction;
+  };
+
+  return function (elem) {
+    function _interfaceFunction(value) {
+      if (value === 'Data') {
+        return _interfaceFunction.dataInterface;
+      }
+      return null;
+    }
+
+    _interfaceFunction._name = 'Data';
+    _interfaceFunction.dataInterface = dataInterfaceFactory(elem);
+    return _interfaceFunction;
+  };
+}());
+
+export default FootageInterface;

package/player/js/utils/expressions/InterfacesProvider.js

@@ -0,0 +1,21 @@
+import LayerExpressionInterface from './LayerInterface';
+import EffectsExpressionInterface from './EffectInterface';
+import CompExpressionInterface from './CompInterface';
+import ShapeExpressionInterface from './ShapeInterface';
+import TextExpressionInterface from './TextInterface';
+import FootageInterface from './FootageInterface';
+
+var interfaces = {
+  layer: LayerExpressionInterface,
+  effects: EffectsExpressionInterface,
+  comp: CompExpressionInterface,
+  shape: ShapeExpressionInterface,
+  text: TextExpressionInterface,
+  footage: FootageInterface,
+};
+
+function getInterface(type) {
+  return interfaces[type] || null;
+}
+
+export default getInterface;

package/player/js/utils/expressions/LayerInterface.js

@@ -0,0 +1,179 @@
+import {
+  getDescriptor,
+} from '../functionExtensions';
+import Matrix from '../../3rd_party/transformation-matrix';
+import MaskManagerInterface from './MaskInterface';
+import TransformExpressionInterface from './TransformInterface';
+
+const LayerExpressionInterface = (function () {
+  function getMatrix(time) {
+    var toWorldMat = new Matrix();
+    if (time !== undefined) {
+      var propMatrix = this._elem.finalTransform.mProp.getValueAtTime(time);
+      propMatrix.clone(toWorldMat);
+    } else {
+      var transformMat = this._elem.finalTransform.mProp;
+      transformMat.applyToMatrix(toWorldMat);
+    }
+    return toWorldMat;
+  }
+
+  function toWorldVec(arr, time) {
+    var toWorldMat = this.getMatrix(time);
+    toWorldMat.props[12] = 0;
+    toWorldMat.props[13] = 0;
+    toWorldMat.props[14] = 0;
+    return this.applyPoint(toWorldMat, arr);
+  }
+
+  function toWorld(arr, time) {
+    var toWorldMat = this.getMatrix(time);
+    return this.applyPoint(toWorldMat, arr);
+  }
+
+  function fromWorldVec(arr, time) {
+    var toWorldMat = this.getMatrix(time);
+    toWorldMat.props[12] = 0;
+    toWorldMat.props[13] = 0;
+    toWorldMat.props[14] = 0;
+    return this.invertPoint(toWorldMat, arr);
+  }
+
+  function fromWorld(arr, time) {
+    var toWorldMat = this.getMatrix(time);
+    return this.invertPoint(toWorldMat, arr);
+  }
+
+  function applyPoint(matrix, arr) {
+    if (this._elem.hierarchy && this._elem.hierarchy.length) {
+      var i;
+      var len = this._elem.hierarchy.length;
+      for (i = 0; i < len; i += 1) {
+        this._elem.hierarchy[i].finalTransform.mProp.applyToMatrix(matrix);
+      }
+    }
+    return matrix.applyToPointArray(arr[0], arr[1], arr[2] || 0);
+  }
+
+  function invertPoint(matrix, arr) {
+    if (this._elem.hierarchy && this._elem.hierarchy.length) {
+      var i;
+      var len = this._elem.hierarchy.length;
+      for (i = 0; i < len; i += 1) {
+        this._elem.hierarchy[i].finalTransform.mProp.applyToMatrix(matrix);
+      }
+    }
+    return matrix.inversePoint(arr);
+  }
+
+  function fromComp(arr) {
+    var toWorldMat = new Matrix();
+    toWorldMat.reset();
+    this._elem.finalTransform.mProp.applyToMatrix(toWorldMat);
+    if (this._elem.hierarchy && this._elem.hierarchy.length) {
+      var i;
+      var len = this._elem.hierarchy.length;
+      for (i = 0; i < len; i += 1) {
+        this._elem.hierarchy[i].finalTransform.mProp.applyToMatrix(toWorldMat);
+      }
+      return toWorldMat.inversePoint(arr);
+    }
+    return toWorldMat.inversePoint(arr);
+  }
+
+  function sampleImage() {
+    return [1, 1, 1, 1];
+  }
+
+  return function (elem) {
+    var transformInterface;
+
+    function _registerMaskInterface(maskManager) {
+      _thisLayerFunction.mask = new MaskManagerInterface(maskManager, elem);
+    }
+    function _registerEffectsInterface(effects) {
+      _thisLayerFunction.effect = effects;
+    }
+
+    function _thisLayerFunction(name) {
+      switch (name) {
+        case 'ADBE Root Vectors Group':
+        case 'Contents':
+        case 2:
+          return _thisLayerFunction.shapeInterface;
+        case 1:
+        case 6:
+        case 'Transform':
+        case 'transform':
+        case 'ADBE Transform Group':
+          return transformInterface;
+        case 4:
+        case 'ADBE Effect Parade':
+        case 'effects':
+        case 'Effects':
+          return _thisLayerFunction.effect;
+        case 'ADBE Text Properties':
+          return _thisLayerFunction.textInterface;
+        default:
+          return null;
+      }
+    }
+    _thisLayerFunction.getMatrix = getMatrix;
+    _thisLayerFunction.invertPoint = invertPoint;
+    _thisLayerFunction.applyPoint = applyPoint;
+    _thisLayerFunction.toWorld = toWorld;
+    _thisLayerFunction.toWorldVec = toWorldVec;
+    _thisLayerFunction.fromWorld = fromWorld;
+    _thisLayerFunction.fromWorldVec = fromWorldVec;
+    _thisLayerFunction.toComp = toWorld;
+    _thisLayerFunction.fromComp = fromComp;
+    _thisLayerFunction.sampleImage = sampleImage;
+    _thisLayerFunction.sourceRectAtTime = elem.sourceRectAtTime.bind(elem);
+    _thisLayerFunction._elem = elem;
+    transformInterface = TransformExpressionInterface(elem.finalTransform.mProp);
+    var anchorPointDescriptor = getDescriptor(transformInterface, 'anchorPoint');
+    Object.defineProperties(_thisLayerFunction, {
+      hasParent: {
+        get: function () {
+          return elem.hierarchy.length;
+        },
+      },
+      parent: {
+        get: function () {
+          return elem.hierarchy[0].layerInterface;
+        },
+      },
+      rotation: getDescriptor(transformInterface, 'rotation'),
+      scale: getDescriptor(transformInterface, 'scale'),
+      position: getDescriptor(transformInterface, 'position'),
+      opacity: getDescriptor(transformInterface, 'opacity'),
+      anchorPoint: anchorPointDescriptor,
+      anchor_point: anchorPointDescriptor,
+      transform: {
+        get: function () {
+          return transformInterface;
+        },
+      },
+      active: {
+        get: function () {
+          return elem.isInRange;
+        },
+      },
+    });
+
+    _thisLayerFunction.startTime = elem.data.st;
+    _thisLayerFunction.index = elem.data.ind;
+    _thisLayerFunction.source = elem.data.refId;
+    _thisLayerFunction.height = elem.data.ty === 0 ? elem.data.h : 100;
+    _thisLayerFunction.width = elem.data.ty === 0 ? elem.data.w : 100;
+    _thisLayerFunction.inPoint = elem.data.ip / elem.comp.globalData.frameRate;
+    _thisLayerFunction.outPoint = elem.data.op / elem.comp.globalData.frameRate;
+    _thisLayerFunction._name = elem.data.nm;
+
+    _thisLayerFunction.registerMaskInterface = _registerMaskInterface;
+    _thisLayerFunction.registerEffectsInterface = _registerEffectsInterface;
+    return _thisLayerFunction;
+  };
+}());
+
+export default LayerExpressionInterface;

package/player/js/utils/expressions/MaskInterface.js

@@ -0,0 +1,50 @@
+import {
+  createSizedArray,
+} from '../helpers/arrays';
+
+const MaskManagerInterface = (function () {
+  function MaskInterface(mask, data) {
+    this._mask = mask;
+    this._data = data;
+  }
+  Object.defineProperty(MaskInterface.prototype, 'maskPath', {
+    get: function () {
+      if (this._mask.prop.k) {
+        this._mask.prop.getValue();
+      }
+      return this._mask.prop;
+    },
+  });
+  Object.defineProperty(MaskInterface.prototype, 'maskOpacity', {
+    get: function () {
+      if (this._mask.op.k) {
+        this._mask.op.getValue();
+      }
+      return this._mask.op.v * 100;
+    },
+  });
+
+  var MaskManager = function (maskManager) {
+    var _masksInterfaces = createSizedArray(maskManager.viewData.length);
+    var i;
+    var len = maskManager.viewData.length;
+    for (i = 0; i < len; i += 1) {
+      _masksInterfaces[i] = new MaskInterface(maskManager.viewData[i], maskManager.masksProperties[i]);
+    }
+
+    var maskFunction = function (name) {
+      i = 0;
+      while (i < len) {
+        if (maskManager.masksProperties[i].nm === name) {
+          return _masksInterfaces[i];
+        }
+        i += 1;
+      }
+      return null;
+    };
+    return maskFunction;
+  };
+  return MaskManager;
+}());
+
+export default MaskManagerInterface;

package/player/js/utils/expressions/ProjectInterface.js

@@ -0,0 +1,31 @@
+const ProjectInterface = (function () {
+  function registerComposition(comp) {
+    this.compositions.push(comp);
+  }
+
+  return function () {
+    function _thisProjectFunction(name) {
+      var i = 0;
+      var len = this.compositions.length;
+      while (i < len) {
+        if (this.compositions[i].data && this.compositions[i].data.nm === name) {
+          if (this.compositions[i].prepareFrame && this.compositions[i].data.xt) {
+            this.compositions[i].prepareFrame(this.currentFrame);
+          }
+          return this.compositions[i].compInterface;
+        }
+        i += 1;
+      }
+      return null;
+    }
+
+    _thisProjectFunction.compositions = [];
+    _thisProjectFunction.currentFrame = 0;
+
+    _thisProjectFunction.registerComposition = registerComposition;
+
+    return _thisProjectFunction;
+  };
+}());
+
+export default ProjectInterface;

package/player/js/utils/expressions/PropertyGroupFactory.js

@@ -0,0 +1,13 @@
+const propertyGroupFactory = (function () {
+  return function (interfaceFunction, parentPropertyGroup) {
+    return function (val) {
+      val = val === undefined ? 1 : val;
+      if (val <= 0) {
+        return interfaceFunction;
+      }
+      return parentPropertyGroup(val - 1);
+    };
+  };
+}());
+
+export default propertyGroupFactory;

package/player/js/utils/expressions/PropertyInterface.js

@@ -0,0 +1,19 @@
+const PropertyInterface = (function () {
+  return function (propertyName, propertyGroup) {
+    var interfaceFunction = {
+      _name: propertyName,
+    };
+
+    function _propertyGroup(val) {
+      val = val === undefined ? 1 : val;
+      if (val <= 0) {
+        return interfaceFunction;
+      }
+      return propertyGroup(val - 1);
+    }
+
+    return _propertyGroup;
+  };
+}());
+
+export default PropertyInterface;