Unity3d之将terrain转化成mesh

Unity3d中，terrain还是比较耗的，为了优化性能，可能需要将terrain转化成mesh。

现提供一工具，思路是根据terrain高度图生成mesh等。

可参考： http://wiki.unity3d.com/index.php?title=TerrainObjExporter

转载请注明出处：

 http://www.cnblogs.com/jietian331/p/5831062.html

代码如下：

using UnityEditor;
using UnityEngine;

public class TerrainToMeshConverter : ScriptableObject
{
    [MenuItem("Custom/Convert terrain to mesh")]
    static void Init()
    {
        if (Selection.objects.Length <= 0)
        {
            Debug.Log("Selection.objects.Length <= 0");
            return;
        }

        var terrainObj = Selection.objects[0] as GameObject;
        if (terrainObj == null)
        {
            Debug.Log("terrainObj == null");
            return;
        }

        var terrain = terrainObj.GetComponent<Terrain>();
        if (terrain == null)
        {
            Debug.Log("terrain == null");
            return;
        }

        var terrainData = terrain.terrainData;
        if (terrainData == null)
        {
            Debug.Log("terrainData == null");
            return;
        }

        int vertexCountScale = 4;       // [dev] 将顶点数稀释 vertexCountScale*vertexCountScale 倍
        int w = terrainData.heightmapWidth;
        int h = terrainData.heightmapHeight;
        Vector3 size = terrainData.size;
        float[, ,] alphaMapData = terrainData.GetAlphamaps(0, 0, terrainData.alphamapWidth, terrainData.alphamapHeight);
        Vector3 meshScale = new Vector3(size.x / (w - 1f) * vertexCountScale, 1, size.z / (h - 1f) * vertexCountScale);
        Vector2 uvScale = new Vector2(1f / (w - 1f), 1f / (h - 1f)) * vertexCountScale * (size.x / terrainData.splatPrototypes[0].tileSize.x);     // [dev] 此处有问题，若每个图片大小不一，则出问题。日后改善

        w = (w - 1) / vertexCountScale + 1;
        h = (h - 1) / vertexCountScale + 1;
        Vector3[] vertices = new Vector3[w * h];
        Vector2[] uvs = new Vector2[w * h];
        Vector4[] alphasWeight = new Vector4[w * h];            // [dev] 只支持4张图片

        // 顶点，uv，每个顶点每个图片所占比重
        for (int i = 0; i < w; i++)
        {
            for (int j = 0; j < h; j++)
            {
                int index = j * w + i;
                float z = terrainData.GetHeight(i * vertexCountScale, j * vertexCountScale);
                vertices[index] = Vector3.Scale(new Vector3(i, z, j), meshScale);
                uvs[index] = Vector2.Scale(new Vector2(i, j), uvScale);

                // alpha map
                int i2 = (int)(i * terrainData.alphamapWidth / (w - 1f));
                int j2 = (int)(j * terrainData.alphamapHeight / (h - 1f));
                i2 = Mathf.Min(terrainData.alphamapWidth - 1, i2);
                j2 = Mathf.Min(terrainData.alphamapHeight - 1, j2);
                var alpha0 = alphaMapData[j2, i2, 0];
                var alpha1 = alphaMapData[j2, i2, 1];
                var alpha2 = alphaMapData[j2, i2, 2];
                var alpha3 = alphaMapData[j2, i2, 3];
                alphasWeight[index] = new Vector4(alpha0, alpha1, alpha2, alpha3);
            }
        }

        /*
         * 三角形
         *     b       c
         *      *******
         *      *   * *
         *      * *   *
         *      *******
         *     a       d
         */
        int[] triangles = new int[(w - 1) * (h - 1) * 6];
        int triangleIndex = 0;
        for (int i = 0; i < w - 1; i++)
        {
            for (int j = 0; j < h - 1; j++)
            {
                int a = j * w + i;
                int b = (j + 1) * w + i;
                int c = (j + 1) * w + i + 1;
                int d = j * w + i + 1;

                triangles[triangleIndex++] = a;
                triangles[triangleIndex++] = b;
                triangles[triangleIndex++] = c;

                triangles[triangleIndex++] = a;
                triangles[triangleIndex++] = c;
                triangles[triangleIndex++] = d;
            }
        }

        Mesh mesh = new Mesh();
        mesh.vertices = vertices;
        mesh.uv = uvs;
        mesh.triangles = triangles;
        mesh.tangents = alphasWeight;       // 将地形纹理的比重写入到切线中

        string transName = "[dev]MeshFromTerrainData";
        var t = terrainObj.transform.parent.Find(transName);
        if (t == null)
        {
            GameObject go = new GameObject(transName, typeof(MeshFilter), typeof(MeshRenderer), typeof(MeshCollider));
            t = go.transform;
        }

        // 地形渲染
        MeshRenderer mr = t.GetComponent<MeshRenderer>();
        Material mat = mr.sharedMaterial;
        if (!mat)
            mat = new Material(Shader.Find("Custom/Environment/TerrainSimple"));

        for (int i = 0; i < terrainData.splatPrototypes.Length; i++)
        {
            var sp = terrainData.splatPrototypes[i];
            mat.SetTexture("_Texture" + i, sp.texture);
        }

        t.parent = terrainObj.transform.parent;
        t.position = terrainObj.transform.position;
        t.gameObject.layer = terrainObj.layer;
        t.GetComponent<MeshFilter>().sharedMesh = mesh;
        t.GetComponent<MeshCollider>().sharedMesh = mesh;
        mr.sharedMaterial = mat;

        t.gameObject.SetActive(true);
        terrainObj.SetActive(false);

        Debug.Log("Convert terrain to mesh finished!");
    }
}

