Papervision3D y Realidad Aumentada (rar)

El paso de parámetros por valor, se utiliza en programación para realizar una copia del valor del objeto cuando es pasado a través de la invocación de un método. Es decir, al llamar a un método de una clase que requiere un objeto, realizo una copia de dicho objeto. Si dentro de la clase, modifico ese objeto, los cambios no son propagados fuera de la clase.

El paso de parámetros por referencia, pasa “un puntero del objeto”, es decir, de alguna manera estamos pasando el objeto, y si dicho objeto es modificado dentro de la propia clase, sus cambios serán propagados fuera de la misma.

Hay lenguajes que permiten definir el método de paso de variables (referencia o valor), como es el caso de C++. En Actionscript, de momento no podemos pasar por valor de manera nativa, aunque nuestro método siempre puede hacer una copia internamente del argumento recibido para no modificar el original. En Actionscript 3, el paso de parámetros, siempre se realiza de la misma manera:

• Las instancias de clases son pasadas por referencia
• Los tipos primitivos se pasan por valor

Si estás aprendiendo Actionscript 3 y has llegado hasta aquí, te recomiendo que analices a fondo este código, puesto que puede resultarte muy esclarecedor para entender este concepto tan básico como fundamental sobre la orientación a objetos.

Primero, definimos dos Clases, ClaseA y ClaseB. ClaseB está compuesta por un atributo, atributoB que es de tipo Number.

package
{
	public class ClaseB
	{
		public var atributoB:Number;	
		public function ClaseB()
		{
		}
	}
}

ClaseA tiene otro atributo de tipo ClaseB. Estamos hablando por tanto, de una relación de composición entre las dos clases.

package
{
	public class ClaseA
	{
		public var atributoA:ClaseB;
		public function ClaseA(atributo:ClaseB){
			atributoA = atributo;
		}
	}
}

Ahora nuestra clase principal. Nótese cómo atributoB devuelve el mismo valor independientemente del lugar desde donde es modificado (es el mismo objeto) y cómo esto no sucede con tipos primitivos. En este caso paso un parámetro al constructor de la clase ClaseA (nuestro objeto de tipo ClaseB), para posteriormente modificarlo desde diferentes ámbitos y trazar los resultados.

package {
	import flash.display.Sprite;
 
	public class ReferenciaValorTest extends Sprite
	{
		/**
		 * @autor Alejandro Sánchez
		 * http://www.electroduendes.com/blog/
		 * */
		public function ReferenciaValorTest()
		{
			var b:ClaseB = new ClaseB();
			b.atributoB = 10;
			trace(b.atributoB) // OUTPUT: 10
 
			var a:ClaseA = new ClaseA(b);
			trace(a.atributoA.atributoB) // OUTPUT: 10
 
			a.atributoA.atributoB = 5;
			trace(a.atributoA.atributoB) // OUTPUT: 5
			trace(b.atributoB) // OUTPUT: 5
 
			b.atributoB = 10;
			trace(a.atributoA.atributoB) // OUTPUT: 10
			trace(b.atributoB) // OUTPUT: 10
 
			var c:Number = 20;
			a.atributoA.atributoB = c			
			trace(a.atributoA.atributoB); // OUTPUT: 20
			trace(b.atributoB); // OUTPUT: 20
			trace(c); // OUTPUT 20
 
			c = 30;
			trace(a.atributoA.atributoB); // OUTPUT: 20
			trace(b.atributoB); // OUTPUT: 20
			trace(c); // OUTPUT 30
 
		}
	}
}

El triángulo de Penrose, es un objeto imposible que fue creado en 1934 por el artista sueco Oscar Reutersvärd. Posteriormente fue redescubierto de forma independiente por el físico Roger Penrose, en la década de 1950, quien lo hizo popular, describiéndolo como “imposibilidad en su más pura forma”.

Fuente: Wikipedia

Pulsa en la imagen para lanzar el experimento

Triángulo de Penrose

El juguete visual está escrito en Actionscript 3 y Papervision3D. El autor del modelo SketchUp es Martin Triebel. Con el artefacto, intento abrir una puerta racional al triángulo de imposibilidad, a través de un juego de interacción, en la idea de que no existe una realidad absoluta, sino meras interpretaciones, ahí queda eso.

Resulta generacional la atención que la gente tiene sobre esta figura, y su repercusión en camisestas, fieltros, esculturas de rotondas y portadas de libros. Desde icono pop hasta figura del op art, este símbolo seguirá sorprendiendo a generaciones y perpetuándose como un ejemplo del escepticismo creativo radical.

Gracias a Dios con la llegada de as3 llevo un tiempo sin sufrir los tediososos attachMovie y createEmptyMovieClip, que resultaban a veces confusos.

El nuevo árbol de herencia de los objetos de visualización es ahora realmente orientado a objetos y muy completo, y es algo que agradecí al migar de as2 a as3.

Con el método addChild, no tengo pegas, pues me parece necesario identificar sobre qué padre vamos a incluir el DisplayObject que estamos creando.

Pero para el método removeChild, cuando estoy eliminando un Sprite, pues realmente no interesa saber cual es el padre, lo que realmente interesa, es eliminarlo y punto.

De hecho, yo tiendo a hacer lo siguiente:

miMc.parent.removeChild(miMc)

Se me ocurrió hace poco que una clase para eliminar Sprites sería útil, algo como un Terminator de DisplayObjects

DisplayObjectTerminator.remove(miMc)

Esta clase, encapsularía este comportamiento y además evitaría problemas tales como que el objeto a elminar exista, que no sea nulo… etc etc.

Y antes de ponerme a escribir, googleé un poco y encontré una clase bastante útil para estos menesteres que comparto con vosotros:

http://www.actionscript.org/forums/showthread.php3?t=178317

/**
 * written by evride //
 * Actionscript.org forums user //
 * found a problem? tell me there //
 */
package com.evride{
	public class RemoveObject {
		public static  function remove(obj:Object) {
			if (obj) {
				if (obj is DisplayObject) {
					if (obj.parent) {
						try {
							obj.parent.removeChild(obj);
						} catch (e:Error) {
							trace("Couldn't remove the object. It wasn't a child of a DisplayObject.");
						}
					} else {
						trace("Couldn't remove object. Parent property is null.");
					}
				} else {
					trace("Couldn't remove object. It is not a DisplayObject.");
				}
			} else {
				trace("Couldn't remove the object. It was null or doesn't exist.");
			}
		}
	}
 
}

Más información:
http://www.subflash.com/talleres/2007/