| var 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] = toWorldMat.props[13] = 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] = toWorldMat.props[13] = 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, 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, 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, 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; |
| } |
| } |
| _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; |
| }; |
| }()); |