public TerrainChunk(Vector2 coord, int size, LODInfo[] detailLevels, Transform parent, Material material)
{
this.detailLevels = detailLevels;
pos = coord * size;
bounds = new Bounds(pos, Vector3.one * size);
Vector3 posv3 = new Vector3(pos.x, 0, pos.y);
meshObject = new GameObject("terrainChunk");
meshRenderer = meshObject.AddComponent <MeshRenderer>();
meshFilter = meshObject.AddComponent <MeshFilter>();
meshRenderer.material = material;
meshObject.transform.position = posv3;
SetVisible(false);
meshObject.transform.parent = parent;
lodMeshes = new LODMesh[detailLevels.Length];
for (int i = 0; i < detailLevels.Length; i++)
{
lodMeshes[i] = new LODMesh(detailLevels[i].lod, UpdateTerrainChunk);
}
mapGenerator.RequestMapData(pos, OnMapDataRecived);
}
public void UpdateCoordChunk()
{
if (mapDataReceived)
{
float viewerDistFromNearestEdge = Mathf.Sqrt(bounds.SqrDistance(viewerPosition));
bool isVisible = viewerDistFromNearestEdge <= maxViewDist;
if (isVisible)
{
int lodIndex = 0;
for (int i = 0; i < detailLevels.Length - 1; i++)
{
if (viewerDistFromNearestEdge > detailLevels[i].visibleDistanceThreshold)
{
lodIndex = i + 1;
}
else
{
break;
}
if (lodIndex != previousLODIndex)
{
LODMesh lodMesh = lodMeshes[lodIndex];
if (lodMesh.hasReceivedMesh)
{
previousLODIndex = lodIndex;
meshFilter.mesh = lodMesh.mesh;
meshCollider.sharedMesh = lodMesh.mesh;
}
else if (!lodMesh.hasRequestedMesh)
{
lodMesh.RequestMesh(mapData);
}
}
terrainChunksVisibleLastUpdate.Add(this);
}
}
SetVisible(isVisible);
}
}
public TerrainChunk(Vector2 coordinates, HeightMapSettings heightMapSettings, HeightMapSettings simplexHeightMapSettings, MeshSettings meshSettings, LODInfo[] detailLevels, int colliderLODIndex, Transform viewer, Transform parent, Material material)
{
this.coordinate = coordinates;
this.detailLevels = detailLevels;
this.colliderLODIndex = colliderLODIndex;
this.heightMapSettings = heightMapSettings;
this.simplexHeightMapSettings = simplexHeightMapSettings;
this.meshSettings = meshSettings;
this.viewer = viewer;
sampleCentre = coordinates * meshSettings.meshWorldSize / meshSettings.meshScale;
Vector2 position = coordinate * meshSettings.meshWorldSize;
bounds = new Bounds(position, Vector2.one * meshSettings.meshWorldSize);
meshObject = new GameObject("Terrain Chunk");
meshRenderer = meshObject.AddComponent <MeshRenderer>();
meshFilter = meshObject.AddComponent <MeshFilter>();
meshCollider = meshObject.AddComponent <MeshCollider>();
meshRenderer.material = material;
meshObject.transform.position = new Vector3(position.x, 0, position.y);
meshObject.transform.parent = parent;
SetVisible(false);
lodMeshes = new LODMesh[detailLevels.Length];
for (int i = 0; i < detailLevels.Length; ++i)
{
lodMeshes[i] = new LODMesh(detailLevels[i].lod);
lodMeshes[i].updateCallback += UpdateTerrainChunk;
if (i == colliderLODIndex)
{
lodMeshes[i].updateCallback += UpdateCollisionMesh;
}
}
maxViewDistance = detailLevels[detailLevels.Length - 1].visibleDistanceThreshold;
}
public void UpdateChunk()
{
if (!heightMapReceived)
{
return;
}
float viewDistanceFromNearestEdge = Mathf.Sqrt(bounds.SqrDistance(viewerPosition));
bool wasVisible = IsVisible();
bool visible = viewDistanceFromNearestEdge <= maxViewDistance;
if (visible)
{
int terrainLODIndex = 0;
for (; terrainLODIndex < detailLevels.Length - 1; terrainLODIndex++)
{
if (detailLevels[terrainLODIndex].visibleDistanceThreshold >= viewDistanceFromNearestEdge)
{
break;
}
}
if (terrainLODIndex != previousLODIndex)
{
LODMesh lodMesh = lodMeshes[terrainLODIndex];
if (lodMesh.hasMesh)
{
previousLODIndex = terrainLODIndex;
meshFilter.mesh = lodMesh.mesh;
}
else if (!lodMesh.hasRequestedMesh)
{
lodMesh.RequestMesh(heightMap, meshSettings);
}
}
}
if (wasVisible != visible)
{
SetVisible(visible);
OnVisibilityChanged?.Invoke(this, visible);
}
}
public TerrainChunk(Vector2 coord, HeightMapSettings hSettings, MeshSettings mSettings, LODInfo[] lods, int colliderIndex, Transform parent, Transform viewer, Material material)
{
detailLevels = lods;
colliderLODIndex = colliderIndex;
coordinate = coord;
sampleCenter = coord * mSettings.MeshWorldSize / mSettings.meshScale;
Vector2 position = coord * mSettings.MeshWorldSize;
bounds = new Bounds(position, Vector2.one * mSettings.MeshWorldSize);
heightMapSettings = hSettings;
meshSettings = mSettings;
viewerTransform = viewer;
meshObject = new GameObject("Chunk");
meshRenderer = meshObject.AddComponent <MeshRenderer>();
meshRenderer.material = material;
meshFilter = meshObject.AddComponent <MeshFilter>();
meshCollider = meshObject.AddComponent <MeshCollider>();
meshObject.transform.position = new Vector3(position.x, 0, position.y);
meshObject.transform.parent = parent;
SetVisible(false);
lodMeshes = new LODMesh[detailLevels.Length];
for (int i = 0; i < detailLevels.Length; i++)
{
lodMeshes[i] = new LODMesh(detailLevels[i].lod);
lodMeshes[i].UpdateCallback += UpdateChunk;
if (i == colliderLODIndex)
{
lodMeshes[i].UpdateCallback += UpdateCollisionMesh;
}
}
maxViewDist = detailLevels[detailLevels.Length - 1].distanceThreshold;
}
public void UpdateTerrainChunk()
{
if (mapDataReceived)
{
float viewerDistFromNearestEdge = Mathf.Sqrt(bounds.SqrDistance(viewerPos));
bool visible = viewerDistFromNearestEdge <= maxViewDist;
if (visible)
{
int lodIndex = 0;
for (int i = 0; i < detailLevels.Length - 1; i++) // dont have to look at last one, because bool visible would then be false
{
if (viewerDistFromNearestEdge > detailLevels [i].visibleDistThreshold)
{
lodIndex = i + 1;
}
else
{
break;
}
}
if (lodIndex != previousLODIndex)
{
LODMesh lodMesh = lodMeshes [lodIndex];
if (lodMesh.hasMesh)
{
previousLODIndex = lodIndex;
meshFilter.mesh = lodMesh.mesh;
}
else if (!lodMesh.hasRequestedMesh)
{
lodMesh.RequestMesh(mapData);
}
}
terrainChunksVisibleLastUpdate.Add(this);
}
SetVisible(visible);
}
}
public TerrainChunk(Vector2 coord, float meshWorldSize, LODInfo[] detailLevels, int colliderLODIndex, Transform parent, Material material, GameObject waterPrefab, Prefabs prefabs)
{
this.prefabs = prefabs;
this.coord = coord;
this.detailLevels = detailLevels;
this.colliderLODIndex = colliderLODIndex;
sampleCentre = coord * meshWorldSize / mapGenerator.meshSettings.meshScale;
Vector2 position = coord * meshWorldSize;
bounds = new Bounds(position, Vector2.one * meshWorldSize);
meshObject = new GameObject("TerrainChunk");
meshRenderer = meshObject.AddComponent <MeshRenderer>();
meshFilter = meshObject.AddComponent <MeshFilter>();
meshCollider = meshObject.AddComponent <MeshCollider>();
meshRenderer.material = material;
meshObject.transform.position = new Vector3(position.x, 0, position.y);
meshObject.transform.parent = parent;
SetVisible(false);
//Vector3 waterPos = new Vector3(meshObject.transform.position.x, meshObject.transform.position.y + (6 * 5), meshObject.transform.position.z);
//waterObject = new GameObject("Water");
//waterObject = Instantiate(waterPrefab, waterPos, Quaternion.identity) as GameObject;
//waterObject.transform.parent = meshObject.transform;
//waterObject.transform.localScale = new Vector3(2.36f * 5, 0, 1.18f * 5);
lodMeshes = new LODMesh[detailLevels.Length];
for (int i = 0; i < detailLevels.Length; i++)
{
lodMeshes[i] = new LODMesh(detailLevels[i].lod);
lodMeshes[i].updateCallback += UpdateTerrainChunk;
if (i == colliderLODIndex)
{
lodMeshes[i].updateCallback += UpdateCollisionMesh;
}
}
mapGenerator.RequestHeightMap(sampleCentre, OnMapDataReceived);
}
public void updateTerrianChunk()
{
if (mapDataRecived)
{
float viewerDistFromNearestEdge = Mathf.Sqrt(bounds.SqrDistance(viewerPosition));
bool visible = viewerDistFromNearestEdge <= maxViewDist;
if (visible)
{
ChunksVisibleLastUpdate.Add(this);
int LodIndex = 0;
for (int i = 0; i < detailLevels.Length - 1; i++)
{
if (viewerDistFromNearestEdge > detailLevels[i].visibleDstThreshold)
{
LodIndex = i + 1;
}
else
{
break;
}
}
if (LodIndex != perviousLOD)
{
LODMesh lodMesh = lodMeshes[LodIndex];
if (lodMesh.hasMesh)
{
perviousLOD = LodIndex;
meshFilter.mesh = lodMesh.mesh;
}
else if (!lodMesh.hasRequestedMesh)
{
lodMesh.RequestMesh(mapData);
}
}
}
setVisible(visible);
}
}
public void UpdateTerainChunk()
{
if (recievedMapdata)
{
float dstFromNearestEdge = Mathf.Sqrt(bounds.SqrDistance(playerPos));
bool visible = dstFromNearestEdge <= maxViewDist;
if (visible)
{
int LODIndex = 0;
for (int i = 0; i < detailLevels.Length - 1; i++)
{
if (dstFromNearestEdge > detailLevels[i].distFromPlayer)
{
LODIndex = i + 1;
}
else
{
break;
}
}
if (LODIndex != prevLODIndex)
{
LODMesh lodMesh = lodMeshes[LODIndex];
if (lodMesh.hasMesh)
{
mFilter.mesh = lodMesh.mesh;
prevLODIndex = LODIndex;
mCollider.sharedMesh = lodMesh.mesh;
}
else if (lodMesh.hasReq == false)
{
lodMesh.requestMesh(mapData);
}
}
prevChunks.Add(this);
}
setVisible(visible);
}
}
public void UpdateTerrainChunk()
{
if (mapDataRecieved)
{
float viewDistFromEdge = Mathf.Sqrt(bounds.SqrDistance(playerPos));
bool isVis = viewDistFromEdge <= maxViewDist;
if (isVis)
{
int lodIdx = 0;
for (int i = 0; i < detailLevels.Length - 1; i++)
{
if (viewDistFromEdge > detailLevels[i].distThreshold)
{
lodIdx = i + 1;
}
else
{
break;
}
}
if (lodIdx != prevLOD)
{
LODMesh LODmesh = lodMeshes[lodIdx];
if (LODmesh.hasMesh)
{
prevLOD = lodIdx;
meshFilter.mesh = LODmesh.mesh;
meshCollider.sharedMesh = meshFilter.mesh;
}
else if (!LODmesh.hasRequestedMEsh)
{
LODmesh.RequestMesh(mapData);
}
}
terrainVisibleLastUpdate.Add(this);
}
SetVisible(isVis);
}
}
public void UpdateTerrainChunk()
{
if (mapDataRecieved)
{
float viewerDistanceFromNearestEdge = Mathf.Sqrt(bounds.SqrDistance(viewerPosition));
bool visible = viewerDistanceFromNearestEdge <= MAX_VIEW_DISTANCE;
if (visible)
{
int lodIndex = 0;
for (int i = 0; i < detailLevels.Length - 1; i++)
{
if (viewerDistanceFromNearestEdge > detailLevels[i].visibleDistanceThreshold)
{
lodIndex = i + 1;
}
else
{
break;
}
}
if (lodIndex != previousLODIndex)
{
LODMesh lodMesh = lodMeshes[lodIndex];
if (lodMesh.hasMesh)
{
previousLODIndex = lodIndex;
meshFilter.mesh = lodMesh.mesh;
}
else if (!lodMesh.hasRequestedMesh)
{
lodMesh.RequestMesh(mapData);
}
}
}
SetVisible(visible);
}
}
public TerrainChunk(Vector2 _coord, HeightMapSettings _heightMapSettings, MeshSettings _meshSettings, LODInfo[] _detailLevels, int _colliderLODIndex, Transform _parent, Transform _viewer, Material _material)
{
coord = _coord;
m_detailLevels = _detailLevels;
m_colliderLODIndex = _colliderLODIndex;
m_heightMapSettings = _heightMapSettings;
m_meshSettings = _meshSettings;
viewer = _viewer;
m_sampleCentre = _coord * _meshSettings.meshWorldSize / _meshSettings.meshScale;
Vector2 position = _coord * _meshSettings.meshWorldSize;
m_bounds = new Bounds(position, Vector2.one * _meshSettings.meshWorldSize);
m_meshObject = new GameObject("Terrain Chunk");
m_meshRenderer = m_meshObject.AddComponent <MeshRenderer>();
m_meshFilter = m_meshObject.AddComponent <MeshFilter>();
m_meshCollider = m_meshObject.AddComponent <MeshCollider>();
m_meshRenderer.material = _material;
m_meshObject.transform.position = new Vector3(position.x, 0, position.y);
m_meshObject.transform.parent = _parent;
SetVisible(false);
m_lodMeshes = new LODMesh[_detailLevels.Length];
for (int i = 0; i < _detailLevels.Length; i++)
{
m_lodMeshes[i] = new LODMesh(_detailLevels[i].lod);
m_lodMeshes[i].updateCallback += UpdateTerrainChunk;
if (i == _colliderLODIndex)
{
m_lodMeshes[i].updateCallback += UpdateCollisionMesh;
}
}
m_maxViewDst = _detailLevels [_detailLevels.Length - 1].visibleDstThreshold;
}
public TerrainChunk(Vector2 coordinates, int size, LODData[] levelOfDetailData, Transform parent, Material material)
{
_position = coordinates * size;
_bounds = new Bounds(_position, Vector2.one * size);
_meshObject = new GameObject("Terrain Chunk");
_levelOfDetailData = levelOfDetailData;
Vector3 positionV3 = new Vector3(_position.x, 0f, _position.y);
_meshObject.transform.position = positionV3 * _mapGenerator.terrainData.uniformScale;
_meshObject.transform.parent = parent;
_meshObject.transform.localScale = Vector3.one * _mapGenerator.terrainData.uniformScale;
_meshCollider = _meshObject.AddComponent <MeshCollider>();
_meshFilter = _meshObject.AddComponent <MeshFilter>();
_meshRenderer = _meshObject.AddComponent <MeshRenderer>();
_meshRenderer.material = material;
_levelOfDetailMeshes = new LODMesh[levelOfDetailData.Length];
for (int i = 0; i < levelOfDetailData.Length; i++)
{
_levelOfDetailMeshes[i] = new LODMesh(levelOfDetailData[i].levelOfDetail, UpdateTerrainChunk);
if (levelOfDetailData[i].useForCollider)
{
_collisionLevelOfDetailMesh = _levelOfDetailMeshes[i];
}
}
_mapGenerator.RequestMapData(_position, OnMapDataReceived);
SetVisibility(false);
}
public TerrainChunk(Vector2 coord, int size, LODInfo[] detailLevels, Transform parent, Material material, bool buildingWall)
{
this.detailLevels = detailLevels;
position = coord * size;
bounds = new Bounds(position, Vector2.one * size);
Vector3 positionV3;
if (buildingWall)
{
positionV3 = new Vector3(position.x, position.y, 0);
}
else
{
positionV3 = new Vector3(position.x, 0, position.y);
}
meshObject = new GameObject("Terrain Chunk");
meshRenderer = meshObject.AddComponent <MeshRenderer>();
meshFilter = meshObject.AddComponent <MeshFilter>();
meshCollider = meshObject.AddComponent <MeshCollider>();
meshObject.AddComponent <MeshDeformBehavior>();
meshObject.tag = "Wall";
meshRenderer.material = material;
meshObject.transform.position = positionV3 * scale;
meshObject.transform.parent = parent;
meshObject.transform.localScale = Vector3.one * scale;
SetVisible(false);
lodMeshes = new LODMesh[detailLevels.Length];
for (int i = 0; i < detailLevels.Length; i++)
{
lodMeshes[i] = new LODMesh(detailLevels[i].lod, UpdateTerrainChunk);
}
mapGenerator.RequestMapData(position, OnMapDataReceived);
}
public TerrainChunk(Vector2 coord, int size, LODInfo[] detailLevels, int colliderLODIndex, Transform parent, Material material)
{
m_coord = coord;
m_detailLevels = detailLevels;
m_colliderLODIndex = colliderLODIndex;
m_position = coord * size;
m_bounds = new Bounds(m_position, Vector2.one * size);
Vector3 positionV3 = new Vector3(m_position.x, 0, m_position.y);
m_meshObject = new GameObject("Terrain Chunk");
m_meshObject.layer = LayerMask.NameToLayer("Terrain");
m_meshRenderer = m_meshObject.AddComponent <MeshRenderer>();
m_meshFilter = m_meshObject.AddComponent <MeshFilter>();
m_meshCollider = m_meshObject.AddComponent <MeshCollider>();
m_meshRenderer.material = material;
m_meshObject.transform.position = positionV3 * s_mapGenerator.TerrainData.UniformScale;
m_meshObject.transform.parent = parent;
m_meshObject.transform.localScale = Vector3.one * s_mapGenerator.TerrainData.UniformScale;
m_lodMeshes = new LODMesh[detailLevels.Length];
for (int i = 0; i < detailLevels.Length; i++)
{
m_lodMeshes[i] = new LODMesh(detailLevels[i].LOD);
m_lodMeshes[i].HasUpdated += UpdateTerrainChunk;
if (i == m_colliderLODIndex)
{
m_lodMeshes[i].HasUpdated += UpdateCollisionMesh;
}
}
s_mapGenerator.RequestMapData(m_position, (heightMap) =>
{
m_heightMap = heightMap;
m_heightDataReceived = true;
UpdateTerrainChunk();
});
}
public TerrainChunk(Vector2 _coord, int _size, LODInfo[] _detailLevels, int _colliderLODIndex, Transform _parent, bool _ocean, Material _mat)
{
coord = _coord;
detailLevels = _detailLevels;
colliderLODIndex = _colliderLODIndex;
position = _coord * _size;
Vector3 positionV3 = new Vector3(position.x, 0, position.y);
bounds = new Bounds(position, Vector2.one * _size);
meshObject = new GameObject("Chunk");
meshRenderer = meshObject.AddComponent <MeshRenderer>();
meshRenderer.material = _mat;
meshFilter = meshObject.AddComponent <MeshFilter>();
meshCollider = meshObject.AddComponent <MeshCollider>();
isOcean = _ocean;
meshObject.transform.position = positionV3 * mapGenerator.terrainData.uniformScale;
meshObject.transform.parent = _parent;
meshObject.transform.localScale = Vector3.one * mapGenerator.terrainData.uniformScale;
SetVisible(false);
lodMeshes = new LODMesh[detailLevels.Length];
for (int i = 0; i < detailLevels.Length; i++)
{
lodMeshes[i] = new LODMesh(detailLevels[i].lod, UpdateTerrainChunk);
lodMeshes[i].updateCallback += UpdateTerrainChunk;
if (i == colliderLODIndex)
{
lodMeshes[i].updateCallback += UpdateTerrainChunk;
}
}
mapGenerator.RequestMapData(position, OnMapDataReceived);
}
public TerrainChunk(Vector2 coord, int size, LODInfo[] detailLevels, Transform parent, Material material)
{
this.detailLevels = detailLevels;
position = coord * size;
bounds = new Bounds(position, Vector3.one * size);
Vector3 positionV3 = new Vector3(position.x, 0, position.y);
meshObject = new GameObject("Terrain Chunk");
meshRenderer = meshObject.AddComponent <MeshRenderer>();
meshFilter = meshObject.AddComponent <MeshFilter>();
meshCollider = meshObject.AddComponent <MeshCollider>();
meshRenderer.material = material;
meshObject.transform.position = positionV3 * mapGenerator.terrainData.uniformScale;
meshObject.transform.parent = parent;
meshObject.transform.localScale = Vector3.one * mapGenerator.terrainData.uniformScale;
SetVisible(false);
lodMeshes = new LODMesh[detailLevels.Length];
for (int i = 0; i < detailLevels.Length; i++)
{
lodMeshes[i] = new LODMesh(detailLevels[i].lod, UpdateTerrainChunk);
if (detailLevels[i].useForCollider)
{
collisionLODMesh = lodMeshes[i];
}
}
//Debug.Log("Requesting map data");
mapGenerator.RequestMapData(position, OnMapDataReceived);
}
public TerrainChunk(Vector2 coord, int size, LODInfo[] detailLevels, Transform parent, Material material)
{
this.detailLevels = detailLevels;
this.coord = coord;
position = coord * size;
bounds = new Bounds(position, Vector2.one * size);
Vector3 positionV3 = new Vector3(position.x, 0, position.y);
meshObject = new GameObject("Terrain Chunk");
meshObject.transform.position = positionV3 * mapGenerator.terrainData.uniformScale;
meshObject.transform.parent = parent;
meshObject.transform.localScale = Vector3.one * mapGenerator.terrainData.uniformScale;
if (mapGenerator.waterPrefab != null)
{
waterObject = (GameObject)Instantiate(mapGenerator.waterPrefab, meshObject.transform.position, Quaternion.identity);
waterObject.transform.parent = meshObject.transform;
waterObject.transform.position += new Vector3(0, 1, 0) * mapGenerator.waterHeight;
waterObject.transform.localScale *= mapGenerator.terrainData.uniformScale;
}
meshRenderer = meshObject.AddComponent <MeshRenderer>();
meshRenderer.material = material;
meshFilter = meshObject.AddComponent <MeshFilter>();
SetVisible(false);
lodMeshes = new LODMesh[detailLevels.Length];
for (int i = 0; i < detailLevels.Length; i++)
{
lodMeshes[i] = new LODMesh(detailLevels[i].lod, UpdateTerrainChunk);
}
mapGenerator.RequestMapData(position, OnMapDataReceived);
}
public MeshTerrain(float[,] _noiseMap, GameObject _objectToSpawn, AnimationCurve _heightCurve, LODInfo[] _detailLevels, Vector2 _coordinates, Transform _parentObject, float _meshHeightMultiplier, float _heightOffsets, bool _inEditorMode = false)
{
noiseMap = _noiseMap;
heightCurve = _heightCurve;
detailLevels = _detailLevels;
meshHeightMultiplier = _meshHeightMultiplier;
meshObject = Instantiate(_objectToSpawn, new Vector3(_parentObject.position.x, _heightOffsets, _parentObject.position.z), new Quaternion(0, 0, 0, 0)) as GameObject;//GameObject.CreatePrimitive(PrimitiveType.Plane);
meshFilter = meshObject.GetComponent <MeshFilter>();
meshCollider = meshObject.GetComponent <MeshCollider>();
meshObject.transform.parent = _parentObject;
lodMeshes = new LODMesh[detailLevels.Length];
for (int i = 0; i < detailLevels.Length; i++)
{
lodMeshes[i] = new LODMesh(detailLevels[i].lod);
if (detailLevels[i].useForCollider)
{
collisionLODMesh = lodMeshes[i];
}
}
}
public Chunk(Vector2 coord, int size, Transform parent, Material material, LODInfo[] detailLevels, int colliderLODIndex)
{
this.coord = coord;
this.detailLevels = detailLevels;
this.colliderLODIndex = colliderLODIndex;
position = coord * size;
bounds = new Bounds(position, Vector2.one * size);
Vector3 positionV3 = new Vector3(position.x, 0, position.y);
meshObject = new GameObject("Chunk");
meshRenderer = meshObject.AddComponent <MeshRenderer>();
meshFilter = meshObject.AddComponent <MeshFilter>();
meshCollider = meshObject.AddComponent <MeshCollider>();
meshRenderer.material = material;
meshObject.layer = 9;
meshObject.transform.position = positionV3 * chunkGenerator.terrainData.uniformScale;
meshObject.transform.parent = parent;
meshObject.transform.localScale = Vector3.one * chunkGenerator.terrainData.uniformScale;
SetVisible(false);
lodMeshes = new LODMesh[detailLevels.Length];
for (int i = 0; i < detailLevels.Length; i++)
{
lodMeshes[i] = new LODMesh(detailLevels[i].LOD);
lodMeshes[i].updateCallback += UpdateChunk;
if (i == colliderLODIndex)
{
lodMeshes[i].updateCallback += UpdateCollisionMesh;
}
}
chunkGenerator.RequestMapData(OnMapDataRecieved, position);
}
public TerrainChunk(Vector2 coord, int size, LODInfo[] detailLevels, Transform parent, Material material) {
this.detailLevels = detailLevels;
position = coord * size;
bounds = new Bounds(position,Vector2.one * size);
Vector3 positionV3 = new Vector3(position.x,0,position.y);
meshObject = new GameObject("Terrain Chunk");
meshRenderer = meshObject.AddComponent<MeshRenderer>();
meshFilter = meshObject.AddComponent<MeshFilter>();
meshRenderer.material = material;
meshObject.transform.position = positionV3 * scale;
meshObject.transform.parent = parent;
meshObject.transform.localScale = Vector3.one * scale;
SetVisible(false);
lodMeshes = new LODMesh[detailLevels.Length];
for (int i = 0; i < detailLevels.Length; i++) {
lodMeshes[i] = new LODMesh(detailLevels[i].lod, UpdateTerrainChunk);
}
mapGenerator.RequestMapData(position,OnMapDataReceived);
}
protected override void OnDestory()
{
colliderMesh.Release();
colliderMesh = null;
GameObject.Destroy(meshObject);
}
protected abstract void RequestLodMeshData(LODMesh lodMesh, LODInfo lodInfo);
public void RequestMesh(LODMesh lodMesh)
{
lodMesh.hasRequestedMesh = true;
UnityTaskManager.ScheduleTask(RequestMeshData, OnMeshDataReceived);
}
public virtual void LoadLODMesh(int level, string filename)
{
if (filename == "avatar_eye_1.llm")
throw new ArgumentException("Eyballs are not LOD Meshes", "filename");
LODMesh lod = new LODMesh();
lod.LoadMesh(filename);
LodMeshes[level] = lod;
}
public void UpdateTerrainChunk(Vector3?viewerPosition)
{
if (heightMapReceived)
{
var viewerPos = viewerPosition ?? calcViewerPosition;
float viewerDstFromNearestEdge = Mathf.Sqrt(bounds.SqrDistance(viewerPos));
bool wasVisible = IsVisible();
bool visible = viewerDstFromNearestEdge <= maxViewDst;
if (visible)
{
int lodIndex = 0;
for (int i = 0; i < detailLevels.Length - 1; i++)
{
if (viewerDstFromNearestEdge > detailLevels[i].visibleDstThreshold)
{
lodIndex = i + 1;
}
else
{
break;
}
}
if (lodIndex != previousLODIndex)
{
LODMesh lodMesh = lodMeshes[lodIndex];
if (lodMesh.hasMesh)
{
previousLODIndex = lodIndex;
meshFilter.mesh = lodMesh.mesh;
CurrentMeshKdTree = lodMesh.KdTreeVertices;
}
else if (!lodMesh.hasRequestedMesh)
{
lodMesh.RequestMesh(heightMap, meshSettings);
}
}
// Position and enable items once mesh is ready
if (lodMeshes[lodIndex] != null && lodMeshes[lodIndex].mesh != null && lodMeshes[lodIndex].mesh.vertexCount > 0)
{
itemHandler.AddPositionIter(PositionItems(lodIndex));
}
// If CURRENT CHUNK PLAYER IS ON
// Build navmesh
//if (viewerDstFromNearestEdge < bounds.extents.x)
//{
// if (!navMeshSurface.enabled && navMeshSurfacesCounter < maxNavMeshSurfaceCount)
// {
// Debug.Log("Building new navmesh");
// navMeshSurface.enabled = true;
// // Build nav mesh for agents to travel on
// //navMeshSurface.BuildNavMesh();
// navMeshSurfacesCounter++;
// }
//}
//else if (navMeshSurface.enabled)
//{
// Debug.Log("Destroying old navmesh");
// // Reset navmesh
// navMeshSurface.enabled = false;
// navMeshSurfacesCounter--;
//}
}
else if (viewerDstFromNearestEdge < maxDistTotal)
{
// Hide but don't destroy
itemHandler.AddDisableIter(DetachItems());
}
if (wasVisible != visible)
{
SetVisible(visible);
if (onVisibilityChanged != null)
{
onVisibilityChanged(this, visible);
}
}
}
}
public void Update()
{
if (!_heightMapReceived)
{
return;
}
float distanceFromNearestEdge = Mathf.Sqrt(_bounds.SqrDistance(viewerPosition));
bool wasVisible = IsVisible();
bool visible = distanceFromNearestEdge <= _maxViewDistance;
if (visible)
{
int lodIndex = 0;
for (int i = 0; i < _detailLevels.Length - 1; i++)
{
if (distanceFromNearestEdge > _detailLevels[i].visibleDstThreshold)
{
lodIndex = i + 1;
}
else
{
break;
}
}
if (_hasToSpawnViewer && _lodMeshes[0].hasMesh)
{
float spawnHeight = _lodMeshes[0].mesh.vertices[Mathf.RoundToInt(viewerPosition.x + viewerPosition.y * _meshSettings.numVertsPerLine)].y;
spawnHeight = _lodMeshes[0].mesh.vertices[Mathf.RoundToInt(viewerPosition.x + spawnHeight * _meshSettings.numVertsPerLine)].y;
_viewer.position = new Vector3(viewerPosition.x, spawnHeight, viewerPosition.y);
_hasToSpawnViewer = false;
}
if (lodIndex != _previousLODIndex)
{
LODMesh lodMesh = _lodMeshes[lodIndex];
if (lodMesh.hasMesh)
{
_previousLODIndex = lodIndex;
_meshFilter.mesh = lodMesh.mesh;
}
else if (!lodMesh.hasRequestedMesh)
{
lodMesh.RequestMesh(_heightMap, _meshSettings);
}
}
}
if (wasVisible != visible)
{
setVisible(visible);
if (onVisibilityChanged != null)
{
onVisibilityChanged(this, visible);
}
}
setVisible(visible);
}
public override void LoadLODMesh(int level, string filename)
{
LODMesh lod = new LODMesh();
lod.LoadMesh(filename);
LodMeshes[level] = lod;
}
private void LOD0ValidStateAvailable(LODMesh lodMesh)
{
RequestAndPlaceCollectibles(lodMesh);
RequestAndPlaceTrees(lodMesh);
}
public void UpdateTerrainChunk()
{
if (!mapDataReceived)
{
return;
}
float viewerDistFromNearestEdge =
Mathf.Sqrt(bounds.SqrDistance(viewerPos));
bool visible = viewerDistFromNearestEdge <= maxViewDistance;
if (visible)
{
int lodIndex = 0;
// don't need to look at final elem as visible will be false,
// viewerDistFromNearestEdge will be > maxViewDistance
for (int i = 0; i < detailLevels.Length - 1; i++)
{
if (viewerDistFromNearestEdge
> detailLevels[i].visibleDistanceThreshold
)
{
lodIndex = i + 1;
}
else
{
break;
}
}
if (lodIndex != previousLODIndex)
{
LODMesh lodMesh = lodMeshes[lodIndex];
if (lodMesh.hasMesh)
{
previousLODIndex = lodIndex;
meshFilter.mesh = lodMesh.mesh;
}
else if (!lodMesh.hasRequestedMesh)
{
lodMesh.RequestMesh(mapData);
}
}
// only if close enough that terrain is rendered at highest LOD
if (lodIndex == 0)
{
if (collisionLODMesh.hasMesh)
{
meshCollider.sharedMesh = collisionLODMesh.mesh;
}
else if (!collisionLODMesh.hasRequestedMesh)
{
collisionLODMesh.RequestMesh(mapData);
}
}
terrainChunksVisibleLastUpdate.Add(this);
}
SetVisible(visible);
}
protected abstract void OnLodMeshReady(LODMesh lodMesh);
public override void Load(string filePath)
{
BinaryReader reader = new BinaryReader(File.OpenRead(filePath));
nameLength = reader.ReadByte();
fileName = reader.ReadBytes(nameLength);
version = reader.ReadInt32();
unknown1 = reader.ReadInt32();
element1Start = reader.ReadVector3();
element1End = reader.ReadVector3();
if (version == 0x16)
{
element2Start = reader.ReadVector3();
element2End = reader.ReadVector3();
}
unk2 = reader.ReadInt32();
unk3 = reader.ReadInt32();
reader.Skip(16);
bbMin = reader.ReadVector3();
bbMax = reader.ReadVector3();
unk4 = reader.ReadSingle();
flag1 = reader.ReadInt32(); // nAnimation States
flag2 = reader.ReadInt32(); // animationEventCount?
flag2Data = new Vector3[flag2];
for (int i = 0; i < flag2; i++)
{
flag2Data[i] = reader.ReadVector3();
}
MeshTypeFlag = reader.ReadInt32();
LODFlag = reader.ReadInt32();
unk5 = reader.ReadInt32();
TotalMeshCount = reader.ReadInt32();
MeshCount = reader.ReadInt32();
lods = new LODMesh[MeshCount];
for (int i = 0; i < MeshCount; i++)
{
LODMesh lod = lods[i] = new LODMesh();
lod.hasBones = reader.ReadInt32();
lod.nCount3 = reader.ReadInt32();
lod.nData3 = new int[lod.nCount3];
for (int j = 0; j < lod.nCount3; j++)
{
lod.nData3[j] = reader.ReadInt32();
}
lod.unknown1 = reader.ReadInt32();
lod.nTerminator = reader.ReadInt32();
lod.transform = reader.ReadMatrix4x4();
lod.bbMin = reader.ReadVector3();
lod.bbMax = reader.ReadVector3();
lod.unk2 = reader.ReadInt32();
lod.opacity = lod.unk2 != 0;
lod.unk2 = reader.ReadInt32();
lod.bump = lod.unk2 != 0;
lod.unk2 = reader.ReadInt32();
lod.rigid = lod.unk2 != 0;
reader.Skip(28);
lod.vertexListSize = reader.ReadInt32();
lod.vertexCount = reader.ReadInt32();
lod.faceListSize = reader.ReadInt32();
lod.indexCount = reader.ReadInt32();
// xData is the verticies
lod.vertexList = new Vector3[lod.vertexListSize];
for (int j = 0; j < lod.vertexListSize; j++)
{
lod.vertexList[j] = reader.ReadVector3();
}
// these are the verticies for the graphics buffer
lod.verticies = new LODMesh.VertPool[lod.vertexCount];
for (int j = 0; j < lod.vertexCount; j++)
{
LODMesh.VertPool vert = lod.verticies[j] = new LODMesh.VertPool();
vert.position = reader.ReadVector3();
if (lod.hasBones == 1)
{
vert.weight1 = reader.ReadSingle();
vert.weight2 = reader.ReadSingle();
vert.bone1 = reader.ReadUInt16();
vert.bone2 = reader.ReadUInt16();
}
vert.normal = reader.ReadVector3();
vert.UV = reader.ReadVector2();
// Translate from DirectX to OpenGL coordinates
vert.UV = new Vector2(vert.UV.x, 1 - vert.UV.y);
}
// faces = indicies
lod.faces = new ushort[lod.indexCount];
for (int j = 0; j < lod.indexCount; j++)
{
lod.faces[j] = reader.ReadUInt16();
}
lod.triangles = new ushort[lod.vertexCount];
for (int j = 0; j < lod.vertexCount; j++)
{
lod.triangles[j] = reader.ReadUInt16();
}
lod.hasPhysique = reader.ReadInt32();
if (lod.hasPhysique != 0)
{
lod.physiqueVerticies = new int[lod.vertexListSize];
for (int j = 0; j < lod.vertexListSize; j++)
{
lod.physiqueVerticies[j] = reader.ReadInt32();
}
}
// materials
lod.hasMaterials = reader.ReadInt32();
if (lod.hasMaterials != 0)
{
lod.materialCount = reader.ReadInt32();
if (lod.materialCount == 0)
{
lod.materialCount = 1;
}
lod.materials = new LODMesh.Material[lod.materialCount];
for (int j = 0; j < lod.materialCount; j++)
{
LODMesh.Material mat = lod.materials[j] = new LODMesh.Material();
mat.diffuse = reader.ReadVector4();
mat.ambient = reader.ReadVector4();
mat.specular = reader.ReadVector4();
mat.emissive = reader.ReadVector4();
mat.materialPower = reader.ReadSingle();
mat.textureNameLen = reader.ReadInt32();
mat.textureName = reader.ReadBytes(mat.textureNameLen);
}
}
lod.matIdCount = reader.ReadInt32();
if (lod.matIdCount > 0)
{
lod.faceMats = new LODMesh.FaceMatId[lod.matIdCount];
for (int j = 0; j < lod.matIdCount; j++)
{
LODMesh.FaceMatId faceMat = lod.faceMats[j] = new LODMesh.FaceMatId();
faceMat.startingVertex = reader.ReadInt32();
faceMat.primitiveCount = reader.ReadInt32();
faceMat.materialId = reader.ReadInt32();
faceMat.effect = reader.ReadUInt32();
faceMat.amount = reader.ReadInt32();
faceMat.usedBoneCount = reader.ReadInt32();
faceMat.usedBones = new int[faceMat.usedBoneCount];
for (int k = 0; k < faceMat.usedBoneCount; k++)
{
faceMat.usedBones[k] = reader.ReadInt32();
}
}
}
}
reader.Close();
this.wasLoaded = true;
}
public virtual void LoadLODMesh(int level, string filename)
{
LODMesh lod = new LODMesh();
lod.LoadMesh(filename);
_lodMeshes[level] = lod;
}
public void UpdateTerrainChunk()
{
if (mapDataReceived)
{
float viewerDstFromNearestEdge = Mathf.Sqrt(bounds.SqrDistance(viewerPosition));
bool wasVisible = IsVisible();
bool visible = viewerDstFromNearestEdge <= maxViewDistance;
if (visible)
{
int lodIndex = 0;
for (int i = 0; i < detailLevels.Length - 1; i++)
{
if (viewerDstFromNearestEdge > detailLevels[i].visibleDstThreshold)
{
lodIndex = i + 1;
}
else
{
break;
}
}
if (lodIndex != 0)
{
for (int i = 0; i < objectList.Count; i++)
{
Destroy(objectList[i].gameObject);
}
}
if (lodIndex != previousLODIndex)
{
LODMesh lodMesh = lodMeshes[lodIndex];
if (lodMesh.hasMesh)
{
previousLODIndex = lodIndex;
meshFilter.mesh = lodMesh.mesh;
if (lodIndex == 0)
{
GameObject waterObject;
Vector3 waterPosition = new Vector3(meshObject.transform.position.x, meshObject.transform.position.y + (6 * 5), meshObject.transform.position.z);
waterObject = new GameObject("Water");
waterObject = Instantiate(prefabs.water, waterPosition, Quaternion.identity) as GameObject;
waterObject.transform.parent = meshObject.transform;
waterObject.transform.localScale = new Vector3(2.36f * 5, 0, 1.18f * 5);
objectList.Add(waterObject);
}
Vector3[] vertices = meshFilter.mesh.vertices;
for (int i = 0; i < vertices.Length; i++)
{
// Handles the creation of assets under the water level
if ((vertices[i].y > 0f) && (vertices[i].y < 20f) && (lodIndex == 0))
{
int prefabRandom = Random.Range(0, 100);
Vector3 position = new Vector3(vertices[i].x + this.meshObject.transform.position.x, vertices[i].y + this.meshObject.transform.position.y, vertices[i].z + this.meshObject.transform.position.z);
GameObject gameObject;
if (prefabRandom == 0)
{
int scaleRandom = Random.Range(15, 35);
gameObject = Instantiate(prefabs.waterRock, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(-90, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale / scaleRandom;
objectList.Add(gameObject);
}
else if (prefabRandom == 1)
{
int scaleRandom = Random.Range(15, 35);
gameObject = Instantiate(prefabs.waterRock2, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(-90, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale / scaleRandom;
objectList.Add(gameObject);
}
else if (prefabRandom == 2)
{
int scaleRandom = Random.Range(15, 35);
gameObject = Instantiate(prefabs.waterRock3, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(-90, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale / scaleRandom;
objectList.Add(gameObject);
}
else if (prefabRandom == 3)
{
int scaleRandom = Random.Range(15, 35);
gameObject = Instantiate(prefabs.waterRock4, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(-90, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale / scaleRandom;
objectList.Add(gameObject);
}
else if (prefabRandom >= 4 && prefabRandom <= 10)
{
int scaleRandom = Random.Range(1, 5);
gameObject = Instantiate(prefabs.waterElement, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(0, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale * scaleRandom;
objectList.Add(gameObject);
}
}
// Handles the creation of assets at the water edge
if ((vertices[i].y > 25f) && (vertices[i].y < 35f) && (lodIndex == 0))
{
int prefabRandom = Random.Range(0, 50);
Vector3 position = new Vector3(vertices[i].x + this.meshObject.transform.position.x, vertices[i].y + this.meshObject.transform.position.y, vertices[i].z + this.meshObject.transform.position.z);
GameObject gameObject;
if (prefabRandom == 0)
{
int scaleRandom = Random.Range(1, 5);
gameObject = Instantiate(prefabs.waterEdge, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(0, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale * scaleRandom;
objectList.Add(gameObject);
}
else if (prefabRandom == 1)
{
int scaleRandom = Random.Range(1, 5);
gameObject = Instantiate(prefabs.waterElement, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(0, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale * scaleRandom;
objectList.Add(gameObject);
}
else if (prefabRandom == 2)
{
int scaleRandom = Random.Range(1, 5);
gameObject = Instantiate(prefabs.waterEdge2, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(0, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale * scaleRandom;
objectList.Add(gameObject);
}
}
// Handles asset creation on grass areas
if ((vertices[i].y > 35f) && (vertices[i].y < 40f) && (lodIndex == 0))
{
int prefabRandom = Random.Range(1, 50);
Vector3 position = new Vector3(vertices[i].x + this.meshObject.transform.position.x, vertices[i].y + this.meshObject.transform.position.y, vertices[i].z + this.meshObject.transform.position.z);
GameObject gameObject;
if (prefabRandom == 0)
{
int scaleRandom = Random.Range(1, 5);
gameObject = Instantiate(prefabs.grassLevel, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(0, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale * scaleRandom;
objectList.Add(gameObject);
}
else if (prefabRandom == 1)
{
int scaleRandom = Random.Range(1, 5);
gameObject = Instantiate(prefabs.grassLevel2, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(0, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale * scaleRandom;
objectList.Add(gameObject);
}
else if (prefabRandom == 2)
{
int scaleRandom = Random.Range(1, 5);
gameObject = Instantiate(prefabs.grassLevel3, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(0, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale * scaleRandom;
objectList.Add(gameObject);
}
else if (prefabRandom == 3)
{
int scaleRandom = Random.Range(1, 5);
gameObject = Instantiate(prefabs.grassLevel4, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(0, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale * scaleRandom;
objectList.Add(gameObject);
}
else if (prefabRandom == 4)
{
int scaleRandom = Random.Range(1, 5);
gameObject = Instantiate(prefabs.grassLevel5, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(0, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale * scaleRandom;
objectList.Add(gameObject);
}
else if (prefabRandom == 5)
{
int scaleRandom = Random.Range(1, 5);
gameObject = Instantiate(prefabs.grassLevel6, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(0, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale * scaleRandom;
objectList.Add(gameObject);
}
else if (prefabRandom == 6)
{
int scaleRandom = Random.Range(1, 5);
gameObject = Instantiate(prefabs.grassLevel7, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(0, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale * scaleRandom;
objectList.Add(gameObject);
}
else if (prefabRandom > 6 && prefabRandom < 30)
{
int scaleRandom = Random.Range(1, 5);
gameObject = Instantiate(prefabs.grassLevel8, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(0, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale * scaleRandom;
objectList.Add(gameObject);
}
}
// Handles asset creation on the mountain regions
if ((vertices[i].y > 45f) && (vertices[i].y < 70f) && (lodIndex == 0))
{
int prefabRandom = Random.Range(0, 30);
Vector3 position = new Vector3(vertices[i].x + this.meshObject.transform.position.x, vertices[i].y + this.meshObject.transform.position.y, vertices[i].z + this.meshObject.transform.position.z);
GameObject gameObject;
if (prefabRandom == 0)
{
int scaleRandom = Random.Range(5, 20);
gameObject = Instantiate(prefabs.rockLevel, position, Quaternion.identity) as GameObject;
gameObject.transform.Rotate(0, Random.Range(0, 100), 0);
gameObject.transform.localScale = gameObject.transform.localScale / scaleRandom;
objectList.Add(gameObject);
}
}
}
}
else if (!lodMesh.hasRequestedMesh)
{
lodMesh.RequestMesh(mapData);
}
}
}
if (wasVisible != visible)
{
if (visible)
{
visibleTerrainChunks.Add(this);
}
else
{
visibleTerrainChunks.Remove(this);
for (int i = 0; i < objectList.Count; i++)
{
Destroy(objectList[i].gameObject);
}
}
SetVisible(visible);
}
}
}
