// Update is called once per frame
void Update()
{
if (--RedrawCountdown == 0)
{
DrawGround();
}
if (_currentToken != null)
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray.origin, ray.direction, out hit, 100f, _layerMaskForMousePosition, QueryTriggerInteraction.Collide))
{
_mousePosition = hit.point;
_mousePositionOnGrid = new Vector2(MathUtils.Round(_mousePosition.x, _scale), MathUtils.Round(_mousePosition.z, _scale));
int x = (int)Math.Round(_mousePositionOnGrid.x);
int y = (int)Math.Round(_mousePositionOnGrid.y);
_mousePositionOnTerra = new TerraVector()
{
x = x, y = y
};
TerraVector mousePositionOnToken = new TerraVector()
{
x = x - _currentToken.Request.left, y = y - _currentToken.Request.top
};
_mousePosition3OnGrid = GetVertice(_currentToken, mousePositionOnToken.x, mousePositionOnToken.y);
// Do something with the object that was hit by the raycast.
}
}
}
public TerraVector ToLocal(TerraVector worldVector)
{
return(new TerraVector()
{
x = worldVector.x - _request.left, y = worldVector.y - _request.top
});
}
protected virtual IEnumerable <TGridDataPoint> GenerateVectorGrid(TerraVector center, TerraVector dimensions)
{
return(GenerateVectorGrid(
left: Math.Max(0, center.x - dimensions.x),
top: Math.Max(0, center.y - dimensions.y),
right: Math.Min(Width - 1, center.x + dimensions.x),
bottom: Math.Min(Height - 1, center.y + dimensions.y)));
}
private void LowerEarth()
{
TerraChunksViewModel vm = Game.Instance.GetViewModel <TerraChunksViewModel>(0);
TerraVector vector = new TerraVector((int)transform.position.x, (int)transform.position.z);
TerraPoint point = vm.CurrentChunk.GetFromWorld(vector);
point.Height -= 1;
vm.CurrentChunk.SetFromWorld(vector, point);
}
private IEnumerable <TerraTerrainGeometryDataPoint> OnDataChange(TerraVector vector)
{
for (int x = vector.x - 1; x <= vector.x + 1; x++)
{
for (int y = vector.y - 1; y <= vector.y + 1; y++)
{
yield return(new TerraTerrainGeometryDataPoint(new TerraVector(x, y), this[x, y]));
}
}
}
public TerraWorldChunk this[TerraVector vector]
{
get
{
if (_chunks.ContainsKey(vector))
{
return(_chunks[vector]);
}
return(null);
}
}
private void UpdateSurroundingHights(TerraVector vector, TerraWorldChunk chunk)
{
for (int x = vector.x - 1; x <= vector.x + 1; x++)
{
for (int y = vector.y - 1; y <= vector.y + 1; y++)
{
this[x, y] = GetVertice(chunk, x, y);
}
}
DataHasChanged(OnDataChange(vector));
}
public void ChangeHeight(TerraVector position, int delta)
{
if (_currentToken == null)
{
throw new InvalidOperationException(string.Format("There is no current {0}", typeof(WorldDataToken)));
}
else
{
Mesh mesh = _renderMeshFilter.sharedMesh;
List <Vector3> vectorTriangles = new List <Vector3>();
var triangles = mesh.triangles;
Vector3[] vertices = mesh.vertices;
Color[] colors = mesh.colors;
Vector2[] uvs = mesh.uv;
Vector3[] normals = mesh.normals;
ushort currentValue = _currentToken.GetUshort(position.x - _currentToken.Request.left, position.y - _currentToken.Request.top, UshortDataID.HeightLayerData);
TerraVector localVector = _currentToken.ToLocal(position);
int vertPosition = (localVector.x * (_currentToken.Request.width + 1)) + localVector.y;
_currentToken.SetUshort(localVector.x, localVector.y, (ushort)((int)currentValue + delta), UshortDataID.HeightLayerData);
//vertices[vertPosition] = GetVertice(_currentToken, localVector.x, localVector.y);
UpdateSurroundingHights(localVector, vertices, _currentToken);
mesh.vertices = vertices;
mesh.RecalculateNormals();
mesh.RecalculateBounds();
mesh.RecalculateTangents();
/*vertices[localVector.x * localVector.y] =
* GetVertice(_currentToken, localVector.x, localVector.y);
* _renderMeshFilter.sharedMesh.vertices = _renderMesh.vertices;
*
*
*
* //SetTriangles(_currentToken, localVector.x, localVector.y, triangles, vectorTriangles);
*
* mesh.Clear();
*
* mesh.vertices = vertices;
* mesh.triangles = triangles;
* mesh.uv = uvs;
* mesh.colors = colors;
* mesh.normals = normals;
*
* _renderMeshFilter.sharedMesh.RecalculateNormals();
* _renderMeshFilter.sharedMesh.RecalculateBounds();
* _renderMeshFilter.sharedMesh.RecalculateTangents();*/
//RedrawCountdown = 1;
// RenderGround(_currentToken);
}
}
/*
* ((token.GetUshort(x, y, UshortDataID.HeightLayerData) +
* token.GetUshort(x - 1, y -1, UshortDataID.HeightLayerData) +
* token.GetUshort(x, y -1, UshortDataID.HeightLayerData) +
* token.GetUshort(x + 1, y -1, UshortDataID.HeightLayerData) +
* token.GetUshort(x + 1, y, UshortDataID.HeightLayerData) +
* token.GetUshort(x + 1, y + 1, UshortDataID.HeightLayerData) +
* token.GetUshort(x, y + 1, UshortDataID.HeightLayerData) +
* token.GetUshort(x - 1, y + 1, UshortDataID.HeightLayerData) +
* token.GetUshort(x - 1, y, UshortDataID.HeightLayerData)) / 9f) * 0.5f,*/
private void UpdateSurroundingHights(TerraVector vector, Vector3[] vertices, WorldDataToken token)
{
UpdateHights(vector, vertices, token);
UpdateHights(new TerraVector()
{
x = vector.x - 1, y = vector.y - 1
}, vertices, token);
UpdateHights(new TerraVector()
{
x = vector.x, y = vector.y - 1
}, vertices, token);
UpdateHights(new TerraVector()
{
x = vector.x + 1, y = vector.y - 1
}, vertices, token);
UpdateHights(new TerraVector()
{
x = vector.x + 1, y = vector.y
}, vertices, token);
UpdateHights(new TerraVector()
{
x = vector.x + 1, y = vector.y + 1
}, vertices, token);
UpdateHights(new TerraVector()
{
x = vector.x, y = vector.y + 1
}, vertices, token);
UpdateHights(new TerraVector()
{
x = vector.x - 1, y = vector.y + 1
}, vertices, token);
UpdateHights(new TerraVector()
{
x = vector.x - 1, y = vector.y
}, vertices, token);
}
public TerraDataPoint(TerraPoint data, TerraVector vector) : base(data, vector)
{
}
public void RemoveChunk(TerraVector position)
{
_chunks.TryGetValue(position, out TerraWorldChunk chunk);
_chunks.Remove(position);
OnChunkRemoved?.Invoke(chunk);
}
public virtual void UpdateData(TerraVector vector)
{
}
public TerraTerrainGeometryDataPoint(TerraVector vector, Vector3 data) : base(data, vector)
{
}
public GridDataPoint(TData data, TerraVector vector)
{
Data = data;
Vector = vector;
}
private void UpdateHights(TerraVector vector, Vector3[] vertices, WorldDataToken token)
{
int vertPosition = (vector.x * (token.Request.width + 1)) + vector.y;
vertices[vertPosition] = GetVertice(_currentToken, vector.x, vector.y);
}
public TerraPoint GetFromWorld(TerraVector vector)
{
return(this[FindDifference(_area.x, vector.x), FindDifference(_area.y, vector.y)]);
}
public void SetFromWorld(TerraVector vector, TerraPoint point)
{
this[FindDifference(_area.x, vector.x), FindDifference(_area.y, vector.y)] = point;
}
public virtual TData this[TerraVector vector]
{
get { return(_data[vector.x, vector.y]); }
set { _data[vector.x, vector.y] = value; }
}
