Particles 3D

PRESS "R" + CLICK TO ROTATE.
DRAG THE GREEN HANDLERS

forked:4
favorite:33
lines:517
license : All rights reserved
modified : 2009-06-09 17:39:15

Embed: Tweet

package {

// PRESS "R" + CLICK TO ROTATE.
// DRAG THE GREEN HANDLERS

import net.hires.debug.Stats;
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.KeyboardEvent;
	import flash.events.MouseEvent;
	import flash.geom.ColorTransform;
	import flash.geom.Matrix3D;
	import flash.geom.Rectangle;
	import flash.geom.Vector3D;
	public class DeformableBezier extends Sprite {

//Variables que definen la malla...
		private var initLink : Particula = new Particula();
		private var nodos : Array = new Array();
		private var segmentsU : uint;
		private var segmentsV : uint;
		private var cantidad : Number;

//Puntos de borde...
		private var Xt0 : Vector3D = new Vector3D();
		private var Xt1 : Vector3D = new Vector3D();
		private var Xb0 : Vector3D = new Vector3D();
		private var Xb1 : Vector3D = new Vector3D();

//Puntos de control internos de las bezier...
		private var Cpt : Vector3D = new Vector3D();
		private var Cpb : Vector3D = new Vector3D();
		private var Cpl : Vector3D = new Vector3D();
		private var Cpr : Vector3D = new Vector3D();

//Variable que contiene una referencia de los vectores de creación...
		private var pointsReference : Vector.<Vector3D> = new Vector.<Vector3D>;

//Puntos que controlan el movimiento de los nodos de las curvas... 
		public var angle : Number = 0;

//BitmapData de representación de las partículas...
		private var bmd : BitmapData;
		private var rect : Rectangle;

//Variable que controla la rotación del objeto espacialmente....
		private var rotationMatrix : Matrix3D = new Matrix3D();
		private var rotationParentMatrix : Matrix3D = new Matrix3D();
		private const X_AXIS : Vector3D = new Vector3D(1, 0, 0);
		private const Y_AXIS : Vector3D = new Vector3D(0, 1, 0);
		private var PIVOT_POINT : Vector3D = new Vector3D(0, 0, 0);

//Variable de colorTransform para limpiar el bitmapData...
		private var colorTransform : ColorTransform = new ColorTransform(0, 0, 0, 1, 0, 0, 0);

//Variable que se encarga de la rotación...
		private var rotate : Boolean;
		private var mouse : Boolean;

//Varible que contiene los distintas asas de control...
		private var asasContainer : Sprite = new Sprite();
		private var lineContainer : Sprite = new Sprite();
		private var persp : Number;

//Variable que guarda referencia de las distintas asas de control...
		private var asas : Array = new Array();
		private var pointer : Vector3D;
		private var asasMatrix : Matrix3D;
		private var asasParentMatrix : Matrix3D;

//Variable que guarda una referencia a la perspectiva utilizada en las transformaciones...
		private var focus : Number = 600;
		private var zoom : Number = 3;
                   
                // Variable de inicialización de la rotacion
                private var init : Boolean = false;
                   
		//Constructor...
		public function DeformableBezier() {
			
			var particle : Particula = initLink;
			Particula.focus = focus;
			Particula.zoom = zoom;
			ControlPoint.focus = focus;
			ControlPoint.zoom = zoom;
			var i : uint;
			var lado : Number = 50;
			
			//Defino los puntos de borde...
			Xt0 = new Vector3D(-lado, 0, -lado);
			Xt1 = new Vector3D(lado, 0, -lado);
			
			Xb0 = new Vector3D(-lado, 0, lado);
			Xb1 = new Vector3D(lado, 0, lado);
			
			//Defino los puntos internos de control...
			Cpt = new Vector3D(0, 0, -lado);
			Cpb = new Vector3D(0, 0, lado);
			Cpl = new Vector3D(-lado, 0, 0);
			Cpr = new Vector3D(lado, 0, 0);
			
			//Guardo los vectores en un vector de referencia...
			pointsReference[0] = Xt0;
			pointsReference[1] = Cpt;
			pointsReference[2] = Xt1;
			pointsReference[3] = Cpr;
			pointsReference[4] = Xb1;
			pointsReference[5] = Cpb;
			pointsReference[6] = Xb0;
			pointsReference[7] = Cpl;
			
			//Inserto las distintas asas en el contenedor...
			for (i = 0;i < 8; i++) {
				asas.push(new ControlPoint(i));
				asas[i].addEventListener(ControlPointEvent.CHANGE, updateControlPoints);
				asasContainer.addChild(asas[i]);
			}
			
			asasContainer.x = stage.stageWidth / 2;
			asasContainer.y = stage.stageHeight / 2;
			
			lineContainer.x = stage.stageWidth / 2;
			lineContainer.y = stage.stageHeight / 2;
			
			//Cantidad de puntos a mostrar...
			segmentsV = 60;
			segmentsU = 60;
			
			//Genero los puntos de las partículas...
			var length : uint = segmentsV * segmentsU;
			for(i = 0;i < length; i++) {
				nodos.push(new Vector3D(0, 0, 0));
			}
						
			cantidad = nodos.length - 1;
			i = 0;
			while(cantidad >= 0) {
				particle.position = nodos[i];
				particle.next = new Particula();
				particle = particle.next;
				cantidad--;
				i++;
			}
			
			bmd = new BitmapData(stage.stageWidth, stage.stageHeight, false, 0);
			rect = new Rectangle(0, 0, stage.stageWidth, stage.stageHeight);

addChild(new Bitmap(bmd, "auto", false));
			addChild(lineContainer);
			addChild(asasContainer);
			addChild(new Stats());
			
			//Inicio la animación...
			stage.addEventListener(KeyboardEvent.KEY_DOWN, initRotation);
			stage.addEventListener(KeyboardEvent.KEY_UP, stopRotation);
			stage.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownListener);
			stage.addEventListener(MouseEvent.MOUSE_UP, mouseUpListener);
			stage.addEventListener(MouseEvent.MOUSE_WHEEL, updateZoom);
			stage.addEventListener(Event.ENTER_FRAME, updatePoints);
		}

//Función que se encarga de actualizar los puntos de control...
		private function updateControlPoints(e : ControlPointEvent) : void {
			switch(e.cp) {
				case 0:
					pointsReference[0] = Xt0 = e.vector;
					break;
				case 1:
					pointsReference[1] = Cpt = e.vector;
					break;
				case 2:
					pointsReference[2] = Xt1 = e.vector;
					break;
				case 3:
					pointsReference[3] = Cpr = e.vector;
					break;
				case 4:
					pointsReference[4] = Xb1 = e.vector;
					break;
				case 5:
					pointsReference[5] = Cpb = e.vector;
					break;
				case 6:
					pointsReference[6] = Xb0 = e.vector;
					break;
				case 7:
					pointsReference[7] = Cpl = e.vector;
					break;
			}
			lineContainer.graphics.clear();
			lineContainer.graphics.lineStyle(0, 0XFFFF00, 1);
			for(var i : uint = 0;i < pointsReference.length; i++) {
				if(i == 0) {
					lineContainer.graphics.moveTo(asas[i].x, asas[i].y);
				} else {
					lineContainer.graphics.lineTo(asas[i].x, asas[i].y);
				}					
			}
			lineContainer.graphics.lineTo(asas[0].x, asas[0].y);
		}

//Función que ejecuta la animación de manera secuencial...
		private function updatePoints(e : Event) : void {			
			var particle : Particula = initLink;
			var i : uint = 0;
			
			//Defino las curvas bezier...
			//Top...
			var BT : Array = new Array(Xt0, Cpt, Xt1);
			
			//Bottom...
			var BB : Array = new Array(Xb0, Cpb, Xb1);

//Izquierda...
			var BL : Array = new Array(Xt0, Cpl, Xb0);
			
			//Derecha...
			var BR : Array = new Array(Xt1, Cpr, Xb1);
			
			//Calculo los puntos...	
			nodos = Bezier.getPatch(Xt0, Xt1, Xb0, Xb1, BT, BB, BL, BR, segmentsU, segmentsV);
                        
                        if(!init){
                            init = true;
                            
                            rotationMatrix.identity();
				rotationParentMatrix.identity();
				rotationMatrix.appendRotation(30, Y_AXIS, PIVOT_POINT);
				rotationParentMatrix.appendRotation(30, X_AXIS, PIVOT_POINT);
				
				asasMatrix = rotationMatrix.clone();
				asasParentMatrix = rotationParentMatrix.clone();
				
				lineContainer.graphics.clear();
				lineContainer.graphics.lineStyle(0, 0XFFFF00, 1);
				asasMatrix.invert();
				asasParentMatrix.invert(); 
				
				for(i = 0;i < pointsReference.length; i++) {
					
					pointer = pointsReference[i];
					pointer = rotationMatrix.deltaTransformVector(pointer);
					pointer = rotationParentMatrix.deltaTransformVector(pointer);
					persp = zoom / (1 + pointer.z / focus);
					
					asas[i].persp = persp;
					asas[i].matrix = asasMatrix;
					asas[i].parentMatrix = asasParentMatrix;
					
					if(persp > 0) {
						asas[i].x = pointer.x * persp;
						asas[i].y = pointer.y * persp;
						if(i == 0) {
							lineContainer.graphics.moveTo(asas[i].x, asas[i].y);
						} else {
							lineContainer.graphics.lineTo(asas[i].x, asas[i].y);
						}
					} else {
						asas[i].x = asas[i].y = -10000000;
					}
				}
				lineContainer.graphics.lineTo(asas[0].x, asas[0].y);
                            }
			//Actualizo los asas de control...
			if(rotate && mouse) {
				
				rotationMatrix.identity();
				rotationParentMatrix.identity();
				rotationMatrix.appendRotation(360 * stage.mouseX / stage.stageWidth, Y_AXIS, PIVOT_POINT);
				rotationParentMatrix.appendRotation(90 * stage.mouseY / stage.stageHeight, X_AXIS, PIVOT_POINT);
				
				asasMatrix = rotationMatrix.clone();
				asasParentMatrix = rotationParentMatrix.clone();
				
				lineContainer.graphics.clear();
				lineContainer.graphics.lineStyle(0, 0XFFFF00, 1);
				asasMatrix.invert();
				asasParentMatrix.invert(); 
				
				for(i = 0;i < pointsReference.length; i++) {
					
					pointer = pointsReference[i];
					pointer = rotationMatrix.deltaTransformVector(pointer);
					pointer = rotationParentMatrix.deltaTransformVector(pointer);
					persp = zoom / (1 + pointer.z / focus);
					
					asas[i].persp = persp;
					asas[i].matrix = asasMatrix;
					asas[i].parentMatrix = asasParentMatrix;
					
					if(persp > 0) {
						asas[i].x = pointer.x * persp;
						asas[i].y = pointer.y * persp;
						if(i == 0) {
							lineContainer.graphics.moveTo(asas[i].x, asas[i].y);
						} else {
							lineContainer.graphics.lineTo(asas[i].x, asas[i].y);
						}
					} else {
						asas[i].x = asas[i].y = -10000000;
					}
				}
				lineContainer.graphics.lineTo(asas[0].x, asas[0].y);
			}
			
			i = 0;
			bmd.lock();
			bmd.colorTransform(bmd.rect, colorTransform);
			
			//Actualizo las posiciones de las partículas...
			while(particle.next != null) {
				
				pointer = nodos[i];
				pointer = rotationMatrix.deltaTransformVector(pointer);
				pointer = rotationParentMatrix.deltaTransformVector(pointer);
				particle.position = pointer;

bmd.setPixel(Math.round(stage.stageWidth / 2 + particle.x), Math.round(stage.stageHeight / 2 + particle.y), 0XFFFFFF);
				particle = particle.next;
				i++;
			}
			
			bmd.unlock();
		}

//Función que se encarga de iniciar la rotación...
		private function initRotation(e : KeyboardEvent) : void {
			if(e.charCode == 114) rotate = true;
		}

//Función que para la rotación...
		private function stopRotation(e : KeyboardEvent) : void {
			if(e.charCode == 114) rotate = false;
		}

//Función que señala que el ratón esta presionado...
		private function mouseDownListener(E : MouseEvent) : void {
			mouse = true;
		}

//Función que señala que el ratón esta presionado...
		private function mouseUpListener(E : MouseEvent) : void {
			mouse = false;
		}

//Función que se encarga de modificar el zoom...
		private function updateZoom(e : MouseEvent) : void {
			trace(e.delta);
			zoom += e.delta / 10;
			Particula.zoom = zoom;
			ControlPoint.zoom = zoom;
			var persp : Number;
			lineContainer.graphics.clear();
			lineContainer.graphics.lineStyle(0, 0XFFFF00, 1);
			for(var i : uint = 0;i < pointsReference.length; i++) {
				var pointer : Vector3D = pointsReference[i];
				pointer = rotationMatrix.deltaTransformVector(pointer);
				pointer = rotationParentMatrix.deltaTransformVector(pointer);
				persp = zoom / (1 + pointer.z / focus);
				asas[i].persp = persp;
				var asasMatrix : Matrix3D = rotationMatrix.clone();
				asasMatrix.invert();
				var asasParentMatrix : Matrix3D = rotationParentMatrix.clone();
				asasParentMatrix.invert(); 
				asas[i].matrix = asasMatrix;
				asas[i].parentMatrix = asasParentMatrix;
				if(persp > 0) {
					asas[i].x = pointer.x * persp;
					asas[i].y = pointer.y * persp;
					if(i == 0) {
						lineContainer.graphics.moveTo(asas[i].x, asas[i].y);
					} else {
						lineContainer.graphics.lineTo(asas[i].x, asas[i].y);
					}
				} else {
					asas[i].x = asas[i].y = -10000000;
				}
			}
			lineContainer.graphics.lineTo(asas[0].x, asas[0].y);
		}
	}
}

