Section 1
//Parametros (clases.Parametros)
package clases {
public class Parametros {
public var alto:Number;// = 1
public var ancho:Number;// = 1
public var principal:Principal;
public static var nombreFuente:String = "embebida";
public static var calidadStage:String = "low";
private static var getInstanceFunction:Function = Parametros.instantiate;
private static var _instance:Parametros;
public function Parametros(func:Function){
super();
if (func != Parametros.instantiate){
throw (new Error("Parametros se accede con getInstance()"));
};
}
private static function returnInstance():Parametros{
return (_instance);
}
private static function instantiate():Parametros{
if (_instance == null){
_instance = new Parametros(instantiate);
getInstanceFunction = returnInstance;
};
return (_instance);
}
public static function getInstance():Parametros{
return (getInstanceFunction());
}
}
}//package clases
Section 2
//Principal (clases.Principal)
package clases {
import flash.events.*;
import personales.interfaz.deslizadores.*;
import personales.espacios.tresDimensiones.*;
import personales.fisica.*;
import flash.text.*;
import flash.display.*;
import personales.interfaz.botones.*;
import personales.redes.elementos.*;
import personales.interfaz.campos.*;
import personales.utilidades.*;
import personales.grafica.colores.*;
public class Principal extends Sprite {
public var rCirculosFin:Number;// = 20
public var campoEcualizador:TextField;
public var vRotacionFin:Number;// = 0
public var radioFin:Number;// = 200
public var listaPuntos:Array;
public var transparencia:Number;// = 0.5
public var lienzo:Sprite;
public var contenedor:Sprite;
private var ultimoDeslizador:Deslizador;
public var botonMoebio:BotonTextoConURL;
public var botonFS:BotonFullScreen;
public var transparenciaFin:Number;// = 0.5
public var espacio3D:Espacio3D;
public var escalaVentana:Function;
public var matriz:MatrizFuerzas;
public var vRotacion:Number;// = 0
public var nOscila:Number;// = 1
public var nBlurFin:Number;// = 5
public var rCirculos:Number;// = 20
private var ecualizacionesInteresantes:Array;
public var campoMensaje:TextField;
private var t:Number;
public var nBlur:Number;// = 5
public var motorF:MotorFisico;
public var ecualizador:Ecualizador;
public var radio:Number;// = 200
public var nOscilaFin:Number;// = 1
public var superContenedor:Sprite;
public static var parametros:Parametros = Parametros.getInstance();
public static var fuente:String = Parametros.nombreFuente;
public static var nPuntos:uint = 200;
public function Principal(){
escalaVentana = escalaVentana0;
listaPuntos = [];
t = (10 * Math.random());
ecualizacionesInteresantes = [[0.42, 0.19, 0.85, 1, 0.1, 0.34], [0.52, 0.69, 0.76, 0.99, 0.41, 0.74], [0.84, 0.91, 0.22, 0.87, 0.44, 0.41], [0.25, 0.18, 0.25, 0.77, 0.48, 0.94], [0.69, 0.53, 0.62, 0.950464953668416, 0.37, 0.75], [0.51, 0.9, 0.19, 1, 0.23, 0.15], [0.45, 0.41, 0.6, 0.94, 0.88, 0.2], [0.42, 0.26, 0.82, 0.65, 0.6, 0.6], [0.21, 0.46, 0.11, 0.77, 0.07, 0.64], [0.94, 0.96, 0.14, 0.47, 0.97, 0.62]];
super();
parametros.principal = this;
lienzo = new Sprite();
addChild(lienzo);
lienzo.mouseEnabled = false;
superContenedor = new Sprite();
contenedor = new Sprite();
superContenedor.addChild(contenedor);
espacio3D = new Espacio3D(300, contenedor, lienzo);
espacio3D.lienzo = contenedor;
botonFS = new BotonFullScreen(0, Colores.rojo);
addChild(botonFS);
inicio();
}
public function ciclo(e:Event):void{
var nodo:Nodo;
nBlur = (((10 * nBlur) + nBlurFin) / 11);
nOscila = (((100 * nOscila) + nOscilaFin) / 101);
radio = (((10 * radio) + radioFin) / 11);
transparencia = (((100 * transparencia) + transparenciaFin) / 101);
rCirculos = (((20 * rCirculos) + rCirculosFin) / 21);
vRotacion = (((5 * vRotacion) + vRotacionFin) / 6);
t++;
espacio3D.alfa = (espacio3D.alfa + (vRotacion * Math.cos((t * 0.02))));
espacio3D.beta = (espacio3D.beta + (vRotacion * Math.sin((t * 0.02))));
espacio3D.actualizaEjes();
var i:uint;
while (i < nPuntos) {
nodo = listaPuntos[i];
nodo.graphics.clear();
nodo.graphics.beginFill(EscalasColores.escalaTemperatura((i / nPuntos)), transparencia);
nodo.graphics.drawCircle(0, 0, rCirculos);
nodo.centro = Op3D.normalizaPuntoEscalado(nodo.centro, radio);
i++;
};
espacio3D.proyeccion.proyectaObjetosLista(listaPuntos);
espacio3D.proyeccion.nivelaObjetosListaDesordenable(listaPuntos);
PaletasColores.stampaPaletaDesdeFuncionConBlur(lienzo, superContenedor, parametros.ancho, parametros.alto, oscilacion, nBlur);
}
private function oscilacion(t:Number):Number{
return (((Math.sin((((nOscila + 0.5) * Math.PI) * t)) * 0.5) + 0.5));
}
private function cambiaEcualizador(ecualizador:Ecualizador, deslizador:Deslizador, valor:Number):void{
switch (deslizador.n){
case 0:
radioFin = ((deslizador.posY * 500) + 100);
campoEcualizador.text = ("sphere radius = " + String(Math.floor(radioFin)));
break;
case 1:
rCirculosFin = ((deslizador.posY * 100) + 1);
campoEcualizador.text = ("circles radius = " + String(Math.floor(rCirculosFin)));
break;
case 2:
nBlurFin = (Math.pow(deslizador.posY, 2) * 300);
campoEcualizador.text = ("blur = " + String(Math.floor(nBlurFin)));
break;
case 3:
nOscilaFin = (Math.pow(deslizador.posY, 2) * 20);
campoEcualizador.text = ("color oscillation frequency = " + String((Math.floor((nOscilaFin * 10)) / 10)));
break;
case 4:
transparenciaFin = deslizador.posY;
campoEcualizador.text = ("alpha channel circles = " + String((Math.floor((transparenciaFin * 100)) / 100)));
break;
case 5:
vRotacionFin = ((Math.pow(deslizador.posY, 3) * 0.12) + 0.001);
campoEcualizador.text = ("rotation speed = " + String((Math.floor((vRotacionFin * 1000)) / 100)));
break;
};
ultimoDeslizador = deslizador;
campoEcualizador.y = (((1 - deslizador.posY) * 100) + 20);
if (ultimoDeslizador.presionado){
campoEcualizador.visible = true;
} else {
campoEcualizador.visible = false;
};
}
private function traceEcualizacion():void{
var ecualizacion:String = "[";
var i:uint;
while (i < ecualizador.nDeslizadores) {
ecualizacion = (ecualizacion + (String((Math.floor((100 * Deslizador(ecualizador.listaDeslizadores[i]).posY)) / 100)) + ", "));
i++;
};
ecualizacion = (ecualizacion.substr(0, (ecualizacion.length - 2)) + "], ");
trace(ecualizacion);
}
public function escalaVentana0(ancho:Number, alto:Number):void{
contenedor.x = Math.floor((ancho * 0.5));
contenedor.y = Math.floor((alto * 0.5));
botonFS.x = ((ancho - botonFS.width) - 10);
botonFS.y = ((alto - botonFS.height) - 10);
botonMoebio.x = ((botonFS.x - botonMoebio.width) + 1);
botonMoebio.y = botonFS.y;
campoMensaje.x = ((botonMoebio.x - campoMensaje.width) + 1);
campoMensaje.y = botonFS.y;
}
public function escalaVentana1(ancho:Number, alto:Number):void{
escalaVentana0(ancho, alto);
}
private function clicaRandom(me:MouseEvent):void{
var i:uint;
var config:Array;
if (!ecualizador.hitTestPoint(mouseX, mouseY)){
if (Math.random() < 0.6){
i = 0;
while (i < ecualizador.nDeslizadores) {
Deslizador(ecualizador.listaDeslizadores[i]).fuerza(Math.random());
i++;
};
} else {
config = ecualizacionesInteresantes[Math.floor((Math.random() * ecualizacionesInteresantes.length))];
i = 0;
while (i < ecualizador.nDeslizadores) {
Deslizador(ecualizador.listaDeslizadores[i]).fuerza(config[i]);
i++;
};
};
};
traceEcualizacion();
}
public function inicio():void{
var nodo:Nodo;
var i:uint;
while (i < nPuntos) {
nodo = new Nodo();
contenedor.addChild(nodo);
listaPuntos.push(nodo);
i++;
};
motorF = new MotorFisico(1);
matriz = Disposiciones3D.esfera(listaPuntos, radio);
campoEcualizador = CreaCampos.creaCampoSimpleConFuenteEmbebida(10);
addChild(campoEcualizador);
campoEcualizador.x = 90;
campoEcualizador.y = 100;
campoEcualizador.visible = false;
ecualizador = new Ecualizador(6, cambiaEcualizador, Arreglos.creaArregloDe(0.5, 6), 120, 12, 10, 0, Colores.blanco, 0);
addChild(ecualizador);
ecualizador.x = 20;
ecualizador.y = 20;
botonMoebio = new BotonTextoConURL("moebio |", "http://moebio.com/santiago", true, 0, Colores.rojo, 0, 0, 10, 0);
addChild(botonMoebio);
campoMensaje = CreaCampos.creaCampoSimpleConFuenteEmbebida(10, "click anywhere to set random parameters |", 0);
addChild(campoMensaje);
campoMensaje.width;
buttonMode = true;
useHandCursor = true;
addEventListener(MouseEvent.CLICK, clicaRandom, false, -1);
this.addEventListener(Event.ENTER_FRAME, ciclo);
}
}
}//package clases
Section 3
//FontAsset (mx.core.FontAsset)
package mx.core {
import flash.text.*;
public class FontAsset extends Font implements IFlexAsset {
mx_internal static const VERSION:String = "3.0.0.0";
public function FontAsset(){
super();
}
}
}//package mx.core
Section 4
//IFlexAsset (mx.core.IFlexAsset)
package mx.core {
public interface IFlexAsset {
}
}//package mx.core
Section 5
//mx_internal (mx.core.mx_internal)
package mx.core {
public namespace mx_internal = "http://www.adobe.com/2006/flex/mx/internal";
}//package mx.core
Section 6
//Mallado3D (personales.espacios.tresDimensiones.bitmap3D.Mallado3D)
package personales.espacios.tresDimensiones.bitmap3D {
import personales.espacios.tresDimensiones.*;
import flash.display.*;
import flash.geom.*;
import personales.espacios.tresDimensiones.objetosTridimensionales.*;
public class Mallado3D extends ObjetoTridimensional {
public var matriz3D:Array;
public var matriz2D:Array;
public function Mallado3D(m:uint, n:uint, ancho:Number, alto:Number, centro:Punto3D=null){
var j:uint;
matriz2D = [];
matriz3D = [];
super();
this.m = m;
this.n = n;
this.ancho = ancho;
this.alto = alto;
if (centro == null){
centro = new Punto3D();
};
_centro = centro;
var i:uint;
while (i < m) {
matriz2D[i] = [];
matriz3D[i] = [];
j = 0;
while (j < n) {
matriz3D[i][j] = new Punto3D(((((ancho * i) / (m - 1)) - (ancho * 0.5)) + centro.x), ((((alto * j) / (n - 1)) - (alto * 0.5)) + centro.y), centro.z);
matriz2D[i][j] = new Point(0, 0);
j++;
};
i++;
};
}
override public function set beta(beta:Number):void{
_beta = beta;
modificaMallado();
}
public function asignaCoordenadas3D(matrizTriangulos:Array):void{
var triangulo:ObjetoTridimensional;
var j:uint;
var i:uint;
while (i < (m - 1)) {
j = 0;
while (j < (n - 1)) {
triangulo = matrizTriangulos[i][j][0];
triangulo.graphics.clear();
triangulo.centro = Op3D.centroGravedadListaCoordenadas([matriz3D[i][j], matriz3D[(i + 1)][j], matriz3D[i][(j + 1)]]);
triangulo = matrizTriangulos[i][j][1];
triangulo.graphics.clear();
triangulo.centro = Op3D.centroGravedadListaCoordenadas([matriz3D[(i + 1)][j], matriz3D[(i + 1)][(j + 1)], matriz3D[i][(j + 1)]]);
j++;
};
i++;
};
}
public function graficaMallado(malladoB:MalladoBitmap, colorMallado:uint):void{
var j:uint;
var tri:TrianguloMalla;
var matriz:Array = matriz2D;
var i:uint;
while (i < (m - 1)) {
j = 0;
while (j < (n - 1)) {
tri = malladoB.matrizTriangulos[i][j][0];
tri.graphics.lineStyle(1, colorMallado, 0.7);
tri.graphics.moveTo(matriz[i][(j + 1)].x, matriz2D[i][(j + 1)].y);
tri.graphics.lineTo(matriz[i][j].x, matriz2D[i][j].y);
tri.graphics.lineTo(matriz[(i + 1)][j].x, matriz2D[(i + 1)][j].y);
tri.graphics.lineTo(matriz[i][(j + 1)].x, matriz2D[i][(j + 1)].y);
tri = malladoB.matrizTriangulos[i][j][1];
tri.graphics.lineStyle(1, colorMallado, 0.7);
tri.graphics.moveTo(matriz[i][(j + 1)].x, matriz2D[i][(j + 1)].y);
tri.graphics.lineTo(matriz[(i + 1)][(j + 1)].x, matriz2D[(i + 1)][(j + 1)].y);
tri.graphics.lineTo(matriz[(i + 1)][j].x, matriz2D[(i + 1)][j].y);
tri.graphics.lineTo(matriz[i][(j + 1)].x, matriz2D[i][(j + 1)].y);
j++;
};
i++;
};
}
public function cambiaParametros(centro:Punto3D, alfa:Number, beta:Number):void{
_alfa = alfa;
_beta = beta;
_centro = centro;
modificaMallado();
}
override public function set centro(centro:Punto3D):void{
_centro = centro;
modificaMallado();
}
public function addTriangulos(contenedor:Sprite, matrizTriangulos:Array):void{
var triangulo:ObjetoTridimensional;
var j:uint;
var i:uint;
while (i < (m - 1)) {
j = 0;
while (j < (n - 1)) {
triangulo = matrizTriangulos[i][j][0];
contenedor.addChild(triangulo);
triangulo = matrizTriangulos[i][j][1];
contenedor.addChild(triangulo);
j++;
};
i++;
};
}
override public function set alfa(alfa:Number):void{
_alfa = alfa;
modificaMallado();
}
private function modificaMallado():void{
var j:uint;
var i:uint;
while (i < m) {
matriz3D[i] = [];
j = 0;
while (j < n) {
matriz3D[i][j] = Op3D.sumaDosPuntos(Espacio3D.funcionRotacionInversa(new Punto3D((((ancho * i) / (m - 1)) - (ancho * 0.5)), (((alto * j) / (n - 1)) - (alto * 0.5)), 0), _alfa, _beta, _gama), centro);
j++;
};
i++;
};
}
public function regenera(m:uint, n:uint, ancho:Number, alto:Number, centro:Punto3D=null):void{
var j:uint;
this.m = m;
this.n = n;
this.ancho = ancho;
this.alto = alto;
var i:uint;
while (i < m) {
matriz2D[i] = [];
matriz3D[i] = [];
j = 0;
while (j < n) {
matriz3D[i][j] = new Punto3D(((((ancho * i) / (m - 1)) - (ancho * 0.5)) + centro.x), ((((alto * j) / (n - 1)) - (alto * 0.5)) + centro.y), centro.z);
matriz2D[i][j] = new Point(0, 0);
j++;
};
i++;
};
}
public function aplicaFuncionSobreMallado(funcionRRaRRR:Function):void{
var j:uint;
var i:uint;
while (i < m) {
j = 0;
while (j < n) {
matriz3D[i][j] = funcionRRaRRR(new Point((i / m), (j / n)));
j++;
};
i++;
};
}
public function actualizaMatriz2D(espacio3D:Espacio3D):void{
var j:uint;
var coordenadas2D:Point;
var par2D:Point;
var i:uint;
while (i < m) {
j = 0;
while (j < n) {
par2D = matriz2D[i][j];
if (espacio3D.profundidad(matriz3D[i][j]) < (-(espacio3D.l) + 10)){
matriz2D[i][j].x = Infinity;
} else {
coordenadas2D = espacio3D.calculaCoordenadas2D(matriz3D[i][j]);
par2D.x = coordenadas2D.x;
par2D.y = coordenadas2D.y;
};
j++;
};
i++;
};
}
}
}//package personales.espacios.tresDimensiones.bitmap3D
Section 7
//MalladoBitmap (personales.espacios.tresDimensiones.bitmap3D.MalladoBitmap)
package personales.espacios.tresDimensiones.bitmap3D {
import flash.display.*;
import flash.geom.*;
public class MalladoBitmap {
private var lado:Number;
private var shape:Sprite;
public var matriz:Array;
private var m:uint;
private var n:uint;
public var matrizTriangulos:Array;
private var alto:Number;
private var bitmapData:BitmapData;
public function MalladoBitmap(bitmapData:BitmapData, matriz2D:Array, shape:Sprite){
super();
this.shape = shape;
this.matriz = matriz2D;
this.bitmapData = bitmapData;
m = matriz.length;
n = matriz[0].length;
triangulosDesdeMatrizBitmap();
}
public function renderizaTriangulos():void{
var triangulo:TrianguloMalla;
var j:uint;
var i:uint;
while (i < (m - 1)) {
j = 0;
while (j < (n - 1)) {
if (matriz[i][j].x != Infinity){
triangulo = matrizTriangulos[i][j][0];
if (((((!((triangulo.puntos[0].x == Infinity))) && (!((triangulo.puntos[1].x == Infinity))))) && (!((triangulo.puntos[2].x == Infinity))))){
renderizaTriangulo(triangulo, shape);
} else {
triangulo.graphics.clear();
};
triangulo = matrizTriangulos[i][j][1];
if (((((!((triangulo.puntos[0].x == Infinity))) && (!((triangulo.puntos[1].x == Infinity))))) && (!((triangulo.puntos[2].x == Infinity))))){
renderizaTriangulo(triangulo, shape);
} else {
triangulo.graphics.clear();
};
} else {
triangulo = matrizTriangulos[i][j][0];
triangulo.graphics.clear();
triangulo = matrizTriangulos[i][j][1];
triangulo.graphics.clear();
};
j++;
};
i++;
};
}
public function renderizaTriangulos3D():void{
var triangulo:TrianguloMalla;
var j:uint;
var i:uint;
while (i < (m - 1)) {
j = 0;
while (j < (n - 1)) {
triangulo = matrizTriangulos[i][j][0];
renderizaTriangulo(triangulo, triangulo);
triangulo = matrizTriangulos[i][j][1];
renderizaTriangulo(triangulo, triangulo);
j++;
};
i++;
};
}
public function triangulosDesdeMatrizBitmap():void{
var i:uint;
var j:uint;
var p0:Point;
var p1:Point;
var p2:Point;
var p3:Point;
var _w:Number = bitmapData.width;
var _h:Number = bitmapData.height;
lado = (_w / (matriz.length - 1));
alto = (_h / (matriz[0].length - 1));
matrizTriangulos = [];
i = 0;
while (i < (m - 1)) {
matrizTriangulos[i] = [];
j = 0;
while (j < (n - 1)) {
matrizTriangulos[i][j] = [];
p0 = new Point((i * lado), (j * alto));
p1 = new Point((i * lado), ((j + 1) * alto));
p2 = new Point(((i + 1) * lado), (j * alto));
p3 = new Point(((i + 1) * lado), ((j + 1) * alto));
matrizTriangulos[i][j][0] = cortaTriangulo([p0, p1, p2], p0, [matriz[i][j], matriz[i][(j + 1)], matriz[(i + 1)][j]], matriz[i][j]);
matrizTriangulos[i][j][1] = cortaTriangulo([p3, p1, p2], p0, [matriz[(i + 1)][(j + 1)], matriz[i][(j + 1)], matriz[(i + 1)][j]], matriz[i][j]);
j++;
};
i++;
};
}
private function cortaTriangulo(triRecorte:Array, origenBitmap:Point, trifinal:Array=null, origenFinal:Point=null, spriteRenderiza:Sprite=null):TrianguloMalla{
var xMin:Number = triRecorte[0].x;
var xMax:Number = triRecorte[0].x;
var yMin:Number = triRecorte[0].y;
var yMax:Number = triRecorte[0].y;
var i:uint;
while (i < 3) {
xMin = Math.min(xMin, triRecorte[i].x);
xMax = Math.max(xMax, triRecorte[i].x);
yMin = Math.min(yMin, triRecorte[i].y);
yMax = Math.max(yMax, triRecorte[i].y);
i++;
};
var ancho:Number = (xMax - xMin);
var alto:Number = (yMax - yMin);
var bitmapDataCortado:BitmapData = new BitmapData(ancho, alto);
var rect:Rectangle = new Rectangle(xMin, yMin, ancho, alto);
var pt:Point = new Point(0, 0);
bitmapDataCortado.copyPixels(this.bitmapData, rect, pt);
return (new TrianguloMalla(trifinal, origenFinal, bitmapDataCortado));
}
public function regenera(bitmapData:BitmapData, matriz:Array):void{
this.matriz = matriz;
this.bitmapData = bitmapData;
m = matriz.length;
n = matriz[0].length;
triangulosDesdeMatrizBitmap();
}
private function actualizaBitmapTriangulo(tri:TrianguloMalla, triRecorte:Array):void{
var xMin:Number = triRecorte[0].x;
var xMax:Number = triRecorte[0].x;
var yMin:Number = triRecorte[0].y;
var yMax:Number = triRecorte[0].y;
var i:uint;
while (i < 3) {
xMin = Math.min(xMin, triRecorte[i].x);
xMax = Math.max(xMax, triRecorte[i].x);
yMin = Math.min(yMin, triRecorte[i].y);
yMax = Math.max(yMax, triRecorte[i].y);
i++;
};
var ancho:Number = (xMax - xMin);
var alto:Number = (yMax - yMin);
var bitmapDataCortado:BitmapData = new BitmapData(ancho, alto);
var rect:Rectangle = new Rectangle(xMin, yMin, ancho, alto);
var pt:Point = new Point(0, 0);
bitmapDataCortado.copyPixels(bitmapData, rect, pt);
tri.actualizaBitmap(bitmapDataCortado);
}
public function actualizaBitmapData(bitmapData:BitmapData):void{
var j:uint;
var p0:Point;
var p1:Point;
var p2:Point;
var p3:Point;
this.bitmapData = bitmapData;
lado = (bitmapData.width / (matriz.length - 1));
alto = (bitmapData.height / (matriz[0].length - 1));
var i:uint;
while (i < (m - 1)) {
j = 0;
while (j < (n - 1)) {
p0 = new Point((i * lado), (j * alto));
p1 = new Point((i * lado), ((j + 1) * alto));
p2 = new Point(((i + 1) * lado), (j * alto));
p3 = new Point(((i + 1) * lado), ((j + 1) * alto));
actualizaBitmapTriangulo(matrizTriangulos[i][j][0], [p0, p1, p2]);
actualizaBitmapTriangulo(matrizTriangulos[i][j][1], [p3, p1, p2]);
j++;
};
i++;
};
}
public static function creaMatrizBitmap(bmpData:BitmapData, dimensiones:Array):Array{
var j:uint;
var _w:Number = bmpData.width;
var _h:Number = bmpData.height;
var matriz:Array = new Array();
var lado:Number = (_w / (dimensiones[0] - 1));
var alto:Number = (_h / (dimensiones[1] - 1));
var i:uint;
while (i < dimensiones[0]) {
matriz[i] = [];
j = 0;
while (j < dimensiones[1]) {
matriz[i][j] = new Point((i * lado), (j * alto));
j++;
};
i++;
};
return (matriz);
}
public static function renderizaTriangulo(tri:TrianguloMalla, shape:Sprite):void{
var punto:Point;
var t:Number;
var vertices:Array;
var p0:Point;
var p1:Point;
var p2:Point;
var tl:Point;
var br_x:Number;
var br_y:Number;
var br:Point;
var tl_x:Number;
var tl_y:Number;
var bitmapDataCortado:BitmapData = tri.bitmapData;
var _w:Number = bitmapDataCortado.width;
var _h:Number = bitmapDataCortado.height;
var tr:Point = tri.puntos[2];
var bl:Point = tri.puntos[1];
if ((((tri.puntos[0].x == tri.origenBitmap.x)) && ((tri.puntos[0].y == tri.origenBitmap.y)))){
tl = tri.origenBitmap;
br_x = (tr.x - (tl.x - bl.x));
br_y = (tr.y - (tl.y - bl.y));
br = new Point(br_x, br_y);
} else {
br = tri.puntos[0];
tl_x = (bl.x - (br.x - tr.x));
tl_y = (bl.y - (br.y - tr.y));
tl = new Point(tl_x, tl_y);
};
var _xMin:Number = tl.x;
var _yMin:Number = tl.y;
var dx30:Number = (bl.x - tl.x);
var dy30:Number = (bl.y - tl.y);
var dx21:Number = (br.x - tr.x);
var dy21:Number = (br.y - tr.y);
var gx:Number = ((tl.x - _xMin) / _w);
var gy:Number = ((tl.y - _yMin) / _h);
var bx:Number = (tl.x + (gy * dx30));
var by:Number = (tl.y + (gy * dy30));
var tlsx:Number = (bx + (gx * ((tr.x + (gy * dx21)) - bx)));
var tlsy:Number = (by + (gx * ((tr.y + (gy * dy21)) - by)));
var sP:Array = [];
var i:int;
while (i < 3) {
sP[i] = new Point(0, 0);
punto = tri.puntos[i];
gx = ((punto.x - _xMin) / _w);
gy = ((punto.y - _yMin) / _h);
bx = (tl.x + (gy * dx30));
by = (tl.y + (gy * dy30));
sP[i].x = (bx + (gx * ((tr.x + (gy * dx21)) - bx)));
sP[i].y = (by + (gx * ((tr.y + (gy * dy21)) - by)));
i++;
};
var _sMat:Matrix = new Matrix();
var _tMat:Matrix = new Matrix();
p0 = tri.puntos[0];
p1 = tri.puntos[1];
p2 = tri.puntos[2];
var x0:Number = tlsx;
var y0:Number = tlsy;
var x1:Number = sP[1].x;
var y1:Number = sP[1].y;
var x2:Number = sP[2].x;
var y2:Number = sP[2].y;
var u0:Number = tl.x;
var v0:Number = tl.y;
var u1:Number = p1.x;
var v1:Number = p1.y;
var u2:Number = p2.x;
var v2:Number = p2.y;
_tMat.tx = 0;
_tMat.ty = 0;
_tMat.a = ((u1 - u0) / _w);
_tMat.b = ((v1 - v0) / _w);
_tMat.c = ((u2 - u0) / _h);
_tMat.d = ((v2 - v0) / _h);
_sMat.a = ((x1 - x0) / _w);
_sMat.b = ((y1 - y0) / _w);
_sMat.c = ((x2 - x0) / _h);
_sMat.d = ((y2 - y0) / _h);
_sMat.tx = x0;
_sMat.ty = y0;
_tMat.invert();
_tMat.concat(_sMat);
shape.graphics.beginBitmapFill(bitmapDataCortado, _tMat, false, true);
shape.graphics.moveTo(p0.x, p0.y);
shape.graphics.lineTo(p1.x, p1.y);
shape.graphics.lineTo(p2.x, p2.y);
shape.graphics.endFill();
}
}
}//package personales.espacios.tresDimensiones.bitmap3D
Section 8
//RectanguloImagen3D (personales.espacios.tresDimensiones.bitmap3D.RectanguloImagen3D)
package personales.espacios.tresDimensiones.bitmap3D {
import personales.espacios.tresDimensiones.*;
import flash.display.*;
import personales.espacios.tresDimensiones.objetosTridimensionales.*;
public class RectanguloImagen3D extends ObjetoTridimensional {
private var resolucionHorizontal:uint;
public var malladoB:MalladoBitmap;
private var resolucionVertical:uint;
public var mallado:Mallado3D;
public var bitmapData:BitmapData;
public function RectanguloImagen3D(bitmapData:BitmapData, centro:Punto3D, resolucionHorizontal:uint=3, resolucionVertical:uint=3){
super();
_centro = centro;
this.resolucionHorizontal = resolucionHorizontal;
this.resolucionVertical = resolucionVertical;
this.ancho = bitmapData.width;
this.alto = bitmapData.height;
mallado = new Mallado3D(resolucionHorizontal, resolucionVertical, ancho, alto, centro);
malladoB = new MalladoBitmap(bitmapData, mallado.matriz2D, this);
}
override public function set beta(beta:Number):void{
_beta = beta;
mallado.beta = _beta;
}
override public function set alfa(alfa:Number):void{
_alfa = alfa;
mallado.alfa = _alfa;
}
override public function set centro(centro:Punto3D):void{
_centro = centro;
mallado.centro = _centro;
}
public function regenera(bitmapData:BitmapData, centro:Punto3D, resolucionHorizontal:uint=3, resolucionVertical:uint=3):void{
_centro = centro;
this.resolucionHorizontal = resolucionHorizontal;
this.resolucionVertical = resolucionVertical;
this.ancho = bitmapData.width;
this.alto = bitmapData.height;
mallado.regenera(resolucionHorizontal, resolucionVertical, ancho, alto, centro);
malladoB.regenera(bitmapData, mallado.matriz2D);
}
}
}//package personales.espacios.tresDimensiones.bitmap3D
Section 9
//TrianguloMalla (personales.espacios.tresDimensiones.bitmap3D.TrianguloMalla)
package personales.espacios.tresDimensiones.bitmap3D {
import flash.display.*;
import flash.geom.*;
import personales.espacios.tresDimensiones.objetosTridimensionales.*;
public class TrianguloMalla extends ObjetoTridimensional {
public var bitmapData:BitmapData;
public var origenBitmap:Point;
public var puntos:Array;
public function TrianguloMalla(puntos:Array, origenBitmap:Point, bitmapData:BitmapData, spriteFinal:Sprite=null){
super();
this.bitmapData = bitmapData;
this.puntos = puntos;
this.origenBitmap = origenBitmap;
}
public function actualizaBitmap(bitmapData:BitmapData):void{
this.bitmapData = bitmapData;
}
}
}//package personales.espacios.tresDimensiones.bitmap3D
Section 10
//GraficaCurvas3D (personales.espacios.tresDimensiones.graficadores.GraficaCurvas3D)
package personales.espacios.tresDimensiones.graficadores {
import personales.espacios.tresDimensiones.*;
import flash.display.*;
import personales.espacios.tresDimensiones.objetosTridimensionales.*;
public class GraficaCurvas3D {
public var ii:Punto3D;
public var kk:Punto3D;
public var centro:Punto3D;
public var jj:Punto3D;
public var lienzo:Sprite;
public var espacio3D:Espacio3D;
public static var planoCorte:Number = 10;
public static var Pi2:Number = 6.28318530717959;
public function GraficaCurvas3D(espacio3D:Espacio3D){
super();
this.espacio3D = espacio3D;
centro = espacio3D.centro;
lienzo = espacio3D._lienzo;
ii = espacio3D.ii;
jj = espacio3D.jj;
kk = espacio3D.kk;
}
public function trazaArcoCentrado3D(ambito:Sprite, p0:Punto3D, p1:Punto3D):void{
var p:Punto3D;
var normaMedia:Number = ((Op3D.normaPunto(p0) + Op3D.normaPunto(p1)) * 0.5);
var d:Number = Op3D.distanciaPuntos(p0, p1);
var nSaltos:uint = Math.floor((d / 10));
espacio3D.lienzo = ambito;
moveTo3D(p0);
var i:uint = 1;
while (i < nSaltos) {
p = Op3D.normalizaPuntoEscalado(Op3D.interpolacion(p0, p1, (i / (nSaltos - 1))), normaMedia);
lineTo3D(p);
i++;
};
}
public function moveTo3D(punto:Punto3D):void{
var l:Number = espacio3D.l;
punto = new Punto3D((punto.x - centro.x), (punto.y - centro.y), (punto.z - centro.z));
var prescala:Number = (l / (l + Math.max((((ii.z * punto.x) + (jj.z * punto.y)) + (kk.z * punto.z)), (1 - l))));
lienzo.graphics.moveTo(((((ii.x * punto.x) + (jj.x * punto.y)) + (kk.x * punto.z)) * prescala), ((((ii.y * punto.x) + (jj.y * punto.y)) + (kk.y * punto.z)) * prescala));
}
public function curveTo3D(control:Punto3D, punto:Punto3D):void{
var l:Number = espacio3D.l;
control = new Punto3D((control.x - centro.x), (control.y - centro.y), (control.z - centro.z));
punto = new Punto3D((punto.x - centro.x), (punto.y - centro.y), (punto.z - centro.z));
var prescala:Number = (l / (l + Math.max((((ii.z * punto.x) + (jj.z * punto.y)) + (kk.z * punto.z)), (1 - l))));
lienzo.graphics.curveTo(((((ii.x * control.x) + (jj.x * control.y)) + (kk.x * control.z)) * prescala), ((((ii.y * control.x) + (jj.y * control.y)) + (kk.y * control.z)) * prescala), ((((ii.x * punto.x) + (jj.x * punto.y)) + (kk.x * punto.z)) * prescala), ((((ii.y * punto.x) + (jj.y * punto.y)) + (kk.y * punto.z)) * prescala));
}
public function graficaMalladoEnObjeto(ot:ObjetoTridimensional):void{
var j:uint;
var matriz3D:Array = ot.rectanguloImagen3D.mallado.matriz3D;
espacio3D.lienzo = ot;
ot.graphics.lineStyle(0, 0xFF);
var i:uint;
while (i < (matriz3D.length - 1)) {
j = 0;
while (j < (matriz3D[i].length - 1)) {
moveTo3D(matriz3D[i][(j + 1)]);
lineTo3D(matriz3D[i][j]);
lineTo3D(matriz3D[(i + 1)][j]);
lineTo3D(matriz3D[i][(j + 1)]);
j++;
};
i++;
};
}
public function trazaArcoEjeZ(p0:Punto3D, p1:Punto3D, signo:Number=1):void{
var p:Punto3D;
var d:Number = Op3D.distanciaPuntos(p0, p1);
var nSaltos:uint = Math.floor((d / 10));
var t:Number = 0;
moveTo3D(p0);
var i:uint = 1;
while (i < nSaltos) {
t = ((1 - Math.cos(((Math.PI * i) / (nSaltos - 1)))) * 0.5);
p = Op3D.interpolacion(p0, p1, t);
p.z = (((signo * 0.5) * d) * Math.sin(((Math.PI * i) / (nSaltos - 1))));
lineTo3D(p);
i++;
};
}
public function ejes(lado:Number):void{
lienzo.graphics.lineStyle(0, (0xFF << 16));
moveTo3D(new Punto3D(lado, 0, 0));
lineTo3D(new Punto3D(0, 0, 0));
lienzo.graphics.lineStyle(0, (0xFF << 8));
lineTo3D(new Punto3D(0, lado, 0));
moveTo3D(new Punto3D(0, 0, 0));
lienzo.graphics.lineStyle(0, 0xFF);
lineTo3D(new Punto3D(0, 0, lado));
}
public function puntoInterseccion(punto0:Punto3D, punto1:Punto3D):Array{
var t:Number;
var puntoM:Array;
var prescalaM:Number;
var l:Number = espacio3D.l;
var puntoInterseccion:Array;
this.centro = espacio3D.centro;
punto0 = new Punto3D((punto0.x - centro.x), (punto0.y - centro.y), (punto0.z - centro.z));
var prescala0:Number = (l / (((l + (ii.z * punto0.x)) + (jj.z * punto0.y)) + (kk.z * punto0.z)));
punto1 = new Punto3D((punto1.x - centro.x), (punto1.y - centro.y), (punto1.z - centro.z));
var prescala1:Number = (l / (((l + (ii.z * punto1.x)) + (jj.z * punto1.y)) + (kk.z * punto1.z)));
if ((((((prescala0 >= 0)) && ((prescala1 < 0)))) || ((((prescala0 < 0)) && ((prescala1 >= 0)))))){
punto0 = new Punto3D((((ii.x * punto0.x) + (jj.x * punto0.y)) + (kk.x * punto0.z)), (((ii.y * punto0.x) + (jj.y * punto0.y)) + (kk.y * punto0.z)), (((ii.z * punto0.x) + (jj.z * punto0.y)) + (kk.z * punto0.z)));
punto1 = new Punto3D((((ii.x * punto1.x) + (jj.x * punto1.y)) + (kk.x * punto1.z)), (((ii.y * punto1.x) + (jj.y * punto1.y)) + (kk.y * punto1.z)), (((ii.z * punto1.x) + (jj.z * punto1.y)) + (kk.z * punto1.z)));
t = (((-(l) + planoCorte) - punto0.z) / (punto1.z - punto0.z));
puntoM = [(punto0.x + (t * (punto1.x - punto0.x))), (punto0.y + (t * (punto1.y - punto0.y))), (-(l) + planoCorte)];
prescalaM = (l / (l + puntoM[2]));
if (prescala0 > 0){
puntoInterseccion = [((punto0.x * prescala0) + ((puntoM[0] * prescalaM) - (punto0.x * prescala0))), ((punto0.y * prescala0) + ((puntoM[1] * prescalaM) - (punto0.y * prescala0)))];
} else {
puntoInterseccion = [((punto1.x * prescala1) + ((puntoM[0] * prescalaM) - (punto1.x * prescala1))), ((punto1.y * prescala1) + ((puntoM[1] * prescalaM) - (punto1.y * prescala1)))];
};
};
return (puntoInterseccion);
}
public function lineTo3D(punto:Punto3D):void{
var l:Number = espacio3D.l;
punto = new Punto3D((punto.x - centro.x), (punto.y - centro.y), (punto.z - centro.z));
var prescala:Number = (l / (l + Math.max((((ii.z * punto.x) + (jj.z * punto.y)) + (kk.z * punto.z)), (1 - l))));
lienzo.graphics.lineTo(((((ii.x * punto.x) + (jj.x * punto.y)) + (kk.x * punto.z)) * prescala), ((((ii.y * punto.x) + (jj.y * punto.y)) + (kk.y * punto.z)) * prescala));
}
public function curva3D(punto0:Punto3D, control:Punto3D, punto1:Punto3D):void{
var pI0c:Array = puntoInterseccion(punto0, control);
var pI01:Array = puntoInterseccion(punto0, punto1);
var pIc1:Array = puntoInterseccion(control, punto1);
if ((((((pI0c == null)) && ((pI01 == null)))) && ((pIc1 == null)))){
moveTo3D(punto0);
curveTo3D(control, punto1);
} else {
if (((!((pI0c == null))) && (!((pI01 == null))))){
};
};
}
public function linea3D(punto0:Punto3D, punto1:Punto3D):void{
var t:Number;
var puntoM:Array;
var prescalaM:Number;
var l:Number = espacio3D.l;
punto0 = new Punto3D((punto0.x - centro.x), (punto0.y - centro.y), (punto0.z - centro.z));
var prescala0:Number = (l / (((l + (ii.z * punto0.x)) + (jj.z * punto0.y)) + (kk.z * punto0.z)));
punto1 = new Punto3D((punto1.x - centro.x), (punto1.y - centro.y), (punto1.z - centro.z));
var prescala1:Number = (l / (((l + (ii.z * punto1.x)) + (jj.z * punto1.y)) + (kk.z * punto1.z)));
if ((((prescala0 > 0)) || ((prescala1 > 0)))){
if ((((prescala0 > 0)) && ((prescala1 > 0)))){
lienzo.graphics.moveTo(((((ii.x * punto0.x) + (jj.x * punto0.y)) + (kk.x * punto0.z)) * prescala0), ((((ii.y * punto0.x) + (jj.y * punto0.y)) + (kk.y * punto0.z)) * prescala0));
lienzo.graphics.lineTo(((((ii.x * punto1.x) + (jj.x * punto1.y)) + (kk.x * punto1.z)) * prescala1), ((((ii.y * punto1.x) + (jj.y * punto1.y)) + (kk.y * punto1.z)) * prescala1));
} else {
punto0 = new Punto3D((((ii.x * punto0.x) + (jj.x * punto0.y)) + (kk.x * punto0.z)), (((ii.y * punto0.x) + (jj.y * punto0.y)) + (kk.y * punto0.z)), (((ii.z * punto0.x) + (jj.z * punto0.y)) + (kk.z * punto0.z)));
punto1 = new Punto3D((((ii.x * punto1.x) + (jj.x * punto1.y)) + (kk.x * punto1.z)), (((ii.y * punto1.x) + (jj.y * punto1.y)) + (kk.y * punto1.z)), (((ii.z * punto1.x) + (jj.z * punto1.y)) + (kk.z * punto1.z)));
t = (((-(l) + planoCorte) - punto0.z) / (punto1.z - punto0.z));
puntoM = [(punto0.x + (t * (punto1.x - punto0.x))), (punto0.y + (t * (punto1.y - punto0.y))), (-(l) + planoCorte)];
prescalaM = (l / (l + puntoM[2]));
if (prescala0 > 0){
lienzo.graphics.moveTo((punto0.x * prescala0), (punto0.y * prescala0));
lienzo.graphics.lineTo(((punto0.x * prescala0) + ((puntoM[0] * prescalaM) - (punto0.x * prescala0))), ((punto0.y * prescala0) + ((puntoM[1] * prescalaM) - (punto0.y * prescala0))));
} else {
lienzo.graphics.moveTo((punto1.x * prescala1), (punto1.y * prescala1));
lienzo.graphics.lineTo(((punto1.x * prescala1) + ((puntoM[0] * prescalaM) - (punto1.x * prescala1))), ((punto1.y * prescala1) + ((puntoM[1] * prescalaM) - (punto1.y * prescala1))));
};
};
};
}
}
}//package personales.espacios.tresDimensiones.graficadores
Section 11
//GraficaPoligonos3D (personales.espacios.tresDimensiones.graficadores.GraficaPoligonos3D)
package personales.espacios.tresDimensiones.graficadores {
import personales.espacios.tresDimensiones.*;
import flash.display.*;
import personales.espacios.tresDimensiones.objetosTridimensionales.*;
public class GraficaPoligonos3D {
public var ii:Punto3D;
public var kk:Punto3D;
public var centro:Punto3D;
public var jj:Punto3D;
public var lienzo:Sprite;
public var espacio3D:Espacio3D;
public static var Pi2:Number = 6.28318530717959;
public function GraficaPoligonos3D(espacio3D:Espacio3D){
super();
this.espacio3D = espacio3D;
centro = espacio3D.centro;
lienzo = espacio3D._lienzo;
ii = espacio3D.ii;
jj = espacio3D.jj;
kk = espacio3D.kk;
}
private function trazaArcoSimpleXY(a0:Number, a1:Number, r0:Number, r1:Number, dx:Number=0, dy:Number=0):void{
espacio3D.graficaCurvas.moveTo3D(new Punto3D(((r0 * Math.cos(a0)) + dx), ((r0 * Math.sin(a0)) + dy), 0));
espacio3D.graficaCurvas.lineTo3D(new Punto3D(((r1 * Math.cos(a0)) + dx), ((r1 * Math.sin(a0)) + dy), 0));
espacio3D.graficaCurvas.lineTo3D(new Punto3D(((r1 * Math.cos(a1)) + dx), ((r1 * Math.sin(a1)) + dy), 0));
espacio3D.graficaCurvas.lineTo3D(new Punto3D(((r0 * Math.cos(a1)) + dx), ((r0 * Math.sin(a1)) + dy), 0));
espacio3D.graficaCurvas.lineTo3D(new Punto3D(((r0 * Math.cos(a0)) + dx), ((r0 * Math.sin(a0)) + dy), 0));
}
public function trazaArcoXY(a0:Number, a1:Number, r0:Number, r1:Number, dx:Number=0, dy:Number=0, definicion:Number=1):void{
var deltaAngular:Number;
var angulo:Number;
var rs:Number;
var i:uint;
var nPasos:uint = (Math.floor((((definicion * 40) * (a1 - a0)) / Pi2)) + 1);
if (nPasos < 2){
trazaArcoSimpleXY(a0, a1, r0, r1, dx, dy);
} else {
deltaAngular = ((a1 - a0) / nPasos);
angulo = a0;
rs = (r1 / Math.cos((deltaAngular / 2)));
espacio3D.graficaCurvas.moveTo3D(new Punto3D(((r0 * Math.cos(angulo)) + dx), ((r0 * Math.sin(angulo)) + dy), 0));
espacio3D.graficaCurvas.lineTo3D(new Punto3D(((r1 * Math.cos(angulo)) + dx), ((r1 * Math.sin(angulo)) + dy), 0));
i = 0;
while (i < nPasos) {
angulo = (angulo + deltaAngular);
espacio3D.graficaCurvas.lineTo3D(new Punto3D(((r1 * Math.cos(angulo)) + dx), ((r1 * Math.sin(angulo)) + dy), 0));
i++;
};
angulo = a1;
rs = (r0 / Math.cos((deltaAngular / 2)));
espacio3D.graficaCurvas.lineTo3D(new Punto3D(((r0 * Math.cos(angulo)) + dx), ((r0 * Math.sin(angulo)) + dy), 0));
i = 0;
while (i < nPasos) {
angulo = (angulo - deltaAngular);
espacio3D.graficaCurvas.lineTo3D(new Punto3D(((r0 * Math.cos(angulo)) + dx), ((r0 * Math.sin(angulo)) + dy), 0));
i++;
};
};
}
public function trazaCuadrilatero3D(cuadrilatero:Cuadrilatero3D):void{
if (cuadrilatero.colorBorde > -1){
lienzo.graphics.lineStyle(0, cuadrilatero.colorBorde, cuadrilatero.alfaBorde);
};
if (cuadrilatero.colorRelleno > -1){
lienzo.graphics.beginFill(cuadrilatero.colorRelleno, cuadrilatero.alfaRelleno);
};
espacio3D.graficaCurvas.moveTo3D(cuadrilatero.p00);
espacio3D.graficaCurvas.lineTo3D(cuadrilatero.p10);
espacio3D.graficaCurvas.lineTo3D(cuadrilatero.p11);
espacio3D.graficaCurvas.lineTo3D(cuadrilatero.p01);
espacio3D.graficaCurvas.lineTo3D(cuadrilatero.p00);
if (cuadrilatero.colorRelleno){
lienzo.graphics.endFill();
};
}
public function trazaPoligono3D(poligono3D:Poligono3D):void{
if (poligono3D.colorBorde > -1){
lienzo.graphics.lineStyle(0, poligono3D.colorBorde, poligono3D.alfaBorde);
};
if (poligono3D.colorRelleno){
lienzo.graphics.beginFill(poligono3D.colorRelleno, poligono3D.alfaRelleno);
};
espacio3D.graficaCurvas.moveTo3D(poligono3D.listaPuntos[0]);
var i:uint = 1;
while (i < poligono3D.listaPuntos.length) {
espacio3D.graficaCurvas.lineTo3D(poligono3D.listaPuntos[i]);
i++;
};
espacio3D.graficaCurvas.lineTo3D(poligono3D.listaPuntos[0]);
if (poligono3D.colorRelleno){
lienzo.graphics.endFill();
};
}
}
}//package personales.espacios.tresDimensiones.graficadores
Section 12
//Desplazamientos (personales.espacios.tresDimensiones.navegacion.Desplazamientos)
package personales.espacios.tresDimensiones.navegacion {
import flash.events.*;
import personales.espacios.tresDimensiones.*;
import flash.display.*;
import personales.espacios.tresDimensiones.objetosTridimensionales.*;
public class Desplazamientos extends Sprite {
public var paraDesplazamiento:Function;
public var alfaFin:Number;
public var paraDesplazamientoAngular:Function;
private var mouseXanterior:Number;
private var mouseYanterior:Number;
public var rDecAngular:Number;
public var cicloDesplazamientoAngularActivo:Boolean;// = false
public var rIni:Number;
public var retardo:Number;
public var raiz:Sprite;
public var paraDesplazamientoCombinado:Function;
public var retardoAngular:Number;
public var rDec:Number;
public var espacio3D:Espacio3D;
public var gamaFin:Number;
public var propagado:Boolean;// = true
public var cicloArrastreActivo:Boolean;// = false
public var cicloDesplazamientoActivo:Boolean;// = false
public var fr:Number;
public var presionado:Boolean;// = false
public var centroFin:Punto3D;
public var rIniAngular:Number;
public var funcionMovimiento:Function;
public var betaFin:Number;
public function Desplazamientos(espacio3D:Espacio3D):void{
super();
this.espacio3D = espacio3D;
}
public function detieneDesplazamiento():void{
espacio3D._centro.x = centroFin.x;
espacio3D._centro.y = centroFin.y;
espacio3D._centro.z = centroFin.z;
this.removeEventListener(Event.ENTER_FRAME, cicloDesplazamiento);
cicloDesplazamientoActivo = false;
if (paraDesplazamiento != null){
paraDesplazamiento();
};
}
public function detieneArrastre():void{
raiz.removeEventListener(Event.ENTER_FRAME, cicloArrastre);
cicloArrastreActivo = false;
}
protected function cicloDesplazamiento(e:Event):void{
retardo = (retardo * rDec);
espacio3D._centro.x = (((retardo * espacio3D._centro.x) + centroFin.x) / (1 + retardo));
espacio3D._centro.y = (((retardo * espacio3D._centro.y) + centroFin.y) / (1 + retardo));
espacio3D._centro.z = (((retardo * espacio3D._centro.z) + centroFin.z) / (1 + retardo));
if (((Math.pow((espacio3D._centro.x - centroFin.x), 2) + Math.pow((espacio3D._centro.y - centroFin.y), 2)) + Math.pow((espacio3D._centro.z - centroFin.z), 2)) < 0.02){
detieneDesplazamiento();
};
}
public function activaListenerDesplazamientoAngularALista(listaObjetos:Array, rIniAngular:Number, rDecAngular:Number=0.9, paraDesplazamientoAngular:Function=null):void{
var i:uint;
while (i < listaObjetos.length) {
activaListenerDesplazamientoAngular(listaObjetos[i], rIniAngular, rDecAngular, paraDesplazamientoAngular);
i++;
};
}
public function activaDesplazamiento(centroFin:Punto3D, rIni:Number=100, rDec:Number=0.9, paraDesplazamiento:Function=null):void{
this.centroFin = centroFin;
this.rIni = rIni;
if (paraDesplazamiento != null){
this.paraDesplazamiento = paraDesplazamiento;
};
retardo = rIni;
this.rDec = rDec;
cicloDesplazamientoActivo = true;
this.addEventListener(Event.ENTER_FRAME, cicloDesplazamiento);
}
private function cicloArrastre(e:Event):void{
if (presionado){
espacio3D.vXAngular = (((8 * espacio3D.vXAngular) + ((raiz.mouseX - mouseXanterior) / 100)) / 9);
espacio3D.vYAngular = (((8 * espacio3D.vYAngular) - ((raiz.mouseY - mouseYanterior) / 100)) / 9);
mouseXanterior = raiz.mouseX;
mouseYanterior = raiz.mouseY;
} else {
espacio3D.vXAngular = (espacio3D.vXAngular * fr);
espacio3D.vYAngular = (espacio3D.vYAngular * fr);
if ((Math.pow(espacio3D.vXAngular, 2) + Math.pow(espacio3D.vYAngular, 2)) < 1E-6){
raiz.removeEventListener(Event.ENTER_FRAME, cicloArrastre);
cicloArrastreActivo = false;
};
};
espacio3D.setEjesArrastre(espacio3D.vYAngular, espacio3D.vXAngular, espacio3D.centro);
if (funcionMovimiento != null){
funcionMovimiento();
};
}
public function activaArrastre(base:Sprite, fr:Number=0.9, funcionMovimiento:Function=null, propagado:Boolean=false):void{
this.fr = fr;
this.propagado = propagado;
raiz = base;
if (raiz.stage != null){
activaA(undefined);
} else {
raiz.addEventListener(Event.ADDED_TO_STAGE, activaA);
};
if (funcionMovimiento != null){
this.funcionMovimiento = funcionMovimiento;
funcionMovimiento();
};
}
public function activaDesplazamientoAngular(alfaFin:Number, betaFin:Number, gamaFin:Number, rIniAngular:Number=100, rDecAngular:Number=0.9, paraDesplazamientoAngular:Function=null):void{
this.alfaFin = alfaFin;
this.betaFin = betaFin;
this.gamaFin = gamaFin;
if ((alfaFin - espacio3D.alfa) > Math.PI){
this.alfaFin = (this.alfaFin - (2 * Math.PI));
};
if ((espacio3D.alfa - alfaFin) > Math.PI){
this.alfaFin = (this.alfaFin + (2 * Math.PI));
};
if ((betaFin - espacio3D.beta) > Math.PI){
this.betaFin = (this.betaFin - (2 * Math.PI));
};
if ((espacio3D.beta - betaFin) > Math.PI){
this.betaFin = (this.betaFin + (2 * Math.PI));
};
if ((gamaFin - espacio3D.gama) > Math.PI){
this.gamaFin = (this.gamaFin - (2 * Math.PI));
};
if ((espacio3D.gama - gamaFin) > Math.PI){
this.gamaFin = (this.gamaFin + (2 * Math.PI));
};
this.rIniAngular = rIniAngular;
this.rDecAngular = rDecAngular;
if (paraDesplazamientoAngular != null){
this.paraDesplazamientoAngular = paraDesplazamientoAngular;
};
retardoAngular = rIniAngular;
cicloDesplazamientoAngularActivo = true;
this.addEventListener(Event.ENTER_FRAME, cicloDesplazamientoAngular);
}
private function clicParaDesplazamiento(e:Event):void{
var ot:ObjetoTridimensional = ObjetoTridimensional(e.currentTarget);
activaDesplazamiento(ot.centro, rIni, rDec);
}
public function activaListenerDesplazamientoALista(listaObjetos:Array, rIni:Number, rDec:Number=0.9, paraDesplazamiento:Function=null):void{
var i:uint;
while (i < listaObjetos.length) {
activaListenerDesplazamiento(listaObjetos[i], rIni, rDec, paraDesplazamiento);
i++;
};
}
private function clicParaDesplazamientoAngular(e:Event):void{
var ot:ObjetoTridimensional = ObjetoTridimensional(e.currentTarget);
activaDesplazamientoAngular(ot.alfa, ot.beta, rIniAngular, rDecAngular);
}
public function presionaArrastre(e:Event=undefined):void{
if ((((e.target == raiz.stage)) || (propagado))){
presionado = true;
mouseXanterior = raiz.mouseX;
mouseYanterior = raiz.mouseY;
if (!cicloArrastreActivo){
espacio3D.vXAngular = 0;
espacio3D.vYAngular = 0;
};
raiz.addEventListener(Event.ENTER_FRAME, cicloArrastre);
cicloArrastreActivo = true;
};
}
public function activaDesplazamientoHaciaObjetoConEscalaFinal(objeto3D:ObjetoTridimensional, escalaFinal:Number, rIni:Number=100, rDec:Number=0.9, paraDesplazamiento:Function=null):void{
activaDesplazamiento(Op3D.sumaDosPuntos(objeto3D.centro, Op3D.multiplicacionEscalar((espacio3D.l - (espacio3D.l / escalaFinal)), espacio3D.vectorCamara)), rIni, rDec, paraDesplazamiento);
}
public function desActivaArrastre():void{
detieneArrastre();
raiz.stage.removeEventListener(MouseEvent.MOUSE_DOWN, presionaArrastre);
raiz.stage.removeEventListener(MouseEvent.MOUSE_UP, sueltaArrastre);
}
public function detieneDesplazamientoAngular():void{
this.removeEventListener(Event.ENTER_FRAME, cicloDesplazamientoAngular);
cicloDesplazamientoAngularActivo = false;
if (paraDesplazamientoAngular != null){
paraDesplazamientoAngular();
};
}
public function activaDesplazamientoHaciaObjeto(objeto3D:ObjetoTridimensional, rIni:Number=100, rDec:Number=0.9, paraDesplazamiento:Function=null):void{
this.centroFin = objeto3D.centro;
this.rIni = rIni;
if (paraDesplazamiento != null){
this.paraDesplazamiento = paraDesplazamiento;
};
retardo = rIni;
this.rDec = rDec;
cicloDesplazamientoActivo = true;
this.addEventListener(Event.ENTER_FRAME, cicloDesplazamiento);
}
private function sueltaArrastre(e:Event):void{
presionado = false;
}
public function activaListenerDesplazamientoAngular(ot:ObjetoTridimensional, rIniAngular:Number, rDecAngular:Number=0.9, paraDesplazamientoAngular:Function=null):void{
this.rIniAngular = rIniAngular;
this.rDecAngular = rDecAngular;
if (paraDesplazamientoAngular != null){
this.paraDesplazamientoAngular = paraDesplazamientoAngular;
};
ot.addEventListener(MouseEvent.CLICK, clicParaDesplazamientoAngular);
}
public function activaDesplazamientoYAngulosHaciaObjeto(objeto3D:ObjetoTridimensional, rIni:Number=100, rDec:Number=0.9, paraDesplazamiento:Function=null):void{
if (paraDesplazamiento != null){
this.paraDesplazamientoCombinado = paraDesplazamiento;
};
activaDesplazamientoAngular(objeto3D.alfa, objeto3D.beta, 0, rIni, rDec, paraDesplazamientoYAngulosHaciaObjeto3D);
activaDesplazamientoHaciaObjeto(objeto3D, rIni, rDec, paraDesplazamientoYAngulosHaciaObjeto3D);
}
protected function cicloDesplazamientoAngular(e:Event):void{
retardoAngular = (retardoAngular * rDecAngular);
espacio3D.alfa = (((retardoAngular * espacio3D.alfa) + alfaFin) / (1 + retardoAngular));
espacio3D.beta = (((retardoAngular * espacio3D.beta) + betaFin) / (1 + retardoAngular));
espacio3D.gama = (((retardoAngular * espacio3D.gama) + gamaFin) / (1 + retardoAngular));
if (((Math.pow((espacio3D.alfa - alfaFin), 2) + Math.pow((espacio3D.beta - betaFin), 2)) + Math.pow((espacio3D.gama - gamaFin), 2)) < 1E-7){
espacio3D.alfa = alfaFin;
espacio3D.beta = betaFin;
espacio3D.gama = gamaFin;
detieneDesplazamientoAngular();
};
}
private function paraDesplazamientoYAngulosHaciaObjeto3D():void{
if (((!(cicloDesplazamientoAngularActivo)) && (!(cicloDesplazamientoActivo)))){
if (paraDesplazamientoCombinado != null){
paraDesplazamientoCombinado();
};
};
}
public function activaListenerDesplazamiento(ot:ObjetoTridimensional, rIni:Number, rDec:Number=0.9, paraDesplazamiento:Function=null):void{
this.rIni = rIni;
this.rDec = rDec;
if (paraDesplazamiento != null){
this.paraDesplazamiento = paraDesplazamiento;
};
ot.addEventListener(MouseEvent.CLICK, clicParaDesplazamiento);
}
public function limpia():void{
raiz.removeEventListener(Event.ENTER_FRAME, cicloArrastre);
raiz.removeEventListener(Event.ENTER_FRAME, cicloDesplazamiento);
}
private function activaA(e:Event):void{
raiz.stage.addEventListener(MouseEvent.MOUSE_DOWN, presionaArrastre);
raiz.stage.addEventListener(MouseEvent.MOUSE_UP, sueltaArrastre);
}
}
}//package personales.espacios.tresDimensiones.navegacion
Section 13
//Cuadrilatero3D (personales.espacios.tresDimensiones.objetosTridimensionales.Cuadrilatero3D)
package personales.espacios.tresDimensiones.objetosTridimensionales {
import personales.espacios.tresDimensiones.*;
public class Cuadrilatero3D extends Poligono3D {
public var p00:Punto3D;
public var p01:Punto3D;
public var p10:Punto3D;
public var p11:Punto3D;
public function Cuadrilatero3D(p00:Punto3D, p10:Punto3D, p11:Punto3D, p01:Punto3D){
super([p00, p10, p11, p01]);
this.p00 = p00;
this.p10 = p10;
this.p01 = p01;
this.p11 = p11;
}
}
}//package personales.espacios.tresDimensiones.objetosTridimensionales
Section 14
//ObjetoTridimensional (personales.espacios.tresDimensiones.objetosTridimensionales.ObjetoTridimensional)
package personales.espacios.tresDimensiones.objetosTridimensionales {
import personales.espacios.tresDimensiones.*;
import flash.display.*;
import personales.espacios.tresDimensiones.bitmap3D.*;
public class ObjetoTridimensional extends Sprite {
protected var _centro:Punto3D;
protected var _alfa:Number;// = 0
public var rectanguloImagen3D:RectanguloImagen3D;
protected var _gama:Number;// = 0
protected var _beta:Number;// = 0
public var modificado:Boolean;// = true
public var ancho:Number;// = 0
public var alto:Number;// = 0
public var congelado:Boolean;// = false
public var m:uint;// = 2
public var n:uint;// = 2
public var profundidad:Number;// = 0
public function ObjetoTridimensional(){
_centro = new Punto3D();
super();
}
public function set centro(centro:Punto3D):void{
_centro = centro;
}
public function set gama(gama:Number):void{
_gama = beta;
}
public function set alfa(alfa:Number):void{
_alfa = alfa;
}
public function get centro():Punto3D{
return (_centro);
}
public function set beta(beta:Number):void{
_beta = beta;
}
public function get beta():Number{
return (_beta);
}
public function get gama():Number{
return (_gama);
}
public function get alfa():Number{
return (_alfa);
}
}
}//package personales.espacios.tresDimensiones.objetosTridimensionales
Section 15
//Poligono3D (personales.espacios.tresDimensiones.objetosTridimensionales.Poligono3D)
package personales.espacios.tresDimensiones.objetosTridimensionales {
import personales.espacios.tresDimensiones.*;
public class Poligono3D extends ObjetoTridimensional {
public var alfaBorde:Number;// = 1
public var _colorBorde:int;// = -1
public var alfaRelleno:Number;// = 0
public var _colorRelleno:int;// = -1
public var listaPuntos:Array;
public function Poligono3D(listaPuntos:Array){
listaPuntos = [];
super();
this.listaPuntos = listaPuntos.slice();
}
public function get colorBorde():int{
return (_colorBorde);
}
public function set colorBorde(colorBorde:int):void{
_colorBorde = colorBorde;
}
public function adicionaPunto(punto3D:Punto3D):void{
listaPuntos.push(punto3D);
}
public function get colorRelleno():int{
return (_colorRelleno);
}
public function set colorRelleno(colorRelleno:int):void{
_colorRelleno = colorRelleno;
}
}
}//package personales.espacios.tresDimensiones.objetosTridimensionales
Section 16
//Proyeccion (personales.espacios.tresDimensiones.proyecciones.Proyeccion)
package personales.espacios.tresDimensiones.proyecciones {
import personales.espacios.tresDimensiones.*;
import flash.display.*;
import flash.geom.*;
import personales.espacios.tresDimensiones.objetosTridimensionales.*;
import personales.redes.elementos.*;
import personales.espacios.tresDimensiones.bitmap3D.*;
public class Proyeccion {
public var jj:Punto3D;
public var limX:Number;// = 800
public var limY:Number;// = 800
public var resolucionMax:uint;// = 5
public var contenedor:Sprite;
public var ii:Punto3D;
public var minimoEscala:Number;// = 0.02
public var centro:Punto3D;
public var kk:Punto3D;
public var resolucionDinamica:Boolean;// = false
public var espacio3D:Espacio3D;
public static var Pi2:Number = 6.28318530717959;
public function Proyeccion(espacio3D:Espacio3D){
super();
this.espacio3D = espacio3D;
this.contenedor = espacio3D.contenedor;
centro = espacio3D.centro;
ii = espacio3D.ii;
jj = espacio3D.jj;
kk = espacio3D.kk;
}
public function proyeccionConCongelamientoObjetosContenedor():void{
var objeto:Nodo;
var i:uint;
while (i < contenedor.numChildren) {
objeto = Nodo(contenedor.getChildAt(i));
proyeccionConCongelamiento(objeto);
i++;
};
}
public function proyeccionConCongelamientoListaNodoS(listaNodoS:Array):void{
var i:uint;
while (i < listaNodoS.length) {
proyeccionConCongelamiento(listaNodoS[i]);
i++;
};
}
public function proyectaObjetosContenedor():void{
var objeto:ObjetoTridimensional;
var i:uint;
while (i < contenedor.numChildren) {
objeto = ObjetoTridimensional(contenedor.getChildAt(i));
proyeccion(objeto);
i++;
};
}
public function proyectaObjetosListaSinVisible(lista:Array):void{
var i:uint;
while (i < lista.length) {
proyeccionSinVisible(lista[i]);
i++;
};
}
public function proyeccion(ot:ObjetoTridimensional):void{
var l:Number = espacio3D.l;
var vector:Punto3D = new Punto3D((ot.centro.x - centro.x), (ot.centro.y - centro.y), (ot.centro.z - centro.z));
var prescala:Number = (l / (((l + (ii.z * vector.x)) + (jj.z * vector.y)) + (kk.z * vector.z)));
if (prescala > 0){
ot.visible = true;
ot.x = ((((ii.x * vector.x) + (jj.x * vector.y)) + (kk.x * vector.z)) * prescala);
ot.y = ((((ii.y * vector.x) + (jj.y * vector.y)) + (kk.y * vector.z)) * prescala);
ot.scaleX = prescala;
ot.scaleY = prescala;
} else {
ot.visible = false;
};
}
public function nivelaObjetosListaDesordenable(listaObjetosTridimensionales:Array):void{
var objeto:ObjetoTridimensional;
var i:uint;
while (i < listaObjetosTridimensionales.length) {
objeto = ObjetoTridimensional(listaObjetosTridimensionales[i]);
objeto.profundidad = espacio3D.profundidad(objeto.centro);
i++;
};
listaObjetosTridimensionales.sortOn("profundidad", (Array.NUMERIC | Array.DESCENDING));
i = 0;
while (i < listaObjetosTridimensionales.length) {
contenedor.setChildIndex(listaObjetosTridimensionales[i], i);
i++;
};
}
public function escalaEnPunto(punto3D:Punto3D):Number{
var l:Number = espacio3D.l;
var vector:Punto3D = new Punto3D((punto3D.x - centro.x), (punto3D.y - centro.y), (punto3D.z - centro.z));
return ((l / (((l + (ii.z * vector.x)) + (jj.z * vector.y)) + (kk.z * vector.z))));
}
public function nivelaPorParesAleatorio(listaObjetosTridimensionales:Array):void{
var ot0:ObjetoTridimensional = listaObjetosTridimensionales[Math.floor((listaObjetosTridimensionales.length * Math.random()))];
var ot1:ObjetoTridimensional = listaObjetosTridimensionales[Math.floor((listaObjetosTridimensionales.length * Math.random()))];
if ((((ot0.numChildren < ot1.numChildren)) && ((espacio3D.escala(ot0.centro) < espacio3D.escala(ot1.centro))))){
contenedor.swapChildren(ot0, ot1);
};
}
private function gestionaResolucion(nodoS:Nodo, escala:Number):void{
var nuevaEscala:uint = (Math.floor((escala * (resolucionMax - 2))) + 2);
if (nodoS.m != nuevaEscala){
nodoS.m = nuevaEscala;
nodoS.n = nuevaEscala;
nodoS.modificado = true;
congelaNodoS(nodoS);
};
}
public function nivelaObjetosLista(listaObjetosTridimensionales:Array):void{
var i:uint;
var objeto:ObjetoTridimensional;
var listaObjetos:Array = [];
i = 0;
while (i < listaObjetosTridimensionales.length) {
objeto = ObjetoTridimensional(listaObjetosTridimensionales[i]);
listaObjetos.push(objeto);
objeto.profundidad = espacio3D.profundidad(objeto.centro);
i++;
};
listaObjetos.sortOn("profundidad", (Array.NUMERIC | Array.DESCENDING));
i = 0;
while (i < listaObjetos.length) {
contenedor.setChildIndex(listaObjetos[i], i);
i++;
};
}
public function proyeccionConCongelamiento(nodoS:Nodo):void{
var coordenadas2D:Point;
var l:Number = espacio3D.l;
var vector:Punto3D = new Punto3D((nodoS.centro.x - centro.x), (nodoS.centro.y - centro.y), (nodoS.centro.z - centro.z));
var prescala:Number = (l / (((l + (ii.z * vector.x)) + (jj.z * vector.y)) + (kk.z * vector.z)));
if ((((prescala > 0)) && ((prescala > minimoEscala)))){
coordenadas2D = espacio3D.calculaCoordenadas2D(nodoS.centro);
if ((((((((coordenadas2D.x > -(limX))) && ((coordenadas2D.x < limX)))) && ((coordenadas2D.y > -(limY))))) && ((coordenadas2D.y < limY)))){
congelaNodoS(nodoS);
nodoS.visible = true;
if (nodoS.congelado){
if (resolucionDinamica){
gestionaResolucion(nodoS, prescala);
};
proyectaRectanguloImagen3D(nodoS.rectanguloImagen3D);
};
} else {
nodoS.visible = false;
};
} else {
nodoS.visible = false;
};
}
public function proyectaRectanguloImagen3D(rectanguloImagen3D:RectanguloImagen3D):void{
rectanguloImagen3D.graphics.clear();
if (espacio3D.profundidad(rectanguloImagen3D.centro) >= -(espacio3D.l)){
rectanguloImagen3D.visible = true;
rectanguloImagen3D.graphics.clear();
rectanguloImagen3D.mallado.actualizaMatriz2D(espacio3D);
rectanguloImagen3D.malladoB.renderizaTriangulos();
} else {
rectanguloImagen3D.visible = false;
};
}
public function proyeccionSinVisible(ot:ObjetoTridimensional):void{
var l:Number = espacio3D.l;
var vector:Punto3D = new Punto3D((ot.centro.x - centro.x), (ot.centro.y - centro.y), (ot.centro.z - centro.z));
var prescala:Number = (l / (((l + (ii.z * vector.x)) + (jj.z * vector.y)) + (kk.z * vector.z)));
ot.x = ((((ii.x * vector.x) + (jj.x * vector.y)) + (kk.x * vector.z)) * prescala);
ot.y = ((((ii.y * vector.x) + (jj.y * vector.y)) + (kk.y * vector.z)) * prescala);
ot.scaleX = (ot.scaleY = prescala);
}
public function proyectaObjetosContenedorSinVisible():void{
var objeto:ObjetoTridimensional;
var i:uint;
while (i < contenedor.numChildren) {
objeto = ObjetoTridimensional(contenedor.getChildAt(i));
proyeccionSinVisible(objeto);
i++;
};
}
public function proyectaObjetosLista(lista:Array):void{
var i:uint;
while (i < lista.length) {
proyeccion(lista[i]);
i++;
};
}
public function nivelaObjetosEnContenedor():void{
var objeto:ObjetoTridimensional;
var listaObjetos:Array = [];
var i:uint;
while (i < contenedor.numChildren) {
objeto = ObjetoTridimensional(contenedor.getChildAt(i));
listaObjetos.push(objeto);
objeto.profundidad = espacio3D.profundidad(objeto.centro);
i++;
};
listaObjetos.sortOn("profundidad", (Array.NUMERIC | Array.DESCENDING));
i = 0;
while (i < contenedor.numChildren) {
contenedor.setChildIndex(listaObjetos[i], i);
i++;
};
}
public function congelaNodoS(nodoS:Nodo):void{
var bmData:BitmapData;
var rectangle:Rectangle;
if ((((((Math.min(Math.abs((nodoS.alfa - espacio3D.alfa)), Math.abs((Math.abs((nodoS.alfa - espacio3D.alfa)) - Pi2))) + Math.min(Math.abs((nodoS.beta - espacio3D.beta)), Math.abs((Math.abs((nodoS.beta - espacio3D.beta)) - Pi2)))) + Math.min(Math.abs((nodoS.gama - espacio3D.gama)), Math.abs((Math.abs((nodoS.gama - espacio3D.gama)) - Pi2)))) + Math.abs((nodoS.centro.x - espacio3D.centro.x))) + Math.abs((nodoS.centro.y - espacio3D.centro.y))) + Math.abs((nodoS.centro.z - espacio3D.centro.z))) < 0.001){
if (nodoS.congelado){
if (nodoS.rectanguloImagen3D != null){
nodoS.removeChild(nodoS.rectanguloImagen3D);
};
nodoS.contenedor.visible = true;
nodoS.congelado = false;
};
} else {
if (!nodoS.congelado){
nodoS.modificado = false;
nodoS.contenedor.visible = false;
nodoS.congelado = true;
nodoS.modificado = true;
};
if (nodoS.modificado){
bmData = new BitmapData(nodoS.contenedor.width, nodoS.contenedor.height, true, 0);
rectangle = nodoS.contenedor.getRect(nodoS.contenedor);
bmData.draw(nodoS.contenedor, new Matrix(1, 0, 0, 1, -(rectangle.x), -(rectangle.y)));
if (nodoS.rectanguloImagen3D == null){
nodoS.rectanguloImagen3D = new RectanguloImagen3D(bmData, nodoS.centro, nodoS.m, nodoS.n);
} else {
nodoS.rectanguloImagen3D.regenera(bmData, nodoS.centro, nodoS.m, nodoS.n);
};
nodoS.rectanguloImagen3D.alfa = nodoS.alfa;
nodoS.rectanguloImagen3D.beta = nodoS.beta;
nodoS.modificado = false;
if (!nodoS.contains(nodoS.rectanguloImagen3D)){
nodoS.addChild(nodoS.rectanguloImagen3D);
};
};
};
}
}
}//package personales.espacios.tresDimensiones.proyecciones
Section 17
//Disposiciones3D (personales.espacios.tresDimensiones.Disposiciones3D)
package personales.espacios.tresDimensiones {
import personales.fisica.*;
import personales.fisica.fuerzas.*;
import personales.redes.elementos.*;
public class Disposiciones3D {
public static var Pi2:Number = 6.28318530717959;
public static var origen:Punto3D = new Punto3D();
public function Disposiciones3D(){
super();
}
public static function circuloXY(listaObjetos3D:Array, radio:Number, centro:Punto3D=null):void{
var angulo:Number;
if (centro == null){
centro = origen;
};
var dA:Number = ((2 * Math.PI) / listaObjetos3D.length);
var i:uint;
while (i < listaObjetos3D.length) {
angulo = (i * dA);
listaObjetos3D[i].centro = new Punto3D((radio * Math.cos(angulo)), (radio * Math.sin(angulo)), 0);
i++;
};
}
public static function esfera(listaObjetosFisicos:Array, radio:Number, centro:Punto3D=null):MatrizFuerzas{
var nodo:Nodo;
var alfa:Number;
var beta:Number;
var gama:Number;
var resorte:Resorte;
var j:uint;
if (centro == null){
centro = new Punto3D();
};
var i:uint;
while (i < listaObjetosFisicos.length) {
alfa = (Math.random() * Pi2);
beta = (Math.random() * Pi2);
gama = (Math.random() * Pi2);
nodo = listaObjetosFisicos[i];
nodo.centro = Op3D.creaPuntoAngulos(radio, alfa, beta, gama);
i++;
};
var matrizF:MatrizFuerzas = new MatrizFuerzas();
i = 0;
while (i < (listaObjetosFisicos.length - 1)) {
nodo = listaObjetosFisicos[i];
j = (i + 1);
while (j < listaObjetosFisicos.length) {
resorte = new Resorte(nodo, listaObjetosFisicos[j], 0.1, ((100 * radio) / listaObjetosFisicos.length));
matrizF.adicionaFuerza(resorte);
j++;
};
i++;
};
var motorF:MotorFisico = new MotorFisico(1);
while (motorF.friccion > 0.2) {
MotorFisico.aplicaFuerzasConfinadasDeMatrizResortes(matrizF);
motorF.ejecutaFuerzasEnListaYAplicaFriccion(listaObjetosFisicos);
i = 0;
while (i < listaObjetosFisicos.length) {
nodo = listaObjetosFisicos[i];
nodo.centro = Op3D.normalizaPuntoEscalado(nodo.centro, radio);
i++;
};
motorF.friccion = (motorF.friccion * 0.95);
};
return (matrizF);
}
public static function mismoCentro(listaObjetos3D:Array, punto3D:Punto3D):void{
var i:uint;
while (i < listaObjetos3D.length) {
listaObjetos3D[i].centro = punto3D;
i++;
};
}
public static function aleatorioEnPrisma(listaObjetos3D:Array, dx:Number, dy:Number, dz:Number=0, centro:Punto3D=null):void{
if (centro == null){
centro = origen;
};
var i:uint;
while (i < listaObjetos3D.length) {
listaObjetos3D[i].centro = new Punto3D((centro.x + ((Math.random() - 0.5) * dx)), (centro.y + ((Math.random() - 0.5) * dy)), (centro.z + ((Math.random() - 0.5) * dz)));
i++;
};
}
}
}//package personales.espacios.tresDimensiones
Section 18
//Ejes3D (personales.espacios.tresDimensiones.Ejes3D)
package personales.espacios.tresDimensiones {
public class Ejes3D {
public var ii:Punto3D;
public var tx:Number;// = 0
public var ty:Number;// = 0
public var kk:Punto3D;
public var jj:Punto3D;
public function Ejes3D(ii:Punto3D=null, jj:Punto3D=null, kk:Punto3D=null, tx:Number=0, ty:Number=0){
ii = new Punto3D(1, 0, 0);
jj = new Punto3D(0, 1, 0);
kk = new Punto3D(0, 0, 1);
super();
if (ii != null){
this.ii = ii;
};
if (jj != null){
this.jj = jj;
};
if (kk != null){
this.kk = kk;
};
this.tx = tx;
this.ty = ty;
}
}
}//package personales.espacios.tresDimensiones
Section 19
//Espacio3D (personales.espacios.tresDimensiones.Espacio3D)
package personales.espacios.tresDimensiones {
import flash.display.*;
import flash.geom.*;
import personales.espacios.tresDimensiones.navegacion.*;
import personales.espacios.tresDimensiones.proyecciones.*;
import personales.espacios.tresDimensiones.graficadores.*;
public class Espacio3D {
public var _centro:Punto3D;
private var _alfa:Number;// = 0
private var iiProvisional:Punto3D;
public var rotacionLibre:Boolean;// = false
protected var _graficaCurvas:GraficaCurvas3D;
public var ejes:Ejes3D;
protected var _graficaPoligonos:GraficaPoligonos3D;
public var contenedor:Sprite;
public var ii:Punto3D;
public var origen:Punto3D;
public var kkSemilla:Punto3D;
public var vYAngular:Number;// = 0
public var _lienzo:Sprite;
private var _gama:Number;// = 0
private var _beta:Number;// = 0
public var jjSemilla:Punto3D;
public var angulosEuler:Function;
private var kkProvisional:Punto3D;
public var kk:Punto3D;
public var jj:Punto3D;
public var vXAngular:Number;// = 0
public var l:uint;
protected var _proyeccion:Proyeccion;
private var jjProvisional:Punto3D;
public var iiSemilla:Punto3D;
protected var _desplazamientos:Desplazamientos;
public static var funcionRotacionInversa:Function = Op3D.RxyzInversa;
public static var funcionRotacion:Function = Op3D.Rxyz;
public function Espacio3D(l:uint=300, contenedor:Sprite=null, lienzo:Sprite=null){
_centro = new Punto3D();
angulosEuler = Op3D.angulosXYZ;
origen = new Punto3D(0, 0, 0);
iiSemilla = new Punto3D(1, 0, 0);
jjSemilla = new Punto3D(0, 1, 0);
kkSemilla = new Punto3D(0, 0, 1);
ii = new Punto3D(1, 0, 0);
jj = new Punto3D(0, 1, 0);
kk = new Punto3D(0, 0, 1);
ejes = new Ejes3D(ii, jj, kk);
iiProvisional = new Punto3D(1, 0, 0);
jjProvisional = new Punto3D(0, 1, 0);
kkProvisional = new Punto3D(0, 0, 1);
super();
this.l = l;
this.contenedor = contenedor;
this.lienzo = lienzo;
}
public function escala(punto:Punto3D):Number{
return ((l / (l + Math.max((((ii.z * (punto.x - _centro.x)) + (jj.z * (punto.y - _centro.y))) + (kk.z * (punto.z - _centro.z))), (1 - l)))));
}
public function setEjes(alfa:Number, beta:Number, gama:Number, centro:Punto3D=null):void{
if (centro != null){
this.centro = centro;
};
_alfa = alfa;
_beta = beta;
_gama = gama;
actualizaEjes();
}
public function calculaEjesDesdeArrastre():void{
if (!rotacionLibre){
desplazamientos.detieneDesplazamientoAngular();
rotacionLibre = true;
actualizaAngulos();
iiProvisional.copiaValores(ii);
jjProvisional.copiaValores(jj);
kkProvisional.copiaValores(kk);
};
ii.copiaValores(funcionRotacion(iiProvisional, vYAngular, vXAngular, 0));
jj.copiaValores(funcionRotacion(jjProvisional, vYAngular, vXAngular, 0));
kk.copiaValores(funcionRotacion(kkProvisional, vYAngular, vXAngular, 0));
iiProvisional.copiaValores(ii);
jjProvisional.copiaValores(jj);
kkProvisional.copiaValores(kk);
}
public function setEjesArrastre(vYAngular:Number, vXAngular:Number, centro:Punto3D=null):void{
if (centro != null){
_centro = centro;
};
this.vYAngular = vYAngular;
this.vXAngular = vXAngular;
calculaEjesDesdeArrastre();
}
public function set lienzo(lienzo:Sprite):void{
_lienzo = lienzo;
if (_graficaCurvas != null){
_graficaCurvas.lienzo = _lienzo;
};
if (_graficaPoligonos != null){
_graficaPoligonos.lienzo = _lienzo;
};
}
public function get graficaPoligonos():GraficaPoligonos3D{
if (_graficaPoligonos == null){
_graficaPoligonos = new GraficaPoligonos3D(this);
};
return (_graficaPoligonos);
}
public function get desplazamientos():Desplazamientos{
if (_desplazamientos == null){
_desplazamientos = new Desplazamientos(this);
};
return (_desplazamientos);
}
public function actualizaEjes():void{
if (rotacionLibre){
rotacionLibre = false;
desplazamientos.detieneArrastre();
};
ii.copiaValores(rotaPunto3D(iiSemilla));
jj.copiaValores(rotaPunto3D(jjSemilla));
kk.copiaValores(rotaPunto3D(kkSemilla));
}
public function get alfa():Number{
if (rotacionLibre){
actualizaAngulos();
};
return (_alfa);
}
public function get vectorCamara():Punto3D{
return (funcionRotacionInversa(new Punto3D(0, 0, 1), alfa, beta, gama));
}
public function set centro(centro:Punto3D):void{
_centro.copiaValores(centro);
actualizaEjes();
}
private function actualizaAngulos():void{
var angulosEuler:Array = angulosEuler(this);
_alfa = angulosEuler[0];
_beta = angulosEuler[1];
_gama = angulosEuler[2];
}
public function set alfa(alfa:Number):void{
_alfa = alfa;
actualizaEjes();
}
public function calculaCoordenadas2D(punto:Punto3D):Point{
var vector:Punto3D = new Punto3D((punto.x - _centro.x), (punto.y - _centro.y), (punto.z - _centro.z));
var prescala:Number = (l / (l + (((ii.z * vector.x) + (jj.z * vector.y)) + (kk.z * vector.z))));
return (new Point(((((ii.x * vector.x) + (jj.x * vector.y)) + (kk.x * vector.z)) * prescala), ((((ii.y * vector.x) + (jj.y * vector.y)) + (kk.y * vector.z)) * prescala)));
}
public function get proyeccion():Proyeccion{
if (_proyeccion == null){
_proyeccion = new Proyeccion(this);
};
return (_proyeccion);
}
public function set gama(gama:Number):void{
_gama = gama;
actualizaEjes();
}
public function get centro():Punto3D{
return (_centro);
}
public function rotaPunto3D(punto3D:Punto3D):Punto3D{
return (funcionRotacion(punto3D, _alfa, _beta, _gama));
}
public function get beta():Number{
if (rotacionLibre){
actualizaAngulos();
};
return (_beta);
}
public function get gama():Number{
if (rotacionLibre){
actualizaAngulos();
};
return (_gama);
}
public function profundidad(punto:Punto3D):Number{
return ((((ii.z * (punto.x - _centro.x)) + (jj.z * (punto.y - _centro.y))) + (kk.z * (punto.z - _centro.z))));
}
public function set beta(beta:Number):void{
_beta = beta;
actualizaEjes();
}
public function get graficaCurvas():GraficaCurvas3D{
if (_graficaCurvas == null){
_graficaCurvas = new GraficaCurvas3D(this);
};
return (_graficaCurvas);
}
}
}//package personales.espacios.tresDimensiones
Section 20
//Op3D (personales.espacios.tresDimensiones.Op3D)
package personales.espacios.tresDimensiones {
import personales.espacios.tresDimensiones.objetosTridimensionales.*;
public class Op3D {
public function Op3D(){
super();
}
public static function RyxCuadrilatero(cuadrilatero:Cuadrilatero3D, alfa:Number, beta:Number):void{
cuadrilatero.p00 = Ryx(cuadrilatero.p00, alfa, beta);
cuadrilatero.p10 = Ryx(cuadrilatero.p10, alfa, beta);
cuadrilatero.p11 = Ryx(cuadrilatero.p11, alfa, beta);
cuadrilatero.p01 = Ryx(cuadrilatero.p01, alfa, beta);
}
public static function sumaDosPuntos(p1:Punto3D, p2:Punto3D):Punto3D{
return (new Punto3D((p1.x + p2.x), (p1.y + p2.y), (p1.z + p2.z)));
}
public static function RyxInversa(punto:Punto3D, alfa:Number, beta:Number):Punto3D{
var ca:Number = Math.cos(alfa);
var sa:Number = Math.sin(alfa);
var cb:Number = Math.cos(beta);
var sb:Number = Math.sin(beta);
return (new Punto3D((((punto.x * cb) + ((punto.y * sa) * sb)) + ((punto.z * ca) * sb)), ((punto.y * ca) - (punto.z * sa)), (((-(punto.x) * sb) + ((punto.y * sa) * cb)) + ((punto.z * ca) * cb))));
}
public static function RyxzInversa(punto:Punto3D, alfa:Number, beta:Number, gama:Number):Punto3D{
return (RyInversa(RxInversa(RzInversa(punto, alfa), beta), gama));
}
public static function productoPunto(p0:Punto3D, p1:Punto3D):Number{
return ((((p0.x * p1.x) + (p0.y * p1.y)) + (p0.z * p1.z)));
}
public static function RyInversa(punto:Punto3D, beta:Number):Punto3D{
return (new Punto3D(((punto.x * Math.cos(beta)) + (punto.z * Math.sin(beta))), punto.y, ((-(punto.x) * Math.sin(beta)) + (punto.z * Math.cos(beta)))));
}
public static function Rxyz(punto:Punto3D, alfa:Number, beta:Number, gama:Number):Punto3D{
var ca:Number = Math.cos(alfa);
var sa:Number = Math.sin(alfa);
var cb:Number = Math.cos(beta);
var sb:Number = Math.sin(beta);
var cg:Number = Math.cos(gama);
var sg:Number = Math.sin(gama);
return (new Punto3D(((((punto.x * cg) * cb) + (punto.y * (((cg * sa) * sb) + (sg * ca)))) + (punto.z * ((sg * sa) - ((cg * ca) * sb)))), ((((-(punto.x) * sg) * cb) + (punto.y * ((cg * ca) - ((sg * sa) * sb)))) + (punto.z * (((sg * ca) * sb) + (cg * sa)))), (((punto.x * sb) - ((punto.y * sa) * cb)) + ((punto.z * cb) * ca))));
}
public static function restaPuntosEscalado(p0:Punto3D, p1:Punto3D, k:Number):Punto3D{
var p:Punto3D = restaDosPuntos(p0, p1);
var n:Number = normaPunto(p);
return (new Punto3D(((k * p.x) / n), ((k * p.y) / n), ((k * p.z) / n)));
}
public static function restaDosPuntos(p1:Punto3D, p2:Punto3D):Punto3D{
return (new Punto3D((p1.x - p2.x), (p1.y - p2.y), (p1.z - p2.z)));
}
public static function Ryxz(punto:Punto3D, alfa:Number, beta:Number, gama:Number):Punto3D{
return (Rz(Rx(Ry(punto, alfa), beta), gama));
}
public static function Rzxz(punto:Punto3D, alfa:Number, beta:Number, gama:Number):Punto3D{
return (Rz(Rx(Rz(punto, alfa), beta), gama));
}
public static function Rzyx(punto:Punto3D, alfa:Number, beta:Number, gama:Number):Punto3D{
return (Ryx(Rz(punto, gama), alfa, beta));
}
public static function distancia(objeto1:ObjetoTridimensional, objeto2:ObjetoTridimensional):Number{
return (Math.sqrt(((Math.pow((objeto1.centro.x - objeto2.centro.x), 2) + Math.pow((objeto1.centro.y - objeto2.centro.y), 2)) + Math.pow((objeto1.centro.z - objeto2.centro.z), 2))));
}
public static function Rzy(punto:Punto3D, alfa:Number, beta:Number):Punto3D{
return (Ry(Rz(punto, alfa), beta));
}
public static function Rxy(punto:Punto3D, alfa:Number, beta:Number):Punto3D{
var ca:Number = Math.cos(alfa);
var sa:Number = Math.sin(alfa);
var cb:Number = Math.cos(beta);
var sb:Number = Math.sin(beta);
return (new Punto3D((((punto.x * cb) + ((punto.y * sa) * sb)) - ((punto.z * ca) * sb)), ((punto.y * ca) + (punto.z * sa)), (((punto.x * sb) - ((punto.y * sa) * cb)) + ((punto.z * ca) * cb))));
}
public static function productoCruz(p0:Punto3D, p1:Punto3D):Punto3D{
return (new Punto3D(((p0.y * p1.z) - (p0.z * p1.y)), ((p0.z * p1.x) - (p0.x * p1.z)), ((p0.x * p1.y) - (p0.y * p1.x))));
}
public static function interpolacion(p1:Punto3D, p2:Punto3D, t:Number):Punto3D{
return (new Punto3D(((t * p2.x) + ((1 - t) * p1.x)), ((t * p2.y) + ((1 - t) * p1.y)), ((t * p2.z) + ((1 - t) * p1.z))));
}
public static function distanciaPuntos(p1:Punto3D, p2:Punto3D):Number{
return (Math.sqrt(((Math.pow((p1.x - p2.x), 2) + Math.pow((p1.y - p2.y), 2)) + Math.pow((p1.z - p2.z), 2))));
}
public static function normaProductoCruz(p0:Punto3D, p1:Punto3D):Number{
return (Math.sqrt(((Math.pow(((p0.y * p1.z) - (p0.z * p1.y)), 2) + Math.pow(((p0.z * p1.x) - (p0.x * p1.z)), 2)) + Math.pow(((p0.x * p1.y) - (p0.y * p1.x)), 2))));
}
public static function multiplicacionEscalar(r:Number, p:Punto3D):Punto3D{
return (new Punto3D((r * p.x), (r * p.y), (r * p.z)));
}
public static function RzyInversa(punto:Punto3D, alfa:Number, beta:Number):Punto3D{
return (RzInversa(RyInversa(punto, alfa), beta));
}
public static function creaPuntoAngulos(norma:Number, alfa:Number, beta:Number, gama:Number):Punto3D{
var punto:Punto3D = new Punto3D(norma, 0, 0);
punto = Rxyz(punto, alfa, beta, gama);
return (punto);
}
public static function normaPunto(p:Punto3D):Number{
return (Math.sqrt(((Math.pow(p.x, 2) + Math.pow(p.y, 2)) + Math.pow(p.z, 2))));
}
public static function RxyInversa(punto:Punto3D, alfa:Number, beta:Number):Punto3D{
var ca:Number = Math.cos(alfa);
var sa:Number = Math.sin(alfa);
var cb:Number = Math.cos(beta);
var sb:Number = Math.sin(beta);
return (new Punto3D(((punto.x * cb) + (punto.z * sb)), ((((punto.x * sa) * sb) + (punto.y * ca)) - ((punto.z * sa) * cb)), ((((-(punto.x) * ca) * sb) + (punto.y * sa)) + ((punto.z * ca) * cb))));
}
public static function rota(punto:Punto3D, alfa:Number, beta:Number):Array{
var i:uint;
trace("rota es obselto, se usa Rxy");
var cb:Number = Math.cos(beta);
var sb:Number = Math.sin(beta);
var ca:Number = Math.cos(alfa);
var sa:Number = Math.sin(alfa);
var nuevoPunto:Array = [];
nuevoPunto[0] = ((punto.x * cb) - (punto.z * sb));
nuevoPunto[1] = ((((punto.x * sa) * sb) + (punto.y * ca)) + ((punto.z * sa) * cb));
nuevoPunto[2] = ((((punto.x * ca) * sb) - (punto.y * sa)) + ((punto.z * ca) * cb));
return (nuevoPunto);
}
public static function RzInversa(punto:Punto3D, gama:Number):Punto3D{
return (new Punto3D(((punto.x * Math.cos(gama)) - (punto.y * Math.sin(gama))), ((punto.x * Math.sin(gama)) + (punto.y * Math.cos(gama))), punto.z));
}
public static function RxyzInversa(punto:Punto3D, alfa:Number, beta:Number, gama:Number):Punto3D{
var ca:Number = Math.cos(alfa);
var sa:Number = Math.sin(alfa);
var cb:Number = Math.cos(beta);
var sb:Number = Math.sin(beta);
var cg:Number = Math.cos(gama);
var sg:Number = Math.sin(gama);
return (new Punto3D(((((punto.x * cg) * cb) - ((punto.y * sg) * cb)) + (punto.z * sb)), (((punto.x * (((cg * sa) * sb) + (sg * ca))) + (punto.y * ((cg * ca) - ((sg * sa) * sb)))) - ((punto.z * sa) * cb)), (((punto.x * ((sg * sa) - ((cg * ca) * sb))) + (punto.y * (((sg * ca) * sb) + (cg * sa)))) + ((punto.z * cb) * ca))));
}
public static function Rx(punto:Punto3D, alfa:Number):Punto3D{
return (new Punto3D(punto.x, ((punto.y * Math.cos(alfa)) + (punto.z * Math.sin(alfa))), ((-(punto.y) * Math.sin(alfa)) + (punto.z * Math.cos(alfa)))));
}
public static function normalizaPuntoEscalado(p:Punto3D, k:Number):Punto3D{
var n:Number = normaPunto(p);
return (new Punto3D(((k * p.x) / n), ((k * p.y) / n), ((k * p.z) / n)));
}
public static function Rz(punto:Punto3D, gama:Number):Punto3D{
return (new Punto3D(((punto.x * Math.cos(gama)) + (punto.y * Math.sin(gama))), ((-(punto.x) * Math.sin(gama)) + (punto.y * Math.cos(gama))), punto.z));
}
public static function puntoMedioDosPuntos(p1:Punto3D, p2:Punto3D):Punto3D{
return (new Punto3D(((p1.x + p2.x) * 0.5), ((p1.y + p2.y) * 0.5), ((p1.z + p2.z) * 0.5)));
}
public static function distancia2(objeto1:ObjetoTridimensional, objeto2:ObjetoTridimensional):Number{
return (((Math.pow((objeto1.centro.x - objeto2.centro.x), 2) + Math.pow((objeto1.centro.y - objeto2.centro.y), 2)) + Math.pow((objeto1.centro.z - objeto2.centro.z), 2)));
}
public static function Rxzx(punto:Punto3D, alfa:Number, beta:Number, gama:Number):Punto3D{
return (Rx(Rz(Rx(punto, alfa), beta), gama));
}
public static function RzyxInversa(punto:Punto3D, alfa:Number, beta:Number, gama:Number):Punto3D{
return (RzyInversa(RxInversa(punto, gama), alfa, beta));
}
public static function RxInversa(punto:Punto3D, alfa:Number):Punto3D{
return (new Punto3D(punto.x, ((punto.y * Math.cos(alfa)) - (punto.z * Math.sin(alfa))), ((punto.y * Math.sin(alfa)) + (punto.z * Math.cos(alfa)))));
}
public static function Ry(punto:Punto3D, beta:Number):Punto3D{
return (new Punto3D(((punto.x * Math.cos(beta)) - (punto.z * Math.sin(beta))), punto.y, ((punto.x * Math.sin(beta)) + (punto.z * Math.cos(beta)))));
}
public static function Rzxy(punto:Punto3D, alfa:Number, beta:Number, gama:Number):Punto3D{
return (Ry(Rx(Rz(punto, alfa), beta), gama));
}
public static function centroGravedadListaObjetosTridimensionales(listaObjetosTridimensionales:Array):Punto3D{
var centro:Punto3D = new Punto3D();
var i:uint;
while (i < listaObjetosTridimensionales.length) {
centro.x = (centro.x + listaObjetosTridimensionales[i].centro.x);
centro.y = (centro.y + listaObjetosTridimensionales[i].centro.y);
centro.z = (centro.z + listaObjetosTridimensionales[i].centro.z);
i++;
};
centro.x = (centro.x / listaObjetosTridimensionales.length);
centro.y = (centro.y / listaObjetosTridimensionales.length);
centro.z = (centro.z / listaObjetosTridimensionales.length);
return (centro);
}
public static function sumaPuntoACuadrilatero(cuadrilatero:Cuadrilatero3D, punto3D:Punto3D):void{
cuadrilatero.p00 = sumaDosPuntos(cuadrilatero.p00, punto3D);
cuadrilatero.p10 = sumaDosPuntos(cuadrilatero.p10, punto3D);
cuadrilatero.p11 = sumaDosPuntos(cuadrilatero.p11, punto3D);
cuadrilatero.p01 = sumaDosPuntos(cuadrilatero.p01, punto3D);
}
public static function Ryzy(punto:Punto3D, alfa:Number, beta:Number, gama:Number):Punto3D{
return (Ry(Rz(Ry(punto, alfa), beta), gama));
}
public static function sumaPuntoAVector(vector:Array, punto:Punto3D):Array{
var i:uint;
while (i < vector.length) {
vector[i] = sumaDosPuntos(vector[i], punto);
i++;
};
return (vector);
}
public static function centroGravedadListaCoordenadas(listaPuntos3D:Array):Punto3D{
var centro:Punto3D = new Punto3D();
var i:uint;
while (i < listaPuntos3D.length) {
centro.x = (centro.x + listaPuntos3D[i].x);
centro.y = (centro.y + listaPuntos3D[i].y);
centro.z = (centro.z + listaPuntos3D[i].z);
i++;
};
centro.x = (centro.x / listaPuntos3D.length);
centro.y = (centro.y / listaPuntos3D.length);
centro.z = (centro.z / listaPuntos3D.length);
return (centro);
}
public static function Ryx(punto:Punto3D, alfa:Number, beta:Number):Punto3D{
var ca:Number = Math.cos(alfa);
var sa:Number = Math.sin(alfa);
var cb:Number = Math.cos(beta);
var sb:Number = Math.sin(beta);
return (new Punto3D(((punto.x * cb) - (punto.z * sb)), ((((punto.x * sa) * sb) + (punto.y * ca)) + ((punto.z * sa) * cb)), ((((punto.x * ca) * sb) - (punto.y * sa)) + ((punto.z * ca) * cb))));
}
public static function distancia2Puntos(p1:Punto3D, p2:Punto3D):Number{
return (((Math.pow((p1.x - p2.x), 2) + Math.pow((p1.y - p2.y), 2)) + Math.pow((p1.z - p2.z), 2)));
}
public static function RxyCuadrilatero(cuadrilatero:Cuadrilatero3D, alfa:Number, beta:Number):void{
cuadrilatero.p00 = Rxy(cuadrilatero.p00, alfa, beta);
cuadrilatero.p10 = Rxy(cuadrilatero.p10, alfa, beta);
cuadrilatero.p11 = Rxy(cuadrilatero.p11, alfa, beta);
cuadrilatero.p01 = Rxy(cuadrilatero.p01, alfa, beta);
}
public static function normalizaPunto(p:Punto3D):Punto3D{
var n:Number = normaPunto(p);
return (new Punto3D((p.x / n), (p.y / n), (p.z / n)));
}
public static function interpolacionEscalar(p0:Punto3D, p1:Punto3D, d:Number):Array{
var restaEscalado:Punto3D = restaPuntosEscalado(p1, p0, d);
return ([(p1.x + restaEscalado[0]), (p1.y + restaEscalado[1]), (p1.z + restaEscalado[2])]);
}
public static function angulosXYZ(espacio3D:Espacio3D):Array{
var ii:Punto3D = espacio3D.ii;
var jj:Punto3D = espacio3D.jj;
var kk:Punto3D = espacio3D.kk;
var alfa:Number = Math.atan2(-(jj.z), kk.z);
var beta:Number = Math.asin(ii.z);
var gama:Number = Math.atan2(-(ii.y), ii.x);
return ([alfa, beta, gama]);
}
public static function angulosYXZ(espacio3D:Espacio3D):Array{
var ii:Punto3D = espacio3D.ii;
var jj:Punto3D = espacio3D.jj;
var kk:Punto3D = espacio3D.kk;
var alfa:Number = Math.asin(-(jj.z));
var beta:Number = Math.atan2(ii.z, kk.z);
var gama:Number = Math.atan2(jj.x, jj.y);
return ([beta, alfa, gama]);
}
public static function angulosZXZ(espacio3D:Espacio3D):Array{
var ii:Punto3D = espacio3D.ii;
var jj:Punto3D = espacio3D.jj;
var kk:Punto3D = espacio3D.kk;
var n:Punto3D = productoCruz(new Punto3D(0, 0, 1), kk);
var alfa:Number = -(Math.atan2(kk.x, -(kk.y)));
var beta:Number = Math.atan2(Math.sqrt((Math.pow(kk.x, 2) + Math.pow(kk.y, 2))), kk.z);
var gama:Number = Math.atan2(ii.z, jj.z);
return ([alfa, beta, gama]);
}
}
}//package personales.espacios.tresDimensiones
Section 21
//Punto3D (personales.espacios.tresDimensiones.Punto3D)
package personales.espacios.tresDimensiones {
import flash.geom.*;
public class Punto3D extends Point {
public var z:Number;
public function Punto3D(x:Number=0, y:Number=0, z:Number=0){
super(x, y);
this.z = z;
}
public function tracePunto3D(mensaje:String=""):void{
if (mensaje != ""){
mensaje = (" ----> " + mensaje);
};
trace((((((x + ", ") + y) + ", ") + z) + mensaje));
}
public function copiaValores(punto:Punto3D):void{
x = punto.x;
y = punto.y;
z = punto.z;
}
public function clona():Punto3D{
return (new Punto3D(x, y, z));
}
public function asignaValores(x:Number, y:Number, z:Number):void{
this.x = x;
this.y = y;
this.z = z;
}
}
}//package personales.espacios.tresDimensiones
Section 22
//FuerzaDeNodo (personales.fisica.fuerzas.FuerzaDeNodo)
package personales.fisica.fuerzas {
import personales.fisica.*;
public class FuerzaDeNodo {
public var nodo:ObjetoFisico;
public function FuerzaDeNodo(nodo:ObjetoFisico){
super();
this.nodo = nodo;
}
public function aplicaFuerzaANodo():void{
}
}
}//package personales.fisica.fuerzas
Section 23
//FuerzaEntreNodos (personales.fisica.fuerzas.FuerzaEntreNodos)
package personales.fisica.fuerzas {
import personales.fisica.*;
public class FuerzaEntreNodos {
public var nodo0:ObjetoFisico;
public var nodo1:ObjetoFisico;
public function FuerzaEntreNodos(nodo0:ObjetoFisico, nodo1:ObjetoFisico){
super();
this.nodo0 = nodo0;
this.nodo1 = nodo1;
}
public function aplicaFuerzaANodos():void{
var dx:Number = (nodo1.centro.x - nodo0.centro.x);
var dy:Number = (nodo1.centro.y - nodo0.centro.y);
var dz:Number = (nodo1.centro.z - nodo0.centro.z);
var d:Number = Math.sqrt((((dx * dx) + (dy * dy)) + (dz * dz)));
aplicaFuerzaANodos2(d, dx, dy, dz);
}
public function aplicaFuerzaANodos2(d:Number, dx:Number, dy:Number, dz:Number=0):void{
}
}
}//package personales.fisica.fuerzas
Section 24
//Resorte (personales.fisica.fuerzas.Resorte)
package personales.fisica.fuerzas {
import personales.fisica.*;
public class Resorte extends FuerzaEntreNodos {
public var distancaEquilibrio:Number;
public var k:Number;
public var isPreactive:Boolean;// = false
public function Resorte(nodo0:ObjetoFisico, nodo1:ObjetoFisico, k:Number, distancaEquilibrio:Number){
super(nodo0, nodo1);
this.k = k;
this.distancaEquilibrio = distancaEquilibrio;
}
override public function aplicaFuerzaANodos2(d:Number, dx:Number, dy:Number, dz:Number=0):void{
var fuerzaDivididaDistancia:Number = ((k * (d - distancaEquilibrio)) / d);
nodo0.ax = (nodo0.ax + ((fuerzaDivididaDistancia * dx) * nodo1.masa));
nodo0.ay = (nodo0.ay + ((fuerzaDivididaDistancia * dy) * nodo1.masa));
nodo0.az = (nodo0.az + ((fuerzaDivididaDistancia * dz) * nodo1.masa));
nodo1.ax = (nodo1.ax - ((fuerzaDivididaDistancia * dx) * nodo0.masa));
nodo1.ay = (nodo1.ay - ((fuerzaDivididaDistancia * dy) * nodo0.masa));
nodo1.az = (nodo1.az - ((fuerzaDivididaDistancia * dz) * nodo0.masa));
}
}
}//package personales.fisica.fuerzas
Section 25
//MatrizFuerzas (personales.fisica.MatrizFuerzas)
package personales.fisica {
import personales.fisica.fuerzas.*;
import personales.utilidades.*;
public class MatrizFuerzas {
public var matriz:Array;
public var listaObjetos:Array;
public var nResortes:uint;// = 0
public function MatrizFuerzas(){
listaObjetos = [];
matriz = [];
super();
}
public function creaResorte(nodo0:ObjetoFisico, nodo1:ObjetoFisico, k:Number, length:Number):Resorte{
var resorte:Resorte = new Resorte(nodo0, nodo1, k, length);
var numMin:uint = Math.min(nodo0.numero, nodo1.numero);
listaObjetos.push(resorte);
nResortes++;
if (matriz[numMin] == null){
matriz[numMin] = [];
};
matriz[numMin][Math.max(nodo0.numero, nodo1.numero)] = resorte;
return (resorte);
}
public function eliminaResorte(nodo0:ObjetoFisico, nodo1:ObjetoFisico):void{
apagaPorCoordenadas(nodo0.numero, nodo1.numero);
}
public function apagaPorCoordenadas(i:uint, j:uint):Boolean{
var min:uint = Math.min(i, j);
var max:uint = Math.max(i, j);
if (((!((matriz[min] == null))) && (!((matriz[min][max] == null))))){
Arreglos.eliminaSegunElementoUnaVez(listaObjetos, matriz[min][max]);
matriz[min][max] = null;
nResortes--;
return (true);
};
return (false);
}
public function apagaPorCoordenadasOrdenCorrecto(i:uint, j:uint):Boolean{
if (((!((matriz[i] == null))) && (!((matriz[i][j] == null))))){
Arreglos.eliminaSegunElementoUnaVez(listaObjetos, matriz[i][j]);
matriz[i][j] = null;
nResortes--;
return (true);
};
return (false);
}
public function limpia():void{
listaObjetos = [];
matriz = [];
nResortes = 0;
}
public function adicionaFuerza(fuerza:FuerzaEntreNodos):void{
var numMin:uint = Math.min(fuerza.nodo0.numero, fuerza.nodo1.numero);
listaObjetos.push(fuerza);
nResortes++;
if (matriz[numMin] == null){
matriz[numMin] = [];
};
matriz[numMin][Math.max(fuerza.nodo0.numero, fuerza.nodo1.numero)] = fuerza;
}
}
}//package personales.fisica
Section 26
//MotorFisico (personales.fisica.MotorFisico)
package personales.fisica {
import personales.fisica.fuerzas.*;
public class MotorFisico {
public var finalVerificationRadius:Number;// = 1.4
public var sepringsInterval:uint;// = 1000
public var friccion:Number;
public var verificationRadius:Number;// = 4
private var preActiveSeprings:Array;
private var nE:uint;// = 0
public function MotorFisico(friccion:Number=0.9){
preActiveSeprings = [];
super();
this.friccion = friccion;
}
public function aplicaFuerzasConfinadasDeMatrizResortesEficiente(matrizResortes:MatrizFuerzas):void{
var nodo0:ObjetoFisico;
var nodo1:ObjetoFisico;
var sepring:Resorte;
var nPreActives:uint;
var d:Number;
var dx:Number;
var dy:Number;
var dz:Number;
var forceDividedByDistance:Number;
var i:uint = nE;
while (i < (nE + sepringsInterval)) {
sepring = matrizResortes.listaObjetos[(i % matrizResortes.nResortes)];
nodo0 = sepring.nodo0;
nodo1 = sepring.nodo1;
d = Math.sqrt(((Math.pow((nodo0.centro.x - nodo1.centro.x), 2) + Math.pow((nodo0.centro.y - nodo1.centro.y), 2)) + Math.pow((nodo0.centro.z - nodo1.centro.z), 2)));
if ((((d < (sepring.distancaEquilibrio * verificationRadius))) && (!(sepring.isPreactive)))){
preActiveSeprings.push(sepring);
sepring.isPreactive = true;
};
i++;
};
nE = ((nE + sepringsInterval) % matrizResortes.nResortes);
nPreActives = preActiveSeprings.length;
i = 0;
while (i < nPreActives) {
sepring = preActiveSeprings[i];
nodo0 = sepring.nodo0;
nodo1 = sepring.nodo1;
dx = (nodo1.centro.x - nodo0.centro.x);
dy = (nodo1.centro.y - nodo0.centro.y);
dz = (nodo1.centro.z - nodo0.centro.z);
d = Math.sqrt(((Math.pow((nodo0.centro.x - nodo1.centro.x), 2) + Math.pow((nodo0.centro.y - nodo1.centro.y), 2)) + Math.pow((nodo0.centro.z - nodo1.centro.z), 2)));
if (d < sepring.distancaEquilibrio){
sepring.aplicaFuerzaANodos2(d, dx, dy, dz);
} else {
if (d > (sepring.distancaEquilibrio * verificationRadius)){
preActiveSeprings.splice(i, 1);
i--;
nPreActives--;
sepring.isPreactive = false;
};
};
i++;
};
verificationRadius = (((150 * verificationRadius) + finalVerificationRadius) / 151);
}
public function ejecutaFuerzasEnListaYAplicaFriccion(nodosList:Array):void{
var nodo:ObjetoFisico;
var i:uint;
while (i < nodosList.length) {
nodo = nodosList[i];
nodo.ejecutaFuerzas();
nodo.vx = (nodo.vx * friccion);
nodo.vy = (nodo.vy * friccion);
nodo.vz = (nodo.vz * friccion);
i++;
};
}
public function aplicaFriccionEnObjeto(nodo:ObjetoFisico):void{
nodo.vx = (nodo.vx * friccion);
nodo.vy = (nodo.vy * friccion);
nodo.vz = (nodo.vz * friccion);
}
public function aplicaFriccionEnLista(nodosList:Array):void{
var i:uint;
while (i < nodosList.length) {
aplicaFriccionEnObjeto(nodosList[i]);
i++;
};
}
public static function ejecutaFuerzasEnListaConFisicaActiva(nodosList:Array):void{
var nodo:ObjetoFisico;
var i:uint;
while (i < nodosList.length) {
nodo = nodosList[i];
if (nodo.fisicaActiva){
nodo.ejecutaFuerzas();
};
i++;
};
}
public static function ejecutaFuerzasEnObjeto(nodo:ObjetoFisico):void{
nodo.ejecutaFuerzas();
}
public static function aplicaFuerzasConfinadasDeMatrizResortes(matrizResortes:MatrizFuerzas):void{
var i:uint;
while (i < matrizResortes.nResortes) {
aplicaFuerzaConfinadaResorte(matrizResortes.listaObjetos[i]);
i++;
};
}
public static function ejecutaFuerzasEnObjetoConFisicaActiva(nodo:ObjetoFisico):void{
if (nodo.fisicaActiva){
nodo.ejecutaFuerzas();
};
}
public static function ejecutaFuerzasEnLista(nodosList:Array):void{
var nodo:ObjetoFisico;
var i:uint;
while (i < nodosList.length) {
nodo = nodosList[i];
nodo.ejecutaFuerzas();
i++;
};
}
public static function aplicaFuerzasDeMatriz(matrizFuerzas:MatrizFuerzas):void{
var i:uint;
while (i < matrizFuerzas.nResortes) {
FuerzaEntreNodos(matrizFuerzas.listaObjetos[i]).aplicaFuerzaANodos();
i++;
};
}
public static function aplicaFuerzaConfinadaResorte(resorte:Resorte):void{
var nodo0:ObjetoFisico = resorte.nodo0;
var nodo1:ObjetoFisico = resorte.nodo1;
var dx:Number = (nodo1.centro.x - nodo0.centro.x);
var dy:Number = (nodo1.centro.y - nodo0.centro.y);
var dz:Number = (nodo1.centro.z - nodo0.centro.z);
var d:Number = Math.sqrt((((dx * dx) + (dy * dy)) + (dz * dz)));
if (d < resorte.distancaEquilibrio){
resorte.aplicaFuerzaANodos2(d, dx, dy, dz);
};
}
}
}//package personales.fisica
Section 27
//ObjetoFisico (personales.fisica.ObjetoFisico)
package personales.fisica {
import personales.fisica.fuerzas.*;
import personales.espacios.tresDimensiones.objetosTridimensionales.*;
public class ObjetoFisico extends ObjetoTridimensional {
public var az:Number;// = 0
public var vx:Number;// = 0
public var vy:Number;// = 0
public var ay:Number;// = 0
public var x0:Number;// = 0
public var x1:Number;// = 0
public var vz:Number;// = 0
public var fisicaActiva:Boolean;// = true
public var numero:uint;
public var masa:Number;// = 1
public var fuerza:FuerzaDeNodo;
public var ax:Number;// = 0
public var radio:Number;// = 1
public var t0:Number;// = 0
public var t1:Number;// = 0
public function ObjetoFisico(numero:uint){
super();
}
public function ejecutaFuerzas():void{
vx = (vx + ax);
vy = (vy + ay);
vz = (vz + az);
centro.x = (centro.x + vx);
centro.y = (centro.y + vy);
centro.z = (centro.z + vz);
ax = (ay = (az = 0));
}
}
}//package personales.fisica
Section 28
//PuntoGeo (personales.geo.objetos.PuntoGeo)
package personales.geo.objetos {
public class PuntoGeo {
public var longitud:Number;
public var latitud:Number;
public function PuntoGeo(longitud:Number, latitud:Number){
super();
this.longitud = longitud;
this.latitud = latitud;
}
public function get letraLongitud():String{
if (longitud < 0){
return ("W");
};
return ("E");
}
public function get minutosLatitud():Number{
return (Math.floor((((signoLatitud * latitud) - Math.floor((signoLatitud * latitud))) * 60)));
}
public function get signoLatitud():int{
if (latitud < 0){
return (-1);
};
return (1);
}
public function get signoLongitud():int{
if (longitud < 0){
return (-1);
};
return (1);
}
public function get minutosLongitud():Number{
return (Math.floor((((signoLongitud * longitud) - Math.floor((signoLongitud * longitud))) * 60)));
}
public function get gradosLatitud():Number{
return (Math.floor((signoLatitud * latitud)));
}
public function get gradosLongitud():Number{
return (Math.floor((signoLongitud * longitud)));
}
public function get textoCoordenadas():String{
var signoLat = 1;
var letraLat:String = "N";
if (latitud < 0){
signoLat = -1;
letraLat = "S";
};
var signoLong = 1;
var letraLong:String = "E";
if (longitud < 0){
signoLong = -1;
letraLong = "W";
};
return (((((((((((gradosLatitud + "º") + minutosLatitud) + "' ") + letraLat) + ", ") + gradosLongitud) + "º") + minutosLongitud) + "' ") + letraLongitud));
}
public function traceCoordenadas(decimales:Boolean=true):void{
if (decimales){
trace(((((Math.floor((longitud * 100)) / 100) + "º, ") + (Math.floor((latitud * 100)) / 100)) + "º"));
} else {
trace(textoCoordenadas);
};
}
public function get letraLatitud():String{
if (latitud < 0){
return ("S");
};
return ("N");
}
}
}//package personales.geo.objetos
Section 29
//Colores (personales.grafica.colores.Colores)
package personales.grafica.colores {
public class Colores {
public static var grisClaro:uint = (((230 << 16) | (230 << 8)) | 230);
public static var gris6:uint = creaGris(0.6);
public static var gris7:uint = creaGris(0.7);
public static var gris8:uint = creaGris(0.8);
public static var gris5:uint = creaGris(0.5);
public static var azul:uint = 0xFF;
public static var cian:uint = (azul | verde);
public static var gris01:uint = creaGris(0.01);
public static var cafeOscuro:uint = ((30 << 16) | (5 << 8));
public static var gris03:uint = creaGris(0.03);
public static var gris04:uint = creaGris(0.04);
public static var gris06:uint = creaGris(0.06);
public static var morado:uint = (((200 << 16) | (10 << 8)) | 180);
public static var rosado:uint = ((rojo | (200 << 8)) | 200);
public static var verdeOscuro:uint = (100 << 8);
public static var gris05:uint = creaGris(0.05);
public static var blanco:uint = ((azul | verde) | rojo);
public static var cafe:uint = ((180 << 16) | (20 << 8));
public static var azulClaro:uint = (((200 << 16) | (200 << 8)) | azul);
public static var magenta:uint = (rojo | azul);
public static var gris09:uint = creaGris(0.09);
public static var gris02:uint = creaGris(0.02);
public static var naranjaOscuro:uint = ((rojo | (100 << 8)) | 20);
public static var cafeClaro:uint = ((210 << 16) | (40 << 8));
public static var rojo:uint = (0xFF << 16);
public static var amarillo:uint = (rojo | verde);
public static var gris07:uint = creaGris(0.07);
public static var naranja:uint = ((rojo | (150 << 8)) | 50);
public static var negro:uint = 0;
public static var verdeClaro:uint = (((100 << 16) | verde) | 100);
public static var naranjaClaro:uint = ((rojo | (220 << 8)) | 200);
public static var gris:uint = (((128 << 16) | (128 << 8)) | 128);
public static var gris08:uint = creaGris(0.08);
public static var gris9:uint = creaGris(0.9);
public static var azulOscuro:uint = 100;
public static var rosadoClaro:uint = ((rojo | (230 << 8)) | 230);
public static var amarilloClaro:uint = ((rojo | verde) | 150);
public static var verde:uint = (0xFF << 8);
public static var gris1:uint = creaGris(0.1);
public static var gris2:uint = creaGris(0.2);
public static var gris3:uint = creaGris(0.3);
public static var gris4:uint = creaGris(0.4);
public function Colores(){
super();
}
public static function separa32(color0:uint):Array{
return ([(color0 >> 24), ((color0 >> 16) - ((color0 >> 24) << 16)), (color0 - ((color0 >> 8) << 16))]);
}
public static function creaColorAleatorio():uint{
return ((((Math.floor((0x0100 * Math.random())) << 16) | (Math.floor((0x0100 * Math.random())) << 8)) | Math.floor((0x0100 * Math.random()))));
}
public static function creaColorAleatorioConRango(min:Number, max:Number):uint{
return ((((Math.floor((0x0100 * (min + ((max - min) * Math.random())))) << 16) | (Math.floor((0x0100 * (min + ((max - min) * Math.random())))) << 8)) | Math.floor((0x0100 * (min + ((max - min) * Math.random()))))));
}
public static function promedioLista(listaColores:Array):uint{
var r0:uint;
var g0:uint;
var b0:uint;
var i:uint;
while (i < listaColores.length) {
r0 = (r0 + (listaColores[i] >> 16));
g0 = (g0 + ((listaColores[i] >> 8) - ((listaColores[i] >> 16) << 8)));
b0 = (b0 + (listaColores[i] - ((listaColores[i] >> 8) << 8)));
i++;
};
return ((((Math.floor((r0 / listaColores.length)) << 16) | (Math.floor((g0 / listaColores.length)) << 8)) | Math.floor((b0 / listaColores.length))));
}
public static function mideLuz(color0:uint):Number{
return (((((color0 >> 16) + ((color0 >> 8) - ((color0 >> 16) << 8))) + (color0 - ((color0 >> 8) << 8))) / 765));
}
public static function creaGrisAleatorio():uint{
return (creaGris(Math.random()));
}
public static function creaGris(ng:Number):uint{
return ((((Math.floor((0xFF * (1 - ng))) << 16) | (Math.floor((0xFF * (1 - ng))) << 8)) | Math.floor((0xFF * (1 - ng)))));
}
public static function separa(color0:uint):Array{
return ([(color0 >> 16), ((color0 >> 8) - ((color0 >> 16) << 8)), (color0 - ((color0 >> 8) << 8))]);
}
public static function creaColorNormalizado(ir:Number, ig:Number, ib:Number):uint{
return ((((Math.floor((0xFF * ir)) << 16) | (Math.floor((0xFF * ig)) << 8)) | Math.floor((0xFF * ib))));
}
public static function vectorHSVaRGB(vectorHSV:Array):uint{
var r:Number;
var g:Number;
var b:Number;
var i:int;
var f:Number;
var p:Number;
var q:Number;
var t:Number;
var h:Number = vectorHSV[0];
var s:Number = vectorHSV[1];
var v:Number = vectorHSV[2];
if (s == 0){
b = v;
g = b;
r = g;
return ((((Math.floor((r * 0xFF)) << 16) | (Math.floor((g * 0xFF)) << 8)) | Math.floor((b * 0xFF))));
};
h = (h / 60);
i = Math.floor(h);
f = (h - i);
p = (v * (1 - s));
q = (v * (1 - (s * f)));
t = (v * (1 - (s * (1 - f))));
switch (i){
case 0:
r = v;
g = t;
b = p;
break;
case 1:
r = q;
g = v;
b = p;
break;
case 2:
r = p;
g = v;
b = t;
break;
case 3:
r = p;
g = q;
b = v;
break;
case 4:
r = t;
g = p;
b = v;
break;
default:
r = v;
g = p;
b = q;
break;
};
return ((((Math.floor((r * 0xFF)) << 16) | (Math.floor((g * 0xFF)) << 8)) | Math.floor((b * 0xFF))));
}
public static function promedioPonderadoLista(matrizColoresYPesos:Array):uint{
var r0:uint;
var g0:uint;
var b0:uint;
var pesos:Number = 0;
var i:uint;
while (i < matrizColoresYPesos.length) {
r0 = (r0 + (matrizColoresYPesos[i][1] * (matrizColoresYPesos[i][0] >> 16)));
g0 = (g0 + (matrizColoresYPesos[i][1] * ((matrizColoresYPesos[i][0] >> 8) - ((matrizColoresYPesos[i][0] >> 16) << 8))));
b0 = (b0 + (matrizColoresYPesos[i][1] * (matrizColoresYPesos[i][0] - ((matrizColoresYPesos[i][0] >> 8) << 8))));
pesos = (pesos + matrizColoresYPesos[i][1]);
i++;
};
return ((((Math.floor((r0 / pesos)) << 16) | (Math.floor((g0 / pesos)) << 8)) | Math.floor((b0 / pesos))));
}
public static function vectorRGBavectorHSV(vectorRGB:Array):Array{
var h:Number;
var s:Number;
var v:Number;
var r:Number = (vectorRGB[0] / 0xFF);
var g:Number = (vectorRGB[1] / 0xFF);
var b:Number = (vectorRGB[2] / 0xFF);
var min:Number = Math.min(Math.min(r, g), b);
var max:Number = Math.max(Math.max(r, g), b);
v = max;
var delta:Number = (max - min);
if (max != 0){
s = (delta / max);
} else {
s = 0;
h = -1;
return ([h, s, v]);
};
if (r == max){
h = ((g - b) / delta);
} else {
if (g == max){
h = (2 + ((b - r) / delta));
} else {
h = (4 + ((r - g) / delta));
};
};
h = (h * 60);
if (h < 0){
h = (h + 360);
};
return ([h, s, v]);
}
public static function promedio(color0:uint, color1:uint):uint{
var r0:uint = (color0 >> 16);
var g0:uint = ((color0 >> 8) - ((color0 >> 16) << 8));
var b0:uint = (color0 - ((color0 >> 8) << 8));
var r1:uint = (color1 >> 16);
var g1:uint = ((color1 >> 8) - ((color1 >> 16) << 8));
var b1:uint = (color1 - ((color1 >> 8) << 8));
return ((((Math.floor(((r0 + r1) * 0.5)) << 16) | (Math.floor(((g0 + g1) * 0.5)) << 8)) | Math.floor(((b0 + b1) * 0.5))));
}
public static function creaColor(r:uint, g:uint, b:uint):uint{
return ((((r << 16) | (g << 8)) | b));
}
public static function vectorHSVavectorRGB(vectorHSV:Array):Array{
var r:Number;
var g:Number;
var b:Number;
var i:int;
var f:Number;
var p:Number;
var q:Number;
var t:Number;
var h:Number = vectorHSV[0];
var s:Number = vectorHSV[1];
var v:Number = vectorHSV[2];
if (s == 0){
b = v;
g = b;
r = g;
return ([Math.floor((r * 0xFF)), Math.floor((g * 0xFF)), Math.floor((b * 0xFF))]);
};
h = (h / 60);
i = Math.floor(h);
f = (h - i);
p = (v * (1 - s));
q = (v * (1 - (s * f)));
t = (v * (1 - (s * (1 - f))));
switch (i){
case 0:
r = v;
g = t;
b = p;
break;
case 1:
r = q;
g = v;
b = p;
break;
case 2:
r = p;
g = v;
b = t;
break;
case 3:
r = p;
g = q;
b = v;
break;
case 4:
r = t;
g = p;
b = v;
break;
default:
r = v;
g = p;
b = q;
break;
};
return ([Math.floor((r * 0xFF)), Math.floor((g * 0xFF)), Math.floor((b * 0xFF))]);
}
public static function interpolacion(color0:uint, color1:uint, nivel:Number):uint{
var r0:uint = (color0 >> 16);
var g0:uint = ((color0 >> 8) - ((color0 >> 16) << 8));
var b0:uint = (color0 - ((color0 >> 8) << 8));
var r1:uint = (color1 >> 16);
var g1:uint = ((color1 >> 8) - ((color1 >> 16) << 8));
var b1:uint = (color1 - ((color1 >> 8) << 8));
return ((((Math.floor((r0 + ((r1 - r0) * nivel))) << 16) | (Math.floor((g0 + ((g1 - g0) * nivel))) << 8)) | Math.floor((b0 + ((b1 - b0) * nivel)))));
}
}
}//package personales.grafica.colores
Section 30
//EscalasColores (personales.grafica.colores.EscalasColores)
package personales.grafica.colores {
public class EscalasColores {
public function EscalasColores(){
super();
}
public static function espectro(n:Number):uint{
return (Colores.vectorHSVaRGB([(Math.floor((n * 360)) % 360), 1, 1]));
}
public static function gamaCompleta(n:Number):uint{
return ((((Math.floor((0xFF * n)) << 16) | (Math.floor((0xFF * ((0.5 * Math.cos((((n * 3) * Math.PI) - Math.PI))) + 0.5))) << 8)) | Math.floor((0xFF * ((0.5 * Math.cos((((n * 7) * Math.PI) - Math.PI))) + 0.5)))));
}
public static function gamaNegroARojo(n:Number):uint{
return ((Math.floor((0xFF * n)) << 16));
}
public static function colorHSV(h:Number, s:Number, v:Number):uint{
return (Colores.vectorHSVaRGB([h, s, v]));
}
public static function gamaCompletaInversa(n:Number):uint{
return ((((Math.floor((0xFF * (1 - n))) << 16) | (Math.floor((0xFF * ((0.5 * Math.cos(((((1 - n) * 3) * Math.PI) - Math.PI))) + 0.5))) << 8)) | Math.floor((0xFF * ((0.5 * Math.cos(((((1 - n) * 7) * Math.PI) - Math.PI))) + 0.5)))));
}
public static function gamaBlancoAAzulOscuro(n:Number):uint{
return ((((Math.floor((0xFF * (1 - n))) << 16) | (Math.floor((0xFF * (1 - n))) << 8)) | Math.floor((0xFF * (1 - (n * 0.4))))));
}
public static function escalaTemperatura(valor:Number):uint{
if (valor < 0.2){
return (Colores.interpolacion(0, espectro(0.65), (valor * 5)));
};
if (valor > 0.85){
return (Colores.interpolacion(espectro(0), Colores.blanco, ((valor - 0.85) / 0.15)));
};
return (espectro((0.65 - (valor - 0.2))));
}
}
}//package personales.grafica.colores
Section 31
//PaletasColores (personales.grafica.colores.PaletasColores)
package personales.grafica.colores {
import flash.display.*;
import flash.geom.*;
import flash.filters.*;
public class PaletasColores {
public function PaletasColores(){
super();
}
public static function aplicaBlurYPaletaDesdeFuncion(mb:BitmapData, rectangulo:Rectangle, funcionDistribuyeColor:Function, rBlur:Number=60):void{
var blur:BlurFilter = new BlurFilter(rBlur, rBlur);
mb.applyFilter(mb, rectangulo, new Point(0, 0), blur);
var arreglosDeColor:Array = tresArreglosDeColorDesdeFuncion(funcionDistribuyeColor);
mb.paletteMap(mb, rectangulo, new Point(0, 0), arreglosDeColor[0], arreglosDeColor[1], arreglosDeColor[2]);
}
public static function aplicaPaletaDesdeFuncion(mb:BitmapData, rectangulo:Rectangle, funcionDistribuyeColor:Function):void{
var arreglosDeColor:Array = tresArreglosDeColorDesdeFuncion(funcionDistribuyeColor);
mb.paletteMap(mb, rectangulo, new Point(0, 0), arreglosDeColor[0], arreglosDeColor[1], arreglosDeColor[2]);
}
public static function stampaPaletaDesdeFuncionConBlur(lienzo:Sprite, fuente:Sprite, ancho:Number, alto:Number, funcionDistribuyeColor:Function, rBlur:Number=60):void{
var bmpData:BitmapData = new BitmapData(ancho, alto, false, 0xFFFFFF);
bmpData.draw(fuente, new Matrix(1, 0, 0, 1, 0, 0));
var blur:BlurFilter = new BlurFilter(rBlur, rBlur);
bmpData.applyFilter(bmpData, new Rectangle(0, 0, ancho, alto), new Point(0, 0), blur);
aplicaPaletaDesdeFuncion(bmpData, new Rectangle(0, 0, ancho, alto), funcionDistribuyeColor);
lienzo.graphics.clear();
lienzo.graphics.beginBitmapFill(bmpData, new Matrix(1, 0, 0, 1, 0, 0));
lienzo.graphics.drawRect(0, 0, ancho, alto);
lienzo.graphics.endFill();
}
public static function aplicaArreglos(mb:BitmapData, rectangulo:Rectangle, arregloRojo:Array, arregloVerde:Array, arregloAzul:Array):void{
mb.paletteMap(mb, rectangulo, new Point(0, 0), arregloRojo, arregloVerde, arregloAzul);
}
private static function tresArreglosDeColorDesdeFuncion(funcionDistribuyeColor:Function):Array{
return ([arregloDeColorDesdeFuncion(Colores.rojo, funcionDistribuyeColor), arregloDeColorDesdeFuncion(Colores.verde, funcionDistribuyeColor), arregloDeColorDesdeFuncion(Colores.azul, funcionDistribuyeColor)]);
}
public static function estampaPaletaDesdeFuncion(lienzo:Sprite, fuente:Sprite, ancho:Number, alto:Number, funcionDistribuyeColor:Function):void{
var bmpData:BitmapData = new BitmapData(ancho, alto, false, 0xFFFFFF);
bmpData.draw(fuente, new Matrix(1, 0, 0, 1, 0, 0));
aplicaPaletaDesdeFuncion(bmpData, new Rectangle(0, 0, ancho, alto), funcionDistribuyeColor);
lienzo.graphics.clear();
lienzo.graphics.beginBitmapFill(bmpData, new Matrix(1, 0, 0, 1, 0, 0));
lienzo.graphics.drawRect(0, 0, ancho, alto);
lienzo.graphics.endFill();
}
public static function arregloDeColorDesdeFuncion(colorBase:uint, funcionDistribuyeColor:Function):Array{
var arreglo:Array = new Array(0x0100);
var i:uint;
while (i < 0x0100) {
arreglo[i] = Colores.interpolacion(Colores.negro, colorBase, funcionDistribuyeColor((i / 0x0100)));
i++;
};
return (arreglo);
}
}
}//package personales.grafica.colores
Section 32
//BotonFullScreen (personales.interfaz.botones.BotonFullScreen)
package personales.interfaz.botones {
import flash.events.*;
import flash.display.*;
public class BotonFullScreen extends BotonTexto {
public var modoPantalla:Boolean;// = false
public function BotonFullScreen(colorTexto0:uint=0, colorTexto1:uint=16320, colorFondo0:uint=0, colorFondo1:uint=0, tamano:uint=10, alfa:Number=0){
super("fullscreen", colorTexto0, colorTexto1, colorFondo0, colorFondo1, clicaFullscreen, tamano, alfa);
}
private function clicaFullscreen(botonFullscreen:BotonTexto):void{
if (!modoPantalla){
botonFullscreen.texto = "x fullscreen";
goFullScreen();
modoPantalla = true;
} else {
botonFullscreen.texto = "fullscreen";
exitFullScreen(undefined);
modoPantalla = false;
};
}
protected function goFullScreen():void{
this.stage.displayState = StageDisplayState.FULL_SCREEN;
this.stage.addEventListener(Event.RESIZE, exitFullScreen);
}
protected function exitFullScreen(e:Event=null):void{
this.stage.displayState = StageDisplayState.NORMAL;
this.stage.removeEventListener(Event.RESIZE, exitFullScreen);
}
}
}//package personales.interfaz.botones
Section 33
//BotonTexto (personales.interfaz.botones.BotonTexto)
package personales.interfaz.botones {
import flash.events.*;
import clases.*;
import flash.text.*;
import flash.display.*;
public class BotonTexto extends Sprite {
public var campo:TextField;
public var colorTexto0:uint;
public var colorTexto1:uint;
public var numero:uint;
private var _texto:String;
public var alfa:Number;
public var funcionClic:Function;
public var colorFondo0:uint;
public var colorFondo1:uint;
public var evento:Event;
public function BotonTexto(texto:String, colorTexto0:uint, colorTexto1:uint, colorFondo0:uint, colorFondo1:uint, funcionClic:Function=null, tamano:uint=12, alfa:Number=1){
super();
ubicaCampo();
this.texto = texto;
tamanoTexto(tamano);
this.colorTexto0 = colorTexto0;
this.colorTexto1 = colorTexto1;
this.colorFondo0 = colorFondo0;
this.colorFondo1 = colorFondo1;
this.funcionClic = funcionClic;
this.alfa = alfa;
this.texto = texto;
comportamientos();
if (this.stage == null){
this.addEventListener(Event.ADDED_TO_STAGE, rectanguloInicial);
} else {
rectanguloInicial(undefined);
};
}
public function tamanoTexto(tamano:uint):void{
var formato:TextFormat = new TextFormat();
formato.size = tamano;
campo.defaultTextFormat = formato;
campo.autoSize = "left";
rectangulo(colorFondo0);
}
private function rectangulo(colorRectangulo:uint):void{
this.graphics.clear();
this.graphics.beginFill(colorRectangulo, alfa);
this.graphics.drawRect(0, 2, (Math.floor(campo.width) + 1), (Math.round(campo.height) - 4));
this.graphics.endFill();
}
public function clic(e:Event):void{
evento = e;
funcionClic(this);
e.stopImmediatePropagation();
}
public function set texto(texto:String):void{
_texto = texto;
campo.text = _texto;
campo.autoSize = "left";
campo.textColor = colorTexto0;
rectangulo(colorFondo0);
}
private function sale(e:Event):void{
rectangulo(colorFondo0);
campo.textColor = colorTexto0;
}
private function rectanguloInicial(e:Event):void{
campo.mouseEnabled = false;
this.buttonMode = true;
this.useHandCursor = true;
this.mouseEnabled = true;
rectangulo(colorFondo0);
}
private function ubicaCampo():void{
campo = new TextField();
var formato:TextFormat = new TextFormat(Principal.fuente, 12, colorTexto0);
campo.defaultTextFormat = formato;
campo.selectable = false;
campo.embedFonts = true;
campo.antiAliasType = "advanced";
this.addChild(campo);
}
public function desActiva():void{
this.removeEventListener(MouseEvent.MOUSE_OVER, sobre);
this.removeEventListener(MouseEvent.MOUSE_OUT, sale);
this.removeEventListener(MouseEvent.CLICK, clic);
this.removeEventListener(Event.ADDED_TO_STAGE, rectanguloInicial);
}
public function get texto():String{
return (_texto);
}
public function reActiva():void{
this.addEventListener(MouseEvent.MOUSE_OVER, sobre);
this.addEventListener(MouseEvent.MOUSE_OUT, sale);
this.addEventListener(MouseEvent.CLICK, clic);
this.addEventListener(Event.ADDED_TO_STAGE, rectanguloInicial);
}
public function sobre(e:Event):void{
rectangulo(colorFondo1);
campo.textColor = colorTexto1;
}
private function comportamientos():void{
this.addEventListener(MouseEvent.MOUSE_OVER, sobre, false, 0, true);
this.addEventListener(MouseEvent.MOUSE_OUT, sale, false, 0, true);
if (funcionClic != null){
this.addEventListener(MouseEvent.CLICK, clic, false, 0, true);
};
}
public function limpia():void{
this.removeEventListener(MouseEvent.MOUSE_OVER, sobre);
this.removeEventListener(MouseEvent.MOUSE_OUT, sale);
this.removeEventListener(MouseEvent.CLICK, clic);
this.removeEventListener(Event.ADDED_TO_STAGE, rectanguloInicial);
this.buttonMode = false;
this.useHandCursor = false;
this.mouseEnabled = false;
removeChild(campo);
this.graphics.clear();
}
}
}//package personales.interfaz.botones
Section 34
//BotonTextoConURL (personales.interfaz.botones.BotonTextoConURL)
package personales.interfaz.botones {
import flash.events.*;
import flash.text.*;
import flash.display.*;
import flash.net.*;
public class BotonTextoConURL extends Sprite {
public var campo:TextField;
public var colorTexto0:uint;
public var colorTexto1:uint;
public var blank:Boolean;
public var numero:uint;
private var _texto:String;
public var alfa:Number;
public var colorFondo0:uint;
public var colorFondo1:uint;
public var url:String;
public var anchoDeterminado:Number;
public function BotonTextoConURL(texto:String, url:String, blank:Boolean, colorTexto0:uint, colorTexto1:uint, colorFondo0:uint, colorFondo1:uint, tamano:uint=12, alfa:Number=1, anchoDeterminado:Number=-1){
super();
ubicaCampo();
this.url = url;
this.blank;
this.colorTexto0 = colorTexto0;
this.colorTexto1 = colorTexto1;
this.colorFondo0 = colorFondo0;
this.colorFondo1 = colorFondo1;
this.alfa = alfa;
this.texto = texto;
this.anchoDeterminado = anchoDeterminado;
comportamientos();
tamanoTexto(tamano);
if (this.stage == null){
this.addEventListener(Event.ADDED_TO_STAGE, rectanguloInicial);
} else {
rectanguloInicial(undefined);
};
}
public function tamanoTexto(tamano:uint):void{
var formato:TextFormat = new TextFormat();
formato.font = "embebida";
formato.size = tamano;
campo.defaultTextFormat = formato;
campo.text = texto;
campo.autoSize = "left";
rectangulo(colorFondo0);
}
private function rectangulo(colorRectangulo:uint):void{
this.graphics.clear();
this.graphics.beginFill(colorRectangulo, alfa);
campo.width;
if (anchoDeterminado > 0){
this.graphics.drawRect(0, 2, Math.max((Math.floor(campo.width) + 1), anchoDeterminado), (Math.round(campo.height) - 3));
} else {
this.graphics.drawRect(0, 2, (Math.floor(campo.width) + 1), (Math.round(campo.height) - 3));
};
this.graphics.endFill();
}
public function set texto(_texto:String):void{
this._texto = _texto;
campo.text = _texto;
campo.autoSize = "left";
campo.textColor = colorTexto0;
rectangulo(colorFondo0);
}
private function sale(e:Event):void{
rectangulo(colorFondo0);
campo.textColor = colorTexto0;
}
private function rectanguloInicial(e:Event):void{
this.buttonMode = true;
this.useHandCursor = true;
this.mouseEnabled = true;
rectangulo(colorFondo0);
}
private function ubicaCampo():void{
campo = new TextField();
var formato:TextFormat = new TextFormat();
formato.font = "embebida";
formato.size = 12;
campo.defaultTextFormat = formato;
campo.selectable = false;
campo.textColor = colorTexto0;
campo.embedFonts = true;
campo.antiAliasType = "advanced";
campo.mouseEnabled = false;
this.addChild(campo);
}
public function get texto():String{
return (_texto);
}
private function clicURL(e:MouseEvent):void{
var request:URLRequest = new URLRequest(url);
if (blank){
navigateToURL(request, "_blank");
} else {
navigateToURL(request, null);
};
e.stopImmediatePropagation();
}
public function sobre(e:Event):void{
rectangulo(colorFondo1);
campo.textColor = colorTexto1;
}
private function comportamientos():void{
this.addEventListener(MouseEvent.MOUSE_OVER, sobre);
this.addEventListener(MouseEvent.MOUSE_OUT, sale);
this.addEventListener(MouseEvent.CLICK, clicURL);
}
public function limpia():void{
this.removeEventListener(MouseEvent.MOUSE_OVER, sobre);
this.removeEventListener(MouseEvent.MOUSE_OUT, sale);
this.removeEventListener(MouseEvent.CLICK, clicURL);
this.removeEventListener(Event.ADDED_TO_STAGE, rectanguloInicial);
this.buttonMode = false;
this.useHandCursor = false;
this.mouseEnabled = false;
removeChild(campo);
this.graphics.clear();
}
}
}//package personales.interfaz.botones
Section 35
//CreaCampos (personales.interfaz.campos.CreaCampos)
package personales.interfaz.campos {
import clases.*;
import flash.text.*;
public class CreaCampos {
public function CreaCampos(){
super();
}
public static function creaCampoInputConFuenteEmbebida(tamano:uint=14, texto:String="", colorTexto:uint=0):TextField{
var campo:TextField = new TextField();
var formato:TextFormat = new TextFormat();
formato.font = "embebida";
formato.size = tamano;
campo.defaultTextFormat = formato;
campo.type = TextFieldType.INPUT;
campo.text = texto;
campo.textColor = colorTexto;
campo.embedFonts = true;
campo.antiAliasType = "advanced";
campo.autoSize = "left";
return (campo);
}
public static function creaCampoSimpleConFuenteEmbebida(tamano:uint=14, texto:String="", colorTexto:uint=0, subpixel:Boolean=false):TextField{
var campo:TextField = new TextField();
var formato:TextFormat = new TextFormat(Principal.fuente, tamano, colorTexto);
campo.defaultTextFormat = formato;
campo.text = texto;
campo.autoSize = "left";
campo.selectable = false;
campo.embedFonts = true;
campo.antiAliasType = "advanced";
if (subpixel){
campo.gridFitType = GridFitType.SUBPIXEL;
};
return (campo);
}
}
}//package personales.interfaz.campos
Section 36
//Deslizador (personales.interfaz.deslizadores.Deslizador)
package personales.interfaz.deslizadores {
import flash.events.*;
import flash.text.*;
import flash.display.*;
import flash.geom.*;
public class Deslizador extends Sprite {
private var conTexto:Boolean;
private var rectangulo:Rectangle;
public var posY:Number;// = 0
private var colorArrastrable:uint;
private var modifica:Function;
public var presionado:Boolean;// = false
private var caja:TextField;
private var ancho:Number;
public var nDeslizador:uint;
public var altoReal:Number;
public var altoArrastrable:Number;
private var alto:Number;
public var arrastrable:Sprite;
public var evento:Event;
private var colorBarra:uint;
public var n:uint;
public var ecualizador:Ecualizador;// = null
public function Deslizador(modifica:Function, alto:Number=100, ancho:Number=8, altoArrastrable:Number=20, colorArrastrable:Number=0, colorBarra:Number=0xC8C8C8, apaisado:Boolean=false, conTexto:Boolean=false, colorTexto:Number=0){
super();
this.modifica = modifica;
this.alto = alto;
this.ancho = ancho;
this.altoArrastrable = altoArrastrable;
this.conTexto = conTexto;
this.colorArrastrable = colorArrastrable;
this.colorBarra = colorBarra;
arrastrable = new Sprite();
dibuja();
arrastrable.y = 0;
arrastrable.buttonMode = true;
arrastrable.useHandCursor = true;
arrastrable.addEventListener(MouseEvent.MOUSE_DOWN, arrastra);
arrastrable.addEventListener(MouseEvent.MOUSE_UP, suelta);
this.addEventListener(MouseEvent.MOUSE_DOWN, presionaBarra);
this.addChild(arrastrable);
if (apaisado){
this.rotation = -90;
};
if (conTexto){
cajaTexto(apaisado, colorTexto);
};
if (stage != null){
eventosEnStage(undefined);
} else {
this.addEventListener(Event.ADDED_TO_STAGE, eventosEnStage);
};
}
public function actualizaAltura(alto:Number):void{
this.alto = alto;
dibuja();
arrastrable.y = (posY * altoReal);
}
private function cajaTexto(apaisado:Boolean, colorTexto:Number):void{
caja = new TextField();
caja.text = String(posY);
caja.autoSize = "left";
caja.selectable = false;
caja.textColor = colorTexto;
this.addChild(caja);
if (apaisado){
caja.y = -(alto);
caja.rotation = -90;
caja.x = ((-(caja.height) / 2) - 2);
} else {
caja.x = (-(caja.width) / 2);
caja.y = ((ancho / 2) + 3);
};
}
public function reActiva():void{
arrastrable.addEventListener(MouseEvent.MOUSE_DOWN, arrastra);
arrastrable.addEventListener(MouseEvent.MOUSE_UP, suelta);
this.addEventListener(MouseEvent.MOUSE_DOWN, presionaBarra);
if (stage != null){
eventosEnStage(undefined);
} else {
this.addEventListener(Event.ADDED_TO_STAGE, eventosEnStage);
};
}
private function ciclo(e:Event):void{
posY = (arrastrable.y / altoReal);
caja.text = String((Math.floor((posY * 100)) / 100));
modifica(this);
}
private function cicloSinTexto(e:Event):void{
posY = (arrastrable.y / altoReal);
modifica(this);
}
private function presionaBarra(e:Event):void{
evento = e;
if ((((this.mouseY < arrastrable.y)) || ((this.mouseY > (arrastrable.y + altoArrastrable))))){
arrastrable.y = Math.max(Math.min((this.mouseY - (altoArrastrable * 0.5)), altoReal), 0);
arrastra(undefined);
};
modifica(this);
}
private function dibuja():void{
altoReal = (alto - altoArrastrable);
rectangulo = new Rectangle(0, 0, 0, altoReal);
this.graphics.clear();
this.graphics.beginFill(colorBarra);
this.graphics.drawRect(-(Math.floor((ancho / 2))), 0, ancho, alto);
this.graphics.endFill();
arrastrable.graphics.clear();
arrastrable.graphics.beginFill(colorArrastrable);
arrastrable.graphics.drawRect((-(Math.floor((ancho / 2))) + 2), 1, (ancho - 4), (altoArrastrable - 2));
arrastrable.graphics.endFill();
}
public function fuerzaArrastrable(valor:Number):void{
posY = valor;
arrastrable.y = (posY * altoReal);
}
public function fuerza(valor:Number):void{
posY = valor;
arrastrable.y = (posY * altoReal);
modifica(this);
}
public function activaRueda(raiz:DisplayObject):void{
raiz.stage.addEventListener(MouseEvent.MOUSE_WHEEL, rueda);
}
private function arrastra(e:Event):void{
evento = e;
arrastrable.startDrag(false, rectangulo);
if (conTexto){
addEventListener("enterFrame", ciclo);
} else {
addEventListener("enterFrame", cicloSinTexto);
};
presionado = true;
}
public function desActiva():void{
stopDrag();
removeEventListener("enterFrame", ciclo);
removeEventListener("enterFrame", cicloSinTexto);
arrastrable.removeEventListener(MouseEvent.MOUSE_DOWN, arrastra);
arrastrable.removeEventListener(MouseEvent.MOUSE_UP, suelta);
this.removeEventListener(MouseEvent.MOUSE_DOWN, presionaBarra);
this.removeEventListener(Event.ADDED_TO_STAGE, eventosEnStage);
}
public function suelta(e:Event):void{
evento = e;
stopDrag();
removeEventListener("enterFrame", ciclo);
removeEventListener("enterFrame", cicloSinTexto);
presionado = false;
modifica(this);
}
public function eventosEnStage(e:Event):void{
stage.addEventListener(MouseEvent.MOUSE_UP, suelta);
}
public function asignaEcualizador(ecualizador:Ecualizador):void{
this.ecualizador = ecualizador;
}
public function rueda(e:MouseEvent):void{
fuerza(Math.min(Math.max((posY - (e.delta * 0.005)), 0), 1));
}
}
}//package personales.interfaz.deslizadores
Section 37
//Ecualizador (personales.interfaz.deslizadores.Ecualizador)
package personales.interfaz.deslizadores {
import flash.events.*;
import flash.display.*;
public class Ecualizador extends Sprite {
public var listaDeslizadores:Array;
public var nDeslizadores:uint;
public var listaValores:Array;
public var funcionCambio:Function;
public function Ecualizador(nDeslizadores:uint, funcionCambio:Function, valoresIniciales:Array, alto:Number=102, separacion:Number=10, anchoDeslizador:Number=9, colorFondo:Number=0, colorArrastrable:Number=0, colorBarra:Number=0xC8C8C8){
var deslizador:Deslizador;
listaValores = [];
listaDeslizadores = [];
super();
this.funcionCambio = funcionCambio;
this.nDeslizadores = nDeslizadores;
var altoDeslizador:Number = (alto - 2);
var i:uint;
while (i < nDeslizadores) {
listaValores[i] = valoresIniciales[i];
deslizador = new Deslizador(modifica, altoDeslizador, anchoDeslizador, 20, colorArrastrable, colorBarra);
listaDeslizadores.push(deslizador);
deslizador.ecualizador = this;
deslizador.nDeslizador = i;
this.addChild(deslizador);
deslizador.x = (i * separacion);
deslizador.fuerzaArrastrable(valoresIniciales[i]);
deslizador.n = i;
deslizador.scaleY = -1;
deslizador.y = deslizador.height;
funcionCambio(this, deslizador, listaValores[i]);
i++;
};
}
public function fuerza(nDeslizador:uint, posY:Number):void{
var d:Deslizador = listaDeslizadores[nDeslizador];
d.fuerza(posY);
listaValores[nDeslizador] = posY;
funcionCambio(this, d, posY);
}
public function modifica(deslizador:Deslizador):void{
listaValores[deslizador.n] = deslizador.posY;
funcionCambio(this, deslizador, deslizador.posY);
}
public function sueltaArrastre(raiz:DisplayObject):void{
var i:uint;
i = 0;
while (i < listaDeslizadores.length) {
listaDeslizadores[i].sueltaArrastre(raiz);
i++;
};
}
public function desActiva():void{
var i:uint;
while (i < nDeslizadores) {
Deslizador(listaDeslizadores[i]).desActiva();
i++;
};
}
public function reActiva():void{
var i:uint;
while (i < nDeslizadores) {
Deslizador(listaDeslizadores[i]).reActiva();
i++;
};
}
public function suelta(e:Event):void{
var i:uint;
i = 0;
while (i < listaDeslizadores.length) {
listaDeslizadores[i].suelta(undefined);
i++;
};
}
public function get presionado():Boolean{
var i:uint;
while (i < nDeslizadores) {
if (Deslizador(listaDeslizadores[i]).presionado){
return (true);
};
i++;
};
return (false);
}
}
}//package personales.interfaz.deslizadores
Section 38
//Nodo (personales.redes.elementos.Nodo)
package personales.redes.elementos {
import clases.*;
import personales.fisica.*;
import flash.text.*;
import flash.display.*;
import personales.geo.objetos.*;
public class Nodo extends ObjetoFisico {
public var nivel:int;// = 0
public var padre:Nodo;
public var campo:TextField;
public var colorNodo:uint;
public var peso:Number;// = 0
public var nodo:Nodo;
public var nHijo:uint;// = 0
public var nNodos:uint;// = 0
public var contenedor:Sprite;
public var comentario:String;
public var listaNodos:Array;
protected var _nombre:String;
public var centroGeo:PuntoGeo;
public var _activo:Boolean;// = false
public var listaRelaciones:Array;
public function Nodo(numero:int=undefined, nombre:String=""){
listaNodos = [];
listaRelaciones = [];
centroGeo = new PuntoGeo(0, 0);
super(numero);
creaCampo();
this.nombre = nombre;
}
public function preparaContenedor():void{
contenedor = new Sprite();
addChild(contenedor);
}
public function anadeNodo(nodo:Nodo, relacionS:Relacion):void{
listaNodos.push(nodo);
listaRelaciones.push(relacionS);
nNodos++;
}
protected function creaCampo(subpixel:Boolean=false):void{
campo = new TextField();
var formato:TextFormat = new TextFormat(Principal.fuente, 12, 0);
campo.defaultTextFormat = formato;
campo.autoSize = "left";
campo.selectable = false;
campo.embedFonts = true;
campo.antiAliasType = "advanced";
if (subpixel){
campo.gridFitType = GridFitType.SUBPIXEL;
};
}
public function estaNodo(nodo:Nodo):Boolean{
var i:uint;
i = 0;
while (i < nNodos) {
if (listaNodos[i] == nodo){
return (true);
};
i++;
};
return (false);
}
public function set nombre(nombre:String):void{
_nombre = nombre;
campo.text = nombre;
}
public function eliminaNodoDesdeIdRelacionS(id:Number):Boolean{
var i:uint;
i = 0;
while (i < nNodos) {
if (listaRelaciones[i].id == id){
listaNodos.splice(i, 1);
listaRelaciones.splice(i, 1);
nNodos--;
return (true);
};
i++;
};
return (false);
}
public function get activo():Boolean{
return (_activo);
}
public function set activo(activo:Boolean):void{
_activo = activo;
}
public function get nombre():String{
return (_nombre);
}
public function traceNodo():void{
var j:uint;
trace("-nodo-------------------");
trace("------------------------");
trace(("nombre " + nombre));
trace(("numero " + numero));
trace(("nNodos " + nNodos));
j = 0;
while (j < nNodos) {
trace((" " + listaNodos[j].nombre));
j++;
};
}
public function eliminaNodo(nodo:Nodo):Boolean{
var i:uint;
i = 0;
while (i < nNodos) {
if (listaNodos[i] == nodo){
listaNodos.splice(i, 1);
listaRelaciones.splice(i, 1);
nNodos--;
return (true);
};
i++;
};
return (false);
}
public function eliminaTodosNodo(nodo:Nodo):void{
var i:uint;
i = 0;
while (i < nNodos) {
if (listaNodos[i] == nodo){
listaNodos.splice(i, 1);
listaRelaciones.splice(i, 1);
nNodos--;
i--;
};
i++;
};
}
public function traceDatosFisicos():void{
trace(centro.x, centro.y, centro.z, vx, vy, vz, ax, ay, az);
}
}
}//package personales.redes.elementos
Section 39
//Relacion (personales.redes.elementos.Relacion)
package personales.redes.elementos {
import personales.espacios.tresDimensiones.*;
public class Relacion extends Nodo {
public var texto:String;
public var nodo0:Nodo;
public var nodo1:Nodo;
public var colorRelacion:uint;// = 0
public var tipo:Object;
public var id:uint;
public function Relacion(nodo0:Nodo, nodo1:Nodo, peso:Number=0, id:uint=0, colorRelacion:uint=0, texto:String="", tipo:Object=null){
super();
this.nodo0 = nodo0;
this.nodo1 = nodo1;
this.id = id;
this.peso = peso;
this.colorRelacion = colorRelacion;
this.texto = texto;
this.tipo = tipo;
}
public function traceRelacionS():void{
trace("nodo0.nombre, nodo1.nombre, peso, id:", nodo0.nombre, nodo1.nombre, peso, id);
}
override public function get centro():Punto3D{
return (Op3D.puntoMedioDosPuntos(nodo0.centro, nodo1.centro));
}
}
}//package personales.redes.elementos
Section 40
//Arreglos (personales.utilidades.Arreglos)
package personales.utilidades {
import flash.geom.*;
public class Arreglos {
public function Arreglos(){
super();
}
public static function interseccion(arreglo0:Array, arreglo1:Array):Array{
var i:uint;
var j:uint;
var arreglo:Array = [];
i = 0;
while (i < arreglo0.length) {
j = 0;
while (j < arreglo0.length) {
if (arreglo0[i] == arreglo1[j]){
arreglo.push(arreglo0[i]);
};
j++;
};
i++;
};
return (arreglo);
}
public static function posicionYNumeroMaximo(listaNumeros:Array):Point{
var posicion:uint;
var max:Number = -(Infinity);
var i:uint;
while (i < listaNumeros.length) {
if (listaNumeros[i] > max){
max = listaNumeros[i];
posicion = i;
};
i++;
};
return (new Point(posicion, max));
}
public static function diferencia(arreglo0:Array, arreglo1:Array):Array{
var i:uint;
var j:uint;
var arreglo:Array = [];
i = 0;
while (i < arreglo0.length) {
if (noEstaEn(arreglo0[i], arreglo1)){
arreglo.push(arreglo0[i]);
};
i++;
};
i = 0;
while (i < arreglo1.length) {
if (noEstaEn(arreglo1[i], arreglo0)){
arreglo.push(arreglo1[i]);
};
i++;
};
return (arreglo);
}
public static function noEstaEn(objeto:Object, arreglo:Array):Boolean{
var i:uint;
i = 0;
while (i < arreglo.length) {
if (arreglo[i] == objeto){
return (false);
};
i++;
};
return (true);
}
public static function tienenUnElementoComun(arreglo0:Array, arreglo1:Array):Boolean{
var i:uint;
var j:uint;
var nElementosComunes:uint;
i = 0;
while (i < arreglo0.length) {
j = 0;
while (j < arreglo1.length) {
if (arreglo0[i] == arreglo1[j]){
return (true);
};
j++;
};
i++;
};
return (false);
}
public static function copiaArreglo(arreglo:Array):Array{
trace("atención------> slice sustituye a copiaArreglo: nuevoArreglo = arreglo.slice(0)");
return (arreglo.slice(0));
}
public static function indiceDeMayorBajoFuncion(arreglo:Array, funcion:Function):uint{
var j:uint;
var valor:Number = -(Infinity);
var i:uint;
while (i < arreglo.length) {
if (funcion(arreglo[i]) > valor){
valor = funcion(arreglo[i]);
j = i;
};
i++;
};
return (j);
}
public static function ordenAletorio(arreglo:Array):void{
arreglo.sort(funcionOrdenAleatorio);
}
public static function eliminaRepeticionesYLasCuenta(arreglo:Array):uint{
var i:uint;
var j:uint;
var n:uint;
i = 0;
while (i < arreglo.length) {
j = (i + 1);
while (j < arreglo.length) {
if (arreglo[i] == arreglo[j]){
arreglo.splice(j, 1);
j--;
n++;
};
j++;
};
i++;
};
return (n);
}
public static function union(arreglo0:Array, arreglo1:Array):Array{
var i:uint;
var j:uint;
var arreglo:Array = arreglo0.concat(arreglo1);
eliminaRepeticiones(arreglo);
return (arreglo);
}
public static function eliminaSegunElemento(arreglo:Array, elemento:Object):uint{
var i:uint;
var conteo:uint;
i = 0;
while (i < arreglo.length) {
if (arreglo[i] == elemento){
arreglo.splice(i, 1);
i--;
conteo++;
};
i++;
};
return (conteo);
}
public static function injertaElemento(arreglo:Array, elemento:Object, pos:uint):void{
arreglo.splice(pos, 0, elemento);
}
public static function buscaPorPropiedad(nombrePropiedad:String, valor:Object, arreglo:Array):Object{
var i:uint;
i = 0;
while (i < arreglo.length) {
if (arreglo[i][nombrePropiedad] == valor){
return (arreglo[i]);
};
i++;
};
return (null);
}
public static function creaArregloDe0(n:uint):Array{
var i:uint;
var arregloNuevo:Array = [];
i = 0;
while (i < n) {
arregloNuevo.push(0);
i++;
};
return (arregloNuevo);
}
public static function espectroDeMatriz(matriz:Array):Array{
var espectro:Array = [];
var i:uint;
while (i < matriz.length) {
espectro[i] = matriz[i].length;
i++;
};
return (espectro);
}
public static function subArregloAleatorio(arreglo:Array, n:uint):Array{
var i:uint;
var nElemento:uint;
var arregloNuevo:Array = [];
var copia:Array = arreglo.slice(0);
i = 0;
while (i < n) {
nElemento = Math.floor((Math.random() * copia.length));
arregloNuevo.push(copia[nElemento]);
copia.splice(nElemento, 1);
i++;
};
return (arregloNuevo);
}
public static function cambiaPosicionElemento(arreglo:Array, posActual:uint, posNueva:uint):void{
var elemento:Object = arreglo[posActual];
arreglo.splice(posActual, 1);
injertaElemento(arreglo, elemento, posNueva);
}
public static function eliminaSegunElementoUnaVez(arreglo:Array, elemento:Object):int{
var i:uint;
var conteo:uint;
i = 0;
while (i < arreglo.length) {
if (arreglo[i] == elemento){
arreglo.splice(i, 1);
return (i);
};
i++;
};
return (-1);
}
public static function creaArregloDe(valor:Object, n:uint):Array{
var i:uint;
var arregloNuevo:Array = [];
i = 0;
while (i < n) {
arregloNuevo.push(valor);
i++;
};
return (arregloNuevo);
}
public static function subArregloAleatorioDistribuidoHaciaAbajo(arreglo:Array, n:uint, potenciaDistribucion:uint):Array{
var i:uint;
var nElemento:uint;
var arregloNuevo:Array = [];
var copia:Array = arreglo.slice(0);
i = 0;
while (i < n) {
nElemento = Math.floor((Math.pow(Math.random(), potenciaDistribucion) * copia.length));
arregloNuevo.push(copia[nElemento]);
copia.splice(nElemento, 1);
i++;
};
return (arregloNuevo);
}
private static function funcionOrdenAleatorio(obj0:Object, obj1:Object):int{
if (Math.random() < 0.5){
return (-1);
};
return (1);
}
public static function eliminaRepeticiones(arreglo:Array):void{
var i:uint;
var j:uint;
i = 0;
while (i < (arreglo.length - 1)) {
j = (i + 1);
while (j < arreglo.length) {
if (arreglo[i] == arreglo[j]){
arreglo.splice(j, 1);
j--;
};
j++;
};
i++;
};
}
public static function numeroMaximo(listaNumeros:Array):Number{
var max:Number = -(Infinity);
var i:uint;
while (i < listaNumeros.length) {
max = Math.max(max, listaNumeros[i]);
i++;
};
return (max);
}
public static function estaEn(objeto:Object, arreglo:Array):Boolean{
var i:uint;
i = 0;
while (i < arreglo.length) {
if (arreglo[i] == objeto){
return (true);
};
i++;
};
return (false);
}
public static function traceArregloConSalto(arreglo:Array):void{
trace("<");
var i:uint;
while (i < arreglo.length) {
trace(arreglo[i]);
i++;
};
trace(">");
}
public static function primeraPosicion(objeto:Object, arreglo:Array):int{
var i:uint;
i = 0;
while (i < arreglo.length) {
if (arreglo[i] == objeto){
return (i);
};
i++;
};
return (-1);
}
private static function ordenPorPosicion1(arreglo0:Array, arreglo1:Array):int{
if (arreglo0[1] < arreglo1[1]){
return (-1);
};
return (1);
}
public static function soloPares(arreglo:Array):Array{
var i:uint;
var nuevoArreglo:Array = [];
i = 0;
while (i < arreglo.length) {
nuevoArreglo.push(arreglo[i]);
i = (i + 2);
};
return (nuevoArreglo);
}
public static function sustrae(arreglo0:Array, arreglo1:Array):Array{
var nuevoArreglo:Array = arreglo0.concat([]);
var i:uint;
while (i < arreglo1.length) {
eliminaSegunElementoUnaVez(nuevoArreglo, arreglo1[i]);
i++;
};
return (nuevoArreglo);
}
public static function numeroMinimo(listaNumeros:Array):Number{
var min:Number = Infinity;
var i:uint;
while (i < listaNumeros.length) {
min = Math.min(min, listaNumeros[i]);
i++;
};
return (min);
}
public static function copiaMatrizCubica(matriz:Array):Array{
var i:uint;
var nuevaMatriz:Array = [];
i = 0;
while (i < matriz.length) {
nuevaMatriz.push(copiaMatriz(matriz[i]));
i++;
};
return (nuevaMatriz);
}
public static function cuentaElementosComunes(arreglo0:Array, arreglo1:Array):uint{
var i:uint;
var j:uint;
var nElementosComunes:uint;
i = 0;
while (i < arreglo0.length) {
j = 0;
while (j < arreglo1.length) {
if (arreglo0[i] == arreglo1[j]){
nElementosComunes++;
break;
};
j++;
};
i++;
};
return (nElementosComunes);
}
public static function cuentaRepeticiones(arreglo:Array):uint{
var i:uint;
var j:uint;
var nRepeticiones:uint;
i = 0;
while (i < arreglo.length) {
j = (i + 1);
while (j < arreglo.length) {
if (arreglo[i] == arreglo[j]){
nRepeticiones++;
};
j++;
};
i++;
};
return (nRepeticiones);
}
public static function noRepitePorPropiedad(objeto:Object, nombrePropiedad:String, arreglo:Array):Boolean{
var i:uint;
i = 0;
while (i < arreglo.length) {
if (arreglo[i][nombrePropiedad] == objeto[nombrePropiedad]){
return (false);
};
i++;
};
return (true);
}
public static function ordenaPorPosicion1(matriz:Array):void{
matriz.sort(ordenPorPosicion1);
}
public static function colapsa(arreglo:Array):Array{
var i:uint;
var arregloNuevo:Array = arreglo[0];
i = 1;
while (i < arreglo.length) {
arregloNuevo = arregloNuevo.concat(arreglo[i]);
i++;
};
return (arregloNuevo);
}
public static function creaArregloDeArreglosVacios(n:uint):Array{
var matriz:Array = [];
var i:uint;
while (i < n) {
matriz[i] = [];
i++;
};
return (matriz);
}
public static function copiaMatriz(matriz:Array):Array{
var i:uint;
var nuevaMatriz:Array = [];
i = 0;
while (i < matriz.length) {
nuevaMatriz.push(matriz[i].slice(0));
i++;
};
return (nuevaMatriz);
}
}
}//package personales.utilidades
Section 41
//edgeNetwork (edgeNetwork)
package {
import flash.events.*;
import clases.*;
import flash.display.*;
public class edgeNetwork extends Sprite {
public var fuenteEmbebida:Class;
public var parametros:Parametros;
public var principal:Principal;
public function edgeNetwork(){
fuenteEmbebida = edgeNetwork_fuenteEmbebida;
parametros = Parametros.getInstance();
super();
preparaStage();
inicio();
escalaVentana();
}
public function inicio():void{
principal = new Principal();
this.addChild(principal);
}
private function preparaStage():void{
stage.quality = Parametros.calidadStage;
stage.align = StageAlign.TOP_LEFT;
stage.scaleMode = StageScaleMode.NO_SCALE;
stage.addEventListener(Event.RESIZE, escalaVentana);
}
public function escalaVentana(o:Object=undefined):void{
parametros.ancho = stage.stageWidth;
parametros.alto = stage.stageHeight;
principal.escalaVentana(stage.stageWidth, stage.stageHeight);
}
}
}//package
Section 42
//edgeNetwork_fuenteEmbebida (edgeNetwork_fuenteEmbebida)
package {
import mx.core.*;
public class edgeNetwork_fuenteEmbebida extends FontAsset {
}
}//package
