//A simple vertex program in AGAL
const VERTEX_SHADER:String =
    "m44 op, va0, vc0 \n" +	
	"mov v0, va1"; 

//A simple fragment (or pixel) program in AGAL		
const FRAGMENT_SHADER:String = "mov oc, v0";  

var vertexAssembly:AGALMiniAssembler = new AGALMiniAssembler();
var fragmentAssembly:AGALMiniAssembler = new AGALMiniAssembler();
var programPair:Program3D;

//Compile shaders
vertexAssembly.assemble( Context3DProgramType.VERTEX, VERTEX_SHADER, false );
fragmentAssembly.assemble( Context3DProgramType.FRAGMENT, FRAGMENT_SHADER, false );			

//Upload programs to render context
programPair = renderContext.createProgram();
programPair.upload( vertexAssembly.agalcode, fragmentAssembly.agalcode );
renderContext.setProgram( programPair );

const dataPerVertex:int = 6;
var vertexData:Vector.<Number> = Vector.<Number>(
    [
	  // x, y, z    r, g, b format
	     0, 0, 0,   1, 1, 1,
	    -1, 1, 0,   0, 0,.5,
	     1, 1, 0,   0, 0, 1,
	     1,-1, 0,  .5, 0, 0,
	    -1,-1, 0,   1, 0, 0
	]
);
var vertexes:VertexBuffer3D = renderContext.createVertexBuffer( vertexData.length/dataPerVertex, dataPerVertex );
vertexes.uploadFromVector( vertexData, 0, vertexData.length/dataPerVertex );
			
//Identify vertex data inputs for vertex program
renderContext.setVertexBufferAt( 0, vertexes, 0, Context3DVertexBufferFormat.FLOAT_3 ); //Defines shader input va0 as the position data
renderContext.setVertexBufferAt( 1, vertexes, 3, Context3DVertexBufferFormat.FLOAT_3 ); //Defines shader input va1 as the color data

package
{
    import com.adobe.utils.AGALMiniAssembler;
	
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.Sprite;
	import flash.display.Stage3D;
	import flash.display3D.Context3D;
	import flash.display3D.Context3DProgramType;
	import flash.display3D.Context3DRenderMode;
	import flash.display3D.Context3DVertexBufferFormat;
	import flash.display3D.IndexBuffer3D;
	import flash.display3D.Program3D;
	import flash.display3D.VertexBuffer3D;
	import flash.events.Event;
	import flash.filters.DropShadowFilter;
	
	public class Context3D_drawToBitmapData extends Sprite
	{
		public const viewWidth:Number = 320;
		public const viewHeight:Number = 200;
		
		private var bitmap:Bitmap;
		private var stage3D:Stage3D;
		private var renderContext:Context3D;
		private var indexList:IndexBuffer3D;
		private var vertexes:VertexBuffer3D;
		
		private const VERTEX_SHADER:String =
			"mov op, va0	\n" +	//copy position to output 
			"mov v0, va1"; //copy color to varying variable v0
		
		private const FRAGMENT_SHADER:String = 
			"mov oc, v0"; //Set the output color to the value interpolated from the three triangle vertices 

		private var vertexAssembly:AGALMiniAssembler = new AGALMiniAssembler();
		private var fragmentAssembly:AGALMiniAssembler = new AGALMiniAssembler();
		private var programPair:Program3D;
		
		public function Context3D_drawToBitmapData()
		{
			stage3D = this.stage.stage3Ds[0];
			stage3D.x = 0;
			stage3D.y = 0;

			//Add event listener before requesting the context
			stage3D.addEventListener( Event.CONTEXT3D_CREATE, contextCreated );			
			stage3D.requestContext3D( Context3DRenderMode.AUTO );
			
			//Compile shaders
			vertexAssembly.assemble( Context3DProgramType.VERTEX, VERTEX_SHADER, false );
			fragmentAssembly.assemble( Context3DProgramType.FRAGMENT, FRAGMENT_SHADER, false );			
		}
		
		//Note, context3DCreate event can happen at any time, such as when the hardware resources are taken by another process
		private function contextCreated( event:Event ):void
		{
			renderContext = Stage3D( event.target ).context3D;
			trace( "3D driver: " + renderContext.driverInfo );

			renderContext.enableErrorChecking = true; //Can slow rendering - only turn on when developing/testing
			renderContext.configureBackBuffer( viewWidth, viewHeight, 2, false );
			
			//Create vertex index list for the triangles
			var triangles:Vector.<uint> = Vector.<uint>( [ 0, 1, 2, 0, 3, 4 ] );
			indexList = renderContext.createIndexBuffer( triangles.length );
			indexList.uploadFromVector( triangles, 0, triangles.length );
			
			//Create vertexes
			const dataPerVertex:int = 6;
			var vertexData:Vector.<Number> = Vector.<Number>(
				[
				  // x, y, z    r, g, b format
					 0, 0, 0,   1, 1, 1,
					-1, 1, 0,   0, 0,.5,
					 1, 1, 0,   0, 0, 1,
					 1,-1, 0,  .5, 0, 0,
					-1,-1, 0,   1, 0, 0
				]
			);
			vertexes = renderContext.createVertexBuffer( vertexData.length/dataPerVertex, dataPerVertex );
			vertexes.uploadFromVector( vertexData, 0, vertexData.length/dataPerVertex );
			
			//Identify vertex data inputs for vertex program
			renderContext.setVertexBufferAt( 0, vertexes, 0, Context3DVertexBufferFormat.FLOAT_3 ); //va0 is position
			renderContext.setVertexBufferAt( 1, vertexes, 3, Context3DVertexBufferFormat.FLOAT_3 ); //va1 is color
			
			//Upload programs to render context
			programPair = renderContext.createProgram();
			programPair.upload( vertexAssembly.agalcode, fragmentAssembly.agalcode );
			renderContext.setProgram( programPair );
			
			//Clear required before first drawTriangles() call
			renderContext.clear( .3,.3,.3 );
			
			
			//Draw the 2 triangles
			renderContext.drawTriangles( indexList, 0, 2 );
			
			var renderedBitmapData:BitmapData = new BitmapData( viewWidth, viewHeight, true );
			renderContext.drawToBitmapData( renderedBitmapData );
			
			renderContext.present();
			
			//Add to stage
			bitmap = new Bitmap( renderedBitmapData );
			this.addChild( bitmap );
			bitmap.x = 55;
			bitmap.y = 25;
			bitmap.filters = [new DropShadowFilter( 8, 235, .4 )];
		}
	}
}

