void GenerateEditorFragment(TerrainFragment fragment, LodInfos lodInfo)
{
//in editor stuff
GameObject fragmentObj = new GameObject();
fragment.gameObject = fragmentObj;
fragment.BuildMesh();
fragmentObj.name = "Fragment lod " + lodInfo.lodLevel + " center " + lodInfo.center;
MeshRenderer meshRenderer = fragmentObj.AddComponent <MeshRenderer>();
if (material == null)
{
meshRenderer.sharedMaterial = new Material(Shader.Find("Standard"));
}
else
{
meshRenderer.sharedMaterial = material;
}
fragmentObj.transform.parent = transform;
MeshFilter meshFilter = fragmentObj.AddComponent <MeshFilter>();
meshFilter.sharedMesh = fragment.mesh;
}
void FragmentDataThread(TerrainFragment fragment, Action <FragmentMeshData> callback)
{
FragmentMeshData data = fragment.BuildMeshData();
lock (fragmentTaskCallbacksQueue)
{
ThreadTaskCallback <FragmentMeshData> task = new ThreadTaskCallback <FragmentMeshData>(callback, data);
fragmentTaskCallbacksQueue.Enqueue(task);
}
}
TerrainFragment CreateNewFragment(LodInfos lodInfo, Vector3 localUp)
{
TerrainFragment fragment = new TerrainFragment(lodInfo, Vector3.up, this);
if (EditorApplication.isPlaying)
{
ThreadPool.QueueUserWorkItem(a => FragmentDataThread(fragment, OnFragmentDataRecived));
}
else
{
GenerateEditorFragment(fragment, lodInfo);
}
return(fragment);
}
void UpdateNeighborsNormals(Vector2 coords, TerrainFragment fragment)
{
Vector2 upCoords = coords + Vector2.up;
Vector2 downCoords = coords + Vector2.down;
Vector2 rightCoords = coords + Vector2.right;
Vector2 leftCoords = coords + Vector2.left;
TerrainFragment up;
TerrainFragment down;
TerrainFragment right;
TerrainFragment left;
if (visibleFragments.TryGetValue(upCoords, out up))
{
//if(up.gameObject.active)
try { fragment.RecalculateNormalsUp(up); }
catch (Exception e) {
Debug.Log(e);
}
}
if (visibleFragments.TryGetValue(downCoords, out down))
{
//if (down.gameObject.active)
try { fragment.RecalculateNormalsDown(down); }
catch (Exception e)
{
Debug.Log(e);
}
}
if (visibleFragments.TryGetValue(rightCoords, out right))
{
//if (right.gameObject.active)
try { fragment.RecalculateNormalsRight(right); }
catch (Exception e)
{
Debug.Log(e);
}
}
if (visibleFragments.TryGetValue(leftCoords, out left))
{
//if (up.gameObject.active)
try { fragment.RecalculateNormalsLeft(left); }
catch (Exception e)
{
Debug.Log(e);
}
}
}
public void RecalculateNormalsDown(TerrainFragment b)
{
for (int i = 0; i < downIndexes.Length; i++)
{
int index = downIndexes[i];
int tIndex = b.upIndexes[i];
Vector3 aNormal = normals[index];
Vector3 bNormal = b.normals[tIndex];
Vector3 normal = aNormal + bNormal;
normal.Normalize();
normals[index] = normal;
b.normals[tIndex] = normal;
}
}
void GenerateFragements()
{
visibleLastframeFragments = visibleFragments;
visibleFragments = new Dictionary <Vector2, TerrainFragment>();
int currentFragmentCoordX = Mathf.RoundToInt(viewerPosition.x / terrainSettings.fragmentSize);
int currentFragmentCoordY = Mathf.RoundToInt(viewerPosition.z / terrainSettings.fragmentSize); // to get the right player plane
for (int yOffset = -fragmentVisibleInViewDistance; yOffset <= fragmentVisibleInViewDistance; yOffset++)
{
for (int xOffset = -fragmentVisibleInViewDistance; xOffset <= fragmentVisibleInViewDistance; xOffset++)
{
Vector2 viewedFragmentCoord = new Vector2(currentFragmentCoordX + xOffset, currentFragmentCoordY + yOffset);
TerrainFragment existingFragment;
//need to check for lod level
//AnimationCurve lodCurveInfo = new AnimationCurve(lodCurve.keys);
LodInfos lodInfo = new LodInfos(viewedFragmentCoord, terrainSettings, lodThresholdsLevels, viewerPosition);
if (visibleLastframeFragments.TryGetValue(viewedFragmentCoord, out existingFragment))
{
if (existingFragment.lodInfos == lodInfo)
{
visibleFragments.Add(viewedFragmentCoord, existingFragment);
visibleLastframeFragments.Remove(viewedFragmentCoord);
}
else
{
TerrainFragment fragment = CreateNewFragment(lodInfo, Vector3.up);
visibleFragments.Add(viewedFragmentCoord, fragment);
}
}
else
{
TerrainFragment fragment = CreateNewFragment(lodInfo, Vector3.up);
visibleFragments.Add(viewedFragmentCoord, fragment);
}
}
}
}
public Terrain(string pathToCsvFile)
{
Fragments = new List <TerrainFragment>();
TextAsset entireCSV = Resources.Load(pathToCsvFile) as TextAsset;
var lines = entireCSV.text.Split('\n');
foreach (var line in lines)
{
var locationString = line.Split(',');
// If parse from string to double did not succeed set the value to zero
var longitudeString = locationString[0].Trim();
float longitude;
if (float.TryParse(longitudeString, out longitude) == false)
{
longitude = 0;
}
var latitudeString = locationString[1].Trim();
float latitude;
if (float.TryParse(latitudeString, out latitude) == false)
{
latitude = 0;
}
var altitudeString = locationString[2].Trim();
float altitude;
if (float.TryParse(altitudeString, out altitude) == false)
{
altitude = 0;
}
var coordinates = new Coordinates(longitude, latitude);
var locationToAdd = new TerrainFragment(coordinates, altitude);
Fragments.Add(locationToAdd);
}
}
public void RecalculateNormalDownLeft(TerrainFragment t)
{
}
public void RecalculateNormalUpRight(TerrainFragment t)
{
}
/// <summary>
/// Sets an internal variable to true if the object is to be culled.
/// Mobies and shrubs are culled by their drawDistance.
/// Ties, terrain and shrubs are culled by frustum culling.
/// </summary>
public void ComputeCulling(Camera camera, bool distanceCulling, bool frustumCulling)
{
if (distanceCulling)
{
float dist = (modelObject.position - camera.position).Length;
if (dist > renderDistance)
{
culled = true;
return;
}
}
if (frustumCulling)
{
if (type == RenderedObjectType.Terrain || type == RenderedObjectType.Tie || type == RenderedObjectType.Shrub)
{
Vector3 center = Vector3.Zero;
float size = 0.0f;
switch (type)
{
case RenderedObjectType.Terrain:
TerrainFragment frag = (TerrainFragment)modelObject;
center = frag.cullingCenter;
size = frag.cullingSize;
break;
case RenderedObjectType.Shrub:
ShrubModel shrub = (ShrubModel)modelObject.model;
center = new Vector3(shrub.cullingX, shrub.cullingY, shrub.cullingZ);
center = modelObject.rotation * center;
center += modelObject.position;
float shrubScale = MathF.MaxMagnitude(modelObject.scale.X, MathF.MaxMagnitude(modelObject.scale.Y, modelObject.scale.Z));
size = shrub.cullingRadius * shrubScale;
break;
case RenderedObjectType.Tie:
TieModel tie = (TieModel)modelObject.model;
center = new Vector3(tie.cullingX, tie.cullingY, tie.cullingZ);
center = modelObject.rotation * center;
center += modelObject.position;
float tieScale = MathF.MaxMagnitude(modelObject.scale.X, MathF.MaxMagnitude(modelObject.scale.Y, modelObject.scale.Z));
size = tie.cullingRadius * tieScale;
break;
}
for (int i = 0; i < 6; i++)
{
Vector3 planeNormal = camera.frustumPlaneNormals[i];
Vector3 planePoint = camera.frustumPlanePoints[i];
if (Vector3.Dot(center - planePoint, planeNormal) < -size)
{
culled = true;
return;
}
}
}
}
culled = false;
}
