flash on 2014-11-29

by bradsedito
♥0 | Line 165 | Modified 2014-11-29 10:29:31 | MIT License
play

ActionScript3 source code

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

package
{
        import away3d.cameras.Camera3D;
        import away3d.containers.ObjectContainer3D;
        import away3d.containers.Scene3D;
        import away3d.containers.View3D;
        import away3d.core.base.Face;
        import away3d.core.base.Mesh;
        import away3d.core.base.Object3D;
        import away3d.core.base.Vertex;
        import away3d.core.clip.RectangleClipping;
        import away3d.core.utils.Cast;
        import away3d.events.MouseEvent3D;
        import away3d.lights.DirectionalLight3D;
        import away3d.lights.PointLight3D;
        import away3d.loaders.Loader3D;
        import away3d.loaders.Swf;
        import away3d.materials.BitmapMaterial;
        import away3d.materials.ColorMaterial;
        import away3d.materials.ShadingColorMaterial;
        import away3d.materials.WireColorMaterial;
        import away3d.materials.WireframeMaterial;
        import away3d.primitives.Cone;
        import away3d.primitives.Cube;
        import away3d.primitives.LineSegment;
        import away3d.primitives.Plane;
        import away3d.primitives.Sphere;
        import away3d.primitives.TextField3D;
        import away3d.primitives.Trident;
        import away3d.sprites.MovieClipSprite;
        import away3d.sprites.Sprite3D;
         
        import com.greensock.TweenLite;
         
        import flash.display.Sprite;
        import flash.display.StageAlign;
        import flash.display.StageScaleMode;
        import flash.events.Event;
        import flash.geom.Vector3D;
         
        import wumedia.vector.VectorText;
         
    [SWF(backgroundColor='#333333', frameRate='60')]
    public class PositionOnSphere extends Sprite
    {
        private var _scene:Scene3D;
        private var _camera:Camera3D;
        private var _view:View3D;
         
        public var  _lookX:int = 300;
        public var _lookY:int = 200;
        public var _lookZ:int = 700;
        private var sphere:Sphere;
        private var sphereOrbit1:Sphere;
        private var sphereOrbit1Phi:Number;
        private var sphereOrbit1Theta:Number;
         
        private var sphereOrbit2:Sphere;
        private var sphereOrbit2Phi:Number;
        private var sphereOrbit2Theta:Number;
         
        private var sphereOrbit3:Sphere;
        private var sphereOrbit3Phi:Number;
        private var sphereOrbit3Theta:Number;
        private var target01:Cube;
        private var target02:Cube;
         
        public function PositionOnSphere()
        {
            super();
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
             
            initScene();
            initObjects();
             
            this.addEventListener(Event.ENTER_FRAME, render);
        }
 
         
        private function initScene():void
        {
            _scene = new Scene3D();
            _camera = new Camera3D({z:-1000});
            _view = new View3D({scene:_scene, camera:_camera});
            _view.x = stage.stageWidth/2;
            _view.y = stage.stageHeight/2;
            _view.clipping = new RectangleClipping({minX:-stage.stageWidth/2, minY:-stage.stageHeight/2, maxX:stage.stageWidth/2, maxY:stage.stageHeight/2});
            addChild(_view);
             
            // Add trident for reference
            var tri:Trident = new Trident( (1000/2+100),true);
            _scene.addChild(tri);
             
        }
        private function initObjects():void
        {
            var plane:Plane = new Plane();
            plane.width = plane.height = 50000;
            plane.y = -1000;
            plane.segmentsW = plane.segmentsH = 12;
            plane.material = new WireframeMaterial(0x222222);
            _scene.addChild(plane);
             
            sphere = new Sphere({material:"white#black",radius:200});
            sphere.ownCanvas = true;
            sphere.alpha = .7;
            sphere.bothsides = true;
            sphere.x = _lookX;
            sphere.y = _lookY;
            sphere.z = _lookZ;
            _scene.addChild(sphere);
             
            //setup target objects
            target01 = new Cube({material:"black#white", depth:50, width:50, height:50});
            _scene.addChild(target01);
             
            target02 = new Cube({material:"black#white", depth:50, width:50, height:50});
            _scene.addChild(target02);
            target02.x = _lookX;
            target02.y = _lookY;
            target02.z = _lookZ;
             
            target01.addEventListener(MouseEvent3D.MOUSE_DOWN,objectHandler);
            target02.addEventListener(MouseEvent3D.MOUSE_DOWN,objectHandler);
            //set up orbiting spheres
             
            sphereOrbit1 = new Sphere({material:"yellow#black",radius:20});
            sphereOrbit1Phi = radians(0);
            sphereOrbit1Theta = radians(90);
             
            _scene.addChild(sphereOrbit1);
             
            sphereOrbit2 = new Sphere({material:"red#black",radius:20});
            sphereOrbit2Phi = radians(90);
            sphereOrbit2Theta = 0;
             
            _scene.addChild(sphereOrbit2);
             
            sphereOrbit3 = new Sphere({material:"blue#black",radius:20});
            sphereOrbit3Phi = 0
            sphereOrbit3Theta = radians(90);
             
            _scene.addChild(sphereOrbit3);
        }
         
 
        private function objectHandler(e:MouseEvent3D):void
        {
            var obj:Object3D = e.target as Object3D;
            tweenCameraTarget(obj.x,obj.y,obj.z)
             
        }
        private function setCoords(_targetObject:Object3D,_radius:Number = 300,_phi:Number = 0,_theta:Number = 0):void{
             
            var xp:int = _lookX - (_radius) * Math.sin(_phi) * Math.cos(_theta);
            var zp:int = _lookZ - (_radius) * Math.sin(_phi) * Math.sin(_theta);
            var yp:int = _lookY - (_radius) * Math.cos(_phi);
             
             
            _targetObject.x = xp;
            _targetObject.y = yp;
            _targetObject.z = zp;
        }
        private function hoverCamera():void
        {
            var mX:Number = this.mouseX > 0 ? this.mouseX : 0;
            var mY:Number = this.mouseY > 0 ? this.mouseY : 0;
             
             
            //you need to init tarX and tarY with the _lookX and _lookY
            var tarX:Number = _lookX +  5*(mX  - (stage.stageWidth*.5 ));
            var tarY:Number = _lookY + -5*(mY - (stage.stageHeight*.5));
             
            var dX:Number = _camera.x - tarX;
            var dY:Number = _camera.y - tarY;
            var dZ:Number = _lookZ - 1000 ;
             
             
            _camera.x -= dX*0.25;
            _camera.y -= dY*0.25;
            //always keep Z 1000 away from target
            _camera.z = _lookZ - 1000;
            _camera.lookAt(new Vector3D(_lookX, _lookY, _lookZ));
             
             
             
        }
        private function tweenCameraTarget(_x:int,_y:int,_z:int):void{
             
            //this tweens the look at variables
            TweenLite.to(this, 1, {_lookX:_x,_lookY:_y,_lookZ:_z});
            TweenLite.to(sphere,1,{x:_x, y:_y, z:_z});
             
        }
        private function radians(_degrees:Number):Number{
            //convert degrees to radians
            return _degrees*(Math.PI/180);
        }
        private function degrees(_radians:Number):Number{
            //convert radians to degrees
            return _radians*(180/Math.PI);
        }
        private function render(evt:Event):void
        {
            hoverCamera();
             
            setCoords(sphereOrbit1,300,sphereOrbit1Phi+=radians(1),sphereOrbit1Theta+=radians(3));
             
            setCoords(sphereOrbit2,330,sphereOrbit2Phi,sphereOrbit2Theta += radians(2) );
         
            setCoords(sphereOrbit3,270,sphereOrbit3Phi +=radians(4),sphereOrbit3Theta);
             
             
            _view.render();
        }
    }
}