package
{
    import com.adobe.utils.AGALMiniAssembler;
	
	import flash.display.Sprite;
	import flash.display.Stage3D;
	import flash.display3D.Context3D;
	import flash.display3D.Context3DProgramType;
	import flash.display3D.Context3DRenderMode;
	import flash.display3D.Context3DVertexBufferFormat;
	import flash.display3D.IndexBuffer3D;
	import flash.display3D.Program3D;
	import flash.display3D.VertexBuffer3D;
	import flash.events.Event;
	
	public class Context3D_drawTriangles extends Sprite
	{
		public const viewWidth:Number = 320;
		public const viewHeight:Number = 200;
		
		private var stage3D:Stage3D;
		private var renderContext:Context3D;
		private var indexList:IndexBuffer3D;
		private var vertexes:VertexBuffer3D;
		
		private const VERTEX_SHADER:String =
			"mov op, va0	\n" +	//copy position to output 
			"mov v0, va1"; //copy color to varying variable v0
		
		private const FRAGMENT_SHADER:String = 
			"mov oc, v0"; //Set the output color to the value interpolated from the three triangle vertices 

		private var vertexAssembly:AGALMiniAssembler = new AGALMiniAssembler();
		private var fragmentAssembly:AGALMiniAssembler = new AGALMiniAssembler();
		private var programPair:Program3D;
		
		public function Context3D_drawTriangles()
		{
			stage3D = this.stage.stage3Ds[0];
			stage3D.x = 10;
			stage3D.y = 10;

			//Add event listener before requesting the context
			stage3D.addEventListener( Event.CONTEXT3D_CREATE, contextCreated );			
			stage3D.requestContext3D( Context3DRenderMode.AUTO );
			
			//Compile shaders
			vertexAssembly.assemble( Context3DProgramType.VERTEX, VERTEX_SHADER, false );
			fragmentAssembly.assemble( Context3DProgramType.FRAGMENT, FRAGMENT_SHADER, false );			
		}
		
		//Note, context3DCreate event can happen at any time, such as when the hardware resources are taken by another process
		private function contextCreated( event:Event ):void
		{
			renderContext = Stage3D( event.target ).context3D;
			trace( "3D driver: " + renderContext.driverInfo );

			renderContext.enableErrorChecking = true; //Can slow rendering - only turn on when developing/testing
			renderContext.configureBackBuffer( viewWidth, viewHeight, 2, false );
			
			//Create vertex index list for the triangles
			var triangles:Vector.<uint> = Vector.<uint>( [ 0, 1, 2, 0, 3, 4 ] );
			indexList = renderContext.createIndexBuffer( triangles.length );
			indexList.uploadFromVector( triangles, 0, triangles.length );
			
			//Create vertexes
			const dataPerVertex:int = 6;
			var vertexData:Vector.<Number> = Vector.<Number>(
				[
				  // x, y, z    r, g, b format
					 0, 0, 0,   1, 1, 1,
					-1, 1, 0,   0, 0,.5,
					 1, 1, 0,   0, 0, 1,
					 1,-1, 0,  .5, 0, 0,
					-1,-1, 0,   1, 0, 0
				]
			);
			vertexes = renderContext.createVertexBuffer( vertexData.length/dataPerVertex, dataPerVertex );
			vertexes.uploadFromVector( vertexData, 0, vertexData.length/dataPerVertex );
			
			//Identify vertex data inputs for vertex program
			renderContext.setVertexBufferAt( 0, vertexes, 0, Context3DVertexBufferFormat.FLOAT_3 ); //va0 is position
			renderContext.setVertexBufferAt( 1, vertexes, 3, Context3DVertexBufferFormat.FLOAT_3 ); //va1 is color
			
			//Upload programs to render context
			programPair = renderContext.createProgram();
			programPair.upload( vertexAssembly.agalcode, fragmentAssembly.agalcode );
			renderContext.setProgram( programPair );
			
			//Clear required before first drawTriangles() call
			renderContext.clear( .3,.3,.3 );
			
			//Draw the 2 triangles
			renderContext.drawTriangles( indexList, 0, 2 );
			
			//Show the frame
			renderContext.present();
		}
	}
}

package
{
    import com.adobe.utils.v3.AGALMiniAssembler;
	
	import flash.display.Sprite;
	import flash.display.Stage3D;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.display3D.Context3D;
	import flash.display3D.Context3DProgramType;
	import flash.display3D.Context3DTriangleFace;
	import flash.display3D.Context3DVertexBufferFormat;
	import flash.display3D.IndexBuffer3D;
	import flash.display3D.Program3D;
	import flash.display3D.VertexBuffer3D;
	import flash.events.Event;
	import flash.geom.Matrix3D;
	import flash.utils.ByteArray;
	
	public class Context3D_HelloInstancedDrawing extends Sprite
	{
		private var W:int;
		private var H:int;
		
		private var renderContext:Context3D;
		private var program:Program3D;
		private var vertexBuffer:VertexBuffer3D;
		private var instanceBufferColor:VertexBuffer3D;
		private var instanceBufferTranslation:VertexBuffer3D;
		private var indexBuffer:IndexBuffer3D;
		private var m:Matrix3D;
		private var vertexShader:ByteArray;
		private var fragmentShader:ByteArray;
		
		public function Context3D_HelloInstancedDrawing()
		{
			if (hasEventListener(Event.ADDED_TO_STAGE))
				removeEventListener(Event.ADDED_TO_STAGE, init);
			W = stage.stageWidth;
			H = stage.stageHeight;
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = StageAlign.TOP_LEFT;
			stage.stage3Ds[0].addEventListener(Event.CONTEXT3D_CREATE, contextCreated);
			//We need to request context3D in standard extended profile as instanced drawing requires standard extended profile.
			stage.stage3Ds[0].requestContext3D("auto","standardExtended");			
			
		}
		
		//Note: <code>context3DCreate</code> event can happen at any time. For example, when the hardware resources are taken up by another process.
		private function contextCreated( event:Event ):void
		{
			var t:Stage3D = event.target as Stage3D;
			renderContext = t.context3D;
			trace( "3D driver: " + renderContext.driverInfo );
			setupScene();
		}
		
		
		private function setupScene():void
		{
			renderContext.enableErrorChecking = true;
			renderContext.configureBackBuffer( W, H, 2, false );
			renderContext.setCulling( Context3DTriangleFace.BACK );
			
			//create vertex buffer for geometry information of the instances (same geometry of the instances)
			vertexBuffer = renderContext.createVertexBuffer(3, 3);
			
			//The color and translation information varies across the instances. Use <code>createVertexBufferForInstances</code> for color and translation information.
			//the intancesPerElement parameter used is 1 which means that each instance will use unique element of the instances buffer
			//if the intancesPerElement is 3 then sets of 3 instances will use the same element of the instances buffer
			instanceBufferColor = renderContext.createVertexBufferForInstances(4,3,1);
			instanceBufferTranslation = renderContext.createVertexBufferForInstances(4,3,1);
			//create index buffer for the triangle
			indexBuffer = renderContext.createIndexBuffer(3);
			
			//create and compile program
			program = renderContext.createProgram();
			var assembler:AGALMiniAssembler = new AGALMiniAssembler();
			
			// VERTEX SHADER
			var code:String = "";
			//The vertex shader code runs for every vertex of each instance.
			//The vertex buffers uploaded for instance data (va1,va2) are used when the vertex shader for that particular instance is being executed.
			code += "add vt0, va0, va2\n";
			code += "mov op, vt0\n";
			code += "mov v0, va1\n";
			
			vertexShader = assembler.assemble(Context3DProgramType.VERTEX, code);
			
			//FRAGMENT SHADER
			code = "mov oc, v0\n"; 
			
			// Compile the agal code into bytecode using agalminiassembler
			fragmentShader = assembler.assemble(Context3DProgramType.FRAGMENT, code);
			
			//upload program to gpu
			program.upload(vertexShader, fragmentShader);
			
			//geometry data for the instances
			var vertexData:Vector.<Number>=Vector.<Number>([
				-0.3, -0.3, 0, 	// - 1st vertex x,y,z
				0, 0.3, 1, 	    // - 2nd vertex x,y,z 
				0.3, -0.3, 0    // - 3rd vertex x,y,z
			]);
			
			//per instance color data
			var instanceColorData:Vector.<Number>=Vector.<Number>([
				1.0, 0.0, 0.0, 	// - 1st instance r,g,b
				0.0, 1.0, 0.0,  // - 2nd instance r,g,b
				1.0, 1.0, 1.0,	// - 3rd instance r,g,b
				0.7, 0.0, 1.0   // - 4th instance r,g,b
			]);
			//per instance translation data
			var instanceTranslationData:Vector.<Number>=Vector.<Number>([
				-0.3, -0.3, 0.0, 	// - 1st instance x,y,z
				0.3, 0.3, 0.0, 		// - 2nd instance x,y,z
				-0.3, 0.3, 0.0,	    // - 3rd instance x,y,z
				0.3, -0.3, 0.0      // - 4th instance x,y,z
			]);
			
			vertexBuffer.uploadFromVector(vertexData, 0, 3);
			instanceBufferColor.uploadFromVector(instanceColorData, 0, 4);
			indexBuffer.uploadFromVector(Vector.<uint>([0, 1, 2]), 0, 3);
			instanceBufferTranslation.uploadFromVector(instanceTranslationData, 0, 4);
			
			//pass data to program
			renderContext.setVertexBufferAt(0, vertexBuffer, 0, Context3DVertexBufferFormat.FLOAT_3);
			renderContext.setVertexBufferAt(1, instanceBufferColor, 0, Context3DVertexBufferFormat.FLOAT_3);
			renderContext.setVertexBufferAt(2, instanceBufferTranslation, 0, Context3DVertexBufferFormat.FLOAT_3);
			
			//set active program
			renderContext.setProgram(program);
			renderContext.enableErrorChecking = true;
			addEventListener(Event.ENTER_FRAME, render);
			
		}
		
		private function render( event:Event ):void
		{
			renderContext.clear(0.3, 0.2, 1, 1); // Clear the backbuffer by filling it with the given color
			//Draw three instances of the same geometry but with varying instance data specified using <code>vertexBufferForInstances</code>.
			renderContext.drawTrianglesInstanced(indexBuffer,4);
			renderContext.present(); // render the backbuffer on screen.
		}	
	}
}