class MathFunctions {

//Función que se encarga de generar un signo aleatorio...
	public static function signo() : Number {
		return Math.random() >= 0.5 ? 1 : -1;
	}
	//Función que cambia de degrees a radianes...
	public static function radians(angle : Number) : Number {
		return angle * Math.PI / 180;
	}
	//Función que cambia de radianes  adegrees...
	public static function degrees(angle : Number) : Number {
		return angle * 180 / Math.PI;
	}

//Función que se encarga de la combinatoria entre dos números...
	public static function combinatoria(n : Number, i : Number) : Number {
		return factorial(n) / (factorial(i) * factorial(n - i));
	}

//Función que calcula el factorial de un número entero
	public static function factorial(n : Number) : Number {
			
		var i : Number;
		var salida : Number = 1;
		if(n != 0) {
			for(i = 1;i <= n; i++) {
				salida *= i;
			}
		} else {
			salida = 1;
		}
		
		return salida;
	}
	
	
	//Fin del programa....
}

import flash.geom.Vector3D;

/**
 * @author hector arellano
 * Clase que se encarga de generar una parametrización
 * Bezier de trayectoria o superficie.
 * 
 */
class Bezier {
	//Variable que permite tener los datos de la combinatoria para cada grado...
	private static var combinatoriaData : Array = new Array();
	combinatoriaData[0] = [0];
	combinatoriaData[1] = [1];
	