渲染地形的shader如下（不支持光照）：

Shader "Custom/Environment/TerrainSimple"
{
    Properties
    {
        _Texture0 ("Texture 1", 2D) = "white" {}
        _Texture1 ("Texture 2", 2D) = "white" {}
        _Texture2 ("Texture 3", 2D) = "white" {}
        _Texture3 ("Texture 4", 2D) = "white" {}
    }
    
    SubShader
    {
        Tags { "RenderType" = "Opaque" }
        LOD 200
        
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            sampler2D _Texture0;
            sampler2D _Texture1;
            sampler2D _Texture2;
            sampler2D _Texture3;

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 tangent : TANGENT;
            };

            struct v2f
            {
                float4 pos : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 weight : TEXCOORD1;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.weight = v.tangent;
                o.uv = v.uv;
                return o;
            }

            fixed4 frag(v2f i) : SV_TARGET
            {
                fixed4 t0 = tex2D(_Texture0, i.uv);
                fixed4 t1 = tex2D(_Texture1, i.uv);
                fixed4 t2 = tex2D(_Texture2, i.uv);
                fixed4 t3 = tex2D(_Texture3, i.uv);
                fixed4 tex = t0 * i.weight.x + t1 * i.weight.y + t2 * i.weight.z + t3 * i.weight.w;
                return tex;
            }

            ENDCG
        }
    }

    Fallback "Diffuse"
}

生成的mesh与原terrain对比如下，左边为mesh，右边为terrain:

另提供一支持光照的地形shader：

// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'

