光源，摄像机，简单的工厂

摄像机用法总结

---

如何应用左手法则决定方向，应用 Field of view 设置场景大小

首先说明左手定则的应用是在unity中物体旋转方向的确定，据一个例子：

首先我放置一个camera，一个物体，让camera能照射到物体：

此时camera的坐标和角度是如下的：

目前的我的观察角度是在 “从y轴看下去”更形象一点就是 “Y轴箭头扎眼睛的方向”，我改变camera的y轴rotate的值如下：

摄像机角度改变如下：

如图所示，摄像机是旋转方向为 顺时针，如果将y轴替换为大拇指，则旋的方向为4个手指的方向，也就是左手定则

应用Field of views改变场景大小，例子如下：

其实Field of views 就是视角，因为Unity中，也是把对象投影在一个范围内的，所以也会有视角这个设定，比如说人的视角差不多是120度，而《火影忍者》里宁次的视角差不多是360度，所以他可以看到背后的敌人。鱼的双眼视角差不多也是360度，摄像机只能模仿一个眼睛的效果，如下：

---

Camera 继承的类

从源码看 Camera 是继承于 Behaviour 类的，而Behaviour继承于 Component，所以Camera是组件

---

Camera 有哪些静态属性，用程序验证并管理所有的 Camera ，并在程序中 enabled 部分有用的 Camera （切换摄像机）

根据官方文档可查到，Camera的静态变量有以下：
* allCameras 返回所有可以使用的camera
* allCamerasCount 翻译场景中所有照相机的数量
* current 当前用于渲染的相机，只用于低级的渲染控制
* main 第一个被启用的Camera会被标记为main
* onPostRender 任何一个camera结束rendering都会触发的时间
* onPreCull 任何一个camera开始culling的时候触发的事件
* onPrerRender 任何一个camera在开始rendering之前都会触发的事件

使用程序来控制camera：

对象树如下：

控制代码如下:

using UnityEngine;
using System.Collections;

public class camera : MonoBehaviour {
    public Camera maincamera; 
    public Camera currentcamera;
    public Camera[] cameras;

    // Use this for initialization
    void Start () {
        print ("Cameralength = " + Camera.allCamerasCount); //输出camera数量
        maincamera = Camera.main; // 获取maincamera
        cameras = Camera.allCameras; // 获取所有的camera
        currentcamera = Camera.current; // 获取当前的camera
    }

    // Update is called once per frame
    void Update () {
        changeCamera ();
    }

    void changeCamera(){
        // 点击1，2，3切换canmera，注意3个camera必须在同一个display下
        if (Input.GetKeyUp (KeyCode.Alpha1)) {
            cameras [0].enabled = true;
            cameras [1].enabled = false;
            cameras [2].enabled = false;
        } else if (Input.GetKeyUp (KeyCode.Alpha2)) {
            cameras [0].enabled = false;
            cameras [1].enabled = true;
            cameras [2].enabled = false;
        } else if (Input.GetKeyUp(KeyCode.Alpha3)){
            cameras [0].enabled = false;
            cameras [1].enabled = false;
            cameras [2].enabled = true;
        } else if (Input.GetKeyUp (KeyCode.M)) {
            //点击M后，所有camera设为false，除了主摄像机以外
            cameras [0].enabled = false;
            cameras [1].enabled = false;
            cameras [2].enabled = false;
            maincamera.enabled = true;
        }

    }
}

---

添加一个 Empty 游戏对象， 添加一个 Camera 部件（Rendering 分类下），有什么效果

添加前：

添加后：

就已经是camera了，充分证明了camera的组件性质

---

光源用法总结

camera聚光灯

其实就是个camera添加light组件，light设为术光

---

给sun对象添加光源部分

使用light组件作为光源比用glew11更简单方便

---

没有将 Camera,Light 设计为 GameObject ，这给开发者带来哪些好处？

可以更方便的对对象进行使用，添加，修改。

---

面向对象语言接口和超类有哪些异同？

• 接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的
• 实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法
• 接口可以实现多重继承，而一个类只能继承一个超类

---

IU3dActionCompleted 能设计为超类吗？为什么？ 画 UML 图说明

