天气系统：雨、雪

实现原理：雨和雪的实现基本类似，天空中飘的雨和雪，地上的水花和雪花，增加一个下落速度和风速，就形成了天气了。

天气雪实现步骤：

1、预生成Mesh：随机生成多个空中飘落的雪网格和地面上的雪花网格。

2、预生成雪shader和雪花shader，雪shader支持雪的显示，雪花shader支持序列帧动画显示。

3、新建一个雪相机，该相机只渲染Water层，所有和雪有关的都挂到Water层。

4、创建雪模板gameobj，模板包括MeshRenderer、雪shader创建的材质Material、MeshFilter。

5、创建雪花模板gameobj，模板包括MeshRenderer、雪花shader创建的材质Material、MeshFilter。

6、根据模板创建雪群：按高度分为上中下三层，随着时间下落到一定高度最下层会放到最上层，如此循环。

7、帧循环更新：雪相机跟随主相机偏移(xz变y不变)，雪根据下落速度变化高度，根据风速变化水平位移，风速随时间变化，雪花随时间变化显示不同的动画关键帧。

8、雪从最高点重新下落会随机更新MeshFilter中mesh网格。

9、关闭雪的时候不是一下全部消失，得有个缓冲过程，都下落到最低点的时候消失。

雪网格：

using UnityEngine;
using UnityEditor;
using System.IO;
using System.Collections;

public class GenSnowMesh
{

    public const int numberOfParticles = 60;   //雪的粒子数
    public const float areaSize = 80.0f;    //范围 因为雪的下落速度比较慢，所以范围要大一点，防止人物移动太快造成穿帮
    public const float areaHeight = 15.0f;  
    public const float particleSize = 0.3f;
    public const float flakeRandom = 0.1f;
    public const float flakeWidth = 0.15f;
    public static Vector3 cameraRight = new Vector3(-1, 0, 0);
    [MenuItem("GameEditor/scene/Weather/Snow/GenMesh")]
    static public void GenMesh()
    {
        for (int i = 0; i < 10; i++)
        {
            Mesh m1 = CreateMesh();
            AssetDatabase.CreateAsset(m1, "Assets/_Resource/model/prefab/weather/snow/SnowFx/snow_LQ" + i + ".asset");
        }
    }

    public static Mesh CreateMesh()
    {
        //Vector3 cameraRight1 = cameraRight * Random.Range(0.1f, 2.0f) + cameraRight * Random.Range(0.1f, 2.0f);// Vector3.forward;//Camera.main.transform.right;
        //cameraRight1 = Vector3.Normalize(cameraRight1);
        Vector3 cameraUp = new Vector3(0, 0.7f, 0.7f);
        Mesh mesh = new Mesh();
        int particleNum = numberOfParticles;
        Vector3[] verts = new Vector3[4 * particleNum];
        Vector2[] uvs = new Vector2[4 * particleNum];

        int[] tris = new int[2 * 3 * particleNum];

        Vector3 position;
        for (int i = 0; i < particleNum; i++)
        {
            int i4 = i * 4;
            int i6 = i * 6;

            position.x = areaSize * (Random.value - 0.5f);
            position.y = areaHeight * Random.value;
            position.z = areaSize * (Random.value - 0.5f);

            //float rand = Random.value;
            float widthWithRandom = particleSize  + Random.Range(-flakeRandom, flakeRandom);
            float heightWithRandom = widthWithRandom;//particleSize + rand * flakeRandom;

            verts[i4 + 0] = position - cameraRight * widthWithRandom;// - 0.0 * heightWithRandom;
            verts[i4 + 1] = position + cameraRight * widthWithRandom;// - 0.0 * heightWithRandom;
            verts[i4 + 2] = position + cameraRight * widthWithRandom + cameraUp * 2.0f * heightWithRandom;
            verts[i4 + 3] = position - cameraRight * widthWithRandom + cameraUp * 2.0f * heightWithRandom;


            uvs[i4 + 0] = new Vector2(0.0f, 0.0f);
            uvs[i4 + 1] = new Vector2(1.0f, 0.0f);
            uvs[i4 + 2] = new Vector2(1.0f, 1.0f);
            uvs[i4 + 3] = new Vector2(0.0f, 1.0f);


            tris[i6 + 0] = i4 + 0;
            tris[i6 + 1] = i4 + 1;
            tris[i6 + 2] = i4 + 2;
            tris[i6 + 3] = i4 + 0;
            tris[i6 + 4] = i4 + 2;
            tris[i6 + 5] = i4 + 3;
        }

        mesh.vertices = verts;
        mesh.triangles = tris;
        mesh.uv = uvs;
        mesh.RecalculateBounds();

        return mesh;
    }

