Example #1
0
        public ApplicationSprite()
        {
            // Set the default stage behavior
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align     = StageAlign.TOP_LEFT;

            // Request a 3D context instance
            stage3D = stage.stage3Ds[0];


            //stage3D.addEventListener(Event.CONTEXT3D_CREATE, contextReady, false, 0, true);
            stage3D.context3DCreate +=
                e =>
            {
                //stage3D.removeEventListener(Event.CONTEXT3D_CREATE, contextReady);
                //trace("Got context!");

                // Get the new context
                context = stage3D.context3D;

                // Configure back buffer
                context.configureBackBuffer(CONTEXT_WIDTH, CONTEXT_HEIGHT, 2, true);
                stage3D.x = stage3D.y = 0;

                // Prepare vertex data
                Vector <double> vertexData = new[] {
                    -0.5, -0.5, 0, 1.0, 0.0, 0.0,                                       //<- 1st vertex x,y,z, r,g,b
                    -0.5, 0.5, 0, 0.0, 1.0, 0.0,                                        //<- 2nd vertex x,y,z, r,g,b
                    0.5, 0.0, 0, 0.0, 0.0, 1.0                                          //<- 3rd vertex x,y,z, r,g,b
                };

                // Connect the vertices into a triangle (in counter-clockwise order)
                Vector <uint> indexData = new uint[] { 0, 1, 2 };

                // Prepare a shader for rendering
                shader = new BasicRender();
                shader.upload(context);
                shader.setGeometry(vertexData, indexData);

                // ...and start rendering frames!
                //addEventListener(Event.ENTER_FRAME, renderFrame, false, 0, true);

                var sw = new Stopwatch();
                sw.Start();

                Func <Matrix3D> makeViewMatrix = delegate
                {
                    var aspect = CONTEXT_WIDTH / CONTEXT_HEIGHT;
                    var zNear  = 0.01;
                    var zFar   = 1000;
                    var fov    = 45 * DEGS_TO_RADIANS;

                    var view = new PerspectiveMatrix3D();
                    view.perspectiveFieldOfViewLH(fov, aspect, zNear, zFar);

                    var m = new Matrix3D();

                    m.appendRotation(sw.ElapsedMilliseconds / 30, Vector3D.Z_AXIS);
                    m.appendTranslation(0, 0, 2);
                    m.append(view);

                    return(m);
                };



                this.enterFrame +=
                    delegate
                {
                    // Clear away the old frame render
                    context.clear();

                    // Calculate the view matrix, and run the shader program!
                    shader.render(makeViewMatrix());

                    // Show the newly rendered frame on screen
                    context.present();
                };
            };

            stage3D.requestContext3D(Context3DRenderMode.AUTO);

            //trace("Awaiting context...");
        }
        public ApplicationSprite()
        {


            this.WithStage3D(
                stage3D =>
                {
                    //AtMessage("WithStage3D");

                    var context3D = stage3D.context3D;

                    context3D.configureBackBuffer(300, 300, 2);

                    // Create program 3D instance for shader  
                    var program = context3D.createProgram();
                    // Assemble vertex shader from its code
                    var vertexAssembler = new AGALMiniAssembler();
                    // partial?
                    vertexAssembler.assemble(Context3DProgramType.VERTEX, vertexShader);
                    // Assemble fragment shader from its code
                    var fragmentAssembler = new AGALMiniAssembler();
                    fragmentAssembler.assemble(Context3DProgramType.FRAGMENT, fragmentShader);
                    // Upload vertex/framgment shader to our program  
                    program.upload(vertexAssembler.agalcode, fragmentAssembler.agalcode);
                    // Set the program instance as currently active program  
                    context3D.setProgram(program);

                    // Create index buffer
                    var __i3dBuffer = context3D.createIndexBuffer(3);
                    // Upload index buffer from predefined values
                    __i3dBuffer.uploadFromVector(new uint[] { 0, 1, 2 }, 0, 3);

                    // Create vertex buffer
                    var __v3dBuffer = context3D.createVertexBuffer(3, 3);
                    // Upload vertex buffer from predefined values
                    __v3dBuffer.uploadFromVector(new double[]{
                    -1, -1, 5,
                    1, -1, 5,
                    0,  1, 5}, 0, 3);
                    // Set vertex buffer, this is what we access in vertex shader register va0
                    context3D.setVertexBufferAt(0, __v3dBuffer, 0, Context3DVertexBufferFormat.FLOAT_3);

                    // Create our projection matrix
                    var projection = new PerspectiveMatrix3D();
                    // Use a helper function to set up the projection
                    projection.perspectiveFieldOfViewLH(45 * Math.PI / 180, 1.2, 0.1, 512);
                    // Set the projection matrix as a vertex program constant, this is what we access in vertex shader register vc0
                    context3D.setProgramConstantsFromMatrix(Context3DProgramType.VERTEX, 0, projection, true);
                    // Set the out color for our polygon as fragment program constant, this is what we access in fragment shader register fc0
                    context3D.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 0, new double[] { 1, 1, 1, 0 });

                    // Hook up enter frame event where we will do our rendering
                    this.enterFrame +=
                        delegate
                        {
                            context3D.clear(0, 0, 0, 0);

                            context3D.drawTriangles(__i3dBuffer, 0, 1);

                            context3D.present();
                        };
                }
            );
        }
