Da Fish in Sea

package com.dafishinsea.tutorials.normalmap
{
    import flash.display.BitmapData;
    import flash.display.Sprite;
    import flash.display.TriangleCulling;
    import flash.events.Event;
    import flash.geom.Matrix3D;
    import flash.geom.PerspectiveProjection;
    import flash.geom.Utils3D;
    import flash.geom.Vector3D;
    import flash.text.TextField;
    /**
     * procedural model of a Pumpkin to demonstrate use of normal map
     */
    [SWF(backgroundColor="0x000000", width="800", height="600", frameRate="20")]
    public class NormalMap1 extends Sprite
    {

        private var vertices:Vector.<Number>;
        private var projectedVerts:Vector.<Number>;
        private var numverts:int;
        private var indices:Vector.<int>;
        private var uvts:Vector.<Number>;
        private var texture:BitmapData;
        private var perspective:PerspectiveProjection;
        private var projMatrix:Matrix3D;
        private var sphereRadius:Number;
        private var sphereCenter:Vector3D;
        private var rows:int;//number of times the sphere is sliced to form segments
        private var cols:int;
        private const PI:Number = Math.PI;//half revolution in radians
        private const HALFPI:Number = Math.PI/2;//1/4 revolution in radians
        private const TWOPI:Number = 2*Math.PI;//full revolution in radians
        private var canvas:Sprite;
        private var r:Number = 0;
        //the number of segments = num slices - 1
        //this is the same as lines of longitude
        //thus there are twice as many as horizontal slices

        public function NormalMap1()
        {
            init();
            createMesh();
            addEventListener(Event.ENTER_FRAME, onEnterFrame);
            addEventListener(Event.RENDER, render);
            //render();
        }
        private function onEnterFrame(event:Event):void {
            r = r + 0.2;
            prerender();
            stage.invalidate();
        }


        /**
         * initialize common properties
         */
        private function init():void
        {
            perspective = root.transform.perspectiveProjection;
            texture = new BitmapData(800,800,false,0xCCCCCC);
            sphereRadius = 100;
            //sphereCenter = new Vector3D(stage.stageWidth/2, stage.stageHeight/2, 200);
            cols = 40;
            rows = 20;
            numverts = (cols+1)*(rows+1);
            vertices = new Vector.<Number>(numverts*3);//x,y,z for each vertex
            projectedVerts = new Vector.<Number>(numverts*3);
            uvts = new Vector.<Number>(numverts*3);
            indices = new Vector.<int>();
            //we need to work around the fact that Utils3D.projectVectors disregards the projection center
            //of the projectionMatrix it is passed .. it always projects around 0,0
            //so we must render things on a canvas centered on stage
            canvas = new Sprite();
            canvas.x = stage.stageWidth/2;
            canvas.y = stage.stageHeight/2;
            addChild(canvas);
        }

        /**
         * create the mesh of the Sphere
         */
        private function createMesh():void
        {
            var lon_incr:Number = TWOPI/cols;
            var lat_incr = PI/rows;
            var lon:Number = 0;//angle of rotation around the y axis, *in radians*
            var lat:Number = 0;//angle of rotation around the x axis
            var x:Number, y:Number, z:Number;
            var vnum:int = 0;
            var ind:int = 0;
            //a full rotation is PI radians
            for(var h:int = 0; h <= rows; ++h)
            {
                y = sphereRadius*Math.cos(lat);//need to shift angle downwards by 1/4 rev
                for(var v:int = 0; v <= cols; ++v)
                {
                    x = sphereRadius*Math.cos(lon)*Math.sin(lat);
                    z = sphereRadius*Math.sin(lon)*Math.sin(lat);//seen from above, z = y

                    //add vertex triplet
                    vertices[vnum] = x;
                    vertices[vnum+1] = y;
                    vertices[vnum+2] = z;
                    vnum+=3;
                    //add indices
                    if(h < rows && v < cols){
                        indices.push(ind, ind+1, ind + cols+1);
                        indices.push(ind + cols+1, ind+1, ind + cols + 2);
                    }
                    ind+=1;
                    lon += lon_incr;
                }
                lat += lat_incr;
            }
        }

        /**
         * prerender the sphere -- project vertices using rotated matrix
         */
        private function prerender():void
        {
            projMatrix = perspective.toMatrix3D();
            projMatrix.prependTranslation(0,0,400);
            projMatrix.prependRotation(r, new Vector3D(0,1,0));
            Utils3D.projectVectors(projMatrix, vertices, projectedVerts,uvts);
        }

        /**
         * render
         */
        private function render(event:Event):void
        {
            canvas.graphics.clear();
            canvas.graphics.beginFill(0xFFFFFF);
            canvas.graphics.lineStyle(1,0xcccccc,1);
            canvas.graphics.drawTriangles(projectedVerts, indices, null /* uvts */, TriangleCulling.POSITIVE);
            canvas.graphics.endFill();
        }
    }
}