Unity3D学习笔记（九）：摄像机

时间：2023-03-08 17:09:39
Unity3D学习笔记（九）：摄像机

3D数学复习

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class w07d1 : MonoBehaviour {

    public Quaternion result1;

    public Quaternion result2;

    public Quaternion result3;

    // 什么是单位四元数？

    // [0, 0, 0, 1]        表示无旋转

    // [n.x * sin<theta/2>, n.y * sin<theta/2>, n.z * sin<theta/2>, cos<theta/2>]   绕y轴旋转0度    [0, 0, 0, 1]    绕y轴旋转360度  [0, 0, 0, -1]

    // 什么是标准四元数？

    // 模长为1的四元数

    // 模长 = Mathf.Sqrt(x*x + y*y + z*z * w*w)

    // 什么是共轭四元数？

    // 虚数部分取负

    // 四元数 * 共轭四元数 = 单位四元数

    // 什么是四元数的逆？

    // q^-1 = q^* / |q|     如果q是标准四元数    q^-1 = q^*

    // 如果一个 四元数 * 向量 = 向量 （模长一样，方向不一样，相当于旋转一个向量）

    void Start () {

        // 绕 (1, 1, 0)轴 旋转45度

        result1 = Quaternion.AngleAxis(, new Vector3(, , ));

        // 绕 (2, 2, 0)轴 旋转45度

        result2 = Quaternion.AngleAxis(, new Vector3(, , ));        // 对轴 标准化

        Quaternion ge = new Quaternion(-result1.x, -result1.y, -result1.z, result1.w);

        result3 = result1 * ge;

        Quaternion q = Quaternion.AngleAxis(, Vector3.up);

        Vector3 v = new Vector3(, , );

        Debug.DrawLine(Vector3.zero, v, Color.green, );

        v = q * v;

        Debug.DrawLine(Vector3.zero, v, Color.red, );

    }

}

RotateAround

Unity3D学习笔记（九）：摄像机

Unity3D学习笔记（九）：摄像机

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class MyRotateAroundTest : MonoBehaviour {

    public Transform target;

    public float rotSpeed = ;

    void Start () {

       }

       void Update () {

        MyRotateAround(target.position, target.up, rotSpeed * Time.deltaTime);

       }

    void MyRotateAround(Vector3 pos, Vector3 axis, float angle)

    {

        Quaternion q = Quaternion.AngleAxis(angle, axis);

        Vector3 dir = transform.position - pos;

        Vector3 projectV = (Vector3.Dot(axis, dir) / axis.magnitude) * axis.normalized;

        Vector3 n = dir - projectV;

        Vector3 newN = q * n;

        Vector3 newPos = pos + projectV + newN;

        transform.position = newPos;

        transform.rotation *= q;

    }

}

摄像机

Unity3D学习笔记（九）：摄像机

Clear Flags（清除标志）：摄像机剔除标志选择
----Skybox（天空盒）：增加显卡渲染负担，2D游戏看不到天空的可以选择 Solid Color纯色
----Solid Color（纯色）：
----Depth only（只深度）：
----Don't Clear（不清除）：会留下残影，此很少用
BackGround：背景色（当选为Solid Color的时候，背景颜色是可选的）
Culling Mask（剔除遮罩）：通过层级来筛选这个Camera要渲染的游戏物体
、给Plane和Sphere添加层级

、辅摄像机添加Depth only，Depth改为1，比主摄像机Depth0要大

、主摄像机剔除小球，辅摄像机只保留小球

Unity3D学习笔记（九）：摄像机

Unity3D学习笔记（九）：摄像机

Unity3D学习笔记（九）：摄像机

Projection：决定了此Camera的投影方式
----Perspective（透视投影，近大远小）：发散形视角
--------Field of View（视野角度大小）：可以做运动相机的鱼眼镜头
----Orthographic（正交投影，没有近大远小）：非发散形视角，以矩形平行出去，2D游戏，暗黑2
--------Size（视口大小）：调整正交投影下视口大小的，通过分辨率运算得出
1方块=1米=100像素

