要搞一个无限动态地形，本来这种和场景相关的功能我都是不管的，美术同事搞个插件即可，毕竟专业人员。
不过同事搞的插件有问题，地形动态拼接有问题，运行几个小时还有内存泄露，于是任务落我头上了，所以记录一下。
首先确定动态地形的地图索引和坐标，这里我使用的九宫格模式，如下：
首先我们创建GroundChunk类，也就是每一块地图：
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class GroundChunk : MonoBehaviour
{
public int index; //块索引
public Vector2Int position; //块坐标
public GroundPanelMesh mesh; //平面网格
public float chunkWidth;
public float chunkLeft;
public float chunkRight;
public float chunkTop;
public float chunkBottom;
private void Awake()
{
mesh = GetComponent<GroundPanelMesh>();
}
void Start()
{
}
public void Init(Vector2Int pos)
{
this.position = pos;
this.index = pos.y * GroundMapController.ROW_CHUNK_COUNT + pos.x;
gameObject.name = string.Format("chunk:{0}", index);
}
public void CreateMesh(int count, float width)
{
mesh.cellCount = count;
mesh.cellWidth = width;
mesh.CreateMesh();
}
public void SetParent(Transform parent)
{
transform.SetParent(parent);
}
public void SetWorldPos(Vector3 wpos)
{
transform.position = wpos;
}
public void SetActive(bool enab)
{
gameObject.SetActive(enab);
}
public void CalculateParameters(Vector3 wpos)
{
chunkWidth = mesh.cellCount * mesh.cellWidth;
float hcwid = chunkWidth / 2f;
chunkLeft = wpos.x - hcwid;
chunkRight = wpos.x + hcwid;
chunkTop = wpos.z + hcwid;
chunkBottom = wpos.z - hcwid;
#if UNITY_EDITOR
Debug.LogWarningFormat("GroundChunk wpos = {0} chunkLeft = {1} chunkRight = {2} chunkTop = {3} chunkBottom = {4}", wpos, chunkLeft, chunkRight, chunkTop, chunkBottom);
#endif
}
public Vector3 GetWorldPos()
{
return transform.position;
}
public bool CheckInBoundary(Vector3 wpos)
{
if (wpos.x >= chunkLeft
&& wpos.x <= chunkRight
&& wpos.z >= chunkBottom
&& wpos.z <= chunkTop)
{
return true;
}
return false;
}
#if UNITY_EDITOR
private void Update()
{
Vector3 lefttop = new Vector3(chunkLeft, 0, chunkTop);
Vector3 leftbottom = new Vector3(chunkLeft, 0, chunkBottom);
Vector3 rightbottom = new Vector3(chunkRight, 0, chunkBottom);
Vector3 righttop = new Vector3(chunkRight, 0, chunkTop);
Debug.DrawLine(lefttop, leftbottom, Color.white);
Debug.DrawLine(leftbottom, rightbottom, Color.red);
Debug.DrawLine(rightbottom, righttop, Color.yellow);
Debug.DrawLine(righttop, lefttop, Color.blue);
}
#endif
}
接下来构建块地图网格类：
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
[RequireComponent(typeof(MeshRenderer))]
[RequireComponent(typeof(MeshFilter))]
public class GroundPanelMesh : MonoBehaviour
{
public int cellCount = 50;
public float cellWidth = 5f;
private MeshRenderer meshRender;
private MeshFilter meshFilter;
private Mesh mesh;
private void Awake()
{
meshRender = GetComponent<MeshRenderer>();
meshFilter = GetComponent<MeshFilter>();
mesh = new Mesh();
}
void Start()
{
}
void Update()
{
}
public void CreateMesh()
{
if (mesh != null)
{
mesh.Clear();
}
int cellVertexCount = cellCount + 1;
Vector3[] vertices = new Vector3[cellVertexCount * cellVertexCount];
Vector3[] normals = new Vector3[cellVertexCount * cellVertexCount];
Vector2[] uvs = new Vector2[cellVertexCount * cellVertexCount];
int[] triangles = new int[cellCount * cellCount * 6];
int triindex = 0;
Vector3 halfbias = new Vector3(cellCount * cellWidth / 2f, 0, cellCount * cellWidth / 2f);
//逐行扫描
//居中生成
for (int y = 0; y <= cellCount; y++)
{
for (int x = 0; x <= cellCount; x++)
{
int index = cellVertexCount * y + x;
vertices[index] = new Vector3(x * cellWidth, 0, y * cellWidth) - halfbias;
normals[index] = new Vector3(0, 1, 0);
uvs[index] = new Vector2((float)x / (float)cellCount, (float)y / (float)cellCount);
if (x < cellCount && y < cellCount)
{
int topindex = x + y * cellVertexCount;
int bottomindex = x + (y + 1) * cellVertexCount;
triangles[triindex + 5] = topindex;
triangles[triindex + 4] = topindex + 1;
triangles[triindex + 3] = bottomindex + 1;
triangles[triindex + 2] = topindex;
triangles[triindex + 1] = bottomindex + 1;
triangles[triindex] = bottomindex;
triindex += 6;
}
}
}
mesh.vertices = vertices;
mesh.normals = normals;
mesh.triangles = triangles;
mesh.uv = uvs;
meshFilter.sharedMesh = mesh;
}
}
接下来就是重要的九宫格管理类，如下：
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Linq;
public class GroundMapController : MonoBehaviour
{
public Transform mainTarget; //锚点
[Range(0, -100f)]
public float mapHeight = -10f; //地图生成y轴高低
[Range(1, 100)]
public int chunkCellCount = 50; //单块地图网格单元格数量
[Range(0.1f, 10f)]
public float chunkCellWidth = 5f; //单元格宽度
public GroundChunk chunkPrefab;
public const int ROW_CHUNK_COUNT = 3; //一行块数量，一共3*3=9
private float chunkWidth; //块宽度
private Queue<GroundChunk> chunkQueue = new Queue<GroundChunk>(); //块队列
private List<GroundChunk> chunkMapList = new List<GroundChunk>(); //9块地图列表
private Vector2Int lastChunkPos; //mainActor九宫格坐标
void Start()
{
InitChunkMap();
}
#region ///chunk factory
private GroundChunk AllocChunk()
{
GroundChunk chunk;
if (chunkQueue.Count > 0)
{
chunk = chunkQueue.Dequeue();
}
else
{
chunk = GameObject.Instantiate<GroundChunk>(chunkPrefab);
}
chunk.SetActive(true);
return chunk;
}
private void RecycleChunk(GroundChunk chunk)
{
if (chunk != null)
{
chunk.SetActive(false);
chunkQueue.Enqueue(chunk);
}
}
#endregion
/// <summary>
/// 0 1 2 （0,0） （1,0） （2,0）
/// 3 4 5 => （0,1） （1,1） （2,1）
/// 6 7 8 （0,2） （1,2） （2,2）
/// 初始化9宫格地图
/// </summary>
private void InitChunkMap()
{
chunkWidth = chunkCellCount * chunkCellWidth;
for (int y = 0; y < ROW_CHUNK_COUNT; y++)
{
for (int x = 0; x < ROW_CHUNK_COUNT; x++)
{
Vector2Int pos = new Vector2Int(x, y);
GroundChunk chunk = AllocChunk();
chunk.Init(pos);
chunk.CreateMesh(chunkCellCount, chunkCellWidth);
chunk.SetParent(transform);
Vector3 cwpos = GetChunkPos(pos, mainTarget.position);
chunk.SetWorldPos(cwpos);
chunk.CalculateParameters(cwpos);
chunkMapList.Add(chunk);
}
}
lastChunkPos = new Vector2Int(1, 1);
}
private Vector3 GetChunkPos(Vector2Int pos, Vector3 tpos)
{
int cindex = ROW_CHUNK_COUNT / 2;
int left = pos.x - cindex;
int top = cindex - pos.y;
Vector3 ret = new Vector3(left * chunkWidth, mapHeight, top * chunkWidth) + new Vector3(tpos.x, 0, tpos.z);
return ret;
}
/// <summary>
/// 释放地图
/// </summary>
private void ReleaseChunkMap()
{
for (int i = 0; i < chunkMapList.Count; i++)
{
GroundChunk chunk = chunkMapList[i];
RecycleChunk(chunk);
}
chunkMapList.Clear();
}
void Update()
{
bool reqinit = false;
Vector2Int cpos = CheckInSudokuChunk(mainTarget.position, ref reqinit);
//如果一次性移动超出9宫格地图范围
//就需要重新初始化地图
if (!reqinit)
{
if (lastChunkPos != cpos)
{
RankChunkMap(cpos);
lastChunkPos = new Vector2Int(1, 1);
}
}
else
{
ReleaseChunkMap();
InitChunkMap();
}
}
/// <summary>
/// 起始index=4（1,1）为中心的棋盘格
/// target一次移动一个格子
/// </summary>
/// <param name="index"></param>
private void RankChunkMap(Vector2Int pos)
{
//区分需要固定块和移动块
//target移动后的chunkindex相邻的chunk不需要移动
//而不相邻的chunk需要重布局
List<GroundChunk> fixedchunklist = new List<GroundChunk>();
List<GroundChunk> movechunklist = new List<GroundChunk>();
for (int i = 0; i < chunkMapList.Count; i++)
{
GroundChunk chunk = chunkMapList[i];
if (CheckAroundChunk(pos, chunk.position))
{
fixedchunklist.Add(chunk);
}
else
{
movechunklist.Add(chunk);
}
}
//9块地图
List<Vector2Int> mapposlist = new List<Vector2Int>
{
new Vector2Int(0,0),
new Vector2Int(1,0),
new Vector2Int(2,0),
new Vector2Int(0,1),
new Vector2Int(1,1),
new Vector2Int(2,1),
new Vector2Int(0,2),
new Vector2Int(1,2),
new Vector2Int(2,2),
};
{
//固定块不移动，但重写position
Vector2Int bpos = lastChunkPos - pos;
for (int i = 0; i < fixedchunklist.Count; i++)
{
GroundChunk chunk = fixedchunklist[i];
Vector2Int cpos = chunk.position + bpos;
chunk.Init(cpos);
mapposlist.Remove(cpos);
}
}
//中间块
GroundChunk cchunk = fixedchunklist.Find(x => x.position == new Vector2Int(1, 1));
{
//移动块移动后，再重写position
for (int i = 0; i < movechunklist.Count; i++)
{
GroundChunk chunk = movechunklist[i];
Vector2Int mpos = mapposlist[i];
Vector3 v3pos = GetChunkPos(mpos, cchunk.GetWorldPos());
chunk.SetWorldPos(v3pos);
chunk.CalculateParameters(v3pos);
chunk.Init(mpos);
}
}
}
/// <summary>
/// 判断i是否相邻（或相同）c
/// 使用vector2int进行坐标判断（abs(xy)<=1）
/// </summary>
/// <param name="c"></param>
/// <param name="i"></param>
/// <returns></returns>
private bool CheckAroundChunk(Vector2Int c, Vector2Int i)
{
//判断相同
if (c == i)
{
return true;
}
Vector2Int ci = i - c;
if (Mathf.Abs(ci.x) <= 1 && Mathf.Abs(ci.y) <= 1)
{
return true;
}
return false;
}
/// <summary>
/// 检测target所处的块九宫格坐标
/// </summary>
/// <param name="wpos"></param>
/// <param name="init"></param>
/// <returns></returns>
private Vector2Int CheckInSudokuChunk(Vector3 wpos, ref bool init)
{
for (int i = 0; i < chunkMapList.Count; i++)
{
GroundChunk chunk = chunkMapList[i];
if (chunk.CheckInBoundary(wpos))
{
return chunk.position;
}
}
#if UNITY_EDITOR
Debug.LogErrorFormat("GroundMapController CheckInSudokuChunk Need ReInitMap");
#endif
init = true;
return new Vector2Int(0, 0);
}
}
这里核心就是根据九宫格的概念，首先居中生成九宫格地图块，target移动到某一块地图块，就重新排列九宫格地图，区分固定不变的地图块和需要移动的地图块，排序完毕后，重置九宫格地图。
效果如下：
接下来进入核心的地图块地形生成，一般情况，我们使用随机噪声贴图生成高低起伏的地形网格。
perlin noise
我们使用柏林噪声生成地形贴图，unity自带即可（Unity Perlin Noise）
测试生成噪声图，如下：
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using System.IO;
public class EditorPerlinNoiseTextureGenerator : EditorWindow
{
private string texWidString;
private int texWidth;
private string texHeiString;
private int texHeight;
private string texScaleString;
private float texScale;
private string texName;
private Texture2D pnTex;
private Color[] pix;
[MenuItem("GameTools/InfinityGround/GeneratePerlinNoiseTexture")]
static void execute()
{
EditorPerlinNoiseTextureGenerator win = (EditorPerlinNoiseTextureGenerator)EditorWindow.GetWindow(typeof(EditorPerlinNoiseTextureGenerator), false, "GeneratePerlinNoiseTexture");
win.Show();
}
private void OnGUI()
{
EditorGUILayout.LabelField("输入Texture宽度");
texWidString = EditorGUILayout.TextField("int类型：", texWidString);
EditorGUILayout.LabelField("输入Texture高度");
texHeiString = EditorGUILayout.TextField("int类型：", texHeiString);
EditorGUILayout.LabelField("输入Texture缩放");
texScaleString = EditorGUILayout.TextField("float类型：", texScaleString);
EditorGUILayout.LabelField("输入Texture名称");
texName = EditorGUILayout.TextField("string类型：", texName);
if (GUILayout.Button("生成贴图"))
{
if (!int.TryParse(texWidString, out texWidth) || !int.TryParse(texHeiString, out texHeight) || !float.TryParse(texScaleString, out texScale))
{
this.ShowNotification(new GUIContent("请输入int类型长宽,float类型缩放"));
return;
}
Generate(texWidth, texHeight, texScale);
}
}
private void Generate(int wid, int hei, float sca)
{
pix = new Color[wid * hei];
int y = 0;
while (y < hei)
{
int x = 0;
while (x < wid)
{
float xcoord = (float)x / (float)wid * sca;
float ycoord = (float)y / (float)hei * sca;
float samp = Mathf.PerlinNoise(xcoord, ycoord);
pix[y * wid + x] = new Color(samp, samp, samp);
x++;
}
y++;
}
pnTex = new Texture2D(wid, hei);
pnTex.SetPixels(pix);
pnTex.Apply();
byte[] buffer = pnTex.EncodeToJPG();
string filepath = Application.dataPath + "/InfinityGround/Texture/" + texName + ".jpg";
File.WriteAllBytes(filepath, buffer);
AssetDatabase.Refresh();
}
}
效果如下：
我们可以通过noise贴图的R值(0-1)标识地形高度，当然使用shader或者c#处理都行，如下：
Shader "InfinityGround/GroundChunkUnTesselSurfaceShader"
{
Properties
{
_Color ("Color", Color) = (1,1,1,1)
_MainTex ("Albedo (RGB)", 2D) = "white" {
}
_Glossiness ("Smoothness", Range(0,1)) = 0.5
_Metallic ("Metallic", Range(0,1)) = 0.0
_NoiseTex("Noise Texture",2D) = "white" {
}
_HeightInten("Height Intensity",Range(1,100)) = 1
}
SubShader
{
Tags {
"RenderType"="Opaque" }
LOD 200
CGPROGRAM
#pragma surface surf Standard fullforwardshadows vertex:vert
#include "UnityCG.cginc"
#pragma target 4.0
sampler2D _MainTex;
struct Input
{
float2 uv_MainTex;
};
half _Glossiness;
half _Metallic;
fixed4 _Color;
sampler2D _NoiseTex; //perlin高度图
float _HeightInten; //高度强度
void vert(inout appdata_full v,out Input o)
{
UNITY_INITIALIZE_OUTPUT(Input,o);
float3 normal = UnityObjectToWorldNormal(v.normal);
float r = tex2Dlod(_NoiseTex,v.texcoord).r;
v.vertex+=float4(normal*_HeightInten*r,0);
}
UNITY_INSTANCING_BUFFER_START(Props)
UNITY_INSTANCING_BUFFER_END(Props)
void surf (Input IN, inout SurfaceOutputStandard o)
{
fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
o.Albedo = c.rgb;
o.Metallic = _Metallic;
o.Smoothness = _Glossiness;
o.Alpha = c.a;
}
ENDCG
}
FallBack "Diffuse"
}
这里我使用shader处理，毕竟我这是为了pc平台使用，性能方面没有极致要求，后面我还可以使用tessellation。而如果在手机平台使用，建议直接c#网格按照高度图处理完成。
效果如下：
添加tessellation看看，如下：
Shader "InfinityGround/GroundChunkTesselSurfaceShader"
{
Properties
{
_Color ("Color", Color) = (1,1,1,1)
_MainTex ("Albedo (RGB)", 2D) = "white" {
}
_Glossiness ("Smoothness", Range(0,1)) = 0.5
_Metallic ("Metallic", Range(0,1)) = 0.0
_TesselMin("Tessellation Min Distance",Range(0,200)) = 1
_TesselMax("Tessellation Max Distance",Range(0,400)) = 1
_TesselFactor("Tessellation Factor",Range(1,20)) = 5
_NoiseTex("Noise Texture",2D) = "white" {
}
_HeightInten("Height Intensity",Range(1,100)) = 10
}
SubShader
{
Tags {
"RenderType"="Opaque" }
LOD 200
CGPROGRAM
#pragma surface surf Standard fullforwardshadows vertex:vert tessellate:tess
#pragma target 5.0
#include "Tessellation.cginc"
sampler2D _MainTex;
struct Input
{
float2 uv_MainTex;
};
half _Glossiness;
half _Metallic;
fixed4 _Color;
float _TesselMin;
float _TesselMax;
int _TesselFactor;
sampler2D _NoiseTex;
float _HeightInten;
float4 tess(appdata_tan v0,appdata_tan v1,appdata_tan v2)
{
float4 v = UnityDistanceBasedTess(v0.vertex,v1.vertex, v2.vertex,_TesselMin,_TesselMax,_TesselFactor);
return v;
}
void vert(inout appdata_tan v)
{
float3 normal = UnityObjectToWorldNormal(v.normal);
float r = tex2Dlod(_NoiseTex,v.texcoord).r;
v.vertex+=float4(normal*_HeightInten*r,0);
}
UNITY_INSTANCING_BUFFER_START(Props)
UNITY_INSTANCING_BUFFER_END(Props)
void surf (Input IN, inout SurfaceOutputStandard o)
{
fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
o.Albedo = c.rgb;
o.Metallic = _Metallic;
o.Smoothness = _Glossiness;
o.Alpha = c.a;
}
ENDCG
}
FallBack "Diffuse"
}
添加一个基于距离细分的功能，效果如下：
unity quick tessellation
因为这里涵盖的技术以前都聊过，所以只简洁说明核心部分。
OK，今天暂时就到这里，下一篇讲解关于动态地形法线贴图和光照的处理。