Пример #1
0
        public override Task <ILayerMasked> GenerateLayer()
        {
            var         oldpoints         = _layerLocalParameters.Polygon.Points.ToList();
            var         mask              = getBlurredMask(oldpoints);
            Vector2     resolution        = mask.Resolution;
            var         noisescaleDown    = .33f;
            const float thatMakesItGoDown = -1;

            _logger.Log(mask, "canyonMask");

            var blured = getBlurredProfile(oldpoints, resolution);
            var layer  = _noise.Do(resolution);

            _layerUtility.IterateValues(blured, (coor, val) =>
            {
                var cv = val.HasValue ? val.Value : 0;

                layer[coor] = layer[coor] * noisescaleDown + cv + thatMakesItGoDown;
            });
            _logger.Log(layer, "canyon");
            layer.Mask = mask;

            applyOffset(_layerLocalParameters.ExtendSize, oldpoints, layer);
            return(Task.FromResult(layer));
        }
Пример #2
0
        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;
        }
Пример #3
0
        private ILayerMasked drawSiteToLayer(IntVector2 size, IEnumerable <IArea> areas)
        {
            var layer = new Layer2DObject(size.X, size.Y);

            _layerUtility.IterateValues(layer, (x, y, va) => layer[x, y] = 0);
            var layerDrawer = new LayerDrawer(layer);

            foreach (var area in areas)
            {
                layerDrawer.DrawArea(area);
            }
            return(layer);
        }