away3d 4.0.9Gold 学习笔记 摄像机与摄像机控制器（7）

View3D在初始化时候就已经创建的Camera3D所以有时候我们没有创建Camera3D但我们依然可以看到3D场景。

Camera3D的默认初始位置在x:0,y:0,z:-1000。

Camera本身属性较多。我列举一些比较常用的。
camea.lookAt(new Vector3D).这个是让摄像机指着某点。即便摄像机移动中。也会一直指着此点。
camera.roll(angle)摄像机绕绿色的轴线旋转
camera.pitch(angle) 摄像机绕蓝色的轴线旋转
amera.yaw(angle)摄像机绕红色的轴线旋转

摄像机按照距离移动。
camera.moveBackward(distance)
camera.moveForward(distance);
camera.moveDown(distance);
camera.moveLeft(distance);
camera.moveRight(distance);
camera.moveUp(distance);

摄像机渲染距离设置
camera.lens.far=distance;

一把鼻涕一把泪--，终于完全搞懂摄像机的控制--，

 

 

 

 

HoverController 摄像机围绕某点旋转。
FirstPersonController。第一人称视角控制器。这个可以完美的模拟出以第一视角漫游。

看一下API：

HoverController(targetObject:Entity = null, lookAtObject:ObjectContainer3D = null, panAngle:Number = 0, tiltAngle:Number = 90, distance:Number = 1000, minTiltAngle:Number = -90, maxTiltAngle:Number = 90, minPanAngle:Number, maxPanAngle:Number, steps:uint = 8, yFactor:Number = 2, wrapPanAngle:Boolean = false)

 

FirstPersonController(targetObject:Entity = null, panAngle:Number = 0, tiltAngle:Number = 90, minTiltAngle:Number = -90, maxTiltAngle:Number = 90, steps:uint = 8)

 

 

2个控制器的基本属性相同。
targetObject. 这个是我们所要给控制器的摄像机对象。
lookAtObject:这个是HoverController 拥有的。就是我们所要环绕的对象。
panAngle:摄像机以Y轴旋转的角度
tiltAngle:摄像机以X轴旋转的角度
distance；射线机的距离。
minPanAngle:以Y轴旋转的最小角度。
minTileAngle:以X轴旋转的最小角度。
maxPanAngle:以Y轴旋转的最大角度。
maxTileAngle:以X轴旋转的最大角度。

以下2个属性是FirstPersonController 可以模拟出第一视角行走
摄像机的方向以speed速度前进
incrementWalk(speed);
以摄像机为方向的90度以speed速度前进
incrementStrafe(speed);

 

练习

 

 

 直接可复制使用

