public ILayerMasked GetCachedZoomedHeightmap()
{
if (HeightmapLayer == null)
{
return(null);
}
if (Zoom == 1)
{
return(HeightmapLayer);
}
if (Zoom == _lastZoom && _cachedZoomedLayer != null && _version == HeightmapVersion)
{
return(_cachedZoomedLayer);
}
_lastZoom = Zoom;
_version = HeightmapVersion;
Layer2DObject l = new Layer2DObject(GetRecalculatedSize());
float xScale = (float)HeightmapLayer.Resolution.X / l.Resolution.X;
float yScale = (float)HeightmapLayer.Resolution.Y / l.Resolution.Y;
for (int y = 0; y < l.Resolution.Y; y++)
{
for (int x = 0; x < l.Resolution.X; x++)
{
var oldX = (int)(x * xScale);
var oldY = (int)(y * yScale);
l[x, y] = HeightmapLayer[oldX, oldY];
}
}
_cachedZoomedLayer = l;
return(l);
}
public ILayerMasked Blur(ILayerMasked l, int fadeSize)
{
var m = new Layer2DObject(l.Resolution);
blur.Process(l, m, fadeSize);
return(m);
}
public void PaintLayerOnLayerMasked(ILayerMasked valueLayer, ILayerMasked maskedLayer, ILayerMasked returnLayer)
{
if (valueLayer.Resolution != maskedLayer.Resolution || maskedLayer.Resolution != returnLayer.Resolution)
{
throw new ArgumentException(error_sizeDoesNotMatch);
}
if (maskedLayer.Mask == null || maskedLayer.Mask.Resolution != maskedLayer.Resolution)
{
throw new ArgumentException();
}
for (int y = maskedLayer.ValueArea.Top; y < valueLayer.ValueArea.Bottom; y++)
{
for (int x = maskedLayer.ValueArea.Left; x < valueLayer.ValueArea.Right; x++)
{
var source = maskedLayer[x, y];
var alpha = maskedLayer.Mask[x, y];
if (source.HasValue && alpha.HasValue && alpha.Value > thres)
{
var target = valueLayer[x, y];
if (target.HasValue)
{
returnLayer[x, y] = ab.Blend(target.Value, source.Value, alpha.Value);
}
else
{
returnLayer[x, y] = source.Value;
}
}
}
}
}
private ILayerMasked merge(IBlendModeAlpha ablend, ILayerMasked baseLayer, IList <DescribedLayer> pars)
{
onMergeStarted();
if (pars == null || pars.Count == 0)
{
throw new ArgumentException();
}
var final = baseLayer;
foreach (var describ in pars)
{
var current = describ.Layer;
var blendMode = describ.GlobalParameters.BlendMode;
var offset = describ.GlobalParameters.Offset - .5f;
var minY = JryMath.Max(0, -current.Offset.Y);
var minX = JryMath.Max(0, -current.Offset.X);
var maxY = JryMath.Min(current.Resolution.Y, final.Resolution.Y - current.Offset.Y);
var maxX = JryMath.Min(current.Resolution.X, final.Resolution.X - current.Offset.X);
for (int y = minY; y < maxY; y++)
{
for (int x = minX; x < maxX; x++)
{
int ix = x + current.Offset.X;
int iy = y + current.Offset.Y;
var curVal = current[x, y];
if (!curVal.HasValue || !final[ix, iy].HasValue || !current.HasMask)
{
continue;
}
var maskValue = current.Mask[x, y];
if (!maskValue.HasValue)
{
continue;
}
var currentLayerValue = curVal.Value + offset;
var currentLayerMaskValue = maskValue.Value;
//currentLayerMaskValue = 1;
var upToThisPointGeneratedLayerValue = final[ix, iy].Value;
var blended = blendMode.Blend(upToThisPointGeneratedLayerValue, currentLayerValue * currentLayerMaskValue);
final[ix, iy] = ablend.Blend(upToThisPointGeneratedLayerValue, blended, currentLayerMaskValue);
if (final[ix, iy] > 0.05f)
{
}
}
}
}
return(baseLayer);
}
public void PrintToLayer(ILayerMasked layer, IList <IArea> areas, Vector2 translateVector)
{
foreach (var area in areas)
//Parallel.ForEach(areas, (area) =>
{
var translatedArea = translateArea(area, translateVector);
drawAreaToLayer(layer, translatedArea);
}
//);
}
private void doErosion(ILayerMasked final, IErosionDescriptor bs)
{
if (bs.HydraulicErosionParams.Strenght <= 0)
{
return;
}
onErosionStarted();
bs.HydraulicErosion.Erode(final, bs.HydraulicErosionParams);
_visualLogger.Log(final, "baseWithEro");
}
private void generateRIvers(ILayerMasked final, int riverAmount)
{
if (riverAmount <= 0)
{
return;
}
onRiver();
doRivers(final, riverAmount);
_visualLogger.Log(final, "baseWithEroAndRivers");
}
private void drawAreaToLayer(ILayerMasked layer, IArea area)
{
var pts = area.Points.ToArray();
for (int i = 0; i < layer.Resolution.Y; i++)
{
for (int j = 0; j < layer.Resolution.X; j++)
{
var coor = new Vector2(j, i);
//if (!_geometryUtiltiy.IsInPolygon(pts, coor)) continue;
var positiveDistance1 = float.MaxValue;
var positiveDistance2 = float.MaxValue;
var positiveDistance3 = float.MaxValue;
//var negativeDistance = float.MaxValue;
foreach (var seg in area.Segments)
{
var dist = _geometryUtiltiy.DistanceFromPointToSegment(coor, seg);
if (dist < positiveDistance1)
{
positiveDistance3 = positiveDistance2;
positiveDistance2 = positiveDistance1;
positiveDistance1 = dist;
}
else if (dist < positiveDistance2)
{
positiveDistance3 = positiveDistance2;
positiveDistance2 = dist;
}
else if (dist < positiveDistance3)
{
positiveDistance3 = dist;
}
}
if (positiveDistance1 == float.MaxValue)
{
positiveDistance1 = 0;
}
if (positiveDistance2 == float.MaxValue)
{
positiveDistance2 = 0;
}
if (positiveDistance3 == float.MaxValue)
{
positiveDistance3 = 0;
}
layer[coor] = positiveDistance1 + positiveDistance2 + positiveDistance3;
}
}
}
public void InitializeSource(ILayer l)
{
// TODO get rid of this stupid exception
if (initialized)
{
throw new InvalidOperationException("Is already initialized");
}
initialized = true;
sourceLayer = l;
updatedLayer = new Layer2DObject(l.Resolution);
ResetMask(l.Resolution);
}
public async Task Compose(IWorld w)
{
var param = w.Parameters;
var fields = w.Fields;
var pars = await generateFields(param, fields);
IErosionDescriptor bs;
ILayerMasked baseLayer;
IBlendModeAlpha ba;
if (w.UseBase)
{
var bsd = _describer.DescribeBaseLayer(param, w.BaseField);
//baseLayer = await bsd.LayerGlobalParameters.Profile
baseLayer = await bsd.LayerGlobalParameters.Generator.GenerateLayer();
//_layerUtils.Normalize(baseLayer);
//HACK baselayers mask extend it size
var x = new Layer2DObject(w.Parameters.BitmapResolution);
_layerUtils.IterateValues(x, (v, val) => x[v] = baseLayer[v]);
baseLayer = x;
ba = bsd.AlphaBlend;
bs = bsd;
}
else
{
baseLayer = new Layer2DObject(w.Parameters.BitmapResolution);
baseLayer.Mask = new Mask(baseLayer.Resolution);
_layerUtils.IterateValues(baseLayer.Mask, (v, val) => baseLayer[v] = 1);
setUpDefaulValue(baseLayer);
bs = new ErosionDescriptor();
ba = new AlphaBlend();
}
bs.HydraulicErosionParams.Strenght = param.ErosionStrength * strengthMultpilier;
ILayerMasked merged = merge(ba, baseLayer, pars);
//_layerUtils.FitInto(merged, 0, 1);
postProcessWholeLayer(merged, bs, w.Parameters.RiverAmount);
ComposedLayer = merged;
}
private void doRivers(ILayerMasked layer, int riverAmount)
{
onRiver();
IDrainageSimulator drainageSimulator = new BallDrainageSimulator();
var drainageMap = drainageSimulator.GetDrainageMap(layer, riverAmount);
_visualLogger.Log(drainageMap, "drainage");
_layerUtils.IterateValues(drainageMap,
(cor, val) =>
{
if (drainageMap[cor].HasValue)
{
layer[cor] -= drainageMap[cor].Value * .01f;
}
}
);
}
private void drawAreaToLayer(ILayerMasked layer, IArea area)
{
var pts = area.Points.ToArray();
var bounds = _geometryUtiltiy.GetBoundsForPoints(pts).RestrictOn(layer.Resolution);
for (int i = bounds.Top; i < bounds.Bottom; i++)
{
for (int j = bounds.Left; j < bounds.Right; j++)
{
if (j == 464 && i == 385)
{
}
if (!_geometryUtiltiy.IsInPolygon(pts, j, i))
{
continue;
}
var coor = new Vector2(j, i);
int indexOfClosestSeg = 0;
var distance = float.MaxValue;
for (var k = 0; k < area.Segments.Count; k++)
{
var seg = area.Segments[k];
var dist = _geometryUtiltiy.DistanceFromPointToSegmentSquare(
ref coor, ref seg);
if (dist < distance)
{
distance = dist;
indexOfClosestSeg = k;
}
}
layer[j, i] = _geometryUtiltiy.DistanceFromPointToSegment(coor, area.Segments[indexOfClosestSeg]);
}
}
}
protected void applyOffset(int extendSize, IList <Vector2> points, ILayerMasked layer)
{
var bounds = _geoUtils.GetBoundsForPoints(points);
layer.Offset = new IntVector2(bounds.Left - extendSize, bounds.Top - extendSize);
}
public DescribedLayer(ILayerGlobalParameters layerGlobalParameters, ILayerMasked layer2DObject) : this()
{
this.GlobalParameters = layerGlobalParameters;
this.Layer = layer2DObject;
}
private void postProcessWholeLayer(ILayerMasked final, IErosionDescriptor bs, int riverAmount)
{
_visualLogger.Log(final, "baseNoEro");
doErosion(final, bs);
generateRIvers(final, riverAmount);
}
public LayerWithInfluence(ILayerMasked layer, float influence)
{
Layer = layer;
Influence = influence;
}
public void InitializeGeneratedObjects(ILayerMasked obj)
{
HeightmapLayer = obj;
_heightmapView.RefreshView();
HeightmapVersion = 0;
}