	//A partír de 2 se tienen la cantidad mínima de puntos para interpolar
	combinatoriaData[2] = new Array(1, 1);
	combinatoriaData[3] = new Array(1, 2, 1);
	combinatoriaData[4] = new Array(1, 3, 3, 1);
	combinatoriaData[5] = new Array(1, 4, 6, 4, 1);
	combinatoriaData[6] = new Array(1, 5, 10, 10, 5, 1);
	combinatoriaData[7] = new Array(1, 6, 15, 20, 15, 6, 1);
	combinatoriaData[8] = new Array(1, 7, 21, 35, 35, 21, 7, 1);
	combinatoriaData[9] = new Array(1, 8, 28, 56, 70, 56, 28, 8, 1);
	combinatoriaData[10] = new Array(1, 9, 36, 84, 126, 126, 84, 36, 9, 1);
	combinatoriaData[11] = new Array(1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1);
	combinatoriaData[12] = new Array(1, 11, 56, 165, 330, 462, 462, 330, 165, 56, 11, 1);

//Variables estáticas que permiten guardar los valores de segmentación de la malla (evita recalcular la cantidad de puntos...)
	private static var Ne : uint = 0;
	private static var Nn : uint = 0;
	private static var paramsE : Array = new Array();
	private static var paramsN : Array = new Array();

//Variable que contiene las constantes de la curva bezier para un grado y una parametrización (cantidad de puntos) fija.
	private static var coeficientesCurva : Array = new Array(); 
	//Función que calcula los coeficientes de la curva...
	public static function bezier(t : Number, controlPoints : Array) : Vector3D {
			
		var salida : Vector3D = new Vector3D;
		var coeficientes : Array = new Array();
		var i : uint;
		var n : uint = controlPoints.length - 1;
			
		//Si los valores de la combinatoria para la cantidad de puntos no estan definidos, los defino...
		if(combinatoriaData[controlPoints.length] == undefined) {
			combinatoriaData[controlPoints.length] = setCoeficients(n);
		}
		
		//Determino los coeficientes...
		for (i = 0;i <= n; i++) {
			coeficientes[i] = combinatoriaData[controlPoints.length][i] * Math.pow(t, i) * Math.pow((1 - t), (n - i));
		}
		
		//Obtengo los valores de salida del vector3D...
		for(i = 0;i <= n; i++) {
			salida.x += coeficientes[i] * controlPoints[i].x;
			salida.y += coeficientes[i] * controlPoints[i].y;
			salida.z += coeficientes[i] * controlPoints[i].z;
		}
		salida.w = 1;
		
		return salida;
	}

//Función que se encarga de obtener un conjunto de puntos xyz agrupados en un array para una curva bezier...
	public static function bezierPoints(m : uint, controlPoints : Array) : Vector.<Vector3D> {
		var salida : Vector.<Vector3D> = new Vector.<Vector3D>();
		var n : uint = controlPoints.length - 1;
		var i : uint;
		var j : uint;
		
		//Si los valores de la combinatoria para la cantidad de puntos no estan definidos, los defino...
		if(combinatoriaData[controlPoints.length] == undefined) {
			combinatoriaData[controlPoints.length] = setCoeficients(m);
		}
		
		//Si no hay un arreglo que guarde la referencia para un grado definido, se define...
		if(coeficientesCurva[n] == undefined) {
			coeficientesCurva[n] = new Array();
		}
		
		//Si no hay un arreglo que guarde los coeficientes para "m" puntos se define...
		//Se guarda un arreglo de cuatro dimensiones según la siguiente definición...
		//
		//coeficientes[n][m][j][i] donde:
		//n : grado,
		//m : cantidad de puntos a parametrizar,
		//j : vector de coeficientes para un valor de parametrización perteneciente al rango [0, 1]
		//i : coeficientes a multiplicar por cada punto para la parametrización anterior...
		//
		if(coeficientesCurva[n][m] == undefined) {
			coeficientesCurva[n][m] = new Array();
			for (j = 0;j < m; j++) {
				//Defino la parametrización...
				var delta : Number = j / (m - 1);
				coeficientesCurva[n][m][j] = new Array();
				for(i = 0;i <= n; i++) {
					coeficientesCurva[n][m][j].push(combinatoriaData[controlPoints.length][i] * Math.pow(delta, i) * Math.pow((1 - delta), (n - i)));
				}
			}
		}
		
		//Obtengo los distintos puntos que componen el vector de salida...
		for(j = 0;j < m; j++) {
			var pointer : Vector3D = new Vector3D();
			for(i = 0;i <= n; i++) {
				pointer.x += coeficientesCurva[n][m][j][i] * controlPoints[i].x;
				pointer.y += coeficientesCurva[n][m][j][i] * controlPoints[i].y;
				pointer.z += coeficientesCurva[n][m][j][i] * controlPoints[i].z;
			}
			pointer.w = 1;
			salida.push(pointer);
		}
		
		return salida;
	}
	//Función que se encarga de conseguir todos los puntos de una malla generada por bordes...
	//Entrega los puntos ordenados de la siguiente manera suponiendo un arreglo de 3X3...
	//
	//  0  1  2
	//  3  4  5
	//  6  7  8
	//
	public static function getPatch(Xt0 : Vector3D, Xt1 : Vector3D, Xb0 : Vector3D, Xb1 : Vector3D, BT : Array, BB : Array, BL : Array, BR : Array, Ne : uint = 10, Nn : uint = 10) : Array {
			
		var i : uint;
		var points : Array = new Array();
		
		//Obtengo los puntos de las curvas para interpolar...
		var b_top : Vector.<Vector3D> = Bezier.bezierPoints(Ne, BT);
		var b_bottom : Vector.<Vector3D> = Bezier.bezierPoints(Ne, BB);
		var b_left : Vector.<Vector3D> = Bezier.bezierPoints(Nn, BL);
		var b_right : Vector.<Vector3D> = Bezier.bezierPoints(Nn, BR);
		
		
		//Genero los parámetros si no estan definidos...
		if(Bezier.Ne != Ne && Bezier.Nn != Ne) {
			Bezier.Ne = Ne;
			Bezier.Nn = Nn;
			paramsN = [];
			paramsE = [];
			for (i = 1;i <= Nn; i++) {
				paramsN.push((i - 1) / (Nn - 1));
			}
		
			for (i = 1;i <= Ne; i++) {
				paramsE.push((i - 1) / (Ne - 1));
			}
		}
		
		//Genero el arreglo de puntos...
		var j : uint;
		var jMax : uint = paramsN.length;
		var iMax : uint = paramsE.length;
		for (j = 0;j < jMax; j++) {
			for (i = 0;i < iMax; i++) {
				points.push(TFI(paramsE[i], paramsN[j], b_top[i], b_bottom[i], b_left[j], b_right[j], Xt0, Xt1, Xb0, Xb1));
			}
		}
		
		return points;
	}
	