package
{
    import away3d.cameras.Camera3D;
    import away3d.containers.Scene3D;
    import away3d.containers.View3D;
    import away3d.controllers.HoverController;
    import away3d.debug.AwayStats;
    import away3d.entities.Mesh;
    import away3d.lights.PointLight;
    import away3d.materials.ColorMaterial;
    import away3d.materials.lightpickers.StaticLightPicker;
    import away3d.primitives.CubeGeometry;
    
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.events.Event;
    import flash.events.KeyboardEvent;
    import flash.events.MouseEvent;
    import flash.ui.Keyboard;
    
    
    [SWF(backgroundColor="#000000", frameRate="60", width="500", height="400")]
    public class basic_cube_v_4 extends Sprite
    {
        //engine variables
        private var scene:Scene3D;
        private var camera:Camera3D;
        private var view:View3D;
        private var awayStats:AwayStats;
        private var cameraController:HoverController;
        
        //light objects
        private var pointLight:PointLight;
        private var lightPicker:StaticLightPicker;
        
        //navigation variables
        private var move:Boolean = false;
        private var lastPanAngle:Number;
        private var lastTiltAngle:Number;
        private var lastMouseX:Number;
        private var lastMouseY:Number;
        
        private var tiltIncrement:Number = 0;
        private var panIncrement:Number = 0;
        private var distanceIncrement:Number = 0;
        public const tiltSpeed:Number = 2;
        public const panSpeed:Number = 2;
        public const distanceSpeed:Number = 2;
        
        /**
         * Constructor
         */
        public function basic_cube_v_4()
        {
            initEngine();
            initLights();
            initObject();
            initListeners();
        }
        
        /**
         * Initialise the engine
         */
        private function initEngine():void
        {
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
            
            view = new View3D();
            view.antiAlias = 4;
            view.forceMouseMove = true;
            scene = view.scene;
            camera = view.camera;
            addChild(view);
            
            //setup controller to be used on the camera
            cameraController = new HoverController(camera, null, 45, 30, 520, -90,90);
            
            // show statistics
            awayStats = new AwayStats(view);
            addChild(awayStats);
        }
        
        /**
         * Initialise the lights
         */
        private function initLights():void
        {
            //create a light for the camera
            pointLight = new PointLight();
            scene.addChild(pointLight);
            // In version 4, you'll need a lightpicker. Materials must then be registered with it (see initObject)
            lightPicker = new StaticLightPicker([pointLight]);
        }
        
        /**
         * Initialise the scene objects
         */
        private function initObject():void
        {
            // cubes
            var cubeGeometry:CubeGeometry = new CubeGeometry(400,400,400, 10, 10, 10);
            var cubeMaterial:ColorMaterial = new ColorMaterial( 0xFF0000 );
            cubeMaterial.lightPicker = lightPicker;
            var mesh:Mesh = new Mesh(cubeGeometry, cubeMaterial);
            scene.addChild(mesh);
        }
        
        /**
         * Initialise the listeners
         */
        private function initListeners():void
        {
            addEventListener(Event.ENTER_FRAME, onEnterFrame);
            view.addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown);
            view.addEventListener(MouseEvent.MOUSE_UP, onMouseUp);
            stage.addEventListener(Event.RESIZE, onResize);
            stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown);
            stage.addEventListener(KeyboardEvent.KEY_UP, onKeyUp);
            onResize();
        }
        
        /**
         * Navigation and render loop
         */
        private function onEnterFrame(event:Event):void
        {
            if (move) {
                cameraController.panAngle = 0.3*(stage.mouseX - lastMouseX) + lastPanAngle;
                cameraController.tiltAngle = 0.3*(stage.mouseY - lastMouseY) + lastTiltAngle;
            }
            
            cameraController.panAngle += panIncrement;
            cameraController.tiltAngle += tiltIncrement;
            cameraController.distance += distanceIncrement;
            
            pointLight.position = camera.position;
            
            view.render();
        }
        
        /**
         * Key down listener for camera control
         */
        private function onKeyDown(event:KeyboardEvent):void
        {
            switch (event.keyCode) {
                case Keyboard.UP:
                case Keyboard.W:
                    tiltIncrement = tiltSpeed;
                    break;
                case Keyboard.DOWN:
                case Keyboard.S:
                    tiltIncrement = -tiltSpeed;
                    break;
                case Keyboard.LEFT:
                case Keyboard.A:
                    panIncrement = panSpeed;
                    break;
                case Keyboard.RIGHT:
                case Keyboard.D:
                    panIncrement = -panSpeed;
                    break;
                case Keyboard.Z:
                    distanceIncrement = distanceSpeed;
                    break;
                case Keyboard.X:
                    distanceIncrement = -distanceSpeed;
                    break;
            }
        }
        
        /**
         * Key up listener for camera control
         */
        private function onKeyUp(event:KeyboardEvent):void
        {
            switch (event.keyCode) {
                case Keyboard.UP:
                case Keyboard.W:
                case Keyboard.DOWN:
                case Keyboard.S:
                    tiltIncrement = 0;
                    break;
                case Keyboard.LEFT:
                case Keyboard.A:
                case Keyboard.RIGHT:
                case Keyboard.D:
                    panIncrement = 0;
                    break;
                case Keyboard.Z:
                case Keyboard.X:
                    distanceIncrement = 0;
                    break;
            }
        }
        
        /**
         * Mouse down listener for navigation
         */
        private function onMouseDown(event:MouseEvent):void
        {
            move = true;
            lastPanAngle = cameraController.panAngle;
            lastTiltAngle = cameraController.tiltAngle;
            lastMouseX = stage.mouseX;
            lastMouseY = stage.mouseY;
            stage.addEventListener(Event.MOUSE_LEAVE, onStageMouseLeave);
        }
        
        /**
         * Mouse up listener for navigation
         */
        private function onMouseUp(event:MouseEvent):void
        {
            move = false;
            stage.removeEventListener(Event.MOUSE_LEAVE, onStageMouseLeave);
        }
        
        /**dd
         * Mouse stage leave listener for navigation
         */
        private function onStageMouseLeave(event:Event):void
        {
            move = false;
            stage.removeEventListener(Event.MOUSE_LEAVE, onStageMouseLeave);
        }
        
        /**
         * stage listener for resize events
         */
        private function onResize(event:Event = null):void
        {
            view.width = stage.stageWidth;
            view.height = stage.stageHeight;
            awayStats.x = stage.stageWidth - awayStats.width;
        }
    }
}