package
{
    import com.adobe.utils.v3.AGALMiniAssembler;
	
	import flash.display.Sprite;
	import flash.display.Stage3D;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.display3D.Context3D;
	import flash.display3D.Context3DProgramType;
	import flash.display3D.Context3DTriangleFace;
	import flash.display3D.Context3DVertexBufferFormat;
	import flash.display3D.IndexBuffer3D;
	import flash.display3D.Program3D;
	import flash.display3D.VertexBuffer3D;
	import flash.events.Event;
	import flash.geom.Matrix3D;
	import flash.utils.ByteArray;
	
	public class Context3D_HelloInstanceIdRegister extends Sprite
	{
		private var W:int;
		private var H:int;
		
		private var renderContext:Context3D;
		private var program:Program3D;
		private var vertexBuffer:VertexBuffer3D;
		private var instanceBufferColor:VertexBuffer3D;
		private var instanceBufferTranslation:VertexBuffer3D;
		private var indexBuffer:IndexBuffer3D;
		private var m:Matrix3D;
		private var vertexShader:ByteArray;
		private var fragmentShader:ByteArray;
		
		public function Context3D_HelloInstanceIdRegister()
		{
			if (hasEventListener(Event.ADDED_TO_STAGE))
				removeEventListener(Event.ADDED_TO_STAGE, init);
			W = stage.stageWidth;
			H = stage.stageHeight;
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = StageAlign.TOP_LEFT;
			stage.stage3Ds[0].addEventListener(Event.CONTEXT3D_CREATE, contextCreated);
			//We need to request context3D in standard extended profile as instanced drawing requires standard extended profile.
			stage.stage3Ds[0].requestContext3D("auto","standardExtended");			
			
		}
		
		//Note: <code>context3DCreate</code> event can happen at any time. For example, when the hardware resources are taken up by another process.
		private function contextCreated( event:Event ):void
		{
			var t:Stage3D = event.target as Stage3D;
			renderContext = t.context3D;
			trace( "3D driver: " + renderContext.driverInfo );
			setupScene();
		}
		
		
		private function setupScene():void
		{
			renderContext.enableErrorChecking = true;
			renderContext.configureBackBuffer( W, H, 2, false );
			renderContext.setCulling( Context3DTriangleFace.BACK );
			
			//create vertex buffer for geometry information of the instances (same geometry of the instances)
			vertexBuffer = renderContext.createVertexBuffer(3, 3);
			
			//The color and translation information varies across the instances. Use <code>createVertexBufferForInstances</code> for color and translation information.
			//the intancesPerElement parameter used is 1 which means that each instance will use unique element of the instances buffer
			//if the intancesPerElement is 3 then sets of 3 instances will use the same element of the instances buffer
			instanceBufferColor = renderContext.createVertexBufferForInstances(4,3,1);
			instanceBufferTranslation = renderContext.createVertexBufferForInstances(4,3,1);
			//create index buffer for the triangle
			indexBuffer = renderContext.createIndexBuffer(3);
			
			//create and compile program
			program = renderContext.createProgram();
			//Note : for instance id support , use the latest AgalMiniAssembler from github - https://github.com/adobe-flash/graphicscorelib/blob/master/src/com/adobe/utils/v3/AGALMiniAssembler.as
			var assembler:AGALMiniAssembler = new AGALMiniAssembler();
			
			// VERTEX SHADER
			var code:String = "";
			//the vertex shader code will run for every vertex of every instance , 
			//the vertex buffers uploaded for instance data (va1,va2) will be used when vertex shader for that particular instance is being executed 
			//the vertex shader code below indexes the program constants matrix using iid.x. iid is a new register introduced in vertex shader for instanced drawing
			//it is a read only register , iid.x gives the current instance id whose shader is being executed
			code += "add vt0, va0, va2\n";
			code += "mul vt1, vt0, vc[iid.x]\n"
			code += "mov op, vt1\n";
			code += "mov v0, va1\n";
			
			vertexShader = assembler.assemble(Context3DProgramType.VERTEX, code, 3);
			
			//FRAGMENT SHADER
			code = "mov oc, v0\n"; 
			
			// Compile the agal code into bytecode using agalminiassembler
			fragmentShader = assembler.assemble(Context3DProgramType.FRAGMENT, code, 3);
			
			//upload program to gpu
			program.upload(vertexShader, fragmentShader);
			
			//geometry data for the instances
			var vertexData:Vector.<Number>=Vector.<Number>([
				-0.3, -0.3, 0, 	// - 1st vertex x,y,z
				0, 0.3, 1, 	    // - 2nd vertex x,y,z 
				0.3, -0.3, 0    // - 3rd vertex x,y,z
			]);
			
			//per instance color data
			var instanceColorData:Vector.<Number>=Vector.<Number>([
				1.0, 0.0, 0.0, 	// - 1st instance r,g,b
				0.0, 1.0, 0.0,  // - 2nd instance r,g,b
				1.0, 1.0, 1.0,	// - 3rd instance r,g,b
				0.7, 0.0, 1.0   // - 4th instance r,g,b
			]);
			//per instance translation data
			var instanceTranslationData:Vector.<Number>=Vector.<Number>([
				-0.3, -0.3, 0.0, 	// - 1st instance x,y,z
				0.3, 0.3, 0.0, 		// - 2nd instance x,y,z
				-0.3, 0.3, 0.0,	    // - 3rd instance x,y,z
				0.3, -0.3, 0.0      // - 4th instance x,y,z
			]);
			
			vertexBuffer.uploadFromVector(vertexData, 0, 3);
			instanceBufferColor.uploadFromVector(instanceColorData, 0, 4);
			indexBuffer.uploadFromVector(Vector.<uint>([0, 1, 2]), 0, 3);
			instanceBufferTranslation.uploadFromVector(instanceTranslationData, 0, 4);
			
			//pass data to program
			renderContext.setVertexBufferAt(0, vertexBuffer, 0, Context3DVertexBufferFormat.FLOAT_3);
			renderContext.setVertexBufferAt(1, instanceBufferColor, 0, Context3DVertexBufferFormat.FLOAT_3);
			renderContext.setVertexBufferAt(2, instanceBufferTranslation, 0, Context3DVertexBufferFormat.FLOAT_3);
			
			//set active program
			renderContext.setProgram(program);
			renderContext.enableErrorChecking = true;
			addEventListener(Event.ENTER_FRAME, render);
			
		}
		
		private function render( event:Event ):void
		{
			renderContext.clear(0.3, 0.2, 1, 1); // Clear the backbuffer by filling it with the given color
			var instanceScalingData:Vector.<Number>=Vector.<Number>([
				1.0, 1.0, 1.0, 1.0, 	// - 1st instance x,y,z,w
				1.4, 1.4, 1.4, 1.0,		// - 2nd instance x,y,z,w
				0.6, 0.6, 0.6, 1.0,		// - 3rd instance x,y,z,w
				0.6, 0.6, 0.6, 1.0
			]);
			var m:Matrix3D = new Matrix3D();
			m.copyRawDataFrom(instanceScalingData);
			renderContext.setProgramConstantsFromMatrix("vertex",0,m,false);
			
			//Draw three instances of the same geometry but with varying instance data specified using <code>vertexBufferForInstances</code>.
			renderContext.drawTrianglesInstanced(indexBuffer,4);
			renderContext.present(); // render the backbuffer on screen.
		}	
	}
}