不能，因为一个类只能继承一个超类，所以U3dActions 不能继承 Monobehaviours的同时再继承一个IU3ActionsCompleted类

---

U3dAction 能设计为接口吗？为什么？ 画 UML 图说明

不能设计为接口，因为接口是不能有自己的私有变量和函数实现的

---

修改简单工厂的代码

理清代码之后，添加一个新动作是非常容易的，只需要3步：

• 首先判断这个动作是自动还是人控制的，然后创建这个动作的类 A 继承于 U3dActionAuto 或者 U3dActionMan,这个类里面的Update方法中写上你希望动作的执行方式
• 在ActionManager中写一个和你这个新动作相匹配的 Apply…（…）
• 在start（）函数里添加该动作
• 在接口函数中写上相应的动作结束的时候，应该执行的动作

添加一个新动作，MoveToTargetAction（持续追击一个目标）

在原来代码的基础上创建一个 gameObject,名字为zhui，然后zhui会以0.9的速度持续追击Cube

---

添加一个新动作，MoveToAB_Action （组合动作，就是将两个MoveTo动作组合成一个新动作，动作执行完，就free掉）

用新写的函数MoveToAB_Action取代之前的让cube来回移动的函数，在该函数里创建子动作并调用，用完后destroy掉。（这里不清楚要求的Free具体是什么意思，所以现在函数里面直接实现，明白的同学求指教下）

---

添加一个新动作，MoveToTargetAB_Action

这个和上一个唯一的不同在于是以两个对象为目标而不是两个position为目标的。其他写法如上

对象树如下：

代码如下：

using UnityEngine;
using System.Collections;
using Com.Mygame;

namespace Com.Mygame {
    public class ActionManager :System.Object {
        private static ActionManager _instance;

        public static ActionManager GetInstance(){
            if (_instance == null) {
                _instance = new ActionManager();
            }
            return _instance;
        }

        public U3dAction ApplyMoveToAction(GameObject obj, Vector3 target, int speed, IU3dActionCompleted completed){
            MoveToAction ac = obj.AddComponent <MoveToAction> ();
            ac.setting (target, speed, completed);
            return ac;
        }

        public U3dAction ApplyMoveToAction(GameObject obj, Vector3 target, int speed) {
            return ApplyMoveToAction (obj, target, speed, null);
        }

        public U3dAction ApplyMoveToAction(GameObject obj, GameObject obj2,float speed){
            MoveToTargetAction ac = obj.AddComponent<MoveToTargetAction> ();
            ac.setting (obj2, speed);
            return ac;
        }

        public U3dAction ApplyMoveToAB_Action(GameObject obj, Vector3 A, Vector3 B, int speed){
            MoveToAB_Action ac = obj.AddComponent<MoveToAB_Action>();
            ac.setting (A,B,speed,obj);
            return ac;
        }

        public U3dAction ApplyMoveToTargetAB_Action(GameObject obj,GameObject A,GameObject B,int speed){
            MoveToTargetAB_Action ac = obj.AddComponent<MoveToTargetAB_Action> ();
            ac.setting (A, B, speed, obj);
            return ac;
        }

    }
    public class U3dActionException : System.Exception {}

    public interface IU3dActionCompleted {
        void OnActionCompleted (U3dAction action);
    }

    public class U3dAction : MonoBehaviour {
        public void Free(){}
    }
    public class U3dActionAuto : U3dAction {}
    public class U3dActionMan : U3dAction {}

    public class MoveToAction :  U3dActionAuto {
        public Vector3 target;
        public int speed;

        private IU3dActionCompleted monitor = null;

        public void setting(Vector3 target, int speed, IU3dActionCompleted monitor){
            this.target = target;
            this.speed = speed;
            this.monitor = monitor;
        }

        void Update () {
            float step = speed * Time.deltaTime;
            transform.position = Vector3.MoveTowards(transform.position, target, step);

            if (transform.position == target) { // Auto Destroy After Completed
                if (monitor != null) {
                    monitor.OnActionCompleted(this);
                }
                Destroy(this);
            }
        }
    }

    public class MoveToTargetAction : U3dActionAuto {
        public GameObject target;
        public float speed;

