package
{
	import caurina.transitions.Tweener;
	
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.PixelSnapping;
	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageQuality;
	import flash.display.StageScaleMode;
	import flash.events.Event;
	import flash.filters.GlowFilter;
	import flash.geom.ColorTransform;
	import flash.media.Camera;
	import flash.media.Video;
	import flash.net.URLLoader;
	import flash.net.URLLoaderDataFormat;
	import flash.net.URLRequest;
	
	import org.libspark.flartoolkit.core.FLARCode;
	import org.libspark.flartoolkit.core.param.FLARParam;
	import org.libspark.flartoolkit.core.raster.rgb.FLARRgbRaster_BitmapData;
	import org.libspark.flartoolkit.core.transmat.FLARTransMatResult;
	import org.libspark.flartoolkit.detector.FLARSingleMarkerDetector;
	import org.libspark.flartoolkit.pv3d.FLARBaseNode;
	import org.libspark.flartoolkit.pv3d.FLARCamera3D;
	import org.papervision3d.core.effects.BitmapFireEffect;
	import org.papervision3d.materials.BitmapMaterial;
	import org.papervision3d.objects.primitives.Plane;
	import org.papervision3d.objects.primitives.Sphere;
	import org.papervision3d.render.LazyRenderEngine;
	import org.papervision3d.scenes.Scene3D;
	import org.papervision3d.view.Viewport3D;
	import org.papervision3d.view.layer.BitmapEffectLayer;
	
	[SWF(backgroundColor="0x000000")]
	
	public class Efecto extends Sprite
	{
		private const CAMERA_PARAM_FILE:String="FLARCameraParams.dat";
		private const LOGO_PARAM_FILE:String="marker16.pat";
		private const WW:Number=320;
		private const HH:Number=240;
		private const CODE_WW:Number=80;
		
		
		
		[Embed(source='Fuego.jpg')]
		private var texture:Class;
		
		private var loader:URLLoader;
		private var cameraParam:FLARParam;
		private var markerCode:FLARCode;
		private var webCamera:Camera;
		private var video:Video;
		private var capture:Bitmap;
		private var captureBmpd:BitmapData;
		private var raster:FLARRgbRaster_BitmapData;
		private var detector:FLARSingleMarkerDetector;
		private var viewport:Viewport3D;
		private var scene:Scene3D;
		private var camera:FLARCamera3D;
		private var renderer:LazyRenderEngine;
		private var baseNode:FLARBaseNode;
		private var resultMatrix:FLARTransMatResult;
		private var plane:Plane;
		private var sphere:Sphere;
		private var flug:int;
		
		
		public function Efecto()
		{
		
			stage.scaleMode=StageScaleMode.NO_SCALE;
			stage.align=StageAlign.TOP_LEFT;
			stage.quality=StageQuality.LOW;
			stage.frameRate=40;
			
			
			loader=new URLLoader();
			loader.dataFormat=URLLoaderDataFormat.BINARY;
			loader.addEventListener(Event.COMPLETE, onLoadCameraParam);
			loader.load(new URLRequest(CAMERA_PARAM_FILE));
		}
		
		
		
		private function onLoadCameraParam(e:Event):void
		{
			loader.removeEventListener(Event.COMPLETE, onLoadCameraParam);
			
			
			cameraParam=new FLARParam();
			cameraParam.loadARParam(loader.data);
			cameraParam.changeScreenSize(WW, HH);
			
			
			loader.dataFormat=URLLoaderDataFormat.TEXT;
			loader.addEventListener(Event.COMPLETE, _onLoadCode);
			loader.load(new URLRequest(LOGO_PARAM_FILE));
		}
		
		
		
		private function _onLoadCode(e:Event):void
		{
		
			markerCode=new FLARCode(16, 16);
			markerCode.loadARPatt(loader.data);
			
			
			loader.removeEventListener(Event.COMPLETE, _onLoadCode);
			loader=null;
			
			
			onInit();
		}
		
		
	
		private function onInit():void
		{
			
			webCamera=Camera.getCamera();
			webCamera.setMode(WW, HH, 30);
			video=new Video(WW, HH);
			video.attachCamera(webCamera);
			
			
			captureBmpd=new BitmapData(WW, HH, false, 0);
			capture=new Bitmap(captureBmpd, PixelSnapping.AUTO, true);
			capture.width=2 * WW;
			capture.height=2 * HH;
			addChild(capture);
			capture.x=(stage.stageWidth - WW * 2) * 0.5;
			capture.y=(stage.stageHeight - HH * 2) * 0.5;
			
			
			raster=new FLARRgbRaster_BitmapData(capture.bitmapData);
			detector=new FLARSingleMarkerDetector(cameraParam, markerCode, CODE_WW);
			
			
			viewport=new Viewport3D(WW * 2, HH * 2);
			viewport.x=(stage.stageWidth - WW * 2) * 0.5 - 4;
			viewport.y=(stage.stageHeight - HH * 2) * 0.5;
			addChild(viewport);
			scene=new Scene3D();
			
			
			camera=new FLARCamera3D(cameraParam);
			renderer=new LazyRenderEngine(scene, camera, viewport);
			
		
			baseNode=scene.addChild(new FLARBaseNode())as FLARBaseNode;
			
			
			resultMatrix=new FLARTransMatResult();
			
			
			var layer:BitmapEffectLayer=new BitmapEffectLayer(viewport, WW * 2, HH * 2);
			var fire:BitmapFireEffect=new BitmapFireEffect();
			fire.fadeRate=0.1;
			fire.flameSpread=1;
			fire.flameHeight=0.5;
			fire.distortion=1;
			fire.distortionScale=1;
			fire.smoke=0.8;
			fire.blueFlame=true;
			
			layer.addEffect(fire);
			viewport.containerSprite.addLayer(layer);
			
	
			
			
			sphere=new Sphere(new BitmapMaterial((new texture as Bitmap).bitmapData, true), 40, 40, 10);
			baseNode.addChild(sphere);
			sphere.scale=0;
			layer.addDisplayObject3D(sphere);
			
			
			flug=0;
			
			
			addEventListener(Event.ENTER_FRAME, onEnterFrame);
			stage.addEventListener(Event.RESIZE, onResize);
		}
		
		
		
		private function onResize(e:Event):void
		{
			capture.x=(stage.stageWidth - WW * 2) * 0.5;
			capture.y=(stage.stageHeight - HH * 2) * 0.5;
			viewport.x=(stage.stageWidth - WW * 2) * 0.5 - 4;
			viewport.y=(stage.stageHeight - HH * 2) * 0.5;
		}
		
		
		
		private function onEnterFrame(e:Event):void
		{
			
			captureBmpd.draw(video);
			
			captureBmpd.colorTransform(captureBmpd.rect, new ColorTransform(0.6, 0.6, 0.6, 1));
			
		
			sphere.rotationX++;
			sphere.rotationY++;
			
			
			if (detector.detectMarkerLite(raster, 80) && detector.getConfidence() > 0.5)
			{
				detector.getTransformMatrix(resultMatrix);
				baseNode.setTransformMatrix(resultMatrix);
				
				if (flug == 0)
				{
					
					Tweener.addTween(sphere, {scale:1, z:50, time:3});
					flug=1;
				}
			}
				
				
			else
			{
				if (flug == 1)
				{
					
					Tweener.addTween(sphere, {scale:0, z:50, time:3});
					flug=0;
				}
			}
			
			
			renderer.render();
		}
	}
}