package
{
    import com.adobe.utils.AGALMiniAssembler;
	
	import flash.display.Sprite;
	import flash.display.Stage3D;
	import flash.display3D.Context3D;
	import flash.display3D.Context3DBlendFactor;
	import flash.display3D.Context3DProgramType;
	import flash.display3D.Context3DRenderMode;
	import flash.display3D.Context3DVertexBufferFormat;
	import flash.display3D.IndexBuffer3D;
	import flash.display3D.Program3D;
	import flash.display3D.VertexBuffer3D;
	import flash.events.ErrorEvent;
	import flash.events.Event;
	import flash.events.KeyboardEvent;
	import flash.ui.Keyboard;
	
	public class Context3D_setBlendMode extends Sprite
	{
		public const viewWidth:Number = 320;
		public const viewHeight:Number = 200;
		
		private var stage3D:Stage3D;
		private var renderContext:Context3D;
		private var indexList:IndexBuffer3D;
		private var vertexes:VertexBuffer3D;
		
		private const VERTEX_SHADER:String =
			"mov op, va0	\n" +	//copy position to output 
			"mov v0, va1"; //copy color to varying variable v0
		
		private const FRAGMENT_SHADER:String = 
			"mov oc, v0"; //Set the output color to the value interpolated from the three triangle vertices 

		private var vertexAssembly:AGALMiniAssembler = new AGALMiniAssembler();
		private var fragmentAssembly:AGALMiniAssembler = new AGALMiniAssembler();
		private var programPair:Program3D;
		
		private var sourceFactor:int = 6;
		private var destinationFactor:int = 4;
		private var blendFactors:Array = [Context3DBlendFactor.DESTINATION_ALPHA,
										  Context3DBlendFactor.DESTINATION_COLOR,
										  Context3DBlendFactor.ONE,
										  Context3DBlendFactor.ONE_MINUS_DESTINATION_ALPHA,
										  Context3DBlendFactor.ONE_MINUS_SOURCE_ALPHA,
										  Context3DBlendFactor.ONE_MINUS_SOURCE_COLOR,
										  Context3DBlendFactor.SOURCE_ALPHA,
										  Context3DBlendFactor.SOURCE_COLOR,
										  Context3DBlendFactor.ZERO];
			
		public function Context3D_setBlendMode()
		{
			this.stage.addEventListener( KeyboardEvent.KEY_DOWN, keyHandler );
			
			stage3D = this.stage.stage3Ds[0];
			stage3D.x = 10;
			stage3D.y = 10;

			//Add event listener before requesting the context
			stage3D.addEventListener( Event.CONTEXT3D_CREATE, contextCreated );
			stage3D.addEventListener( ErrorEvent.ERROR, contextError );
			stage3D.requestContext3D( Context3DRenderMode.AUTO );
			
			//Compile shaders
			vertexAssembly.assemble( Context3DProgramType.VERTEX, VERTEX_SHADER, false );
			fragmentAssembly.assemble( Context3DProgramType.FRAGMENT, FRAGMENT_SHADER, false );			
		}
		
		//Note, context3DCreate event can happen at any time, such as when the hardware resources are taken by another process
		private function contextCreated( event:Event ):void
		{
			renderContext = Stage3D( event.target ).context3D;
			trace( "3D driver: " + renderContext.driverInfo );

			renderContext.enableErrorChecking = true; //Can slow rendering - only turn on when developing/testing
			renderContext.configureBackBuffer( viewWidth, viewHeight, 2, false );
			
			//Create vertex index list for the triangles
			var triangles:Vector.<uint> = Vector.<uint>( [  0, 3 , 2, 
															0, 1, 3,
															6, 4, 5,
															5, 7, 6,
															10, 8, 9,
															9, 11, 10,
															12, 15, 14,
															12, 13, 15,
															16, 17, 19,
															16, 19, 18
														 ] );
			indexList = renderContext.createIndexBuffer( triangles.length );
			indexList.uploadFromVector( triangles, 0, triangles.length );
			
			//Create vertexes
			const dataPerVertex:int = 7;
			var vertexData:Vector.<Number> = Vector.<Number>(
				[
				  // x, y, z    r, g, b, a format
					-1, 1, 0,   1, 1, 1, .5,
					 0, 1, 0,   1, 1, 1, .5,
					-1, 0, 0,   1, 1, 1, .5,
					 0, 0, 0,   1, 1, 1, .5,
					 
					 0, 1, 0,  .8,.8,.8, .6,
					 1, 1, 0,  .8,.8,.8, .6,
					 0, 0, 0,  .8,.8,.8, .6,
					 1, 0, 0,  .8,.8,.8, .6,
					 
					-1, 0, 0,   1, 0, 0, .5,
					 0, 0, 0,   0, 1, 0, .5,
					-1,-1, 0,   0, 0, 1, .5,
					 0,-1, 0,   1, 0, 1, .5,
					 
					 0, 0, 0,   0, 0, 0, .5,
					 1, 0, 0,   0, 0, 0, .5,
					 0,-1, 0,   0, 0, 0, .5,
					 1,-1, 0,   0, 0, 0, .5,
					 
				   -.8,.8, 0,  .6,.4,.2,.4,
				    .8,.8, 0,  .6,.4,.2,.4,
				  -.8,-.8, 0,  .6,.4,.2,.4,
				   .8,-.8, 0,  .6,.4,.2,.4
				]
			);
			vertexes = renderContext.createVertexBuffer( vertexData.length/dataPerVertex, dataPerVertex );
			vertexes.uploadFromVector( vertexData, 0, vertexData.length/dataPerVertex );
			
			//Identify vertex data inputs for vertex program
			renderContext.setVertexBufferAt( 0, vertexes, 0, Context3DVertexBufferFormat.FLOAT_3 ); //va0 is position
			renderContext.setVertexBufferAt( 1, vertexes, 3, Context3DVertexBufferFormat.FLOAT_4 ); //va1 is color
			
			//Upload programs to render context
			programPair = renderContext.createProgram();
			programPair.upload( vertexAssembly.agalcode, fragmentAssembly.agalcode );
			renderContext.setProgram( programPair );
			
			render();
		}
		
		private function render():void
		{
			//Clear required before first drawTriangles() call
			renderContext.clear( 1, 1, 1, 1 );
			//Draw the back triangles
			renderContext.setBlendFactors( Context3DBlendFactor.ONE, Context3DBlendFactor.ZERO ); //No blending
			renderContext.drawTriangles( indexList, 0, 8 );

			//Set blend
			renderContext.setBlendFactors( blendFactors[sourceFactor], blendFactors[destinationFactor] );
			
			//Draw the front triangles
			renderContext.drawTriangles( indexList, 24, 2 );
			
			//Show the frame
			renderContext.present();
		}
		
		private function contextError( error:ErrorEvent ):void
		{
			trace( error.errorID + ": " + error.text );
		}
		
		private function keyHandler( event:KeyboardEvent ):void
		{
			switch ( event.keyCode )
			{
				case Keyboard.NUMBER_1:
					if( --sourceFactor < 0 ) sourceFactor = blendFactors.length - 1; 
					break;
				case Keyboard.NUMBER_2:
					if( ++sourceFactor > blendFactors.length - 1) sourceFactor = 0;
					break;
				case Keyboard.NUMBER_3:
					if( --destinationFactor < 0 ) destinationFactor = blendFactors.length - 1; 
					break;
				case Keyboard.NUMBER_4:
					if( ++destinationFactor > blendFactors.length - 1) destinationFactor = 0;
					break;
			}
			trace( "Source blend factor: " + blendFactors[sourceFactor] + ", destination blend factor: " + blendFactors[destinationFactor] );
			render();
		}
	}
}