Size = 屏幕分辨率 / (unity默认一个方格的像素) / (屏幕高度的一半)

正好可以把背景投射完整
Clipping Planes（剔除裁剪平面）：调整摄像机的近裁面和远裁面，只有在近裁面和远裁面之间的游戏物体，才会被渲染显示
----Near：近裁面（最小值0.01）
----Far：远裁面
Viewpoint Rect（视口矩形框）：调整摄像机渲染的游戏画面在整个游戏屏幕中的比例尺寸，以屏幕左下角为基准点
作用：分屏游戏，小地图（耗费性能，用UI等比例投放）
----X、Y：游戏画面相对于屏幕左下角的位置
----W、H：游戏画面占屏幕的宽、高
Depth（深度）：摄像机深度越大，越后渲染，后渲染的会把先渲染的覆盖掉
使用：
1、渲染顺序
2、CS枪支单独摄像机渲染，再叠加到人物的主摄像机
渲染次序，先渲染场景（-1），后渲染枪支（0），空白部分用Clear Flags - Depth only渲染
Rendering path（渲染路径）：预设渲染路径、延时渲染路径，定点照明渲染路径
Unity3D学习笔记（九）：摄像机
Target Texture（目标贴图）：摄像机渲染出来的画面可以投射到Game视图中，也可以投射到一张纹理贴图上
作用：电脑、赛车游戏的后视镜
Unity3D学习笔记（九）：摄像机
Occlusion Culing（）：渲染范围剔除
Allow HDR（高动态贴图）：需要延时渲染路径
Allow MSAA（抗锯齿）：性能消耗大，不推荐使用，市面流行官方免费插件TSAA，需自行导入
Allow Dynamic Reso：
摄像机跟随功能
Unity2017增加智能相机
VS2015的ReSharper插件安装
强大的智能提示
Unity3D学习笔记（九）：摄像机

补充内容-查找篇：

Unity3D学习笔记（九）：摄像机

标签
GameObject.Find();
GameObject.FindGameObjectsWithTag();//查找所有带标签的游戏物体
GameObject.FindGameObjectWithTag();
GameObject.CompareTag();
层级
前8个层级是Unity默认的，无法修改
碰撞层级矩阵取消，可以取消敌人之间的碰撞
Unity3D学习笔记（九）：摄像机

更换天空球的材质

Unity3D学习笔记（九）：摄像机

赛车游戏
车轮碰撞器
Unity3D学习笔记（九）：摄像机

第三人称视角：人

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class ThirdPersonalCameraControl : MonoBehaviour {

    public float moveSpeed = ;

    public float rotateSpeed = ;

    private float keyboard_h;

    private float keyboard_v;

    private Camera camera;

    // Use this for initialization

    void Start () {

        camera = Camera.main;

    }

       // Update is called once per frame

       void Update () {

        keyboard_h = Input.GetAxis("Horizontal");

        keyboard_v = Input.GetAxis("Vertical");

        PlayerMove();

    }

    void PlayerMove()

    {

        Vector3 cameraForward = Vector3.ProjectOnPlane(camera.transform.forward,Vector3.up).normalized;

        Vector3 cameraRight = Vector3.ProjectOnPlane(camera.transform.right, Vector3.up).normalized;

        transform.Translate(cameraForward * Time.deltaTime * moveSpeed * keyboard_v);

        transform.Translate(cameraRight * Time.deltaTime * moveSpeed * keyboard_h);

    }

}
第三人称视角：摄像机
using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class ThirdCameraControl : MonoBehaviour {

    public Transform player;

    public float rotateSpeed = ;

    private float mouse_h;

    private float mouse_v;

    private float mouseWheel;

    private Vector3 player2CameraVector;

    // Use this for initialization

    void Start () {

        player2CameraVector = transform.position - player.position;

    }

       // Update is called once per frame

       void Update () {

        mouse_h = Input.GetAxis("Mouse X") * rotateSpeed;

        mouse_v = -Input.GetAxis("Mouse Y") * rotateSpeed;

        mouseWheel = Input.GetAxis("Mouse ScrollWheel") * rotateSpeed;

        PlayeRotate();

        MouseScrollWheel();

    }

    void PlayeRotate()

    {

        //一个控制人物（左右转向，放人物身上）

        transform.Rotate(Vector3.up * Time.deltaTime * rotateSpeed * mouse_h);

        Vector3 eulurVector3 = new Vector3(mouse_v, mouse_h, );

        Quaternion targetQ = Quaternion.Euler(eulurVector3);

        Vector3 newVector3 = targetQ * player2CameraVector;

        transform.position = player.position + newVector3;

        transform.LookAt(player);

        //思考题：上下无法移动

    }

    void MouseScrollWheel()

    {

        player2CameraVector = player2CameraVector + player2CameraVector.normalized * mouseWheel;

        Vector3 eulurVector3 = new Vector3(mouse_v, mouse_h, );

        Quaternion targetQ = Quaternion.Euler(eulurVector3);

        Vector3 newVector3 = targetQ * player2CameraVector;

        transform.position = player.position + newVector3;

        transform.LookAt(player);

        //限制

    }

}

