PV3D2 .0 的经典 包含各种渲染和触发

最近发现的宝贝,分享下!!值得收藏!!

/*
        Papervision 2.0a Example
        Lee Felarca
        12/12/2007, plus
       
        Examine the source for examples of ...
       
                - Setting up and rendering a simple 3d scene
               
                - Utilizing new materials found in the org.papervision3d.materials.shadematerials package (GouraudMaterial, PhongMaterial, CellMaterial, FlatShadeMaterial, EnvMapMaterial). Plus, CompositeMaterial.
               
                - Utilizing Shaders (viz., EnvMapShader)
               
                - Utilizing a second viewport (used here to create the 'reflection' on the floor)

                - Handling simple user interaction with the 3d scene with InteractiveSceneManager
*/

package
{
        import caurina.transitions.*;
       
        import flash.display.BitmapData;
        import flash.display.Sprite;
        import flash.display.StageScaleMode;
        import flash.events.Event;
        import flash.filters.BlurFilter;
        import flash.geom.Matrix;
       
        import org.papervision3d.cameras.Camera3D;
        import org.papervision3d.cameras.FreeCamera3D;
        import org.papervision3d.core.math.Number3D;
        import org.papervision3d.core.proto.MaterialObject3D;
        import org.papervision3d.core.utils.InteractiveSceneManager;
        import org.papervision3d.core.utils.Mouse3D;
        import org.papervision3d.events.InteractiveScene3DEvent;
        import org.papervision3d.lights.PointLight3D;
        import org.papervision3d.materials.BitmapMaterial;
        import org.papervision3d.materials.ColorMaterial;
        import org.papervision3d.materials.WireframeMaterial;
        import org.papervision3d.materials.shadematerials.CellMaterial;
        import org.papervision3d.materials.shadematerials.EnvMapMaterial;
        import org.papervision3d.materials.shadematerials.FlatShadeMaterial;
        import org.papervision3d.materials.shadematerials.GouraudMaterial;
        import org.papervision3d.materials.shadematerials.PhongMaterial;
        import org.papervision3d.materials.shaders.EnvMapShader;
        import org.papervision3d.materials.shaders.ShadedMaterial;
        import org.papervision3d.materials.special.CompositeMaterial;
        import org.papervision3d.objects.DisplayObject3D;
        import org.papervision3d.objects.primitives.Plane;
        import org.papervision3d.objects.primitives.Sphere;
        import org.papervision3d.render.BasicRenderEngine;
        import org.papervision3d.scenes.Scene3D;
        import org.papervision3d.view.Viewport3D;
       

        [SWF(width="950", height="500", frameRate="45", backgroundColor="#444444", pageTitle="PV2 Sandbox")]

        public class Pv2Example extends Sprite
        {
                private static const DEGREE:Number = Math.PI/180;
                private const NUMSPHERES:int = 7;

                private const FLOORBMP_SIDE:Number = 500;
                private const ENVSPHEREBMP_WIDTH:Number = stage.stageWidth/2;
                private const ENVSPHEREBMP_HEIGHT:Number = stage.stageHeight/2;

                private var sprScene:Sprite;

                // 3d-related variables
                private var scene:Scene3D;
                private var ism:InteractiveSceneManager;
                private var renderer:BasicRenderEngine;
                private var viewportMain:Viewport3D;
                private var viewportFloor:Viewport3D;
                private var cameraMain:Camera3D;
                private var cameraFloor:FreeCamera3D;
                private var light:PointLight3D;
                private var lightSphereEnv:PointLight3D;
                private var floor:Plane;
                private var matSphereEnv:EnvMapMaterial;
                private var matSphereComposite:CompositeMaterial;
                private var matFloor:CompositeMaterial;
                private var matFloorBmp:BitmapMaterial;

                private var bmdEnvSphere:BitmapData;
                private var bmdFloor:BitmapData;
                private var matrixEnvSphere:Matrix;
                private var matrixFloor:Matrix;
               
                private var counter:int;
               
               
                public function Pv2Example()
                {
                        init();
                        init3d();
                }
               
                private function init():void
                {
                        this.stage.scaleMode = StageScaleMode.NO_SCALE;
                        sprScene = new Sprite();
                        this.addChild(sprScene);
                        this.addEventListener(Event.ENTER_FRAME, onEnterFrame, false,0,true);
                }
               
               
                private function init3d():void
                {
                        renderer = new BasicRenderEngine();
                       
                        scene = new Scene3D();

                        viewportMain = new Viewport3D(stage.stageWidth, stage.stageHeight, false, true); // interactive
                        viewportMain.opaqueBackground = 0;
                        this.addChild(viewportMain);
                       
                        ism = viewportMain.interactiveSceneManager;
                        Mouse3D.enabled = true;
                       
                        light = new PointLight3D(true);
                        lightSphereEnv = new PointLight3D(false);

                        cameraMain = new Camera3D();
                        cameraMain.zoom = 8;
                        cameraMain.y = 100;
                        cameraMain.z = -1000;
                       
                        matrixEnvSphere = new Matrix();
                        matrixEnvSphere.scale(0.5,-0.5);
                        matrixEnvSphere.translate(0, ENVSPHEREBMP_HEIGHT);

                        // Set up spheres
                       
                        for (var i:int = 0; i < NUMSPHERES; i++)
                        {
                                // [a] materials
                               
                                var m:MaterialObject3D;
                               
                                switch (i)
                                {
                                        case 0:
                                                m = new GouraudMaterial(light, 0xFF3300, 0x000000);
                                                break;
                                        case 1:
                                                m = new PhongMaterial(light, 0xFF3300, 0, 3);
                                                break;
                                        case 2:
                                                m = new CellMaterial(light, 0xFF3300, 0x000000, 4);
                                                break;
                                        case 3:
                                                m  = new FlatShadeMaterial(light, 0x000000, 0xFF3300);
                                                break;
                                        case 4:
                                                m = matSphereComposite = new CompositeMaterial();
                                                matSphereComposite.addMaterial( new ColorMaterial(0x0, 0.7) );
                                                matSphereComposite.addMaterial( new WireframeMaterial(0xFF3300, 100) );
                                                break;                                       
                                        case 5:
                                                // An environment map material whose lightmap is
                                                // updated with the BitmapData of the main scene
                                                bmdEnvSphere = new BitmapData(ENVSPHEREBMP_WIDTH,ENVSPHEREBMP_HEIGHT);
                                                m = matSphereEnv = new EnvMapMaterial(lightSphereEnv, bmdEnvSphere, null, 0);
                                                matSphereEnv.lightMap = bmdEnvSphere;
                                                break;
                                        case 6:
                                                // A ShadedMaterial using an environment map shader. Uses perlin noise generator
                                                // for the 'base' bitmap, the environment map bitmap, and the bumpmap.
                                                var bmdBase:BitmapData = new BitmapData(250,250,true,0x0);
                                                bmdBase.perlinNoise(75,75, 5, 0x000001, true, true, 1, true);
                                                var b:BitmapMaterial = new BitmapMaterial(bmdBase);
                                               
                                                var bmdEnv:BitmapData = new BitmapData(250,250,false,0x888888);
                                                bmdEnv.perlinNoise(150,150, 5, 0x000002, true, false, 1|2|4 , true);

                                                var bmdBump:BitmapData = new BitmapData(250,250,false,0x888888);
                                                bmdBump.perlinNoise(150,150, 5, 0x000003, true, false, 1|2|4 , true);

                                                var s:Shader = new EnvMapShader(light, bmdEnv, bmdEnv, 0x0, bmdBump, null);
                                                m = new ShadedMaterial(b, s, 0);
                                                break;
                                }
                                m.interactive = true;
                               
                                // [b] object properties
                               
                                var d:DisplayObject3D = new Sphere( m, 100, 8,6 );
                                d.x = 325;
                                d.y = 100;
                                d.z = 0;
                                var p:Number3D = new Number3D(d.x, d.y, d.z);
                                p = rotateY(p , i/NUMSPHERES * 360 * DEGREE );
                                applyNumber3D(p, d);

                                d.addEventListener(InteractiveScene3DEvent.OBJECT_CLICK, onSphereClick);

                                scene.addChild(d, "s" + i.toString());
                        }
                       
                        // Set up floor:

                        // [a] viewport
                        viewportFloor = new Viewport3D(FLOORBMP_SIDE,FLOORBMP_SIDE, false);
                        viewportFloor.opaqueBackground = 0x222222;
                        viewportFloor.filters = [ new BlurFilter(15,15,1)];

                        // [b] material
                        bmdFloor = new BitmapData(FLOORBMP_SIDE,FLOORBMP_SIDE,true);
                        matFloorBmp = new BitmapMaterial(bmdFloor);
                        matFloor = new CompositeMaterial();
                        matFloor.addMaterial(matFloorBmp);
                        matFloor.addMaterial( new WireframeMaterial(0x444444,100) );
                       
                        // [c] matrix
                        matrixFloor = new Matrix();
                        matrixFloor.scale(1,-1);
                        matrixFloor.translate(0,FLOORBMP_SIDE);

                        // [d] camera (looks up at the spheres from below)
                        cameraFloor = new FreeCamera3D();
                        cameraFloor.zoom = 11.2; // bigger zoom in hopes of minimizing effects of perspective a little
                        cameraFloor.focus = 50;
                        cameraFloor.x = 0;
                        cameraFloor.y = -1000;
                        cameraFloor.z = 0;
                        cameraFloor.pitch(-90);

                        // [e] object setup
                        floor = new Plane(matFloor, 1000,1000, 10,10);
                        floor.x = floor.y = floor.z = 0;
                        floor.rotationX = -90;
                        scene.addChild(floor);
                }
               
                private function onSphereClick(e:InteractiveScene3DEvent):void
                {
                        // Make sphere bounce...
                        Tweener.addTween(e.target, { y:100, _bezier:{ y:600 }, time:3, transition:"easeoutbounce"} );
                }

                private function onEnterFrame(e:Event):void
                {
                        this.stage.focus = this;

                        // Move camera based on mouse position
                        var x:Number = (stage.mouseX - stage.stageWidth/2) / 4;
                        cameraMain.moveLeft(x);
                        var y:Number = (stage.mouseY - stage.stageHeight/2) / 6;
                        cameraMain.moveDown(y);
                        if (cameraMain.y > 1000 || cameraMain.y < -200) cameraMain.moveDown(-y);

                        // Rotate light source around camera
                        counter += 3;
                        var lightPos:Number3D = new Number3D(cameraMain.x, cameraMain.y, cameraMain.z);
                        var r:Number = Math.sin( counter*DEGREE ) * 180;
                        lightPos = rotateY( lightPos, r*DEGREE );
                        applyNumber3D(lightPos, light);
                       
                        // 'Render' and draw floor
                        // [* Alternate method: Use BitmapViewportMaterial + BitmapViewport3D] 
                        renderer.renderScene(scene, cameraFloor, viewportFloor);
                        bmdFloor.draw(viewportFloor, matrixFloor);
                        matFloorBmp.bitmap = bmdFloor;
                        matFloorBmp.updateBitmap();

                        // Update light source for the env. map sphere and then update its bitmap
                        applyNumber3D(lightPos, lightSphereEnv);
                        bmdEnvSphere.draw(viewportMain, matrixEnvSphere);

                        // Render scene
                        renderer.renderScene(scene, cameraMain, viewportMain);
                }

               
                // Helper functions:
               
                public function rotateY(p:Number3D, angleY:Number) : Number3D {
                        var x1:Number = Math.cos(angleY) * p.x - Math.sin(angleY) * p.z;
                        var z1:Number = Math.cos(angleY) * p.z + Math.sin(angleY) * p.x;
                        var y1:Number = p.y;
                        return new Number3D(x1, y1, z1);
                }
               
                public function applyNumber3D(p:Number3D, d:DisplayObject3D):void
                {
                        d.x = p.x;
                        d.y = p.y;
                        d.z = p.z;
                }
        }
}