package
{
    import com.adobe.utils.AGALMiniAssembler;
	
	import flash.display.Sprite;
	import flash.display.Stage3D;
	import flash.display3D.Context3D;
	import flash.display3D.Context3DProgramType;
	import flash.display3D.Context3DRenderMode;
	import flash.display3D.Context3DVertexBufferFormat;
	import flash.display3D.IndexBuffer3D;
	import flash.display3D.Program3D;
	import flash.display3D.VertexBuffer3D;
	import flash.events.Event;
	
	public class Context3D_setColorMask extends Sprite
	{
		public const viewWidth:Number = 320;
		public const viewHeight:Number = 200;
		
		private var stage3D:Stage3D;
		private var renderContext:Context3D;
		private var indexList:IndexBuffer3D;
		private var vertexes:VertexBuffer3D;
		
		private const VERTEX_SHADER:String =
			"mov op, va0	\n" +	//copy position to output 
			"mov v0, va1"; //copy color to varying variable v0
		
		private const FRAGMENT_SHADER:String = 
			"mov oc, v0"; //Set the output color to the value interpolated from the three triangle vertices 

		private var vertexAssembly:AGALMiniAssembler = new AGALMiniAssembler();
		private var fragmentAssembly:AGALMiniAssembler = new AGALMiniAssembler();
		private var programPair:Program3D;
		
		public function Context3D_setColorMask()
		{
			stage3D = this.stage.stage3Ds[0];
			stage3D.x = 10;
			stage3D.y = 10;

			//Add event listener before requesting the context
			stage3D.addEventListener( Event.CONTEXT3D_CREATE, contextCreated );			
			stage3D.requestContext3D( Context3DRenderMode.AUTO );
			
			//Compile shaders
			vertexAssembly.assemble( Context3DProgramType.VERTEX, VERTEX_SHADER, false );
			fragmentAssembly.assemble( Context3DProgramType.FRAGMENT, FRAGMENT_SHADER, false );			
		}
		
		//Note, context3DCreate event can happen at any time, such as when the hardware resources are taken by another process
		private function contextCreated( event:Event ):void
		{
			renderContext = Stage3D( event.target ).context3D;
			trace( "3D driver: " + renderContext.driverInfo );

			renderContext.enableErrorChecking = true; //Can slow rendering - only turn on when developing/testing
			renderContext.configureBackBuffer( viewWidth, viewHeight, 2, false );
			
			//Create vertex index list for the triangles
			var triangles:Vector.<uint> = Vector.<uint>( [ 0, 1, 2, 0, 3, 4 ] );
			indexList = renderContext.createIndexBuffer( triangles.length );
			indexList.uploadFromVector( triangles, 0, triangles.length );
			
			//Create vertexes
			const dataPerVertex:int = 6;
			var vertexData:Vector.<Number> = Vector.<Number>(
				[
				  // x, y, z    r, g, b format
					 0, 0, 0,   1, 1, 1,
					-1, 1, 0,   1, 1, 1,
					 1, 1, 0,   1, 1, 1,
					 1,-1, 0,   1, 1, 1,
					-1,-1, 0,   1, 1, 1
				]
			);
			vertexes = renderContext.createVertexBuffer( vertexData.length/dataPerVertex, dataPerVertex );
			vertexes.uploadFromVector( vertexData, 0, vertexData.length/dataPerVertex );
			
			//Identify vertex data inputs for vertex program
			renderContext.setVertexBufferAt( 0, vertexes, 0, Context3DVertexBufferFormat.FLOAT_3 ); //va0 is position
			renderContext.setVertexBufferAt( 1, vertexes, 3, Context3DVertexBufferFormat.FLOAT_3 ); //va1 is color
			
			//Upload programs to render context
			programPair = renderContext.createProgram();
			programPair.upload( vertexAssembly.agalcode, fragmentAssembly.agalcode );
			renderContext.setProgram( programPair );
			
			renderContext.clear( .3,.3,.3,1 );
			renderContext.drawTriangles( indexList, 0, 1 ); //Top triangle draws all colors, so is white
			renderContext.setColorMask( true, false, false, false ); //Mask all but red channel			
			renderContext.drawTriangles( indexList, 3, 1 ); //Bottom triangle only updates red
			
			//Show the frame
			renderContext.present();
		}
	}
}