	//Función que permite liberar la memoria de la clase Bezier...
	public static function clearMemory() : void{
		coeficientesCurva = [];
		paramsN = [];
		paramsE = [];
		combinatoriaData = [];
		
		coeficientesCurva = paramsN = paramsE = combinatoriaData = null;
	}

//Función que genera una interpolación tranfinita TFI para un grupo de cuatro curvas de borde bezier.
	//Se pasan los puntos de borde Xt0, Xt1, Xb0, Xb1 y los valores e, n definidos de 0 a 1 para pasar de
	//estado plano al definido por las cuatro curvas... se busca generar los puntos P intermedios...
	//
	// 
	//  Xt0 Xt Xt Xt Xt Xt Xt Xt1
	//  Xl                     Xr
	//  Xl                     Xr
	//  Xl   P                 Xr
	//  Xl                     Xr
	//  Xl                     Xr
	//  Xl                     Xr
	//  Xl                     Xr
	//  Xb0 Xb Xb Xb Xb Xb Xb Xb1
	//
	//
	private static function TFI(e : Number, n : Number, Xt : Vector3D, Xb : Vector3D, Xl : Vector3D, Xr : Vector3D , Xt0 : Vector3D, Xt1 : Vector3D, Xb0 : Vector3D, Xb1 : Vector3D) : Vector3D {
			
		var TFIPoint : Vector3D = new Vector3D();
			
		//Evalúo la interpolación para cada coordenada del punto, x, y, z...
		TFIPoint.x = (1 - n) * Xt.x + n * Xb.x + (1 - e) * Xl.x + e * Xr.x - (e * n * Xb1.x + e * (1 - n) * Xt1.x + n * (1 - e) * Xb0.x + (1 - n) * (1 - e) * Xt0.x);
		TFIPoint.y = (1 - n) * Xt.y + n * Xb.y + (1 - e) * Xl.y + e * Xr.y - (e * n * Xb1.y + e * (1 - n) * Xt1.y + n * (1 - e) * Xb0.y + (1 - n) * (1 - e) * Xt0.y);
		TFIPoint.z = (1 - n) * Xt.z + n * Xb.z + (1 - e) * Xl.z + e * Xr.z - (e * n * Xb1.z + e * (1 - n) * Xt1.z + n * (1 - e) * Xb0.z + (1 - n) * (1 - e) * Xt0.z);
		TFIPoint.w = 1;
		return TFIPoint;
	}

//Función que realiza un set de los coeficientes en caso que cantidad de puntos sean distintos a los valores almacenados...
	private static function setCoeficients(n : Number) : Array {
		var datos : Array = new Array();
		var i : Number;
		for (i = 0;i <= n; i++) {
			datos.push(MathFunctions.combinatoria(n, i));
		}
		return datos;
	}
		
		
	//fín del programa....
}

