root/as3/Flash3D/Demo3.as

/*
 * Copyright(c) 2006 the Spark project.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */

package
{
    import org.libspark.geom.Matrix4;
    import org.libspark.geom.Vector3D;
    import org.libspark.geom.Vector4D;
    import org.libspark.thunder.*;
    import org.libspark.protect.ProtectedLoader;
    import flash.display.Sprite;
    import flash.display.BitmapData;
    import flash.display.Bitmap;
    import flash.display.Loader;
    import flash.net.URLRequest;
    import flash.text.TextField;
    import flash.events.Event;
    import flash.utils.getTimer;
    
    public class Demo3 extends Sprite
    {
        private var render:Render3;
        private var worldMatrix:Matrix4;
        private var vertices:Array;
        private var indices:Array;
        private var len:uint;
        private var fps:uint;
        private var fpsField:TextField;
        private var rx:Number;
        private var ry:Number;
        private var rz:Number;
        private var textureSource:Loader;
        private var texture:BitmapData;
        
        public function Demo3()
        {
            stage.scaleMode = 'noScale';
            
            render = new Render3();
            
            initializeTexture(render);
            initializeMatrices(render);
            initializeLight(render);
            initializeModel();
            
            render.setRenderTarget(graphics);
            render.setViewport(new Viewport(0, 0, 320, 240));
            
            initializeFpsField();
            
            rx = ry = rz = 0;
            
            textureSource = new ProtectedLoader(441);
            textureSource.contentLoaderInfo.addEventListener(Event.COMPLETE, completeHandler);
            textureSource.load(new URLRequest('texture.swf'));
        }
        
        private function completeHandler(event:Event):void
        {
            textureSource.removeEventListener(Event.COMPLETE, completeHandler);
            textureSource.content.scaleX = 128 / textureSource.contentLoaderInfo.width;
            textureSource.content.scaleY = 128 / textureSource.contentLoaderInfo.height;
            
            addEventListener(Event.ENTER_FRAME, enterFrameHandler);
        }
        
        private function enterFrameHandler(event:Event):void
        {
            var m:Matrix4 = worldMatrix;
            var r:Render3 = render;
            
            m.identity();
            m.rotateX(rx += 0.01);
            m.rotateY(ry += 0.02);
            m.rotateZ(rz += 0.05);
            
            texture.draw(textureSource);
            
            r.updateMatrix();
            r.clear();
            r.beginScene();
            r.drawIndexedPrimitive(indices, vertices, len);
            var poly:uint = r.endScene();
            r.present();
            
            fpsField.text = Math.floor(1000 / (getTimer() - fps)) + 'fps; ' + poly + 'polygons';
            fps = getTimer();
        }
        
        private function initializeFpsField():void
        {
            fpsField = new TextField();
            fpsField.x = 240;
            fpsField.y = 0;
            addChild(fpsField);
            
            fps = getTimer();
        }
        
        private function initializeTexture(render:Render3):void
        {
            texture = new BitmapData(128, 128, false);
            render.setTexture(texture);
        }
        
        private function initializeMatrices(render:Render3):void
        {
            worldMatrix = new Matrix4();
            render.setWorldMatrix(worldMatrix);
            
            var view:Matrix4 = new Matrix4();
            var vCam:Vector3D = new Vector3D(0, 0, 222);
            var vCamEye:Vector3D = new Vector3D(0, 0, 0);
            var vCamTop:Vector3D = new Vector3D(0, 1, 0);
            var camDiv:Number = 0.1;
            MatrixUtil.lookAt(view, vCam, vCamEye, vCamTop);
            render.setViewMatrix(view);
            
            var projection:Matrix4 = new Matrix4();
            MatrixUtil.perspective(projection, 60 * Math.PI / 180, 3 / 4, 0.01, 100);
            render.setProjectionMatrix(projection);
        }
        
        private function initializeLight(render:Render3):void
        {
            var d:Vector3D = new Vector3D(0, -5, -5);
            d.normalize();
            render.setLight(new Light(d, new ColorValue(0.3, 0.3, 0.3), new ColorValue(0.7, 0.7, 0.7)));
        }
        
        private function initializeModel():void
        {
            vertices = new Array(54);
            createPlane(vertices,  0, new Vertex(-64, 64, -64, 0, 0), new Vertex(-64, 64, 64, 0, 1), new Vertex(64, 64, -64, 1, 0), new Vertex(64, 64, 64, 1, 1));
            createPlane(vertices,  9, new Vertex(-64, -64, 64, 0, 0), new Vertex(-64, -64, -64, 0, 1), new Vertex(64, -64, 64, 1, 0), new Vertex(64, -64, -64, 1, 1));
            createPlane(vertices, 18, new Vertex(-64, 64, 64, 0, 0), new Vertex(-64, -64, 64, 0, 1), new Vertex(64, 64, 64, 1, 0), new Vertex(64, -64, 64, 1, 1));
            createPlane(vertices, 27, new Vertex(64, 64, 64, 0, 0), new Vertex(64, -64, 64, 0, 1), new Vertex(64, 64, -64, 1, 0), new Vertex(64, -64, -64, 1, 1));
            createPlane(vertices, 36, new Vertex(64, 64, -64, 0, 0), new Vertex(64, -64, -64, 0, 1), new Vertex(-64, 64, -64, 1, 0), new Vertex(-64, -64, -64, 1, 1));
            createPlane(vertices, 45, new Vertex(-64, 64, -64, 0, 0), new Vertex(-64, -64, -64, 0, 1), new Vertex(-64, 64, 64, 1, 0), new Vertex(-64, -64, 64, 1, 1));
            indices = new Array(144);
            createPlaneIndex(indices,   0,  0);
            createPlaneIndex(indices,  24,  9);
            createPlaneIndex(indices,  48, 18);
            createPlaneIndex(indices,  72, 27);
            createPlaneIndex(indices,  96, 36);
            createPlaneIndex(indices, 120, 45);
            len = 48;
        }
        
        private function createPlane(v:Array, i:uint, a:Vertex, b:Vertex, c:Vertex, d:Vertex):void
        {
            v[i] = a;
            v[i + 1] = new Vertex((a.vec.x + b.vec.x) / 2, (a.vec.y + b.vec.y) / 2, (a.vec.z + b.vec.z) / 2, (a.u + b.u) / 2, (a.v + b.v) / 2);
            v[i + 2] = b;
            v[i + 3] = new Vertex((a.vec.x + c.vec.x) / 2, (a.vec.y + c.vec.y) / 2, (a.vec.z + c.vec.z) / 2, (a.u + c.u) / 2, (a.v + c.v) / 2);
            v[i + 4] = new Vertex((b.vec.x + c.vec.x) / 2, (b.vec.y + c.vec.y) / 2, (b.vec.z + c.vec.z) / 2, (b.u + c.u) / 2, (b.v + c.v) / 2);
            v[i + 5] = new Vertex((b.vec.x + d.vec.x) / 2, (b.vec.y + d.vec.y) / 2, (b.vec.z + d.vec.z) / 2, (b.u + d.u) / 2, (b.v + d.v) / 2);
            v[i + 6] = c;
            v[i + 7] = new Vertex((c.vec.x + d.vec.x) / 2, (c.vec.y + d.vec.y) / 2, (c.vec.z + d.vec.z) / 2, (c.u + d.u) / 2, (c.v + d.v) / 2);
            v[i + 8] = d;
        }
        
        private function createPlaneIndex(v:Array, i:uint, j:uint):void
        {
            createPolygonIndex(v, i     , j    , j + 1, j + 3, j + 4);
            createPolygonIndex(v, i +  6, j + 1, j + 2, j + 4, j + 5);
            createPolygonIndex(v, i + 12, j + 3, j + 4, j + 6, j + 7);
            createPolygonIndex(v, i + 18, j + 4, j + 5, j + 7, j + 8);
        }
        
        private function createPolygonIndex(v:Array, i:uint, a:uint, b:uint, c:uint, d:uint):void
        {
            v[i] = a;
            v[i + 1] = b;
            v[i + 2] = c;
            v[i + 3] = c;
            v[i + 4] = b;
            v[i + 5] = d;
        }
    }
}