Files

791 lines
27 KiB
ActionScript

package com.greensock.plugins
{
import com.greensock.TweenLite;
import flash.geom.Point;
public class BezierPlugin extends TweenPlugin
{
public static const API:Number = 2;
protected static const _RAD2DEG:Number = 57.29577951308232;
protected static var _r1:Array = [];
protected static var _r2:Array = [];
protected static var _r3:Array = [];
protected static var _corProps:Object = {};
protected var _target:Object;
protected var _autoRotate:Array;
protected var _round:Object;
protected var _lengths:Array;
protected var _segments:Array;
protected var _length:Number;
protected var _func:Object;
protected var _props:Array;
protected var _l1:Number;
protected var _l2:Number;
protected var _li:Number;
protected var _curSeg:Array;
protected var _s1:Number;
protected var _s2:Number;
protected var _si:Number;
protected var _beziers:Object;
protected var _segCount:int;
protected var _prec:Number;
protected var _timeRes:int;
protected var _initialRotations:Array;
protected var _startRatio:int;
public function BezierPlugin()
{
super("bezier");
this._overwriteProps.pop();
this._func = {};
this._round = {};
}
public static function bezierThrough(param1:Array, param2:Number = 1, param3:Boolean = false, param4:Boolean = false, param5:String = "x,y,z", param6:Object = null) : Object
{
var _loc13_:Array = null;
var _loc10_:int = 0;
var _loc14_:String = null;
var _loc11_:int = 0;
var _loc7_:Array = null;
var _loc12_:int = 0;
var _loc15_:Number = NaN;
var _loc8_:Boolean = false;
var _loc9_:Object = null;
var _loc16_:Object = {};
var _loc17_:Object = param6 || param1[0];
param5 = "," + param5 + ",";
if(_loc17_ is Point)
{
_loc13_ = ["x","y"];
}
else
{
_loc13_ = [];
for(_loc14_ in _loc17_)
{
_loc13_.push(_loc14_);
}
}
if(param1.length > 1)
{
_loc9_ = param1[param1.length - 1];
_loc8_ = true;
_loc10_ = int(_loc13_.length);
while(--_loc10_ > -1)
{
_loc14_ = _loc13_[_loc10_];
if(Math.abs(_loc17_[_loc14_] - _loc9_[_loc14_]) > 0.05)
{
_loc8_ = false;
break;
}
}
if(_loc8_)
{
param1 = param1.concat();
if(param6)
{
param1.unshift(param6);
}
param1.push(param1[1]);
param6 = param1[param1.length - 3];
}
}
_r1.length = _r2.length = _r3.length = 0;
_loc10_ = int(_loc13_.length);
while(--_loc10_ > -1)
{
_loc14_ = _loc13_[_loc10_];
_corProps[_loc14_] = param5.indexOf("," + _loc14_ + ",") !== -1;
_loc16_[_loc14_] = _parseAnchors(param1,_loc14_,_corProps[_loc14_],param6);
}
_loc10_ = int(_r1.length);
while(--_loc10_ > -1)
{
_r1[_loc10_] = Math.sqrt(_r1[_loc10_]);
_r2[_loc10_] = Math.sqrt(_r2[_loc10_]);
}
if(!param4)
{
_loc10_ = int(_loc13_.length);
while(--_loc10_ > -1)
{
if(_corProps[_loc14_])
{
_loc7_ = _loc16_[_loc13_[_loc10_]];
_loc12_ = _loc7_.length - 1;
_loc11_ = 0;
while(_loc11_ < _loc12_)
{
_loc15_ = _loc7_[_loc11_ + 1].da / _r2[_loc11_] + _loc7_[_loc11_].da / _r1[_loc11_];
_r3[_loc11_] = (_r3[_loc11_] || 0) + _loc15_ * _loc15_;
_loc11_++;
}
}
}
_loc10_ = int(_r3.length);
while(--_loc10_ > -1)
{
_r3[_loc10_] = Math.sqrt(_r3[_loc10_]);
}
}
_loc10_ = int(_loc13_.length);
_loc11_ = param3 ? 4 : 1;
while(--_loc10_ > -1)
{
_loc14_ = _loc13_[_loc10_];
_loc7_ = _loc16_[_loc14_];
_calculateControlPoints(_loc7_,param2,param3,param4,_corProps[_loc14_]);
if(_loc8_)
{
_loc7_.splice(0,_loc11_);
_loc7_.splice(_loc7_.length - _loc11_,_loc11_);
}
}
return _loc16_;
}
public static function _parseBezierData(param1:Array, param2:String, param3:Object = null) : Object
{
var _loc4_:Number = NaN;
var _loc6_:Number = NaN;
var _loc7_:Number = NaN;
var _loc8_:Number = NaN;
var _loc5_:Array = null;
var _loc13_:Array = null;
var _loc10_:int = 0;
var _loc11_:int = 0;
var _loc12_:int = 0;
var _loc14_:String = null;
var _loc9_:int = 0;
var _loc15_:Object = null;
param2 ||= "soft";
var _loc16_:Object = {};
var _loc17_:int = param2 === "cubic" ? 3 : 2;
var _loc18_:Boolean = param2 === "soft";
if(_loc18_ && param3)
{
param1 = [param3].concat(param1);
}
if(param1 == null || param1.length < _loc17_ + 1)
{
throw new Error("invalid Bezier data");
}
if(param1[1] is Point)
{
_loc13_ = ["x","y"];
}
else
{
_loc13_ = [];
for(_loc14_ in param1[0])
{
_loc13_.push(_loc14_);
}
}
_loc10_ = int(_loc13_.length);
while(--_loc10_ > -1)
{
_loc14_ = _loc13_[_loc10_];
_loc16_[_loc14_] = _loc5_ = [];
_loc9_ = 0;
_loc12_ = int(param1.length);
_loc11_ = 0;
while(_loc11_ < _loc12_)
{
_loc15_ = param1[_loc11_][_loc14_];
_loc4_ = Number(param3 == null ? param1[_loc11_][_loc14_] : (typeof _loc15_ === "string" && _loc15_.charAt(1) === "=" ? param3[_loc14_] + (_loc15_.charAt(0) + _loc15_.substr(2)) : Number(_loc15_)));
if(_loc18_)
{
if(_loc11_ > 1)
{
if(_loc11_ < _loc12_ - 1)
{
_loc5_[_loc9_++] = (_loc4_ + _loc5_[_loc9_ - 2]) / 2;
}
}
}
_loc5_[_loc9_++] = _loc4_;
_loc11_++;
}
_loc12_ = _loc9_ - _loc17_ + 1;
_loc9_ = 0;
_loc11_ = 0;
while(_loc11_ < _loc12_)
{
_loc4_ = Number(_loc5_[_loc11_]);
_loc6_ = Number(_loc5_[_loc11_ + 1]);
_loc7_ = Number(_loc5_[_loc11_ + 2]);
_loc8_ = Number(_loc17_ === 2 ? 0 : _loc5_[_loc11_ + 3]);
_loc5_[_loc9_++] = _loc17_ === 3 ? new Segment(_loc4_,_loc6_,_loc7_,_loc8_) : new Segment(_loc4_,(2 * _loc6_ + _loc4_) / 3,(2 * _loc6_ + _loc7_) / 3,_loc7_);
_loc11_ += _loc17_;
}
_loc5_.length = _loc9_;
}
return _loc16_;
}
protected static function _parseAnchors(param1:Array, param2:String, param3:Boolean, param4:Object) : Array
{
var _loc11_:int = 0;
var _loc10_:int = 0;
var _loc5_:Number = NaN;
var _loc7_:Number = NaN;
var _loc8_:Number = NaN;
var _loc9_:Object = null;
var _loc6_:Array = [];
if(param4)
{
param1 = [param4].concat(param1);
_loc10_ = int(param1.length);
while(--_loc10_ > -1)
{
_loc9_ = param1[_loc10_][param2];
if(typeof _loc9_ === "string")
{
if(_loc9_.charAt(1) === "=")
{
param1[_loc10_][param2] = param4[param2] + (_loc9_.charAt(0) + _loc9_.substr(2));
}
}
}
}
_loc11_ = param1.length - 2;
if(_loc11_ < 0)
{
_loc6_[0] = new Segment(param1[0][param2],0,0,param1[_loc11_ < -1 ? 0 : 1][param2]);
return _loc6_;
}
_loc10_ = 0;
while(_loc10_ < _loc11_)
{
_loc5_ = Number(param1[_loc10_][param2]);
_loc7_ = Number(param1[_loc10_ + 1][param2]);
_loc6_[_loc10_] = new Segment(_loc5_,0,0,_loc7_);
if(param3)
{
_loc8_ = Number(param1[_loc10_ + 2][param2]);
_r1[_loc10_] = (_r1[_loc10_] || 0) + (_loc7_ - _loc5_) * (_loc7_ - _loc5_);
_r2[_loc10_] = (_r2[_loc10_] || 0) + (_loc8_ - _loc7_) * (_loc8_ - _loc7_);
}
_loc10_++;
}
_loc6_[_loc10_] = new Segment(param1[_loc10_][param2],0,0,param1[_loc10_ + 1][param2]);
return _loc6_;
}
protected static function _calculateControlPoints(param1:Array, param2:Number = 1, param3:Boolean = false, param4:Boolean = false, param5:Boolean = false) : void
{
var _loc16_:int = 0;
var _loc9_:Number = NaN;
var _loc10_:Number = NaN;
var _loc11_:Number = NaN;
var _loc19_:Segment = null;
var _loc12_:Number = NaN;
var _loc15_:Number = NaN;
var _loc7_:Number = NaN;
var _loc13_:Number = NaN;
var _loc18_:Array = null;
var _loc21_:Number = NaN;
var _loc8_:Number = NaN;
var _loc20_:Number = NaN;
var _loc17_:int = param1.length - 1;
var _loc6_:int = 0;
var _loc14_:Number = Number(param1[0].a);
_loc16_ = 0;
while(_loc16_ < _loc17_)
{
_loc19_ = param1[_loc6_];
_loc9_ = _loc19_.a;
_loc10_ = _loc19_.d;
_loc11_ = Number(param1[_loc6_ + 1].d);
if(param5)
{
_loc21_ = Number(_r1[_loc16_]);
_loc8_ = Number(_r2[_loc16_]);
_loc20_ = (_loc8_ + _loc21_) * param2 * 0.25 / (param4 ? 0.5 : _r3[_loc16_] || 0.5);
_loc12_ = _loc10_ - (_loc10_ - _loc9_) * (param4 ? param2 * 0.5 : (_loc21_ !== 0 ? _loc20_ / _loc21_ : 0));
_loc15_ = _loc10_ + (_loc11_ - _loc10_) * (param4 ? param2 * 0.5 : (_loc8_ !== 0 ? _loc20_ / _loc8_ : 0));
_loc7_ = _loc10_ - (_loc12_ + ((_loc15_ - _loc12_) * (_loc21_ * 3 / (_loc21_ + _loc8_) + 0.5) / 4 || 0));
}
else
{
_loc12_ = _loc10_ - (_loc10_ - _loc9_) * param2 * 0.5;
_loc15_ = _loc10_ + (_loc11_ - _loc10_) * param2 * 0.5;
_loc7_ = _loc10_ - (_loc12_ + _loc15_) / 2;
}
_loc12_ += _loc7_;
_loc15_ += _loc7_;
_loc19_.c = _loc13_ = _loc12_;
if(_loc16_ != 0)
{
_loc19_.b = _loc14_;
}
else
{
_loc19_.b = _loc14_ = _loc19_.a + (_loc19_.c - _loc19_.a) * 0.6;
}
_loc19_.da = _loc10_ - _loc9_;
_loc19_.ca = _loc13_ - _loc9_;
_loc19_.ba = _loc14_ - _loc9_;
if(param3)
{
_loc18_ = cubicToQuadratic(_loc9_,_loc14_,_loc13_,_loc10_);
param1.splice(_loc6_,1,_loc18_[0],_loc18_[1],_loc18_[2],_loc18_[3]);
_loc6_ += 4;
}
else
{
_loc6_++;
}
_loc14_ = _loc15_;
_loc16_++;
}
_loc19_ = param1[_loc6_];
_loc19_.b = _loc14_;
_loc19_.c = _loc14_ + (_loc19_.d - _loc14_) * 0.4;
_loc19_.da = _loc19_.d - _loc19_.a;
_loc19_.ca = _loc19_.c - _loc19_.a;
_loc19_.ba = _loc14_ - _loc19_.a;
if(param3)
{
_loc18_ = cubicToQuadratic(_loc19_.a,_loc14_,_loc19_.c,_loc19_.d);
param1.splice(_loc6_,1,_loc18_[0],_loc18_[1],_loc18_[2],_loc18_[3]);
}
}
public static function cubicToQuadratic(param1:Number, param2:Number, param3:Number, param4:Number) : Array
{
var _loc5_:Object = {"a":param1};
var _loc6_:Object = {};
var _loc7_:Object = {};
var _loc8_:Object = {"c":param4};
var _loc12_:Number = (param1 + param2) / 2;
var _loc13_:Number = (param2 + param3) / 2;
var _loc14_:Number = (param3 + param4) / 2;
var _loc10_:Number = (_loc12_ + _loc13_) / 2;
var _loc9_:Number = (_loc13_ + _loc14_) / 2;
var _loc11_:Number = (_loc9_ - _loc10_) / 8;
_loc5_.b = _loc12_ + (param1 - _loc12_) / 4;
_loc6_.b = _loc10_ + _loc11_;
_loc5_.c = _loc6_.a = (_loc5_.b + _loc6_.b) / 2;
_loc6_.c = _loc7_.a = (_loc10_ + _loc9_) / 2;
_loc7_.b = _loc9_ - _loc11_;
_loc8_.b = _loc14_ + (param4 - _loc14_) / 4;
_loc7_.c = _loc8_.a = (_loc7_.b + _loc8_.b) / 2;
return [_loc5_,_loc6_,_loc7_,_loc8_];
}
public static function quadraticToCubic(param1:Number, param2:Number, param3:Number) : Object
{
return new Segment(param1,(2 * param2 + param1) / 3,(2 * param2 + param3) / 3,param3);
}
protected static function _parseLengthData(param1:Object, param2:uint = 6) : Object
{
var _loc11_:String = null;
var _loc5_:int = 0;
var _loc8_:int = 0;
var _loc6_:Number = NaN;
var _loc3_:Array = [];
var _loc13_:Array = [];
var _loc4_:Number = 0;
var _loc12_:Number = 0;
var _loc7_:int = param2 - 1;
var _loc10_:Array = [];
var _loc9_:Array = [];
for(_loc11_ in param1)
{
_addCubicLengths(param1[_loc11_],_loc3_,param2);
}
_loc8_ = int(_loc3_.length);
_loc5_ = 0;
while(_loc5_ < _loc8_)
{
_loc4_ += Math.sqrt(_loc3_[_loc5_]);
_loc6_ = _loc5_ % param2;
_loc9_[_loc6_] = _loc4_;
if(_loc6_ == _loc7_)
{
_loc12_ += _loc4_;
_loc6_ = _loc5_ / param2 >> 0;
_loc10_[_loc6_] = _loc9_;
_loc13_[_loc6_] = _loc12_;
_loc4_ = 0;
_loc9_ = [];
}
_loc5_++;
}
return {
"length":_loc12_,
"lengths":_loc13_,
"segments":_loc10_
};
}
private static function _addCubicLengths(param1:Array, param2:Array, param3:uint = 6) : void
{
var _loc4_:Number = NaN;
var _loc8_:Number = NaN;
var _loc11_:Number = NaN;
var _loc13_:Number = NaN;
var _loc14_:Number = NaN;
var _loc15_:Number = NaN;
var _loc9_:Number = NaN;
var _loc5_:int = 0;
var _loc10_:Number = NaN;
var _loc12_:Segment = null;
var _loc6_:int = 0;
var _loc16_:Number = 1 / param3;
var _loc7_:int = int(param1.length);
while(--_loc7_ > -1)
{
_loc12_ = param1[_loc7_];
_loc11_ = _loc12_.a;
_loc13_ = _loc12_.d - _loc11_;
_loc14_ = _loc12_.c - _loc11_;
_loc15_ = _loc12_.b - _loc11_;
_loc4_ = _loc8_ = 0;
_loc5_ = 1;
while(_loc5_ <= param3)
{
_loc9_ = _loc16_ * _loc5_;
_loc10_ = 1 - _loc9_;
_loc4_ = _loc8_ - (_loc8_ = (_loc9_ * _loc9_ * _loc13_ + 3 * _loc10_ * (_loc9_ * _loc14_ + _loc10_ * _loc15_)) * _loc9_);
_loc6_ = _loc7_ * param3 + _loc5_ - 1;
param2[_loc6_] = (param2[_loc6_] || 0) + _loc4_ * _loc4_;
_loc5_++;
}
}
}
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
{
var _loc10_:String = null;
var _loc8_:Boolean = false;
var _loc6_:int = 0;
var _loc7_:int = 0;
var _loc11_:Array = null;
var _loc5_:Object = null;
var _loc4_:Array = null;
var _loc12_:Object = null;
this._target = param1;
var _loc13_:Object = param2 is Array ? {"values":param2} : param2;
this._props = [];
this._timeRes = _loc13_.timeResolution == null ? 6 : int(_loc13_.timeResolution);
_loc4_ = _loc13_.values || [];
var _loc15_:Object = {};
var _loc9_:Object = _loc4_[0];
var _loc14_:Object = _loc13_.autoRotate || param3.vars.orientToBezier;
this._autoRotate = _loc14_ ? (_loc14_ is Array ? _loc14_ as Array : [["x","y","rotation",_loc14_ === true ? 0 : Number(_loc14_)]]) : null;
if(_loc9_ is Point)
{
this._props = ["x","y"];
}
else
{
for(_loc10_ in _loc9_)
{
this._props.push(_loc10_);
}
}
_loc6_ = int(this._props.length);
while(--_loc6_ > -1)
{
_loc10_ = this._props[_loc6_];
this._overwriteProps.push(_loc10_);
_loc8_ = Boolean(this._func[_loc10_] = param1[_loc10_] is Function);
var _temp_4:*;
_loc15_[_loc10_] = !_loc8_ ? param1[_loc10_] : (_temp_4 = param1,param1[_loc10_.indexOf("set") || !("get" + _loc10_.substr(3) in param1) ? _loc10_ : "get" + _loc10_.substr(3)]());
if(!_loc5_)
{
if(_loc15_[_loc10_] !== _loc4_[0][_loc10_])
{
_loc5_ = _loc15_;
}
}
}
this._beziers = _loc13_.type !== "cubic" && _loc13_.type !== "quadratic" && _loc13_.type !== "soft" ? bezierThrough(_loc4_,isNaN(_loc13_.curviness) ? 1 : _loc13_.curviness,false,_loc13_.type === "thruBasic",_loc13_.correlate || "x,y,z",_loc5_) : _parseBezierData(_loc4_,_loc13_.type,_loc15_);
this._segCount = this._beziers[_loc10_].length;
if(this._timeRes)
{
_loc12_ = _parseLengthData(this._beziers,this._timeRes);
this._length = _loc12_.length;
this._lengths = _loc12_.lengths;
this._segments = _loc12_.segments;
this._l1 = this._li = this._s1 = this._si = 0;
this._l2 = this._lengths[0];
this._curSeg = this._segments[0];
this._s2 = this._curSeg[0];
this._prec = 1 / this._curSeg.length;
}
if(_loc11_ == this._autoRotate)
{
this._initialRotations = [];
if(!(_loc11_[0] is Array))
{
this._autoRotate = _loc11_ = [_loc11_];
}
_loc6_ = int(_loc11_.length);
while(--_loc6_ > -1)
{
_loc7_ = 0;
while(_loc7_ < 3)
{
_loc10_ = _loc11_[_loc6_][_loc7_];
this._func[_loc10_] = param1[_loc10_] is Function ? param1[_loc10_.indexOf("set") || !("get" + _loc10_.substr(3) in param1) ? _loc10_ : "get" + _loc10_.substr(3)] : false;
_loc7_++;
}
_loc10_ = _loc11_[_loc6_][2];
this._initialRotations[_loc6_] = this._func[_loc10_] ? this._func[_loc10_]() : this._target[_loc10_];
}
}
_startRatio = param3.vars.runBackwards ? 1 : 0;
return true;
}
override public function _kill(param1:Object) : Boolean
{
var _loc2_:String = null;
var _loc4_:int = 0;
var _loc3_:Array = this._props;
for(_loc2_ in _beziers)
{
if(_loc2_ in param1)
{
delete _beziers[_loc2_];
delete _func[_loc2_];
_loc4_ = int(_loc3_.length);
while(--_loc4_ > -1)
{
if(_loc3_[_loc4_] === _loc2_)
{
_loc3_.splice(_loc4_,1);
}
}
}
}
return super._kill(param1);
}
override public function _roundProps(param1:Object, param2:Boolean = true) : void
{
var _loc3_:Array = null;
_loc3_ = this._overwriteProps;
var _loc4_:int = int(_loc3_.length);
while(--_loc4_ > -1)
{
if(_loc3_[_loc4_] in param1 || "bezier" in param1 || "bezierThrough" in param1)
{
this._round[_loc3_[_loc4_]] = param2;
}
}
}
override public function setRatio(param1:Number) : void
{
var _loc23_:* = 0;
var _loc11_:Number = NaN;
var _loc7_:int = 0;
var _loc12_:String = null;
var _loc6_:Segment = null;
var _loc16_:Number = NaN;
var _loc2_:Number = NaN;
var _loc8_:int = 0;
var _loc17_:Array = null;
var _loc3_:Array = null;
var _loc13_:Segment = null;
var _loc19_:Number = NaN;
var _loc18_:Number = NaN;
var _loc21_:Number = NaN;
var _loc20_:Number = NaN;
var _loc4_:Number = NaN;
var _loc22_:Number = NaN;
var _loc14_:Array = null;
var _loc10_:int = this._segCount;
var _loc15_:Object = this._func;
var _loc9_:Object = this._target;
var _loc5_:Boolean = param1 !== this._startRatio;
if(this._timeRes == 0)
{
_loc23_ = int(param1 < 0 ? 0 : (param1 >= 1 ? _loc10_ - 1 : _loc10_ * param1 >> 0));
_loc16_ = (param1 - _loc23_ * (1 / _loc10_)) * _loc10_;
}
else
{
_loc17_ = this._lengths;
_loc3_ = this._curSeg;
param1 *= this._length;
_loc7_ = this._li;
if(param1 > this._l2 && _loc7_ < _loc10_ - 1)
{
_loc8_ = _loc10_ - 1;
while(_loc7_ < _loc8_ && (this._l2 = _loc17_[++_loc7_]) <= param1)
{
}
this._l1 = _loc17_[_loc7_ - 1];
this._li = _loc7_;
this._curSeg = _loc3_ = this._segments[_loc7_];
this._s2 = _loc3_[this._s1 = this._si = 0];
}
else if(param1 < this._l1 && _loc7_ > 0)
{
while(_loc7_ > 0 && (this._l1 = _loc17_[--_loc7_]) >= param1)
{
}
if(_loc7_ === 0 && param1 < this._l1)
{
this._l1 = 0;
}
else
{
_loc7_++;
}
this._l2 = _loc17_[_loc7_];
this._li = _loc7_;
this._curSeg = _loc3_ = this._segments[_loc7_];
this._s1 = _loc3_[(this._si = _loc3_.length - 1) - 1] || 0;
this._s2 = _loc3_[this._si];
}
_loc23_ = _loc7_;
param1 -= this._l1;
_loc7_ = this._si;
if(param1 > this._s2 && _loc7_ < _loc3_.length - 1)
{
_loc8_ = _loc3_.length - 1;
while(_loc7_ < _loc8_ && (this._s2 = _loc3_[++_loc7_]) <= param1)
{
}
this._s1 = _loc3_[_loc7_ - 1];
this._si = _loc7_;
}
else if(param1 < this._s1 && _loc7_ > 0)
{
while(_loc7_ > 0 && (this._s1 = _loc3_[--_loc7_]) >= param1)
{
}
if(_loc7_ === 0 && param1 < this._s1)
{
this._s1 = 0;
}
else
{
_loc7_++;
}
this._s2 = _loc3_[_loc7_];
this._si = _loc7_;
}
_loc16_ = (_loc7_ + (param1 - this._s1) / (this._s2 - this._s1)) * this._prec;
}
_loc11_ = 1 - _loc16_;
_loc7_ = int(this._props.length);
while(--_loc7_ > -1)
{
_loc12_ = this._props[_loc7_];
_loc6_ = this._beziers[_loc12_][_loc23_];
_loc2_ = (_loc16_ * _loc16_ * _loc6_.da + 3 * _loc11_ * (_loc16_ * _loc6_.ca + _loc11_ * _loc6_.ba)) * _loc16_ + _loc6_.a;
if(this._round[_loc12_])
{
_loc2_ = _loc2_ + (_loc2_ > 0 ? 0.5 : -0.5) >> 0;
}
if(_loc15_[_loc12_])
{
_loc9_[_loc12_](_loc2_);
}
else
{
_loc9_[_loc12_] = _loc2_;
}
}
if(this._autoRotate != null)
{
_loc14_ = this._autoRotate;
_loc7_ = int(_loc14_.length);
while(--_loc7_ > -1)
{
_loc12_ = _loc14_[_loc7_][2];
_loc4_ = Number(_loc14_[_loc7_][3] || 0);
_loc22_ = _loc14_[_loc7_][4] == true ? 1 : 57.29577951308232;
_loc6_ = this._beziers[_loc14_[_loc7_][0]][_loc23_];
_loc13_ = this._beziers[_loc14_[_loc7_][1]][_loc23_];
_loc19_ = _loc6_.a + (_loc6_.b - _loc6_.a) * _loc16_;
_loc21_ = _loc6_.b + (_loc6_.c - _loc6_.b) * _loc16_;
_loc19_ += (_loc21_ - _loc19_) * _loc16_;
_loc21_ += (_loc6_.c + (_loc6_.d - _loc6_.c) * _loc16_ - _loc21_) * _loc16_;
_loc18_ = _loc13_.a + (_loc13_.b - _loc13_.a) * _loc16_;
_loc20_ = _loc13_.b + (_loc13_.c - _loc13_.b) * _loc16_;
_loc18_ += (_loc20_ - _loc18_) * _loc16_;
_loc20_ += (_loc13_.c + (_loc13_.d - _loc13_.c) * _loc16_ - _loc20_) * _loc16_;
_loc2_ = Number(_loc5_ ? Math.atan2(_loc20_ - _loc18_,_loc21_ - _loc19_) * _loc22_ + _loc4_ : this._initialRotations[_loc7_]);
if(_loc15_[_loc12_])
{
_loc9_[_loc12_](_loc2_);
}
else
{
_loc9_[_loc12_] = _loc2_;
}
}
}
}
}
}
class Segment
{
public var a:Number;
public var b:Number;
public var c:Number;
public var d:Number;
public var da:Number;
public var ca:Number;
public var ba:Number;
public function Segment(param1:Number, param2:Number, param3:Number, param4:Number)
{
super();
this.a = param1;
this.b = param2;
this.c = param3;
this.d = param4;
this.da = param4 - param1;
this.ca = param3 - param1;
this.ba = param2 - param1;
}
}