//A simple vertex program in AGAL
const VERTEX_SHADER:String =
    "m44 op, va0, vc0 \n" +	
	"mov v0, va1"; 

//A simple fragment (or pixel) program in AGAL		
const FRAGMENT_SHADER:String = "mov oc, v0";  

var vertexAssembly:AGALMiniAssembler = new AGALMiniAssembler();
var fragmentAssembly:AGALMiniAssembler = new AGALMiniAssembler();
var programPair:Program3D;

//Compile shaders
vertexAssembly.assemble( Context3DProgramType.VERTEX, VERTEX_SHADER, false );
fragmentAssembly.assemble( Context3DProgramType.FRAGMENT, FRAGMENT_SHADER, false );			

//Upload programs to render context
programPair = renderContext.createProgram();
programPair.upload( vertexAssembly.agalcode, fragmentAssembly.agalcode );
renderContext.setProgram( programPair );

package
{
    import com.adobe.utils.AGALMiniAssembler;
	
	import flash.display.Sprite;
	import flash.display.Stage3D;
	import flash.display3D.Context3D;
	import flash.display3D.Context3DBlendFactor;
	import flash.display3D.Context3DProgramType;
	import flash.display3D.Context3DRenderMode;
	import flash.display3D.Context3DVertexBufferFormat;
	import flash.display3D.IndexBuffer3D;
	import flash.display3D.Program3D;
	import flash.display3D.VertexBuffer3D;
	import flash.events.Event;
	import flash.events.KeyboardEvent;
	import flash.events.TimerEvent;
	import flash.geom.Rectangle;
	import flash.ui.Keyboard;
	import flash.utils.Timer;
	
	public class Context3D_ScissorRectangle extends Sprite
	{
		public const viewWidth:Number = 640;
		public const viewHeight:Number = 480;
		
		private var stage3D:Stage3D;
		private var renderContext:Context3D;
		private var indexList:IndexBuffer3D;
		private var vertexes:VertexBuffer3D;
		
		private const VERTEX_SHADER:String =
			"mov op, va0	\n" +	//copy position to output 
			"mov v0, va1"; //copy color to varying variable v0
		
		private const FRAGMENT_SHADER:String = 
			"mov oc, v0"; //Set the output color to the value interpolated from the three triangle vertices 

		private var vertexAssembly:AGALMiniAssembler = new AGALMiniAssembler();
		private var fragmentAssembly:AGALMiniAssembler = new AGALMiniAssembler();
		private var programPair:Program3D;
		
		private var scissorOn:Boolean = false;
		private var toggler:Timer = new Timer( 750 );
		
		public function Context3D_ScissorRectangle()
		{			
			stage3D = this.stage.stage3Ds[0];
			stage3D.x = 10;
			stage3D.y = 10;

			//Add event listener before requesting the context
			stage3D.addEventListener( Event.CONTEXT3D_CREATE, contextCreated );			
			stage3D.requestContext3D( Context3DRenderMode.AUTO );
			
			//Compile shaders
			vertexAssembly.assemble( Context3DProgramType.VERTEX, VERTEX_SHADER, false );
			fragmentAssembly.assemble( Context3DProgramType.FRAGMENT, FRAGMENT_SHADER, false );
			
			//Set up timer to turn scissoring on and off
			toggler.addEventListener( TimerEvent.TIMER, toggleScissor );
		}
		
		//Note, context3DCreate event can happen at any time, such as when the hardware resources are taken by another process
		private function contextCreated( event:Event ):void
		{
			renderContext = Stage3D( event.target ).context3D;
			trace( "3D driver: " + renderContext.driverInfo );

			renderContext.enableErrorChecking = true; //Can slow rendering - only turn on when developing/testing
			renderContext.configureBackBuffer( viewWidth, viewHeight, 2, false );
			
			//Create vertex index list for the triangles
			var triangles:Vector.<uint> = Vector.<uint>( [  0, 3 , 2, 
															0, 1, 3
														 ] );
			indexList = renderContext.createIndexBuffer( triangles.length );
			indexList.uploadFromVector( triangles, 0, triangles.length );
			
			//Create vertexes
			const dataPerVertex:int = 6;
			var vertexData:Vector.<Number> = Vector.<Number>(
				[
				  // x, y, z    r, g, b, a format 
				   -1, 1, 0,  1,0,0,
				    1, 1, 0,  0,0,1,
				   -1,-1, 0,  0,1,0,
				    1,-1, 0,  1,0,1
				]
			);
			vertexes = renderContext.createVertexBuffer( vertexData.length/dataPerVertex, dataPerVertex );
			vertexes.uploadFromVector( vertexData, 0, vertexData.length/dataPerVertex );
			
			//Identify vertex data inputs for vertex program
			renderContext.setVertexBufferAt( 0, vertexes, 0, Context3DVertexBufferFormat.FLOAT_3 ); //va0 is position
			renderContext.setVertexBufferAt( 1, vertexes, 3, Context3DVertexBufferFormat.FLOAT_3 ); //va1 is color
			
			//Upload programs to render context
			programPair = renderContext.createProgram();
			programPair.upload( vertexAssembly.agalcode, fragmentAssembly.agalcode );
			renderContext.setProgram( programPair );
			
			render();
			toggler.start();
		}
		
		private function render():void
		{
			//Clear required before first drawTriangles() call
			renderContext.clear();

			//Sciss a region excluding the outer 100 pixels of the viewport
			var scissor:Rectangle = new Rectangle( 100, 100, viewWidth - 200, viewHeight - 200 );
			if( scissorOn )	renderContext.setScissorRectangle( scissor ); //on
			else renderContext.setScissorRectangle( null ); //off

			//Draw the triangles
			renderContext.drawTriangles( indexList, 0, 2 );
			
			//Show the frame
			renderContext.present();
		}
		
		private function toggleScissor( event:Event ):void
		{
			scissorOn = !scissorOn;
			render();
		}
		
	}
}