    [MenuItem("GameEditor/scene/Weather/Snow/GenSnowLieMesh")]
    static public void GenSnowlieMesh()
    {
        //#if UNITY_EDITOR    
        //    if (generateNewAssetsOnStart) {
        //        // create & save 3 meshes
        for (int i = 0; i < 10; i++)
        {
            Mesh m1 = CreateSplashMesh();
            AssetDatabase.CreateAsset(m1, "Assets/_Resource/model/prefab/weather/snow/SnowFx/snowlie_LQ" + i+".asset");
        }
        //AssetDatabase.CreateAsset(m2, "Assets/Objects/RainFx/" + gameObject.name + "_LQ1.asset");
        //AssetDatabase.CreateAsset(m3, "Assets/Objects/RainFx/" + gameObject.name + "_LQ2.asset");
        //Debug.Log ("Created new rain meshes in Assets/Objects/RainFx/");
        //    }        
        //#endif
    }

    static private Mesh CreateSplashMesh()
    {
        Mesh mesh = new Mesh();
        Vector3 cameraRight1 = cameraRight * Random.Range(0.1f, 2.0f) + cameraRight * Random.Range(0.1f, 2.0f);// Vector3.forward;//Camera.main.transform.right;
        cameraRight1 = Vector3.Normalize(cameraRight1);
        Vector3 cameraUp = Vector3.Cross(cameraRight1, Vector3.up);
        cameraUp = Vector3.Normalize(cameraUp);

        //int particleNum = QualityManager.quality > Quality.Medium ? numberOfParticles : numberOfParticles / 2;
        int particleNum = numberOfParticles;

        Vector3[] verts = new Vector3[4 * particleNum];
        Vector2[] uvs = new Vector2[4 * particleNum];
        Vector2[] uvs2 = new Vector2[4 * particleNum];
        Vector3[] normals = new Vector3[4 * particleNum];

        int[] tris = new int[2 * 3 * particleNum];

        Vector3 position;
        for (int i = 0; i < particleNum; i++)
        {
            int i4 = i * 4;
            int i6 = i * 6;

            position.x = areaSize * (Random.value - 0.5f);
            position.y = 0.0f;
            position.z = areaSize * (Random.value - 0.5f);

            float rand = Random.value;
            float widthWithRandom = flakeWidth + Random.Range(-flakeRandom, flakeRandom);
            float heightWithRandom = widthWithRandom;//particleSize + rand * flakeRandom;

            verts[i4 + 0] = position - cameraRight1 * widthWithRandom;// - 0.0 * heightWithRandom;
            verts[i4 + 1] = position + cameraRight1 * widthWithRandom;// - 0.0 * heightWithRandom;
            verts[i4 + 2] = position + cameraRight1 * widthWithRandom + cameraUp * 2.0f * heightWithRandom;
            verts[i4 + 3] = position - cameraRight1 * widthWithRandom + cameraUp * 2.0f * heightWithRandom;

            uvs[i4 + 0] = new Vector2(0.0f, 0.0f);
            uvs[i4 + 1] = new Vector2(1.0f, 0.0f);
            uvs[i4 + 2] = new Vector2(1.0f, 1.0f);
            uvs[i4 + 3] = new Vector2(0.0f, 1.0f);

            Vector2 tc1 = new Vector2(Random.Range(0.0f, 1.0f), Random.Range(0.0f, 1.0f));
            uvs2[i4 + 0] = new Vector2(tc1.x, tc1.y);
            uvs2[i4 + 1] = new Vector2(tc1.x, tc1.y);
            uvs2[i4 + 2] = new Vector2(tc1.x, tc1.y);
            uvs2[i4 + 3] = new Vector2(tc1.x, tc1.y);

            tris[i6 + 0] = i4 + 0;
            tris[i6 + 1] = i4 + 1;
            tris[i6 + 2] = i4 + 2;
            tris[i6 + 3] = i4 + 0;
            tris[i6 + 4] = i4 + 2;
            tris[i6 + 5] = i4 + 3;
        }

        mesh.vertices = verts;
        mesh.triangles = tris;
        mesh.uv = uvs;
        mesh.uv2 = uvs2;
        mesh.RecalculateBounds();
        return mesh;
    }
}

天气雪：

using UnityEngine;
using System.Collections.Generic;

