package 
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.PixelSnapping;
	import flash.display.Sprite;
	import flash.events.*;
	import flash.geom.Rectangle;
	import flash.media.Camera;
	import flash.media.Video;
	import flash.utils.ByteArray;
	import org.libspark.flartoolkit.core.FLARCode;
	import org.libspark.flartoolkit.core.param.FLARParam;
	import org.libspark.flartoolkit.core.raster.FLARRaster_BitmapData;
	import org.libspark.flartoolkit.core.raster.rgb.FLARRgbRaster_BitmapData;
	import org.libspark.flartoolkit.core.transmat.FLARTransMatResult;
	import org.libspark.flartoolkit.detector.FLARMultiMarkerDetector;
	import org.libspark.flartoolkit.detector.FLARSingleMarkerDetector;
	import org.libspark.flartoolkit.support.pv3d.FLARBaseNode;
	import org.libspark.flartoolkit.support.pv3d.FLARCamera3D;
	import org.papervision3d.lights.PointLight3D;
	import org.papervision3d.materials.BitmapMaterial;
	import org.papervision3d.materials.ColorMaterial;
	import org.papervision3d.materials.shadematerials.FlatShadeMaterial;
	import org.papervision3d.materials.utils.MaterialsList;
	import org.papervision3d.materials.WireframeMaterial;
	import org.papervision3d.objects.primitives.Cube;
	import org.papervision3d.objects.primitives.Plane;
	import org.papervision3d.render.LazyRenderEngine;
	import org.papervision3d.scenes.Scene3D;
	import org.papervision3d.typography.fonts.HelveticaBold;
	import org.papervision3d.typography.Text3D;
	import org.papervision3d.view.Viewport3D;
	import org.papervision3d.materials.special.Letter3DMaterial;

	public class MultiMarkerTest extends Sprite
	{
		protected var _param:FLARParam;
		protected var _code:FLARCode;
		protected var _raster:FLARRgbRaster_BitmapData;
		protected var _detector:FLARMultiMarkerDetector;
		
		protected var _webcam:Camera;
		protected var _video:Video;
		protected var _capture:Bitmap;
		protected var _base:Sprite;
		protected var _viewport:Viewport3D;
		protected var _camera3d:FLARCamera3D;
		protected var _scene:Scene3D;
		protected var _renderer:LazyRenderEngine;
		protected var _markerNodes:Array;
		
		protected var _resultMat:FLARTransMatResult = new FLARTransMatResult();
		protected var _detectedResults:Array;
		
		[Embed(source = "assets/flarlogo.pat", mimeType = "application/octet-stream")]private var FLARCodeData:Class;
		[Embed(source = "assets/patt.hiro", mimeType = "application/octet-stream")]private var HiroCodeData:Class;
		[Embed(source = "assets/artk_jp.pat", mimeType = "application/octet-stream")]private var ARTKData:Class;

		public function MultiMarkerTest() 
		{
			var flarCodeFile:ByteArray = new FLARCodeData() as ByteArray;
			var hiroCodeFile:ByteArray = new HiroCodeData() as ByteArray;
			var artkCodeFile:ByteArray = new ARTKData() as ByteArray;
			
			_param = new FLARParam();
			_param.changeScreenSize(320, 240);
			var flarCode:FLARCode = new FLARCode(16, 16);
			flarCode.loadARPatt(flarCodeFile.readMultiByte(flarCodeFile.length, "shift-jis"));
			var hiroCode:FLARCode = new FLARCode(16, 16);
			hiroCode.loadARPatt(hiroCodeFile.readMultiByte(hiroCodeFile.length, "shift-jis"));
			var artkCode:FLARCode = new FLARCode(16, 16);
			artkCode.loadARPatt(artkCodeFile.readMultiByte(artkCodeFile.length, "shift-jis"));
			
			// setup webcam
			_webcam = Camera.getCamera();
			if (!_webcam) {
				throw new Error('No webcam!!!!');
			}
			_webcam.setMode(640, 480, 30);
			_video = new Video(640, 480);
			_video.attachCamera(_webcam);
			_capture = new Bitmap(new BitmapData(320, 240, false, 0), PixelSnapping.AUTO, true);
			
			// setup ARToolkit
			_raster = new FLARRgbRaster_BitmapData(_capture.bitmapData);
			_detector = new FLARMultiMarkerDetector(_param, [flarCode, hiroCode, artkCode], [80, 80, 80], 3);
			_detector.setContinueMode(true);
			
			_base = addChild(new Sprite()) as Sprite;
			
			_capture.width = 640;
			_capture.height = 480;
			_base.addChild(_capture);
			
			_viewport = _base.addChild(new Viewport3D(640, 480)) as Viewport3D;
			_viewport.scaleX = 1;
			_viewport.scaleY = 1;
			_viewport.x = -4; // 4pix ???
			
			_camera3d = new FLARCamera3D(_param);
			
			_scene = new Scene3D();
			
			_markerNodes = new Array();
			_markerNodes[0] = _scene.addChild(new FLARBaseNode()) as FLARBaseNode;
			_markerNodes[1] = _scene.addChild(new FLARBaseNode()) as FLARBaseNode;
			_markerNodes[2] = _scene.addChild(new FLARBaseNode()) as FLARBaseNode;

			// マーカー上に表示するものを定義
			var light:PointLight3D = new PointLight3D();
			light.x = 0;
			light.y = 1000;
			light.z = -1000;

			var flarFmat:FlatShadeMaterial = new FlatShadeMaterial(light, 0xFF0000, 0x660000);
			var flarCube:Cube = new Cube(new MaterialsList( { all:flarFmat } ), 40, 40, 40);
			flarCube.z = 20;
			_markerNodes[0].addChild(flarCube);

			var hiroFmat:FlatShadeMaterial = new FlatShadeMaterial(light, 0x00FF00, 0x006600);
			var hiroCube:Cube = new Cube(new MaterialsList( { all:hiroFmat } ), 40, 40, 40);
			hiroCube.z = 20;
			_markerNodes[1].addChild(hiroCube);
			
			var artkFmat:FlatShadeMaterial = new FlatShadeMaterial(light, 0x0000FF, 0x000066);
			var artkCube:Cube = new Cube(new MaterialsList( { all:artkFmat } ), 40, 40, 40);
			artkCube.z = 20;
			_markerNodes[2].addChild(artkCube);
						
			_renderer = new LazyRenderEngine(_scene, _camera3d, _viewport);
			
			this._detectedResults = new Array();
			for (var j:int = 0; j < _markerNodes.length; j++) {
				this._detectedResults[j] = { confidence:0, index:0 };
			}

			addEventListener(Event.ENTER_FRAME, _onEnterFrame);
			//this.addChild(new Bitmap(((_detector._bin_raster) as FLARRaster_BitmapData).bitmapData));

		}
		private function _onEnterFrame(e:Event = null):void {
			_capture.bitmapData.draw(_video);
			
			var detectedMarkers:int;
			
			try {
				detectedMarkers = _detector.detectMarkerLite(_raster, 80);
			} catch (e:Error) {}
			for (var i:int = 0; i < detectedMarkers; i++) {
				var confidence:Number = _detector.getConfidence(i);
				var codeIndex:int = _detector.getARCodeIndex(i);
				if (this._detectedResults[codeIndex].confidence < confidence) {
					this._detectedResults[codeIndex].confidence = confidence;
					this._detectedResults[codeIndex].index = i;
				}
			}
			for (var k:int = 0; k < this._detectedResults.length; k++) {
				var node:FLARBaseNode = _markerNodes[k] as FLARBaseNode;
				if (this._detectedResults[k].confidence > 0.5) {
					_detector.getTransmationMatrix(this._detectedResults[k].index, _resultMat);
					node.setTransformMatrix(_resultMat);
					node.visible = true;
				} else {
					node.visible = false;
				}
				this._detectedResults[k].index = 0;
				this._detectedResults[k].confidence = 0;
			}
			_renderer.render();
		}

	}
}