Example #3
0
        public ApplicationSprite()
        {
            this.WithStage3D(
                stage3D =>
            {
                //AtMessage("WithStage3D");

                var context3D = stage3D.context3D;

                context3D.configureBackBuffer(300, 300, 2);

                // Create program 3D instance for shader
                var program = context3D.createProgram();
                // Assemble vertex shader from its code
                var vertexAssembler = new AGALMiniAssembler();
                vertexAssembler.assemble(Context3DProgramType.VERTEX, vertexShader);
                // Assemble fragment shader from its code
                var fragmentAssembler = new AGALMiniAssembler();
                fragmentAssembler.assemble(Context3DProgramType.FRAGMENT, fragmentShader);
                // Upload vertex/framgment shader to our program
                program.upload(vertexAssembler.agalcode, fragmentAssembler.agalcode);
                // Set the program instance as currently active program
                context3D.setProgram(program);

                // Create index buffer
                var __i3dBuffer = context3D.createIndexBuffer(3);
                // Upload index buffer from predefined values
                __i3dBuffer.uploadFromVector(new uint[] { 0, 1, 2 }, 0, 3);

                // Create vertex buffer
                var __v3dBuffer = context3D.createVertexBuffer(3, 3);
                // Upload vertex buffer from predefined values
                __v3dBuffer.uploadFromVector(new double[] {
                    -1, -1, 5,
                    1, -1, 5,
                    0, 1, 5
                }, 0, 3);
                // Set vertex buffer, this is what we access in vertex shader register va0
                context3D.setVertexBufferAt(0, __v3dBuffer, 0, Context3DVertexBufferFormat.FLOAT_3);

                // Create our projection matrix
                var projection = new PerspectiveMatrix3D();
                // Use a helper function to set up the projection
                projection.perspectiveFieldOfViewLH(45 * Math.PI / 180, 1.2, 0.1, 512);
                // Set the projection matrix as a vertex program constant, this is what we access in vertex shader register vc0
                context3D.setProgramConstantsFromMatrix(Context3DProgramType.VERTEX, 0, projection, true);
                // Set the out color for our polygon as fragment program constant, this is what we access in fragment shader register fc0
                context3D.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 0, new double[] { 1, 1, 1, 0 });

                // Hook up enter frame event where we will do our rendering
                this.enterFrame +=
                    delegate
                {
                    context3D.clear(0, 0, 0, 0);

                    context3D.drawTriangles(__i3dBuffer, 0, 1);

                    context3D.present();
                };
            }
                );
        }
        public ApplicationSprite()
        {
            // Set the default stage behavior
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;

            // Request a 3D context instance
            stage3D = stage.stage3Ds[0];


            //stage3D.addEventListener(Event.CONTEXT3D_CREATE, contextReady, false, 0, true);
            stage3D.context3DCreate +=
                e =>
                {
                    //stage3D.removeEventListener(Event.CONTEXT3D_CREATE, contextReady);
                    //trace("Got context!");

                    // Get the new context
                    context = stage3D.context3D;

                    // Configure back buffer
                    context.configureBackBuffer(CONTEXT_WIDTH, CONTEXT_HEIGHT, 2, true);
                    stage3D.x = stage3D.y = 0;

                    // Prepare vertex data
                    Vector<double> vertexData = new[]{
				            -0.5, -0.5,	0,		1.0, 0.0, 0.0,	//<- 1st vertex x,y,z, r,g,b
				            -0.5, 0.5,	0,		0.0, 1.0, 0.0,	//<- 2nd vertex x,y,z, r,g,b
				            0.5,  0.0,	0,		0.0, 0.0, 1.0	//<- 3rd vertex x,y,z, r,g,b
                        };

                    // Connect the vertices into a triangle (in counter-clockwise order)
                    Vector<uint> indexData = new uint[] { 0, 1, 2 };

                    // Prepare a shader for rendering
                    shader = new BasicRender();
                    shader.upload(context);
                    shader.setGeometry(vertexData, indexData);

                    // ...and start rendering frames!
                    //addEventListener(Event.ENTER_FRAME, renderFrame, false, 0, true);

                    var sw = new Stopwatch();
                    sw.Start();

                    Func<Matrix3D> makeViewMatrix = delegate
                    {
                        var aspect = CONTEXT_WIDTH / CONTEXT_HEIGHT;
                        var zNear = 0.01;
                        var zFar = 1000;
                        var fov = 45 * DEGS_TO_RADIANS;

                        var view = new PerspectiveMatrix3D();
                        view.perspectiveFieldOfViewLH(fov, aspect, zNear, zFar);

                        var m = new Matrix3D();

                        m.appendRotation(sw.ElapsedMilliseconds / 30, Vector3D.Z_AXIS);
                        m.appendTranslation(0, 0, 2);
                        m.append(view);

                        return m;
                    };



                    this.enterFrame +=
                        delegate
                        {
                            // Clear away the old frame render
                            context.clear();

                            // Calculate the view matrix, and run the shader program!
                            shader.render(makeViewMatrix());

                            // Show the newly rendered frame on screen
                            context.present();
                        };
                };

            stage3D.requestContext3D(Context3DRenderMode.AUTO);

            //trace("Awaiting context...");
        }