public class SnowManager : MonoBehaviour
{
    private static Vector3 SNOW_CAMERA_POS = new Vector3(-4000.0f, 0.0f, 0.0f);
    private const float SNOW_MESH_HEIGHT = 15;
    private const float SNOW_OFFSET = 35.0f;

    private enum eSnowRunState
    {
        None = 0,
        Load = 2,
        Update = 3,
        Release = 4,
    }
    private eSnowRunState m_state = eSnowRunState.None;

    private static GameObject GlobaSnowManagerObject;

    //摄像机相关
    private Transform m_mainCam;            //主摄像机
    private Transform m_snowCam;          //雪的相机
    private Vector3 m_lastMainCamPos = Vector3.zero;

    class SnowInfo  //雪丝相关参数 
    {
        public int groupCount = 3;
        public int groupChildCount = 2;
        public float speed = 10.0f;
        public float startHeight = 15.0f;
        public float hideHeight = -20.0f;
        public int meshCount = 10;
        public Mesh[] snowMeshs;
        public GameObject snowObject;
        public List<Transform> groupList = new List<Transform>();
    }
    private SnowInfo m_snow = new SnowInfo();


    class GroundSnowInfo  //地面上的雪相关参数
    {
        public bool open = true;
        public int groundSnowCount = 4;
        public int meshCount = 10;
        public Mesh[] meshes;
        public List<Transform> list = new List<Transform>();
        public float[] times;
        public float intervalChangeMesh = 10.0f;
        public GameObject groundSnowObject;
    }
    private GroundSnowInfo m_groundSnow = new GroundSnowInfo();


    class WindInfo //风的参数
    {
        public enum SpeedState
        {
            Calm = 0,  //平静
            Add = 1,    //加速
            Max = 2,    //最大速度
            Weaken = 3, //风速减弱
        }
        public bool open = true;
        public float maxSpeed = 6.0f;
        public float curSpeed = 0.0f;
        public float beginSpeed = 0;
        public float intervalTime = 15.0f;
        public float passTime = 0.0f;
        public float totalExistTime = 5.0f;
        public float curExistTime = 0.0f;
        public SpeedState state = SpeedState.Calm;

        public void reset()
        {
            curSpeed = 0.0f;
            passTime = 0.0f;
            curExistTime = 0.0f;
            state = SpeedState.Calm;
        }
    }
    private WindInfo m_wind = new WindInfo();
    /// <summary>
    /// 创建一个全局雪控制器对象
    /// </summary>
    /// <returns> 全局雪控制器对象</returns>
    public static SnowManager GetInstance()
    {
        SnowManager rm = null;
        if (GlobaSnowManagerObject == null)
        {
            GlobaSnowManagerObject = new GameObject("GlobaSnowManagerObject");
            UnityEngine.Object.DontDestroyOnLoad(GlobaSnowManagerObject);
            rm = GlobaSnowManagerObject.AddComponent(typeof(SnowManager)) as SnowManager;
        }
        else
        {
            rm = GlobaSnowManagerObject.GetComponent("SnowManager") as SnowManager;
        }
        return rm;
    }


    public void OpenSnow()  //开始下雪
    {
        QLog.Log("OpenSnow");

        if (m_state == eSnowRunState.None)
        {
            m_wind.reset();
            LoadSnowResource("map/weather/weather_snow.unity3d");
        }
        return;
    }

    private void DestroySnowImmediately()
    {
        DestroyAllObject();
        SetState(eSnowRunState.None);
    }
    private void DestroyAllObject()
    {
        int count = m_snow.groupList.Count;
        for (int i = 0; i < count; i++)
        {
            Destroy(m_snow.groupList[i].gameObject);
        }
        m_snow.groupList.Clear();

        count = m_groundSnow.list.Count;
        for (int i = 0; i < count; i++)
        {
            Destroy(m_groundSnow.list[i].gameObject);
        }
        m_groundSnow.list.Clear();

        if (m_snowCam != null)
            Destroy(m_snowCam.gameObject);
    }

    public void CloseSnow()
    {
        QLog.Log("ColseSnow");
        SetState(eSnowRunState.Release);
    }
    public static void ForceCloseSnow()
    {
        if (GlobaSnowManagerObject != null)
        {
            SnowManager rm = GlobaSnowManagerObject.GetComponent("SnowManager") as SnowManager;
            if (rm != null)
            {
                rm.DestroySnowImmediately();
            }
        }
    }
    public void SetSnowArg(int groupChildCount, float speed)
    {
        m_snow.groupChildCount = groupChildCount;
        m_snow.speed = speed;
    }

