mehrere planes als movieclip

[THA_BEST]

hi leute,

ich bräuchte eure hilfe. ich wollte mehrere planes als movieclip erstellen und wenn man sie anklickt das auf dem plane rangezoomt wird. leider wird auf beide planes gleichzeitig rangezoomt.

hier ist der code, wenn jmd einen guten rat hat wäre das echt sehr nett!

package {

	import flash.display.Sprite;
	import flash.events.MouseEvent;
	import flash.display.MovieClip;

	import gs.TweenMax;
	import gs.easing.Cubic;
	import org.papervision3d.materials.MovieAssetMaterial;
	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="2000",height="2000",backgroundColor="#000000",frameRate="60")]
	public class TweenToSpatialPlanes extends BasicView {





		private static const NUM_PLANES:int=2;
		private static const TWEEN_TIME:Number=3;
		private static const DISTANCE_FROM_PLANE:Number=1000;

		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;

		private var p:Plane;
		private var p1:Plane;

		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 {

			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 {
			var p:Plane;
			var movieMat:MovieAssetMaterial;
			var alicia1:MovieClip = new MovieClip();




			movieMat=new MovieAssetMaterial("alicia1",true);
			movieMat.doubleSided=true;
			movieMat.interactive=true;
			movieMat.smooth=true;
			movieMat.animated=true;
			p=new Plane(movieMat,200,200,2,2);
			alicia1=MovieClip(movieMat.movie);

			scene.addChild(p);
			p.x=-1150;
			p.z=100;
			p.y=1200;

			p.addEventListener(InteractiveScene3DEvent.OBJECT_CLICK, p_objectClickHandler);



			for (var i:uint=0; i<NUM_PLANES; i++) {
				var p1:Plane;
				var movieMat1:MovieAssetMaterial;
				var alicia2:MovieClip = new MovieClip();

				movieMat1=new MovieAssetMaterial("alicia2",true);
				movieMat1.doubleSided=true;
				movieMat1.interactive=true;
				movieMat1.smooth=true;
				movieMat1.animated=true;
				p1=new Plane(movieMat1,200,200,2,2);
				alicia2=MovieClip(movieMat1.movie);

				scene.addChild(p1);
				p1.x=-950;
				p1.z=500;
				p1.y=1200;

				p1.addEventListener(InteractiveScene3DEvent.OBJECT_CLICK, p1_objectClickHandler);
			}
		}


		private function p_objectClickHandler(event:InteractiveScene3DEvent):void {
			var p:Plane=Plane(event.target);

			cameraTarget.copyTransform(p);
			cameraTarget.moveBackward(DISTANCE_FROM_PLANE);

			createTween(cameraTarget);

		}

		private function p1_objectClickHandler(event:InteractiveScene3DEvent):void {
			var p1:Plane=Plane(event.target);

			cameraTarget.copyTransform(p1);
			cameraTarget.moveBackward(DISTANCE_FROM_PLANE);

			createTween(cameraTarget);
		}



		private function backgroundSprite_clickHandler(event:MouseEvent):void {
			createTween(cameraStart);
		}

		private function createTween(displayObject3d:DisplayObject3D):void {

			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);
		}
	}
}


import org.papervision3d.cameras.Camera3D;
class CameraWithSlerp extends Camera3D {
	public var slerp:Number=0;
}