import org.papervision3d.cameras.Camera3D;
import org.papervision3d.materials.BitmapMaterial;
import org.papervision3d.objects.Collada;
import org.papervision3d.scenes.Scene3D;

import flash.display.BitmapData;


var container:MovieClip;
var scene:Scene3D;
var camera:Camera3D;
var sphere:Collada;

// _______________________________________________________________________
//                                                                    Main
function HelloCollada() {
 init3D();

 this.onEnterFrame = loop3D;
}


// _______________________________________________________________________
//                                                                  Init3D
function init3D() {
 trace("run");
 // Create container movieclip and center it
 container = this.createEmptyMovieClip("container", this.getNextHighestDepth());
 container._x = 200
 container._y =200

 // Create scene
 scene = new Scene3D(container);

 // Create camera
 camera = new Camera3D();
 camera.zoom = 3;

 // Create material
 var texture:BitmapData = BitmapData.loadBitmap("Bitmap");
 var material:BitmapMaterial = new BitmapMaterial(texture);
 material.oneSide = true;// Make it single sided.  this gives a performance boost

 // Load sphere
 sphere = new Collada(material, "world.dae", .2);
 sphere.rotationX = 45;

 // Include in scene
 scene.push(sphere);
}

// _______________________________________________________________________
//                                                                    Loop
function loop3D() {
 sphere.rotationY = container._xmouse/2;
 sphere.rotationX = container._ymouse/2;

 // Render
 scene.renderCamera(camera);
}
HelloCollada()