Shader "Custom/Environment/LightedTerrain"
{
    Properties
    {
        _Texture0 ("Texture 1", 2D) = "white" {}
        _Texture1 ("Texture 2", 2D) = "white" {}
        _Texture2 ("Texture 3", 2D) = "white" {}
        _Texture3 ("Texture 4", 2D) = "white" {}
    }
    
    SubShader
    {
        Tags { "RenderType" = "Opaque" }
        LOD 200
        
        Pass
        {
            Tags
            {
                "LightMode" = "ForwardBase"
            }

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_fwdbase
            #pragma multi_compile_fog

            #include "UnityCG.cginc"
            #include "Lighting.cginc"
            #include "AutoLight.cginc"

            sampler2D _Texture0;
            sampler2D _Texture1;
            sampler2D _Texture2;
            sampler2D _Texture3;

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 tangent : TANGENT;
                float3 normal : NORMAL;
            };

            struct v2f
            {
                float4 pos : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 weight : TEXCOORD1;
                float3 worldPos : TEXCOORD2;
                float3 worldNormal : TEXCOORD3;
                SHADOW_COORDS(4)
                UNITY_FOG_COORDS(5)
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.weight = v.tangent;
                o.uv = v.uv;
                o.worldPos = mul(unity_ObjectToWorld, v.vertex);
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
                TRANSFER_SHADOW(o);
                UNITY_TRANSFER_FOG(o, o.pos);
                return o;
            }

            fixed4 frag(v2f i) : SV_TARGET
            {
                fixed4 t0 = tex2D(_Texture0, i.uv);
                fixed4 t1 = tex2D(_Texture1, i.uv);
                fixed4 t2 = tex2D(_Texture2, i.uv);
                fixed4 t3 = tex2D(_Texture3, i.uv);
                fixed4 tex = t0 * i.weight.x + t1 * i.weight.y + t2 * i.weight.z + t3 * i.weight.w;

                fixed3 albedo = tex.rgb;

                fixed3 ambient = albedo * UNITY_LIGHTMODEL_AMBIENT.rgb;

                float3 worldLight = normalize(UnityWorldSpaceLightDir(i.worldPos));
                float halfLambert = dot(worldLight, i.worldNormal) * 0.5 + 0.5;
                fixed3 diffuse = albedo * _LightColor0.rgb * halfLambert;

                float3 worldView = normalize(UnityWorldSpaceViewDir(i.worldPos));
                float3 halfDir = normalize(worldView + worldLight);
                fixed3 specular = albedo * _LightColor0.rgb * max(dot(halfDir, i.worldNormal), 0);

                UNITY_LIGHT_ATTENUATION(atten, i, i.worldPos);
                fixed4 col = fixed4(ambient + (diffuse + specular) * atten, tex.a);
                UNITY_APPLY_FOG(i.fogCoord, col);

                return col;
            }

            ENDCG
        }

        Pass
        {
            Tags
            {
                "LightMode" = "ForwardAdd"
            }
            Blend One One

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_fwdadd

            #include "UnityCG.cginc"
            #include "Lighting.cginc"
            #include "AutoLight.cginc"

            sampler2D _Texture0;
            sampler2D _Texture1;
            sampler2D _Texture2;
            sampler2D _Texture3;

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 tangent : TANGENT;
                float3 normal : NORMAL;
            };

            struct v2f
            {
                float4 pos : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 weight : TEXCOORD1;
                float3 worldPos : TEXCOORD2;
                float3 worldNormal : TEXCOORD3;
                SHADOW_COORDS(4)
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.weight = v.tangent;
                o.uv = v.uv;
                o.worldPos = mul(unity_ObjectToWorld, v.vertex);
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
                TRANSFER_SHADOW(o);
                return o;
            }

            fixed4 frag(v2f i) : SV_TARGET
            {
                fixed4 t0 = tex2D(_Texture0, i.uv);
                fixed4 t1 = tex2D(_Texture1, i.uv);
                fixed4 t2 = tex2D(_Texture2, i.uv);
                fixed4 t3 = tex2D(_Texture3, i.uv);
                fixed4 tex = t0 * i.weight.x + t1 * i.weight.y + t2 * i.weight.z + t3 * i.weight.w;

                fixed3 albedo = tex.rgb;

                float3 worldLight = normalize(UnityWorldSpaceLightDir(i.worldPos));
                float halfLambert = dot(worldLight, i.worldNormal) * 0.5 + 0.5;
                fixed3 diffuse = albedo * _LightColor0.rgb * halfLambert;

                float3 worldView = normalize(UnityWorldSpaceViewDir(i.worldPos));
                float3 halfDir = normalize(worldView + worldLight);
                fixed3 specular = albedo * _LightColor0.rgb * max(dot(halfDir, i.worldNormal), 0);

                UNITY_LIGHT_ATTENUATION(atten, i, i.worldPos);
                fixed4 col = fixed4((diffuse + specular ) * atten, tex.a);

                return col;
            }

            ENDCG
        }
    }

    Fallback "Diffuse"
}

光照效果如下：