第一人称视角：人

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class FirstPersonalCameraControl : MonoBehaviour {

    public float moveSpeed = ;

    public float rotateSpeed = ;

    private float keyboard_h;

    private float keyboard_v;

    private float mouse_h;

    private float mouse_v;

    // Use this for initialization

    void Start () {

       }

       // Update is called once per frame

       void Update () {

        keyboard_h = Input.GetAxis("Horizontal");

        keyboard_v = Input.GetAxis("Vertical");

        mouse_h = Input.GetAxis("Mouse X");

        mouse_v = Input.GetAxis("Mouse Y");

        PlayerMove();

        PlayeRotate();

    }

    void PlayerMove()

    {

        //写两个代码：一个控制人物（左右转向，放人物身上），一个控制摄像机（上下转向，放摄像机身上）

        transform.Translate(Vector3.forward * Time.deltaTime * moveSpeed * keyboard_v);

        transform.Translate(Vector3.right * Time.deltaTime * moveSpeed * keyboard_h);

    }

    void PlayeRotate()

    {

        //一个控制人物（左右转向，放人物身上）

        transform.Rotate(Vector3.up * Time.deltaTime * rotateSpeed * mouse_h);

    }

}

第一人称视角：摄像机

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class FirstCameraControl : MonoBehaviour {

    //上下转动（180）要比左右转动（360）角度小

    public float rotateSpeed = ;

    private float mouse_v;

    // Use this for initialization

    void Start () {

       }

       // Update is called once per frame

       void Update () {

        mouse_v = Input.GetAxis("Mouse Y");

        PlayeRotate();

    }

    void PlayeRotate()

    {

        //一个控制摄像机（上下转动，放摄像机身上）

        transform.Rotate(Vector3.right * Time.deltaTime * rotateSpeed * -mouse_v);

        //限制摄像机上下转动幅度

    }

}

汽车

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class CarMove : MonoBehaviour {

    public float moveSpeed = ;

    public float rotateSpeed = ;

    private float keyboard_h;

    private float keyboard_v;

    // Use this for initialization

    void Start()

    {

    }

    // Update is called once per frame

    void Update()

    {

        keyboard_h = Input.GetAxis("Horizontal");

        keyboard_v = Input.GetAxis("Vertical");

        transform.Translate(Vector3.forward * Time.deltaTime * moveSpeed * keyboard_v);

        transform.Rotate(Vector3.up * Time.deltaTime * rotateSpeed * keyboard_h);

    }

}
摄像机
SmoothDamp，平滑阻尼，从固定的时间内到达某个位置，可用于摄像机跟随
velocity是Vector3类的结构体，不能直接对外传值，只能用ref传引用的地址，如果有多个物体伴随移动，可以用velocity的速度去控制
ref velocity，返回平滑阻尼的当前帧的速度（在Vector3各方向上的速度）
using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class CarCameraController : MonoBehaviour {

    public Transform car;

    public Transform lookTrans;

    public float followTime = 0.5f;

    private Vector3 currentVelocity;

    // Use this for initialization

    void Start()

    {

    }

    // Update is called once per frame

    void Update()

    {

        transform.position = Vector3.SmoothDamp(transform.position, car.position, ref currentVelocity, followTime);

        Vector3 dir = lookTrans.position - transform.position;

        Quaternion targetQuat = Quaternion.LookRotation(dir);

        transform.rotation = Quaternion.Slerp(transform.rotation, targetQuat, 0.1f);

    }

}