package {
 import flash.display.Bitmap;
 import flash.display.Sprite;
 import flash.events.MouseEvent;
 import flash.display.BitmapData;
 import gs.TweenMax;
 import gs.easing.Cubic;

 import org.papervision3d.core.math.Quaternion;
 import org.papervision3d.events.InteractiveScene3DEvent;
 import org.papervision3d.materials.BitmapMaterial;
 import org.papervision3d.objects.DisplayObject3D;
 import org.papervision3d.objects.primitives.Plane;
 import org.papervision3d.view.BasicView;

 [SWF(width="640", height="480", backgroundColor="#000000", frameRate="60")];
 public class TweenToSpatialPlanes extends BasicView {
  private var image13:BitmapData = new image1(0,0);
  private var image23:BitmapData = new image2(0,0);
  private var image33:BitmapData = new image3(0,0);
  private var image43:BitmapData = new image4(0,0);
  private var image53:BitmapData = new image5(0,0);
  private var image63:BitmapData = new image6(0,0);

  private var assets:Array = [image13, image23, image33, image43, image53,image63];

  private static  const NUM_PLANES:int = 40;
  private static  const TWEEN_TIME:Number = 2;
  private static  const DISTANCE_FROM_PLANE:Number = 500;

  private var cameraWithSlerp:CameraWithSlerp = new CameraWithSlerp();

  private var cameraStart:DisplayObject3D = new DisplayObject3D();
  private var cameraTarget:DisplayObject3D = new DisplayObject3D();

  private var startQuaternion:Quaternion = null;
  private var endQuaternion:Quaternion = null;
  private var currentQuaternion:Quaternion = null;

  public function TweenToSpatialPlanes() {
   setupPapervision3D();
   setupBackground();
   setupPlanes();

   singleRender();
  }
  private function setupPapervision3D():void {
   viewport.interactive = true;
   cameraWithSlerp.target = null;
   cameraWithSlerp.slerp = 0;
   cameraStart.z = -1000;
   scene.addChild(cameraStart);
  }
  private function setupBackground():void {
   //the background is for the "click outside" events
   var backgroundSprite:Sprite = new Sprite();

   backgroundSprite.graphics.beginFill(0x000000);
   backgroundSprite.graphics.drawRect(0, 0, width, height);
   backgroundSprite.graphics.endFill();

   addChildAt(backgroundSprite, getChildIndex(viewport));

   backgroundSprite.addEventListener(MouseEvent.CLICK, backgroundSprite_clickHandler);
  }
  private function setupPlanes():void {
   for (var i:int = 0; i < NUM_PLANES; i++) {
    var bitmapMaterial:BitmapMaterial = createRandomBitmapMaterial();
    bitmapMaterial.interactive = true;
    bitmapMaterial.doubleSided = true;
    bitmapMaterial.precise = true;

    var plane:Plane = new Plane(bitmapMaterial);

    plane.x = Math.random() * 5000 - 2500;
    plane.y = Math.random() * 5000 - 2500;
    plane.z = Math.random() * 2500;
    plane.rotationX = Math.random() * 180 -90;
    plane.rotationY = Math.random() * 180 -90;
    plane.rotationZ = Math.random() * 180 -90;

    scene.addChild(plane);

    plane.addEventListener(InteractiveScene3DEvent.OBJECT_CLICK, plane_objectClickHandler);
   }
  }
  private function createRandomBitmapMaterial():BitmapMaterial {
   //grab a bitmapAsset from the array (this is very ugly, but not important to the concept :) )
   //var bitmap:Bitmap = Bitmap(new assets[Math.floor(Math.random() * assets.length)]);
   var bitmapMaterial:BitmapMaterial = new BitmapMaterial(assets[Math.floor(Math.random() * assets.length)]);

   return bitmapMaterial;
  }
  private function plane_objectClickHandler(event:InteractiveScene3DEvent):void {
   var plane:Plane = Plane(event.target);
   //put the target behind the plane
   cameraTarget.copyTransform(plane);
   cameraTarget.moveBackward(DISTANCE_FROM_PLANE);

   createTween(cameraTarget);
  }
  private function backgroundSprite_clickHandler(event:MouseEvent):void {
   createTween(cameraStart);
  }
  private function createTween(displayObject3d:DisplayObject3D):void {
   //when "slerping", this value is a range from 0 to 1
   //0 being the starting total rotation (AKA transformation)
   //1 being the ending total rotation
   cameraWithSlerp.slerp = 0;

   var tweenObject:Object = {};
   tweenObject.x = displayObject3d.x;
   tweenObject.y = displayObject3d.y;
   tweenObject.z = displayObject3d.z;
   tweenObject.bezierThrough = [{x:0, y:0, z:0, slerp:.1}];
   tweenObject.ease = Cubic.easeInOut;
   tweenObject.slerp = 1;
   tweenObject.onUpdate = camera_updateCallback;

   startQuaternion = Quaternion.createFromMatrix(cameraWithSlerp.transform);
   endQuaternion = Quaternion.createFromMatrix(displayObject3d.transform);

   TweenMax.to(cameraWithSlerp, TWEEN_TIME, tweenObject);
  }
  private function camera_updateCallback():void {
   currentQuaternion = Quaternion.slerp(startQuaternion, endQuaternion, cameraWithSlerp.slerp);
   cameraWithSlerp.transform.copy3x3(currentQuaternion.matrix);
   singleRender();
  }
  override public function singleRender():void {
   renderer.renderScene(scene, cameraWithSlerp, viewport);
  }
 }
}
//a helper class whose sole purpose is to add the slerp property
//I use this for the sake of brevity, but for production code
//you would move this into a new ActionScript file
import org.papervision3d.cameras.Camera3D;
class CameraWithSlerp extends Camera3D {
 public var slerp:Number = 0;
}

