Files
burrow-server/tools/decompiled/old-builds/b1375/com/greensock/plugins/BezierPlugin.as
T

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