4、事件响应函数（二）

    /// <summary>
    /// 这个方法用来推开角色控制器碰到的所有刚体
    /// </summary>
    public float pushPower = 2.0F;
    void OnControllerColliderHit(ControllerColliderHit hit)
    {
        Rigidbody body = hit.collider.attachedRigidbody;
        //没有刚体，返回0
        if (body == null || body.isKinematic)
            return;
        //我们不想推动在我们下边的物体。。moveDirection（当碰撞发生时，角色控制器的方向）
        if (hit.moveDirection.y < -0.3F)
            return;
        //根据移动方向计算推的方向
        //我们只把物体推向一旁，而不是往上或往下
        Vector3 pushDir = new Vector3(hit.moveDirection.x, 0, hit.moveDirection.z);
        //速度=推动方向*推动速度
        body.velocity = pushDir * pushPower;
    }

    /// <summary>
    /// 当一个力大于这个关节的承受力时，关节将被断开。此时OnJointBreak将被调用
    /// 应用到关节的力传入到breakForce
    /// </summary>
    /// <param name="breakForce"></param>
    void OnJoinBreak(float breakForce)
    {
        Debug.Log("Joint Broke!,force:" + breakForce);
    }

    /// <summary>
    /// Legacy Particle System:
    /// 对所有被粒子碰撞的刚体组件施加一个力。
    /// 需要在Particle System的Collision→Type类型设置为World（粒子与世界中的对象相碰）
    /// 并开启sendCollisionMessage
    /// </summary>
    /// <param name="other"></param>
    void OnParticleCollision(GameObject other)
    {
        Rigidbody body = other.GetComponent<Rigidbody>();
        if (body)
        {
            //受力方向
            Vector3 direction = other.transform.position - transform.position;
            //方向标准化
            direction = direction.normalized;
            body.AddForce(direction * 5);
        }
    }

    public ParticleSystem part;
    public List<ParticleCollisionEvent> collisionEvents;
    void Start()
    {
        //初始化组件（ParticleSystem）和事件
        part = GetComponent<ParticleSystem>();
        collisionEvents = new List<ParticleCollisionEvent>();
    }
    void OnParticleCollision(GameObject other)
    {
//other碰撞事件的对象，collisionEvents写碰撞事件的数组
        ParticlePhysicsExtensions.GetCollisionEvents(part, other, collisionEvents);

        //对刚体施加力
        Rigidbody rb = other.GetComponent<Rigidbody>();
        int i = 0;
        while(i<collisionEvents.Count)
        {
            if (rb)
            {
                //方向
                Vector3 pos = collisionEvents[i].intersection;
                //力
                Vector3 force = collisionEvents[i].velocity * 10;
                //force相当于向量
                rb.AddForce(force);
            }
            i++;
        }
    }

    public ParticleSystem part;
    public List<ParticleCollisionEvent> collisionEvents;
    void Start()
    {
        //初始化组件（ParticleSystem）和事件
        part = GetComponent<ParticleSystem>();
        collisionEvents = new List<ParticleCollisionEvent>();
    }
    void OnParticleCollision(GameObject other)
    {
        //定义一个整型变量存储粒子系统的Collision事件
        //other碰撞事件的对象，collisionEvents写碰撞事件的数组
        int numCollisionEvents = part.GetCollisionEvents(other,collisionEvents);

        //对刚体施加力
        Rigidbody rb = other.GetComponent<Rigidbody>();
        for (int i = 0; i < numCollisionEvents; i++)
        {
            if (rb)
            {
                Vector3 pos = collisionEvents[i].intersection;
                Vector3 force = collisionEvents[i].velocity * 10;
                rb.AddForce(force);
            }
        }
        //int i = 0;
        //while(i<numCollisionEvents)
        //{
        //    if (rb)
        //    {
        //        //方向
        //        Vector3 pos = collisionEvents[i].intersection;
        //        //力
        //        Vector3 force = collisionEvents[i].velocity * 10;
        //        //force相当于向量
        //        rb.AddForce(force);
        //    }
        //    i++;
        //}
    }

    void OnLevelWasloaded(int level)
    {
        if (level == 13)
            print("hello");
    }

    /// <summary>
    /// 把它赋给摄像机。所有被它渲染的物体都被翻转
    /// </summary>
    Camera cam;
    void Update()
    {
        cam = GetComponent<Camera>();
    }
    void OnPreCull()
    {
        //重置世界到相机空间的变换矩阵（世界矩阵到相机矩阵）
        cam.ResetWorldToCameraMatrix();
        //重置投影矩阵
        cam.ResetProjectionMatrix();
　　　   //Matrix4x4:标准的4x4矩阵
        cam.projectionMatrix = cam.projectionMatrix * Matrix4x4.Scale(new Vector3(1, -1, 1));
    }
    //相机渲染场景之前被调用
    void OnPreRender()
    {
        //设置它为true我们可以看到翻转的物体
        GL.invertCulling = true;
    }
    //在相机完成场景渲染之后被调用
    void OnPostRender()
    {
        // 再设置它为false,因为我们不想作用于每个相机
        GL.invertCulling = false;
    }

    /// <summary>
    /// 这个脚本用于开启和关闭每个相机的雾
    /// </summary>
    private bool reverFogState = false;
    void OnPreRender()
    {
        reverFogState = RenderSettings.fog;
        RenderSettings.fog = enabled;
    }
    void OnPostRender()
    {
        RenderSettings.fog = reverFogState;
    }

    /// <summary>
    /// 该脚本附加在摄像机上，
    /// 反转目标颜色，在游戏模式下观察效果
    /// </summary>
    private Material mat;
    //常规渲染完成之后调用
    public void OnPostRender()
    {
        if (!mat)
        {
            //Unity有一个内置着色器（shader）,对绘图很有用
            //我们现在想用一个混合模式来反转目标颜色
            var shader = Shader.Find("Hidden/Internal-Colored");
            mat = new Material(shader);
            mat.hideFlags = HideFlags.HideAndDontSave;
            //设置混合模式来反转目标颜色
            mat.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusDstColor);
            mat.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
            //关掉隐面消除
            mat.SetInt("_Cull", (int)UnityEngine.Rendering.CullMode.Off);
            mat.SetInt("_ZWrite", 0);
            mat.SetInt("_ZTest", (int)UnityEngine.Rendering.CompareFunction.Always);
        }
        //PushMatrix方法：将投影和模型视图矩阵都保存到矩阵堆栈中
        GL.PushMatrix();
        //LoadOrtho方法：帮助函数建立一个正交透视变换
        GL.LoadOrtho();

        //激活第一个着色器
        mat.SetPass(0);
        //在整个屏幕绘制一个方形（quad）
        GL.Begin(GL.QUADS);
        GL.Vertex3(0, 0, 0);
        GL.Vertex3(1, 0, 0);
        GL.Vertex3(1,1, 0);
        GL.Vertex3(0, 1, 0);
        GL.End();
        //把投影视图矩阵和模型视图矩阵弹出堆栈。
        GL.PopMatrix();
    }