对象池

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class PlayerControl : MonoBehaviour {

    public float moveSpeed = ;

    Transform firePos;

    private void Awake()

    {

        firePos = transform.Find("firePos");

    }

       void Update () {

        Vector3 moveDir = new Vector3(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"), );

        transform.Translate(moveDir * Time.deltaTime * moveSpeed);

        if(Input.GetKeyDown(KeyCode.Space))

        {

            // 通过实例化创建子弹   替换成对象池管理

            //Instantiate(bulletPrefab, firePos.position, Quaternion.identity);

            PoolManager.Instance.Spawn(firePos.position, Quaternion.identity);//从对象池中取出游戏物体，要记得给对象赋于位置和方向

        }

       }

}
using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class BossControl : MonoBehaviour {

    public int hp = ;

       void Start () {

       }

       void Update () {

       }

    private void OnTriggerEnter(Collider other)

    {

        if(other.gameObject.tag == "Bullet")

        {

            hp -= ;

            // 子弹销毁        替换成对象池管理

            //Destroy(other.gameObject);

            PoolManager.Instance.Push(other.gameObject);

            if(hp <= )

            {

                Destroy(this.gameObject);

            }

        }

    }

}
using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class PoolManager : MonoBehaviour

{

    private static PoolManager instance = null;

    public static PoolManager Instance { get { return instance; } }

    public GameObject bulletPrefab;

    public List<GameObject> bulletPool = new List<GameObject>();

    // 列表来管理

    // 创建的时候 从列表中取一个出来 激活

    // 销毁的时候 把这个要销毁的游戏物体 失活， 放到列表中

    // 把游戏物体 激活、失活

    void Awake()

    {

        instance = this;

    }

    // 从对象池中取游戏物体

    public GameObject Spawn(Vector3 pos, Quaternion qua)

    {

        GameObject go;

        if (bulletPool.Count == )

        {

            go = Instantiate(bulletPrefab, pos, qua);

        }

        else

        {

            go = bulletPool[bulletPool.Count - ];

            go.SetActive(true);

            bulletPool.RemoveAt(bulletPool.Count - );

            go.transform.position = pos;

            go.transform.rotation = qua;

        }

          //粒子特效的拖尾问题处理

        //ParticleSystem ps = go.GetComponent<ParticleSystem>();

        //if (ps) ps.Clear();

        //ParticleSystem[] pses = go.GetComponentsInChildren<ParticleSystem>();

        //foreach (var item in pses)

        //{

        //    item.Clear();

        //}

        TrailRenderer tr = go.GetComponent<TrailRenderer>();//TrailRenderer的拖尾问题处理

        tr.Clear();

        //ps.Play();

        //ps.Pause();

        return go;

    }

    // 把游戏物体放回对象池

    public void Push(GameObject go)

    {

        go.SetActive(false);

        bulletPool.Add(go);

    }

}

Invoke，延时调用函数

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class BulletMove : MonoBehaviour {

    public float moveSpeed = ;

       void Start () {

        // 销毁     替换成对象池管理

        //Destroy(this.gameObject, 5f);

        Invoke("PushBack", 5f);  // 延迟调用

       }

       void Update () {

        transform.Translate(Vector3.forward * Time.deltaTime * moveSpeed);

       }

    void PushBack()

    {

        PoolManager.Instance.Push(this.gameObject);

    }

}

相关文章