package
{
    import com.adobe.utils.AGALMiniAssembler;
	
	import flash.display.Sprite;
	import flash.display.Stage3D;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.display3D.Context3D;
	import flash.display3D.Context3DBlendFactor;
	import flash.display3D.Context3DCompareMode;
	import flash.display3D.Context3DProgramType;
	import flash.display3D.Context3DRenderMode;
	import flash.display3D.Context3DStencilAction;
	import flash.display3D.Context3DTriangleFace;
	import flash.display3D.Context3DVertexBufferFormat;
	import flash.display3D.IndexBuffer3D;
	import flash.display3D.Program3D;
	import flash.display3D.VertexBuffer3D;
	import flash.events.Event;
	import flash.events.KeyboardEvent;
	import flash.events.MouseEvent;
	import flash.events.TimerEvent;
	import flash.geom.Rectangle;
	import flash.text.TextField;
	import flash.text.TextFormat;
	import flash.ui.Keyboard;
	import flash.utils.Timer;
	
	public class Context3D_Stencil extends Sprite
	{
		public const viewWidth:Number = 350;
		public const viewHeight:Number = 240;
		
		private var stage3D:Stage3D;
		private var renderContext:Context3D;
		private var indexList:IndexBuffer3D;
		private var vertexes:VertexBuffer3D;
		
		private const VERTEX_SHADER:String =
			"mov op, va0	\n" +	//copy position to output 
			"mov v0, va1"; //copy color to varying variable v0
		
		private const FRAGMENT_SHADER:String = 
			"mov oc, v0"; //Set the output color to the value interpolated from the three triangle vertices 

		private var vertexAssembly:AGALMiniAssembler = new AGALMiniAssembler();
		private var fragmentAssembly:AGALMiniAssembler = new AGALMiniAssembler();
		private var programPair:Program3D;
				
		public function Context3D_Stencil()
		{			
			stage3D = this.stage.stage3Ds[0];
			stage3D.x = 10;
			stage3D.y = 10;

			//Add event listener before requesting the context
			stage3D.addEventListener( Event.CONTEXT3D_CREATE, contextCreated );			
			stage3D.requestContext3D( Context3DRenderMode.AUTO );
			
			//Compile shaders
			vertexAssembly.assemble( Context3DProgramType.VERTEX, VERTEX_SHADER, false );
			fragmentAssembly.assemble( Context3DProgramType.FRAGMENT, FRAGMENT_SHADER, false );
		
			non3DSetup();
		}
		
		//Note, context3DCreate event can happen at any time, such as when the hardware resources are taken by another process
		private function contextCreated( event:Event ):void
		{
			renderContext = Stage3D( event.target ).context3D;
			trace( "3D driver: " + renderContext.driverInfo );

			renderContext.enableErrorChecking = true; //Can slow rendering - only turn on when developing/testing
			renderContext.configureBackBuffer( viewWidth, viewHeight, 2, true );
			
			//Create vertex index list for the triangles
			var triangles:Vector.<uint> = Vector.<uint>( [  0, 3, 2, 
															0, 1, 3,
															4, 7, 6,
															4, 5, 7,
															8, 9, 10
														 ] );
			indexList = renderContext.createIndexBuffer( triangles.length );
			indexList.uploadFromVector( triangles, 0, triangles.length );
			
			//Create vertexes
			const dataPerVertex:int = 6;
			var vertexData:Vector.<Number> = Vector.<Number>(
				[
				  //x, y, z  r,g,b format 
				   -1, 1, 0,  1,0,0,
				    1, 1, 0,  0,0,1,
				   -1,-1, 0,  0,1,0,
				    1,-1, 0,  1,0,1,

				   -1, 1, 0,  .5,0,0,
					1, 1, 0,  .5,0,0,
				   -1,-1, 0,  .5,0,0,
					1,-1, 0,  .5,0,0,
					
					0, .7,.1, 0,0,0,
				  -.7,-.7,.1, 0,0,0,
				   .7,-.7,.1, 0,0,0
				]);
			vertexes = renderContext.createVertexBuffer( vertexData.length/dataPerVertex, dataPerVertex );
			vertexes.uploadFromVector( vertexData, 0, vertexData.length/dataPerVertex );
			
			//Identify vertex data inputs for vertex program
			renderContext.setVertexBufferAt( 0, vertexes, 0, Context3DVertexBufferFormat.FLOAT_3 ); //va0 is position
			renderContext.setVertexBufferAt( 1, vertexes, 3, Context3DVertexBufferFormat.FLOAT_3 ); //va1 is color
			
			//Upload programs to render context
			programPair = renderContext.createProgram();
			programPair.upload( vertexAssembly.agalcode, fragmentAssembly.agalcode );
			renderContext.setProgram( programPair );
			render();
		}
		private function render():void
		{
			//Clear, setting stencil to 0
			renderContext.clear( .3, .3, .3, 1, 1, 0 );
			
			//Draw stencil, incrementing the stencil buffer value
			renderContext.setStencilReferenceValue( 0 );
			renderContext.setStencilActions( Context3DTriangleFace.FRONT_AND_BACK, 
				Context3DCompareMode.EQUAL, Context3DStencilAction.INCREMENT_SATURATE );			
			if( state > 0 ) renderContext.drawTriangles( indexList, 12, 1 );

			//Change stencil action when stencil passes so stencil buffer is not changed
			renderContext.setStencilActions( Context3DTriangleFace.FRONT_AND_BACK, 
				Context3DCompareMode.EQUAL, Context3DStencilAction.KEEP );
			
			//Draw quad -- doesn't draw where stencil has already drawn
			if( state > 1 ) renderContext.drawTriangles( indexList, 0, 2 );
			
			//Change the reference to 1 so this quad only draws into stenciled area
			renderContext.setStencilReferenceValue( 1 );
			if( state > 2 ) renderContext.drawTriangles( indexList, 6, 2 );
			
			//Show the frame
			renderContext.present();
		}
		
		//The rest of the code is for the example UI and timer 
		private function doState( event:TimerEvent ):void
		{
			switch (state)
			{
				case 0:
					description.text = "Draw triangle with stencil action == increment";
					state = 1;
					break;
				case 1:
					description.text = "Draw the first plane where stencil == 0";
					state = 2;
					break;
				case 2:
					description.text = "Draw second plane where stencil == 1";
					state = 3;
					break;
				case 3:
					description.text = "Clear, setting stencil to 0";
					state = 0;
					break;

				default:
					description.text = "";
					state = 0;		
			}
			render();
		}

		private var state:int = 3;
		private var stateTimer:Timer = new Timer( 1250 );
		private var description:TextField = new TextField();
		
		private function non3DSetup():void
		{
			//Setup timer to animate the stages of drawing the scene
			stateTimer.addEventListener( TimerEvent.TIMER, doState );
			this.stage.addEventListener( MouseEvent.MOUSE_OVER, function(event:Event):void{stateTimer.start()} );
			this.stage.addEventListener( MouseEvent.MOUSE_OUT, function(event:Event):void{stateTimer.stop()} );
			
			description.height = 30;
			description.width = viewWidth;
			this.addChild( description );
			description.y = viewHeight + 15;
			description.defaultTextFormat = new TextFormat( null, 18, 0xffffff );
			description.text = "Mouse over to view.";
			
			//Allows mouse-over events
			var coverSprite:Sprite = new Sprite();
			coverSprite.graphics.beginFill( 0, .01 )
			coverSprite.graphics.lineTo( stage.stageWidth, 0 );
			coverSprite.graphics.lineTo( stage.stageWidth, stage.stageHeight );
			coverSprite.graphics.lineTo( 0, stage.stageHeight );
			coverSprite.graphics.lineTo( 0, 0 );
			this.addChild( coverSprite );			
		}
	}
}

         setTextureAt( 7, null );

         