    public void SetGroundSnowArg(bool open, int groundSnow_count)
    {
        m_groundSnow.open = open;
        m_groundSnow.groundSnowCount = groundSnow_count;
    }

    public void SetWindArg(bool open, float max_speed, float intervalTime, float totalExistTime)
    {
        m_wind.open = open;
        m_wind.beginSpeed = 0;
        m_wind.maxSpeed = max_speed;
        m_wind.intervalTime = intervalTime;
        m_wind.totalExistTime = totalExistTime;
    }

    public void CreateSnowCamera(float fieldOfView, float nearClipPlane, float farClipPlane, float height, float rotationX, float rotationY, float rotationZ)
    {
        //雪的专用摄像头
        if (m_snowCam == null)
        {
            GameObject snow_cam = new GameObject("SnowCamera");
            Camera cam = snow_cam.AddComponent<Camera>();
            cam.clearFlags = CameraClearFlags.Depth;
            cam.fieldOfView = fieldOfView;
            cam.depth = (float)CommonConst.SnowCameraDepth;
            cam.nearClipPlane = nearClipPlane;
            cam.farClipPlane = farClipPlane;
            cam.cullingMask = 1 << LayerMask.NameToLayer("Water");
            m_snowCam = snow_cam.transform;
            m_snowCam.position = SNOW_CAMERA_POS + Vector3.up * height;
            m_snowCam.eulerAngles = new Vector3(rotationX, rotationY, rotationZ);
        }
    }


    private void LoadSnowResource(string path)
    {
        string assetPath = CommonProxy.GetAssetPath(path);
        WWWLoaderBatch wWWLoaderBatch = BatchManager.instance.CreateBatchLoader(new WWWLoaderBatch.BatchComplete(this.LoadSnowCompleted), null);
        wWWLoaderBatch.SetBatchName("snowObject");
        BatchManager.instance.AddDependentLoaderToBatch(wWWLoaderBatch, assetPath, null, null, AssetPRI.DownloadPRI_Common, false);
        wWWLoaderBatch.CmpInsertElementToBatch();
    }

    private void LoadSnowCompleted(WWWLoaderBatch batch)
    {
        if (!WWWLoaderBatch.CheckBatchValid(batch))
        {
            return;
        }
        else
        {
            WWWLoader dependentWWWAssetLoader = batch.dependentLoaderQueue[0];
            if (dependentWWWAssetLoader != null)
            {
                InitInfo(dependentWWWAssetLoader);
            }
            batch.BatchRefCount--;
        }
    }

    private void InitInfo(WWWLoader loader)
    {

        if (this.m_state != SnowManager.eSnowRunState.None)
        {
            return;
        }
        if (ImageEffectManager.GetMainCamera() == null)
        {
            this.DestroySnowImmediately();
            return;
        }
        if (this.m_snowCam == null)
        {
            GameObject gameObject = new GameObject("SnowCamera");
            Camera camera = gameObject.AddComponent<Camera>();
            camera.clearFlags = CameraClearFlags.Depth;
            camera.fieldOfView = 45f;
            camera.depth = (float)CommonConst.SnowCameraDepth;
            camera.nearClipPlane = 5f;
            camera.farClipPlane = 80f;
            camera.cullingMask  = 1 << LayerMask.NameToLayer("Water");
            this.m_snowCam = gameObject.transform;
            this.m_snowCam.position = SnowManager.SNOW_CAMERA_POS;
            this.m_snowCam.eulerAngles = new Vector3(30f, 0f, 0f);
        }

        Material mat;


        //雪网格
        m_snow.snowMeshs = new Mesh[m_snow.meshCount];
        for (int i = 0; i < m_snow.meshCount; i++)
        {
            m_snow.snowMeshs[i] = loader.Load("snow_LQ" + i) as Mesh;
        }

        //地面上的雪网格
        m_groundSnow.meshes = new Mesh[m_groundSnow.meshCount];
        for (int i = 0; i < m_groundSnow.meshCount; i++)
        {
            m_groundSnow.meshes[i] = loader.Load("snowlie_LQ" + i) as Mesh;
        }

        //创建雪的模板
        GameObject snowObject = new GameObject("snow");
        snowObject.layer = LayerMask.NameToLayer("Water");
        MeshRenderer renderer = snowObject.AddComponent<MeshRenderer>();
        mat = new Material(ShaderManager.GetInstance().FindShader("xj/Scene/Rain"));
        mat.mainTexture = loader.Load("snow") as Texture2D;
        renderer.sharedMaterial = mat;
        snowObject.AddComponent<MeshFilter>().mesh = m_snow.snowMeshs[0];
        m_snow.snowObject = snowObject;

        //创建地面上的雪模板
        GameObject groundSnowObject = new GameObject("groundSnow");
        groundSnowObject.layer = LayerMask.NameToLayer("Water");
        renderer = groundSnowObject.AddComponent<MeshRenderer>();
        mat = new Material(ShaderManager.GetInstance().FindShader("xj/Scene/SnowLie"));
        mat.mainTexture = loader.Load("snowlie") as Texture2D;
        renderer.sharedMaterial = mat;
        groundSnowObject.AddComponent<MeshFilter>().mesh = m_groundSnow.meshes[0];
        m_groundSnow.groundSnowObject = groundSnowObject;

        m_mainCam = Camera.main.transform;
        m_lastMainCamPos = m_mainCam.position;

        SetState(eSnowRunState.Load);
    }

