HairShader

package
{
    import Box2D.Common.Math.*;
    import flash.display.*;

    public class HairShader extends Object
    {
        public var y:Number;
        public var sprite:MovieClip;
        public var dir:Number;
        public var spring_coeff:Number;
        public var objects:Array;
        public var dr:Number;
        public var shifta:Number;
        public var root:World;
        public var color:int;
        public var tex_dy:int;
        public var r:Number;
        public var n:int;
        public var shiftx:Number;
        public var shifty:Number;
        public var x:Number;
        public var parent_sprite:MovieClip;
        public static var grav:Number;
        public static var wind:Number;
        public static var m:Number;
        public static var new_r:Number;
        public static var dx:Number;
        public static var dy:Number;
        public static var dz:Number;

        public function HairShader(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:int, param7:World, param8:MovieClip, param9:int) : void
        {
            var _loc_10:* = 0;
            var _loc_11:* = null;
            root = param7;
            x = param1;
            y = param2;
            r = param3;
            n = param5;
            color = param6;
            parent_sprite = param8;
            sprite = new MovieClip();
            if (parent_sprite)
            {
                parent_sprite.addChild(sprite);
            }
            sprite.x = x;
            sprite.y = y;
            sprite.mouseEnabled = false;
            objects = new Array();
            dir = 0;
            dr = param4 / (n - 1);
            _loc_10 = 0;
            while (_loc_10 < n)
            {

                _loc_11 = new ClothJoint(x + _loc_10 * dr, y, 0 + _loc_10 * 0.1, 10);
                _loc_11.mass = Math.pow((n - _loc_10) / n, 1.2) * r;
                objects.push(_loc_11);
                _loc_10++;
            }
            grav = root.gravity_y * 0.5;
            wind = 0.4;
            spring_coeff = 1;
            tex_dy = param9;
            return;
        }// end function

        public function LinkUpdate(param1:ClothJoint, param2:ClothJoint) : void
        {
            dx = param2.x - param1.x;
            dy = param2.y - param1.y;
            dz = param2.z - param1.z;
            new_r = Math.sqrt(dx * dx + dy * dy + dz * dz);
            m = (new_r - dr) / new_r;
            dx = dx * m;
            dy = dy * m;
            dz = dz * m;
            param1.x = param1.x + dx * 0.1;
            param1.y = param1.y + dy * 0.1;
            param1.z = param1.z + dz * 0.1;
            param2.x = param2.x - dx * 0.9;
            param2.y = param2.y - dy * 0.9;
            param2.z = param2.z - dz * 0.9;
            return;
        }// end function

        public function RenderBlack() : void
        {
            var _loc_1:* = 0;
            sprite.graphics.clear();
            sprite.graphics.lineStyle(2, 0);
            sprite.graphics.moveTo(objects[0].x - x, objects[0].y - y);
            _loc_1 = 0;
            while (_loc_1 < n)
            {

                sprite.graphics.lineTo(objects[_loc_1].x - x, objects[_loc_1].y - y);
                _loc_1++;
            }
            return;
        }// end function

        public function Kill() : void
        {
            if (!root)
            {
                return;
            }
            root.RemoveSprite(sprite);
            sprite = null;
            parent_sprite = null;
            objects = null;
            root = null;
            return;
        }// end function

        public function Update(param1:Number, param2:Number, param3:Number, param4:Number = -1) : void
        {
            var _loc_5:* = 0;
            var _loc_6:* = null;
            var _loc_7:* = null;
            var _loc_8:* = null;
            var _loc_9:* = null;
            var _loc_10:* = null;
            var _loc_11:* = null;
            var _loc_12:* = null;
            var _loc_13:* = null;
            var _loc_14:* = param1;
            x = param1;
            sprite.x = _loc_14;
            var _loc_14:* = param2;
            y = param2;
            sprite.y = _loc_14;
            dir = param3;
            _loc_5 = 0;
            while (_loc_5 < n)
            {

                _loc_13 = objects[_loc_5];
                objects[_loc_5].y = _loc_13.y + (grav + root.wind_z * 0.1);
                _loc_13.x = _loc_13.x + root.wind_x * wind;
                _loc_13.z = _loc_13.z + (-root.wind_x) * wind * 0.2;
                dx = (_loc_13.x - _loc_13.oldx) * 0.75;
                dy = (_loc_13.y - _loc_13.oldy) * 0.75;
                dz = (_loc_13.z - _loc_13.oldz) * 0.75;
                _loc_13.oldx = _loc_13.x;
                _loc_13.oldy = _loc_13.y;
                _loc_13.oldz = _loc_13.z;
                _loc_13.x = _loc_13.x + dx;
                _loc_13.y = _loc_13.y + dy;
                _loc_13.z = _loc_13.z + dz;
                _loc_5++;
            }
            objects[0].x = x;
            objects[0].y = y;
            objects[0].z = 0;
            _loc_6 = new b2Vec2(dr, 0);
            _loc_6.Rotate(dir);
            objects[1].x = root.interpolate(objects[1].x, x + _loc_6.x, 0.5 * spring_coeff);
            objects[1].y = root.interpolate(objects[1].y, y + _loc_6.y, 0.5 * spring_coeff);
            _loc_6.Add(_loc_6);
            objects[2].x = root.interpolate(objects[2].x, x + _loc_6.x, 0.2 * spring_coeff);
            objects[2].y = root.interpolate(objects[2].y, y + _loc_6.y, 0.2 * spring_coeff);
            _loc_5 = 0;
            while (_loc_5 < (n - 1))
            {

                LinkUpdate(objects[_loc_5], objects[(_loc_5 + 1)]);
                _loc_5++;
            }
            objects[0].x = x;
            objects[0].y = y;
            objects[0].z = 0;
            _loc_6.Multiply(0.5);
            objects[1].x = root.interpolate(objects[1].x, x + _loc_6.x, spring_coeff);
            objects[1].y = root.interpolate(objects[1].y, y + _loc_6.y, spring_coeff);
            if (param4 > 0)
            {
                _loc_6.Set(dr, 0);
                _loc_6.Rotate(dir);
                _loc_5 = 2;
                while (_loc_5 < n - 3)
                {

                    objects[_loc_5].x = root.interpolate(objects[_loc_5].x, objects[(_loc_5 - 1)].x + _loc_6.x, param4);
                    objects[_loc_5].y = root.interpolate(objects[_loc_5].y, objects[(_loc_5 - 1)].y + _loc_6.y, param4);
                    _loc_6.x = _loc_6.x + (objects[(_loc_5 + 1)].x - objects[_loc_5].x) * 0.5;
                    _loc_6.y = _loc_6.y + (objects[(_loc_5 + 1)].y - objects[_loc_5].y) * 0.5;
                    _loc_6.Multiply(dr / _loc_6.Length());
                    param4 = param4 * 0.8;
                    _loc_5++;
                }
            }
            _loc_5 = 0;
            while (_loc_5 < n - 2)
            {

                DoubleLinkUpdate(objects[_loc_5], objects[_loc_5 + 2], 1, dr * 2);
                _loc_5++;
            }
            _loc_5 = 0;
            while (_loc_5 < n - 3)
            {

                DoubleLinkUpdate(objects[_loc_5], objects[_loc_5 + 3], 1, dr * 3);
                _loc_5++;
            }
            _loc_7 = new b2Vec2(objects[1].x - objects[0].x, objects[1].y - objects[0].y);
            _loc_7.Perpendicular();
            _loc_7.Normalize();
            _loc_8 = new b2Vec2();
            _loc_9 = new b2Vec2();
            _loc_9.SetV(_loc_7);
            _loc_9.Multiply(objects[0].mass);
            _loc_10 = new b2Vec2();
            _loc_11 = root.GetTexture("hair_tex1");
            _loc_12 = new AABB(0, tex_dy, _loc_11.width / (n - 1), 16 + r);
            sprite.graphics.clear();
            _loc_5 = 1;
            while (_loc_5 < n)
            {

                if (_loc_5 < (n - 1))
                {
                    _loc_8.Set(objects[(_loc_5 + 1)].x - objects[_loc_5].x, objects[(_loc_5 + 1)].y - objects[_loc_5].y);
                    _loc_8.Perpendicular();
                    _loc_8.Normalize();
                    _loc_10.SetV(_loc_8);
                    _loc_10.Add(_loc_7);
                    _loc_10.Normalize();
                    _loc_10.Multiply(objects[_loc_5].mass);
                }
                else
                {
                    _loc_10.Set();
                }
                root.RenderQuad(_loc_11, sprite.graphics, _loc_12, objects[(_loc_5 - 1)].x + _loc_9.x - x, objects[(_loc_5 - 1)].y + _loc_9.y - y, objects[_loc_5].x + _loc_10.x - x, objects[_loc_5].y + _loc_10.y - y, objects[_loc_5].x - _loc_10.x - x, objects[_loc_5].y - _loc_10.y - y, objects[(_loc_5 - 1)].x - _loc_9.x - x, objects[(_loc_5 - 1)].y - _loc_9.y - y);
                _loc_12.x = _loc_12.x + _loc_12.w;
                _loc_7.SetV(_loc_8);
                _loc_9.SetV(_loc_10);
                _loc_5++;
            }
            return;
        }// end function

        public function Move(param1:Number, param2:Number, param3:Number) : void
        {
            var _loc_4:* = 0;
            _loc_4 = n - 1;
            while (_loc_4 >= 0)
            {

                objects[_loc_4].oldx = objects[_loc_4].oldx - param1;
                objects[_loc_4].oldy = objects[_loc_4].oldy - param2;
                param1 = param1 * param3;
                param2 = param2 * param3;
                _loc_4 = _loc_4 - 1;
            }
            return;
        }// end function

        public function DoubleLinkUpdate(param1:ClothJoint, param2:ClothJoint, param3:Number, param4:Number) : void
        {
            dx = param2.x - param1.x;
            dy = param2.y - param1.y;
            dz = param2.z - param1.z;
            new_r = Math.sqrt(dx * dx + dy * dy + dz * dz);
            m = (new_r - param4) / new_r * 0.5 * param3;
            dx = dx * m;
            dy = dy * m;
            dz = dz * m;
            param1.x = param1.x + dx * 0.2;
            param1.y = param1.y + dy * 0.2;
            param1.z = param1.z + dz * 0.2;
            param2.x = param2.x - dx * 0.8;
            param2.y = param2.y - dy * 0.8;
            param2.z = param2.z - dz * 0.8;
            return;
        }// end function

        public function SetAhoge() : void
        {
            var _loc_1:* = 0;
            _loc_1 = 0;
            while (_loc_1 < n)
            {

                objects[_loc_1].mass = Math.pow(0.5 - Math.abs((n - _loc_1) / n - 0.5), 1.2) * r;
                _loc_1++;
            }
            return;
        }// end function

    }
}