package
{
 import flash.display.*;
 import flash.events.*;
 import flash.filters.*;
 import flash.geom.*;
 import org.papervision3d.cameras.Camera3D;
 
 import org.papervision3d.view.*;
 import org.papervision3d.materials.*;
 import org.papervision3d.objects.*;
 import org.papervision3d.objects.primitives.*
 
    [SWF(width = "720", height = "480", frameRate = "60", backgroundColor = "#FFFFFF")]
 
 public class Test02 extends BasicView
 { 
  // const vars
  static private const CIRCLE_RANGE :int = 150;
  static private const OBJ_LENGTH   :int = 30;
  static private const OBJ_HEIGHT   :int = 20;
  static private const RASEN_LENGTH :int = 2;
  static private const RASEN_RANGE  :int = 500;
  static private const FOCUS_POS    :int = 600;
  
  // 3d vars
  private var list   :Array = [];
  private var rasens :Array = [];
  private var wrap   :DisplayObject3D;

  /**
   * Constructor
   */
  public function Test02()
  {
   super(450, 250);
   
   // init swf
   stage.scaleMode = StageScaleMode.NO_SCALE;
   stage.align     = StageAlign.TOP_LEFT;
   stage.quality   = StageQuality.HIGH;
   
   init();
  }
  
  public function init():void
  {
   //camera
   camera.focus     = 600;
   camera.zoom      = 1;
   camera.x         = 0;
   camera.y         = 0;
   camera.z         = 1000;
   
   // wrap
   wrap = new DisplayObject3D();
   scene.addChild(wrap);
   
   for (var i:int = 0; i < RASEN_LENGTH; i++ )
   {
    var rasen:DisplayObject3D = new DisplayObject3D();
    var rasenRot:Number = 360 * (i / RASEN_LENGTH)* Math.PI / 180;
    rasen.x = RASEN_RANGE * Math.sin(rasenRot);
    rasen.z = RASEN_RANGE * Math.cos(rasenRot);
    wrap.addChild(rasen);
    rasens.push(rasen);
    
    for (var j:int = 0; j < OBJ_LENGTH; j++)
    {
     var rot:Number = 360 * (j / 20) ; 
     
     var m:ColorMaterial = new ColorMaterial(0x0066CC);
     m.doubleSided = true; 
     
     var o:Plane = new Plane(m, 50, 50, 1, 1);
     
     o.x = CIRCLE_RANGE * Math.sin(rot * Math.PI / 180)
     o.y = OBJ_HEIGHT * j - OBJ_HEIGHT * OBJ_LENGTH /2;
     o.z = CIRCLE_RANGE * Math.cos(rot * Math.PI / 180)
     o.rotationY = rot;
     o.useOwnContainer = true; //
     
     rasen.addChild(o);
     list.push(o);
    }
   }
   
   addEventListener(Event.ENTER_FRAME, enterFrameHandler);
   startRendering();
  }
  
  private function enterFrameHandler(event:Event):void
  {
   //
   wrap.rotationY += ((mouseX / stage.stageWidth * 480) - wrap.rotationY) * .1;
   camera.y += ((mouseY / stage.stageHeight * 2000) - 1000 - camera.y) * .1;
   
   //
   for (var i:int = 0; i < rasens.length; i++)
   {
    rasens[i].yaw(-3);
   }
   
   //
   for (i = 0; i < list.length; i++)
   {
    var o:DisplayObject3D = list[i] as DisplayObject3D;
    
    //
    var deg:Number = Math.abs(calcPointDistanceFromCamera(o) - FOCUS_POS);
    
    //
    var blurVal:int = Math.min(64, deg * .02 << 1 );
    var blurFilter:BlurFilter = new BlurFilter(blurVal, blurVal, 1);
    
    //
    var blightness:Number = deg / 6;
    var blightnessArr:Array =
    [
     1, 0, 0, 0, blightness,
     0, 1, 0, 0, blightness,
     0, 0, 1, 0, blightness,
     0, 0, 0, 1, 0
    ];
    var blightnessFilter:ColorMatrixFilter = new ColorMatrixFilter(blightnessArr);
    
    
    o.filters = [blurFilter, blightnessFilter];
   }
  }
  
  private function calcPointDistanceFromCamera(obj:DisplayObject3D):Number
  {
   var vecX:Number = obj.sceneX - camera.x;
   var vecY:Number = obj.sceneY - camera.y;
   var vecZ:Number = obj.sceneZ - camera.z;
   return Math.sqrt((vecX * vecX) + (vecY * vecY) + (vecZ * vecZ));
  }

 }
}