flash on 2013-1-28

by mutantleg
♥0 | Line 166 | Modified 2013-01-28 20:54:16 | MIT License
play

ActionScript3 source code

/**
 * Copyright mutantleg ( http://wonderfl.net/user/mutantleg )
 * MIT License ( http://www.opensource.org/licenses/mit-license.php )
 * Downloaded from: http://wonderfl.net/c/1a5z
 */

package {
    import flash.events.Event;
    import flash.display.Sprite;
    public class FlashTest extends Sprite {
      
        public function FlashTest() {
            
            
            
            stage.addEventListener(Event.ENTER_FRAME, onEnter);
        }//ctor
        
        public function onEnter(e:Event):void
        {
            graphics.clear();
            graphics.lineStyle(1,0);
            
         /*
            calcFrust(90, 1.0, 0.1, 100.0,
            200,200,-50,
            0,0,1,
            0,1,0,
            1,0,0);
        */

            var sx:Number;
            var sy:Number;
            
            sx = Math.cos(3.14 / 8);
            sy = Math.sin(3.14 / 8);


            calcFrust(90, 1.0, 0.1, 100.0,
            200,200,-50,
            0,0,1,
            -sy,sx,0,
            sx,sy,0);
           
            
            
        }//onenter
        
        
        public var minx:Number = 0;
        public var miny:Number = 0;
        public var maxx:Number = 0;
        public var maxy:Number = 0;
        
        
        public static function lineZedInter(
        v0x:Number, v0y:Number, v0z:Number, 
        v1x:Number, v1y:Number, v1z:Number
        ):Number
        {
            //0,0,0 //p
           //0,0,-1  //n
            
            var dx:Number; var dy:Number; var dz:Number;
            var vx:Number; var vy:Number; var vz:Number;
            var ndotv:Number;

            vx = v1x - v0x;
            vy = v1y - v0y;
            vz = v1z - v0z;

            dx = 0 - v0x;
            dy = 0 - v0y;
            dz = 0 - v0z;
            
            if (v0z == 0) { return -99999; }
            
            return  (v0z / -(v1z - v0z));
            
            /*
             ndotv = (vx * 0) + (vy * 0) + (vz * -1);
            if (ndotv == 0) { return -99999; } //line and plane parallel, no inters

            return (  (0*dx) +(0*dy) + (-1*dz)/ ndotv  );
            return ( ( ( nx * dx) + (ny * dy) + (nz * dz) ) / ndotv );
            */
        }//linezed
        
        /*
        public static function linePlaneInter(
        v0x:Number, v0y:Number, v0z:Number, 
        v1x:Number, v1y:Number, v1z:Number,
        px:Number, py:Number, pz:Number,
        nx:Number, ny:Number, nz:Number
        ):Number
        {
            var dx:Number; var dy:Number; var dz:Number;
            var vx:Number; var vy:Number; var vz:Number;
            var ndotv:Number;

            vx = v1x - v0x;
            vy = v1y - v0y;
            vz = v1z - v0z;

            dx = px - v0x;
            dy = py - v0y;
            dz = pz - v0z;

            ndotv = (vx * nx) + (vy * ny) + (vz * nz);
            if (ndotv == 0) { return -99999; } //line and plane parallel, no inters

            return ( ( ( nx * dx) + (ny * dy) + (nz * dz) ) / ndotv );

        }//linepinter
        */
      
        public function calcFrust(
        fov:Number, aspect:Number, neard:Number, fard:Number,
        posx:Number, posy:Number, posz:Number,
        frontx:Number, fronty:Number, frontz:Number,
        upx:Number, upy:Number, upz:Number,
        sidex:Number, sidey:Number, sidez:Number):void
        {
            var nw:Number;
            var nh:Number;
            var fw:Number;
            var fh:Number;
            var tang:Number;
            
            var fupx:Number, fupy:Number, fupz:Number;
            var fsidex:Number, fsidey:Number, fsidez:Number;
            var nupx:Number, nupy:Number, nupz:Number;
            var nsidex:Number, nsidey:Number, nsidez:Number;
            
            var fcx:Number, fcy:Number, fcz:Number;
            var ncx:Number, ncy:Number, ncz:Number;
            
            fov *= 3.1415 / 180;
            tang = Math.tan ( fov * 0.5 );

            nh = neard * tang;
            nw = nh * aspect;
            
            fh = fard * tang;
            fw = fh * aspect;
             
            fupx = upx * fh;
            fupy = upy * fh;
            fupz = upz * fh;
            
            fsidex = sidex * fw;
            fsidey = sidey * fw;
            fsidez = sidez * fw;
            
            nupx = upx * nh;
            nupy = upy * nh;
            nupz = upz * nh;
            
            nsidex = sidex * nw;
            nsidey = sidey * nw;
            nsidez = sidez * nw;
            
            fcx = posx + frontx * fard;
            fcy = posy + fronty * fard;
            fcz = posz + frontz * fard;
            
            ncx = posx + frontx * neard;
            ncy = posy + fronty * neard;
            ncz = posz + frontz * neard;
            
            
            var ax:Number;
            var ay:Number;
            var az:Number;
            var bx:Number;
            var by:Number;
            var bz:Number;
           
            var t:Number;
            var kx:Number;
            var ky:Number;
            var kz:Number;
            
            minx = 999999;
            miny = 999999;
            maxx = -999999;
            maxy = -999999;
            
            
         
            ax = ncx + (nupx*1)+(nsidex*1);
            ay = ncy + (nupy*1)+(nsidey*1); 
            az = ncz + (nupz*1)+(nsidez*1);
            
            bx = fcx + (fupx*1)+(fsidex*1);
            by = fcy + (fupy*1)+(fsidey*1);
            bz = fcz + (fupz*1)+(fsidez*1);
            
            t =  (az / -(bz - az));
            kx = ax + (bx-ax)*t;
            ky = ay + (by-ay)*t;
            graphics.drawCircle(kx,ky,4);
            //kz = az + (bz-ay)*t;
            minx =  minx < kx ? minx : kx; //   Math.min(minx, kx);
            miny =  miny < ky ? miny : ky; // Math.min(miny, ky);
            maxx = maxx > kx ? maxx : kx; // Math.max(maxx, kx);
            maxy = maxy > ky ? maxy : ky; // Math.max(maxx, ky);     
            
            graphics.drawCircle(ncx,ncy, 8);
            graphics.drawCircle(ax,ay, 4);
            graphics.drawCircle(bx,by,2);
            
   
            ax = ncx + (nupx*-1)+(nsidex*1);
            ay = ncy + (nupy*-1)+(nsidey*1); 
            az = ncz + (nupz*-1)+(nsidez*1);
            
            bx = fcx + (fupx*-1)+(fsidex*1);
            by = fcy + (fupy*-1)+(fsidey*1);
            bz = fcz + (fupz*-1)+(fsidez*1);
            graphics.drawCircle(bx,by,2);
       
            t =  (az / -(bz - az));
            kx = ax + (bx-ax)*t;
            ky = ay + (by-ay)*t;
            graphics.drawCircle(kx,ky,4);
           
            minx =  minx < kx ? minx : kx; 
            miny =  miny < ky ? miny : ky; 
            maxx = maxx > kx ? maxx : kx; 
            maxy = maxy > ky ? maxy : ky;  
            
            
            
            ax = ncx + (nupx*-1)+(nsidex*-1);
            ay = ncy + (nupy*-1)+(nsidey*-1); 
            az = ncz + (nupz*-1)+(nsidez*-1);
   
            bx = fcx + (fupx*-1)+(fsidex*-1);
            by = fcy + (fupy*-1)+(fsidey*-1);
            bz = fcz + (fupz*-1)+(fsidez*-1);
            graphics.drawCircle(bx,by,2);

            t =  (az / -(bz - az));
            kx = ax + (bx-ax)*t;
            ky = ay + (by-ay)*t;
            graphics.drawCircle(kx,ky,4);
           
            minx =  minx < kx ? minx : kx; 
            miny =  miny < ky ? miny : ky; 
            maxx = maxx > kx ? maxx : kx; 
            maxy = maxy > ky ? maxy : ky;  
            
            
            
            ax = ncx + (nupx*1)+(nsidex*-1);
            ay = ncy + (nupy*1)+(nsidey*-1); 
            az = ncz + (nupz*1)+(nsidez*-1);
   
                
            bx = fcx + (fupx*1)+(fsidex*-1);
            by = fcy + (fupy*1)+(fsidey*-1);
            bz = fcz + (fupz*1)+(fsidez*-1);
            graphics.drawCircle(bx,by,2);

            t =  (az / -(bz - az));
            kx = ax + (bx-ax)*t;
            ky = ay + (by-ay)*t;
            graphics.drawCircle(kx,ky,4);
           
            minx =  minx < kx ? minx : kx; 
            miny =  miny < ky ? miny : ky; 
            maxx = maxx > kx ? maxx : kx; 
            maxy = maxy > ky ? maxy : ky;  


            graphics.drawCircle(minx,miny, 16);
            graphics.drawCircle(maxx, maxy, 16);            
        
            graphics.drawRect(minx,miny, maxx-minx, maxy-miny);    
            
        }//calcmouse
        
        
    }//classend
}