    private void Update()
    {
#if ENABLE_PROFILER
        StatHelper.Instance().BeginSample("SnowManager.Update");
#endif
        if (m_state != eSnowRunState.None)
        {
            switch (m_state)
            {
                case eSnowRunState.Load: Load(); break;
                case eSnowRunState.Update: ForUpdate(); break;
                case eSnowRunState.Release: ReleaseSnow(); break;
            }
        }
#if ENABLE_PROFILER
        StatHelper.Instance().EndSample();
#endif
    }

    private void Load()
    {
        Transform tmpTran = null;

        //创建雪群
        GameObject templateObject = m_snow.snowObject;
        for (int i = 0; i < m_snow.groupCount; i++)
        {
            tmpTran = new GameObject("SnowGroup").transform;
            tmpTran.parent = transform;
            tmpTran.localPosition = Vector3.up * (i * SNOW_MESH_HEIGHT);
            m_snow.groupList.Add(tmpTran);
        }

        for (int i = 0; i < m_snow.groupCount * m_snow.groupChildCount; i++)
        {
            if (i == 0)
            {
                tmpTran = templateObject.transform;
            }
            else
            {
                tmpTran = (Object.Instantiate(templateObject) as GameObject).transform;
            }
            tmpTran.GetComponent<MeshFilter>().mesh = m_snow.snowMeshs[i % m_snow.meshCount];

            tmpTran.parent = m_snow.groupList[i % m_snow.groupCount];
            tmpTran.localPosition = Vector3.zero;
            tmpTran.localRotation = Quaternion.identity;
        }

        //创建地面上的雪群
        if (m_groundSnow.open)
        {
            templateObject = m_groundSnow.groundSnowObject;
            Transform groundSnow_root = new GameObject("groundSnow_root").transform;
            groundSnow_root.position = Vector3.zero;
            groundSnow_root.parent = transform;
            m_groundSnow.times = new float[m_groundSnow.groundSnowCount];
            for (int i = 0; i < m_groundSnow.groundSnowCount; i++)
            {
                if (i == 0)  //fix
                {
                    tmpTran = templateObject.transform;
                }
                else
                {
                    tmpTran = (Object.Instantiate(templateObject) as GameObject).transform;
                }
                tmpTran.GetComponent<MeshFilter>().mesh = m_groundSnow.meshes[i % m_groundSnow.meshCount];

                tmpTran.parent = groundSnow_root;
                tmpTran.localPosition = new Vector3(m_mainCam.position.x, 1, m_mainCam.position.z);
                m_groundSnow.list.Add(tmpTran);
                m_groundSnow.times[i] = i;
            }
        }

        SetState(eSnowRunState.Update);
    }

