package {

        import com.adobe.utils.AGALMiniAssembler;
        import com.adobe.utils.PerspectiveMatrix3D;

        import flash.display.Bitmap;
        import flash.display.BitmapData;

        import flash.display.Stage;
        import flash.display3D.Context3D;
        import flash.display3D.Context3DBlendFactor;
        import flash.display3D.Context3DProgramType;
        import flash.display3D.Context3DTextureFormat;
        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.geom.Vector3D;

        public class S3dView
        {
            [Embed(source="texture1.png")]
            private var Texture1Class:Class;
            [Embed(source="texture2.png")]
            private var Texture2Class:Class;
            [Embed(source="screen2.png")]
            private var ScreenClass:Class;

            private var stage:Stage;
            private var _width:Number;
            private var _height:Number;
            //
            private var context3D:Context3D;
            public function S3dView(stage:Stage)
            {
                super();
                //
                this.stage = stage;
                //
                _width = stage.stageWidth;
                _height = stage.stageHeight;
                //
                stage.stage3Ds[0].addEventListener(Event.CONTEXT3D_CREATE, createContextHandler);
                stage.stage3Ds[0].requestContext3D();
            }

            private var vertexBuffer:VertexBuffer3D;
            private var indexBuffer:IndexBuffer3D;
            private var vertexShader:AGALMiniAssembler;
            private var fragmentShader:AGALMiniAssembler;
            private var program:Program3D;
            private function createContextHandler(event:Event):void
            {
                context3D = stage.stage3Ds[0].context3D;
                context3D.configureBackBuffer(stage.stageWidth, stage.stageHeight, 2, true);
                context3D.setBlendFactors(Context3DBlendFactor.ONE, Context3DBlendFactor.ONE_MINUS_SOURCE_ALPHA);
                //
                initTexture();
                //
                context3D.setVertexBufferAt(0, vertexBuffer, 0, Context3DVertexBufferFormat.FLOAT_3);
                context3D.setVertexBufferAt(1, vertexBuffer, 3, Context3DVertexBufferFormat.FLOAT_2);
                //
                program = context3D.createProgram();
                program.upload(vertexShader.agalcode, fragmentShader.agalcode);
                //
                context3D.setProgram(program);
                //
                projection = new PerspectiveMatrix3D();
                var fov:Number = 45;
                var zNear:int = 1;
                var zFar:int = 500;
                projection.perspectiveFieldOfViewRH(fov, stage.stageWidth/stage.stageHeight, zNear, zFar);
                model = new Matrix3D();
                model.appendTranslation(-0.5, -0.5, 0);
                view = new Matrix3D();
                view.appendTranslation(0, 0, -2);
                finalTransform = new Matrix3D();
                //
                stage.addEventListener(Event.ENTER_FRAME, onRender);
            }

            private function initTexture():void
            {
                var vertices:Vector.<Number> = Vector.<Number>([
                    0, 0, 0, 0, 0, // x, y, z, u, v
                    1, 0, 0, 2, 0,
                    1, 1, 0, 2, 2,
                    0, 1, 0, 0, 2
                ]);
                vertexBuffer = context3D.createVertexBuffer(4, 5);
                vertexBuffer.uploadFromVector(vertices, 0, 4);
                //
                var indices:Vector.<uint> = Vector.<uint>([0, 1, 2, 0, 2, 3]);
                indexBuffer = context3D.createIndexBuffer(indices.length);
                indexBuffer.uploadFromVector(indices, 0, indices.length);
                //
                var bitmapData:BitmapData = (new Texture1Class() as Bitmap).bitmapData;
                var texture:* = context3D.createTexture(bitmapData.width, bitmapData.height, Context3DTextureFormat.BGRA, false);
                texture.uploadFromBitmapData(bitmapData);
                context3D.setTextureAt(0, texture);
                //
                vertexShader = new AGALMiniAssembler();
                vertexShader.assemble(Context3DProgramType.VERTEX,
                        "m44 op va0, vc0\n"+
                        "mov v0, va1"
                );
                fragmentShader = new AGALMiniAssembler();
                fragmentShader.assemble(Context3DProgramType.FRAGMENT,
                        "tex ft1, v0, fs0 <2d, repeat, linear>\n"+
                        "mov oc, ft1"
                );
            }

            private var model:Matrix3D;
            private var view:Matrix3D;
            private var projection:PerspectiveMatrix3D;
            private var finalTransform:Matrix3D;

            private function onRender(event:Event):void
            {
                if (!context3D) return;
                //
                model.appendRotation(2, Vector3D.Y_AXIS);
                //
                finalTransform.identity();
                finalTransform.append(model);
                finalTransform.append(view);
                finalTransform.append(projection);
                //
                context3D.setProgramConstantsFromMatrix(Context3DProgramType.VERTEX, 0, finalTransform, true);
                //
                context3D.clear(1, 1, 1, 1);
                context3D.drawTriangles(indexBuffer);
                context3D.present();
            }
        }
    }