import flash.geom.Point;
import flash.geom.Vector3D;
class Particula {

public var next : Particula = null;
	public var x : Number;
	public var y : Number;
	public static var focus : Number = 300;
	public static var zoom : Number = 0;

private var persp : Number;

public function Particula() {
		//En la posición w del vector se define la modificación por la música....
	}
	public function set position(vector : Vector3D) : void {
		persp = zoom * focus / (focus + vector.z);
		if(persp > 0) {
			this.x = vector.x * persp;
			this.y = vector.y * persp;
		} else {
			this.x = this.y = -10000000;
		}
	}
	public function get XY() : Point {
		return new Point(this.x, this.y);
	}
		
	//Fín del programa...
}

import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.geom.Matrix3D;
import flash.geom.Vector3D;	
class ControlPoint extends Sprite {

public var persp : Number;
	public var matrix : Matrix3D;
	public var parentMatrix : Matrix3D;

//Variable que guarda la referencia al punto ...
	private var id : uint;
	private var lado : uint = 7;
	//Variable que guarda una referencia a la perspectiva utilizada en las transformaciones...
	public static var focus : Number = 0;
	public static var zoom : Number = 0;

public function ControlPoint(id : uint) {
		this.id = id;
		graphics.lineStyle(0, 0X00FF00, 1);
		graphics.beginFill(0);
		graphics.drawRect(-lado / 2, -lado / 2, lado, lado);
		this.buttonMode = true;
		
		this.addEventListener(MouseEvent.MOUSE_DOWN, update3DPosition);
	}
	//Función que se encarga de actualizar la posición 3D del asa de tangencia en base a su posición 2D...
	private function update3DPosition(e : MouseEvent) : void {
		this.startDrag();
		trace(id);
		this.addEventListener(Event.ENTER_FRAME, updatePosition);
		stage.addEventListener(MouseEvent.MOUSE_UP, stopDragEvent);
	}
		
		
	//Función que se encarga de actualizar la posición...
	private function updatePosition(e : Event) : void {
		
		var salida : Vector3D = new Vector3D();
		salida.x = this.x / persp;
		salida.y = this.y / persp;
		salida.z = focus * (zoom - persp) / persp;
		
		salida = parentMatrix.deltaTransformVector(salida);
		salida = matrix.deltaTransformVector(salida);
		dispatchEvent(new ControlPointEvent(ControlPointEvent.CHANGE, salida, id));
		
	}
	
	//Función que se encarga de parar el arrastre...
	private function stopDragEvent(e : MouseEvent) : void {
		this.stopDrag();
		this.removeEventListener(Event.ENTER_FRAME, updatePosition);
		stage.removeEventListener(MouseEvent.MOUSE_UP, stopDragEvent);
	}
	//Fín del programa...
}

import flash.events.Event;
import flash.geom.Vector3D;
class ControlPointEvent extends Event {
	
	//Variable estática del tipo de evento..
	public static const CHANGE : String = "CHANGE";
	
	//Puntos del arreglo...
	public var vector : Vector3D;
	public var cp : uint;
	
	//Constructor...
	public function ControlPointEvent(type : String, vector : Vector3D, cp : uint, bubbles : Boolean = false, cancelable : Boolean = false) : void {
		super(type, bubbles, cancelable);
		this.cp = cp;
		this.vector = vector;
	}
	
	//Función que devuelve un clon del evento...
	public override function clone() : Event {
		return new ControlPointEvent(type, vector, cp, bubbles, cancelable);
	}
}

Code Fullscreen

Preview Fullscreen