    private void ForUpdate()
    {

        if (m_snowCam == null || m_mainCam == null)
        {
            DestroySnowImmediately();
            return;
        }

        Vector3 cam_offset = m_mainCam.position - m_lastMainCamPos;
        cam_offset.y = 0;
        m_snowCam.position += cam_offset;
        m_lastMainCamPos = m_mainCam.position;

        Transform m_tempTran;
        for (int i = 0; i < m_snow.groupList.Count; i++)
        {
            m_tempTran = m_snow.groupList[i];
            m_tempTran.position -= m_tempTran.up * m_snow.speed * Time.deltaTime;
            m_tempTran.position += m_tempTran.right * m_wind.curSpeed * Time.deltaTime;
            m_tempTran.eulerAngles = new Vector3(0, 0, Mathf.Atan(m_wind.curSpeed / m_snow.speed) * Mathf.Rad2Deg);
            if (m_tempTran.position.y < m_snow.hideHeight)
            {
                Vector3 followPos = m_snowCam.position + new Vector3(0, 0, SNOW_OFFSET);
                followPos.y = m_snow.startHeight - (m_snow.hideHeight - m_tempTran.position.y);//之所以减去这个值是为了防止卡帧，导致雪集中从起点出现，造成断层 
                m_tempTran.position = followPos;
                for (int c = 0; c < m_tempTran.childCount; c++)
                {
                    m_tempTran.GetChild(c).GetComponent<MeshFilter>().mesh = m_snow.snowMeshs[Random.Range(0, m_snow.meshCount - 1)];
                }
            }
        }

        if (m_groundSnow.open)
        {
            float[] groundSnow_times = m_groundSnow.times;
            for (int i = 0; i < groundSnow_times.Length; i++)
            {
                groundSnow_times[i] -= Time.deltaTime;
                if (groundSnow_times[i] < 0)
                {
                    m_groundSnow.list[i].position = new Vector3(m_mainCam.position.x, 0, m_mainCam.position.z);
                    m_groundSnow.list[i].GetComponent<MeshFilter>().mesh = m_groundSnow.meshes[Random.Range(0, m_groundSnow.meshCount)];
                    groundSnow_times[i] = m_groundSnow.intervalChangeMesh;
                }
            }
        }
        TryChangeWindSpeed();
    }

    private void TryChangeWindSpeed()
    {
        if (m_wind.open)
        {
            switch (m_wind.state)
            {
                case WindInfo.SpeedState.Calm:
                    m_wind.passTime += Time.deltaTime;
                    if (m_wind.passTime > m_wind.intervalTime)
                    {
                        soundManager.GetInstance().PlaySound("scene/wind", false);
                        m_wind.passTime = 0;
                        m_wind.state = WindInfo.SpeedState.Add;
                    }
                    break;
                case WindInfo.SpeedState.Add:
                    m_wind.curSpeed += m_wind.maxSpeed * Time.deltaTime;
                    if (m_wind.curSpeed >= m_wind.maxSpeed)
                    {
                        m_wind.curSpeed = m_wind.maxSpeed;
                        m_wind.state = WindInfo.SpeedState.Max;
                    }
                    break;
                case WindInfo.SpeedState.Max:
                    m_wind.curExistTime += Time.deltaTime;
                    if (m_wind.curExistTime > m_wind.totalExistTime)
                    {
                        m_wind.curExistTime = 0;
                        m_wind.state = WindInfo.SpeedState.Weaken;
                    }
                    break;
                case WindInfo.SpeedState.Weaken:
                    m_wind.curSpeed -= m_wind.maxSpeed * Time.deltaTime * 0.1f;
                    if (m_wind.curSpeed < m_wind.beginSpeed)
                    {
                        m_wind.curSpeed = m_wind.beginSpeed;
                        m_wind.state = WindInfo.SpeedState.Calm;
                    }
                    break;
            }
        }
    }

    private void ReleaseSnow()
    {
        //关闭雪天，有个缓冲过程，雪不要一下子全部消失
        int countShow = m_snow.groupList.Count;
        if (countShow == 0)
        {
            DestroySnowImmediately();
            return;
        }
        Transform m_tempTran;
        for (int i = countShow - 1; i >= 0; i--)
        {
            m_tempTran = m_snow.groupList[i];
            m_tempTran.position -= m_tempTran.up * m_snow.speed * Time.deltaTime;
            m_tempTran.position += m_tempTran.right * m_wind.curSpeed * Time.deltaTime;
            m_tempTran.eulerAngles = new Vector3(0, 0, Mathf.Atan(m_wind.curSpeed / m_snow.speed) * Mathf.Rad2Deg);
            if (m_tempTran.position.y < m_snow.hideHeight)
            {
                Destroy(m_tempTran.gameObject);
                m_snow.groupList.RemoveAt(i);
            }
        }

        if (m_groundSnow.open)
        {
            float[] groundSnow_times = m_groundSnow.times;
            for (int i = groundSnow_times.Length - 1; i >= 0; i--)
            {
                groundSnow_times[i] -= Time.deltaTime;
                if (groundSnow_times[i] < 0)
                {
                    m_groundSnow.list[i].gameObject.SetActive(false);
                    groundSnow_times[i] = 100;
                }
            }
        }
    }

    private void SetState(eSnowRunState state)
    {
        m_state = state;
    }

}