        public void setting(GameObject target,float speed){
            this.target = target;
            this.speed = speed;
        }

        void Update() {
            float step = speed * Time.deltaTime;
            transform.position = Vector3.MoveTowards (transform.position, target.transform.position, step);

            if(transform.position == target.transform.position){
                // if get do nothing
            }
        }
    }

    public class MoveToAB_Action : U3dActionAuto {
        public Vector3 A;
        public Vector3 B;
        public int speed;
        public MoveToAction toA;
        public MoveToAction toB;
        public GameObject obj;

        public void setting(Vector3 A,Vector3 B,int speed,GameObject obj) {
            this.A = A;
            this.B = B;
            this.speed = speed;
            this.obj = obj;
        }

        void Start(){
            toA = obj.AddComponent<MoveToAction> ();
            toA.setting (A, speed, null);
        }

        void Update() {
            float step = speed * Time.deltaTime;
            if (obj.transform.position == A) {
                Destroy (obj.GetComponent("toA"));
                toB = obj.AddComponent<MoveToAction> ();
                toB.setting (B,speed,null);
            }
            if (obj.transform.position == B) {
                Destroy (obj.GetComponent("toB"));
                toA = obj.AddComponent<MoveToAction> ();
                toA.setting (A,speed,null);
            }

        }

    }

}


public class MoveToTargetAB_Action : U3dActionAuto {
    public GameObject A;
    public GameObject B;
    public int speed;
    public MoveToAction toA;
    public MoveToAction toB;
    public GameObject obj;


    public void setting(GameObject A,GameObject B,int speed,GameObject obj) {
        this.A = A;
        this.B = B;
        this.speed = speed;
        this.obj = obj;
    }

    void Start(){
        toA = obj.AddComponent<MoveToAction> ();
        toA.setting (A.transform.position, speed, null);
    }

    void Update() {
        float step = speed * Time.deltaTime;
        if (obj.transform.position == A.transform.position) {
            Destroy (obj.GetComponent("toA"));
            toB = obj.AddComponent<MoveToAction> ();
            toB.setting (B.transform.position,speed,null);
        }
        if (obj.transform.position == B.transform.position) {
            Destroy (obj.GetComponent("toB"));
            toA = obj.AddComponent<MoveToAction> ();
            toA.setting (A.transform.position,speed,null);
        }

    }

}

public class U3dActions : MonoBehaviour, IU3dActionCompleted {

    private GameObject cube;
    private GameObject x;
    private GameObject y;

    private GameObject zhui;

    public void OnActionCompleted (U3dAction action)
    {
        MoveToAction ma = action as MoveToAction;
        if (ma.target == x.transform.position) {
            ActionManager.GetInstance ().ApplyMoveToAction (cube, y.transform.position, 1, this);
        } else {
            ActionManager.GetInstance ().ApplyMoveToAction (cube, x.transform.position, 1, this);
        }
    }

    // Use this for initialization
    void Start () {
        cube = GameObject.Find ("Cube");
        x = GameObject.Find ("xx");
        y = GameObject.Find ("yy");
        zhui = GameObject.Find ("zhui");

        //ActionManager.GetInstance ().ApplyMoveToAction (cube, x.transform.position,1,this);

        // 以下这个是添加追击的方法
        ActionManager.GetInstance ().ApplyMoveToAction (zhui, cube, 0.9f);

        //以下是在两个坐标之间移动的方法
        //ActionManager.GetInstance ().ApplyMoveToAB_Action (cube,x.transform.position, y.transform.position, 1);

        //一下是在两个对象之间移动的方法
        ActionManager.GetInstance ().ApplyMoveToTargetAB_Action (cube, x, y, 1);
    }

    // Update is called once per frame
    void Update () {

    }
}

---

简单工厂的好处，还能再游戏中做什么？

通过工厂模式，外界可以从直接创建具体对象的局面中摆脱出来，只要负责消费就可以了。而且不比管这些对象究竟是如何创建及如何组织的，明确了各自的职责和权利，有利于整个软件体系结构的优化。

所以工厂模式，不仅可以对动作，还可以对对象，方便的创建对象和场景的简单工厂