package
{
    import com.adobe.utils.AGALMiniAssembler;
	import com.adobe.utils.PerspectiveMatrix3D;
	
	import flash.display.Sprite;
	import flash.display.Stage3D;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.display3D.Context3D;
	import flash.display3D.Context3DProgramType;
	import flash.display3D.Context3DRenderMode;
	import flash.display3D.Context3DTriangleFace;
	import flash.display3D.Context3DVertexBufferFormat;
	import flash.display3D.IndexBuffer3D;
	import flash.display3D.Program3D;
	import flash.display3D.VertexBuffer3D;
	import flash.events.ErrorEvent;
	import flash.events.Event;
	import flash.geom.Matrix3D;
	import flash.geom.Vector3D;
	
	public class Context3DExample extends Sprite
	{
		public const viewWidth:Number = 320;
		public const viewHeight:Number = 200;
		public const zNear:Number = 1;
		public const zFar:Number = 500;
		
		public const fov:Number = 45;
		
		private var stage3D:Stage3D;
		private var renderContext:Context3D;
		private var indexList:IndexBuffer3D;
		private var vertexes:VertexBuffer3D;
		
		private var projection:PerspectiveMatrix3D = new PerspectiveMatrix3D();
		private var model:Matrix3D = new Matrix3D();
		private var view:Matrix3D = new Matrix3D();
		private var finalTransform:Matrix3D = new Matrix3D();
		
		//For rotating the cube
		private const pivot:Vector3D = new Vector3D();
		
		private const VERTEX_SHADER:String =
			"m44 op, va0, vc0	\n" +	// 4x4 matrix transform 
			"mov v0, va1"; //copy color to varying variable v0
		
		private const FRAGMENT_SHADER:String = 
			"mov oc, v0"; //Set the output color to the value interpolated from the three triangle vertices 

		private var vertexAssembly:AGALMiniAssembler = new AGALMiniAssembler();
		private var fragmentAssembly:AGALMiniAssembler = new AGALMiniAssembler();
		private var programPair:Program3D;
		
		public function Context3DExample()
		{
			this.stage.scaleMode = StageScaleMode.NO_SCALE;
			this.stage.align = StageAlign.TOP_LEFT;
			this.stage.nativeWindow.activate(); //AIR only
			 			
			stage3D = this.stage.stage3Ds[0];
			stage3D.x = 10;
			stage3D.y = 10;

			//Add event listener before requesting the context
			stage3D.addEventListener( Event.CONTEXT3D_CREATE, contextCreated );
			stage3D.addEventListener( ErrorEvent.ERROR, contextCreationError );
			stage3D.requestContext3D( Context3DRenderMode.AUTO );
			
			//Compile shaders
			vertexAssembly.assemble( Context3DProgramType.VERTEX, VERTEX_SHADER, false );
			fragmentAssembly.assemble( Context3DProgramType.FRAGMENT, FRAGMENT_SHADER, false );			
		}
		
		//Note, context3DCreate event can happen at any time, such as when the hardware resources are taken by another process
		private function contextCreated( event:Event ):void
		{
				renderContext = Stage3D( event.target ).context3D;
				trace( "3D driver: " + renderContext.driverInfo );
				setupScene();
		}
		
		private function setupScene():void
		{
			renderContext.enableErrorChecking = true; //Can slow rendering - only turn on when developing/testing
			renderContext.configureBackBuffer( viewWidth, viewHeight, 2, false );
			renderContext.setCulling( Context3DTriangleFace.BACK );
			
			//Create vertex index list for the triangles forming a cube
			var triangles:Vector.<uint> = Vector.<uint>( [ 
				2,1,0, //front face
				3,2,0,
				4,7,5, //bottom face
				7,6,5,
				8,11,9, //back face
				9,11,10,
				12,15,13, //top face
				13,15,14,
				16,19,17, //left face
				17,19,18,
				20,23,21, //right face
				21,23,22
			] );
			indexList = renderContext.createIndexBuffer( triangles.length );
			indexList.uploadFromVector( triangles, 0, triangles.length );
			
			//Create vertexes - cube faces do not share vertexes
			const dataPerVertex:int = 6;
			var vertexData:Vector.<Number> = Vector.<Number>(
				[
					// x,y,z r,g,b format
					0,0,0, 1,0,0, //front face
					0,1,0, 1,0,0,
					1,1,0, 1,0,0,
					1,0,0, 1,0,0,
					
					0,0,0, 0,1,0, //bottom face
					1,0,0, 0,1,0,
					1,0,1, 0,1,0,
					0,0,1, 0,1,0,
					
					0,0,1, 1,0,0, //back face
					1,0,1, 1,0,0,
					1,1,1, 1,0,0,
					0,1,1, 1,0,0,
					
					0,1,1, 0,1,0, //top face
					1,1,1, 0,1,0,
					1,1,0, 0,1,0,
					0,1,0, 0,1,0,
					
					0,1,1, 0,0,1, //left face
					0,1,0, 0,0,1,
					0,0,0, 0,0,1,
					0,0,1, 0,0,1,
					
					1,1,0, 0,0,1, //right face
					1,1,1, 0,0,1,
					1,0,1, 0,0,1,
					1,0,0, 0,0,1
				]
			);
			vertexes = renderContext.createVertexBuffer( vertexData.length/dataPerVertex, dataPerVertex );
			vertexes.uploadFromVector( vertexData, 0, vertexData.length/dataPerVertex );
			
			//Identify vertex data inputs for vertex program
			renderContext.setVertexBufferAt( 0, vertexes, 0, Context3DVertexBufferFormat.FLOAT_3 ); //va0 is position
			renderContext.setVertexBufferAt( 1, vertexes, 3, Context3DVertexBufferFormat.FLOAT_3 ); //va1 is color
			
			//Upload programs to render context
			programPair = renderContext.createProgram();
			programPair.upload( vertexAssembly.agalcode, fragmentAssembly.agalcode );
			renderContext.setProgram( programPair );
			
			//Set up 3D transforms
			projection.perspectiveFieldOfViewRH( fov, viewWidth/viewHeight, zNear, zFar );			
			view.appendTranslation( 0, 0, -2 );	//Move view back
			model.appendTranslation( -.5, -.5, -.5 ); //center cube on origin
			this.stage.addEventListener( Event.ENTER_FRAME, render );
		}
		
		private function render( event:Event ):void
		{
			//Rotate model on each frame
			model.appendRotation( .5, Vector3D.Z_AXIS, pivot );
			model.appendRotation( .5, Vector3D.Y_AXIS, pivot );
			model.appendRotation( .5, Vector3D.X_AXIS, pivot );
			
			//Combine transforms
			finalTransform.identity();
			finalTransform.append( model );
			finalTransform.append( view );
			finalTransform.append( projection );
			
			//Pass the final transform to the vertex shader as program constant, vc0
			renderContext.setProgramConstantsFromMatrix( Context3DProgramType.VERTEX, 0, finalTransform, true );
			
			//Clear is required before drawTriangles on each frame
			renderContext.clear( .3,.3,.3 );
			
			//Draw the 12 triangles that make up the cube
			renderContext.drawTriangles( indexList, 0, 12 );
			
			//Show the frame
			renderContext.present();
		}
		
		private function contextCreationError( error:ErrorEvent ):void
		{
			trace( error.errorID + ": " + error.text );
		}
	}
}