public SkyIslandMapImagesPhase(
            IStageIdentity stageIdentity,
            IStageBounds stageBounds,
            IAsyncFactory <ChunkOverheadKey, IDisposableValue <IReadOnlySkyIslandMapChunk> > chunkFactory,
            IKeyValueStore statsStore,
            SkyIslandMapImagesOptions imageOptions = null,
            GenerationOptions generationOptions    = null)
        {
            Contracts.Requires.That(stageIdentity != null);
            Contracts.Requires.That(stageBounds != null);
            Contracts.Requires.That(chunkFactory != null);
            Contracts.Requires.That(statsStore != null);

            var phaseIdentity = new GenerationPhaseIdentity(nameof(SkyIslandMapImagesPhase));
            var chunkKeys     = new ChunkOverheadKeyCollection(stageBounds);

            var chunkProcessor = new SkyIslandMapChunkImagesProcessor(stageBounds, statsStore, imageOptions);

            this.Phase = new ChunkedPhase <ChunkOverheadKey, IReadOnlySkyIslandMapChunk>(
                stageIdentity,
                phaseIdentity,
                chunkKeys,
                chunkFactory,
                chunkProcessor,
                generationOptions);
        }
        private static OscillationOrder3D GetOscillationOrder(IStageBounds bounds)
        {
            Contracts.Requires.That(bounds != null);

            var dimensions = bounds.InChunks.Dimensions;

            return(dimensions.X <= dimensions.Z ? OscillationOrder3D.YXZ : OscillationOrder3D.YZX);
        }
Example #3
0
        private static OscillationOrder2D GetOscillationOrder(IStageBounds bounds)
        {
            Contracts.Requires.That(bounds != null);

            var dimensions = bounds.InOverheadChunks.Dimensions;

            return(dimensions.X <= dimensions.Y ? OscillationOrder2D.XY : OscillationOrder2D.YX);
        }
        public void SetFiniteBounds(
            IStageBounds stageBounds, SkyIslandMaps outOfBoundsValue, bool modifyingThrowsException = true)
        {
            Contracts.Requires.That(stageBounds != null);

            this.stageBounds              = stageBounds;
            this.outOfBoundsValue         = outOfBoundsValue;
            this.modifyingThrowsException = modifyingThrowsException;
        }
Example #5
0
        public SkyIslandMapChunkImagesProcessor(
            IStageBounds stageBounds, IKeyValueStore statsStore, SkyIslandMapImagesOptions imagesOptions = null)
        {
            Contracts.Requires.That(stageBounds != null);
            Contracts.Requires.That(statsStore != null);

            this.stageBounds   = stageBounds;
            this.statsStore    = statsStore;
            this.imagesOptions = imagesOptions;
        }
        public ChunkKeyCollection(
            IStageBounds bounds, Func <Index3D, Index3D, IEnumerable <Index3D> > enumerationOrder)
        {
            Contracts.Requires.That(bounds != null);
            Contracts.Requires.That(enumerationOrder != null);

            var chunkKeys =
                enumerationOrder(bounds.InChunks.LowerBounds, bounds.InChunks.Dimensions)
                .Select(index => new ChunkKey(index));

            this.keys = new ReadOnlyLargeCollection <ChunkKey>(
                chunkKeys, bounds.InChunks.LongLength);
        }
Example #7
0
        public StageBoundaryChunkOverheadFactory(
            IStageBounds bounds,
            IAsyncFactory <ChunkOverheadKey, TChunk> interiorFactory,
            IFactory <ChunkOverheadKey, TChunk> exteriorFactory)
        {
            Contracts.Requires.That(bounds != null);
            Contracts.Requires.That(interiorFactory != null);
            Contracts.Requires.That(exteriorFactory != null);

            this.minKey          = bounds.InOverheadChunks.LowerBounds;
            this.maxKey          = bounds.InOverheadChunks.UpperBounds;
            this.interiorFactory = interiorFactory;
            this.exteriorFactory = exteriorFactory;
        }
Example #8
0
        public ContourPhase(
            IStageIdentity stageIdentity,
            IStageBounds stageBounds,
            IRasterChunkConfig <Index3D> voxelChunkConfig,
            IAsyncFactory <ChunkKey, IDisposableValue <IReadOnlyVoxelGridChunk> > voxelChunkFactory,
            IDualContourer <TerrainVoxel, TSurfaceData, NormalColorTextureVertex> contourer,
            IChunkStore <ChunkKey, SerializedMeshChunk> meshChunkStore,
            int maxBufferedChunks,
            BatchSerializeGenerationOptions options = null)
        {
            Contracts.Requires.That(stageIdentity != null);
            Contracts.Requires.That(stageBounds != null);
            Contracts.Requires.That(voxelChunkConfig != null);
            Contracts.Requires.That(voxelChunkFactory != null);
            Contracts.Requires.That(contourer != null);
            Contracts.Requires.That(meshChunkStore != null);
            Contracts.Requires.That(maxBufferedChunks > 0);

            var phaseIdentity = new GenerationPhaseIdentity(nameof(ContourPhase <TSurfaceData>));
            var chunkKeys     = new ChunkKeyCollection(stageBounds);

            var poolOptions = new PoolOptions <IMutableDivisibleMesh <NormalColorTextureVertex> >()
            {
                ResetAction = mesh => mesh.Clear(),
            };

            this.pool = Pool.WithFactory.New(
                Factory.From <IMutableDivisibleMesh <NormalColorTextureVertex> >(
                    () => new MutableDivisibleMesh <NormalColorTextureVertex>()),
                poolOptions);

            var chunkFactory = new ContourMeshFactory <TSurfaceData>(
                voxelChunkConfig, voxelChunkFactory, this.pool, contourer);
            var serializer = DivisibleMeshSerializer.NormalColorTextureVertices.WithColorAlpha[
                options?.SerializationEndianness ?? DefaultSerializationEndianness];
            var persistableFactory = new SerializeMeshChunkFactory(chunkFactory, serializer);

            this.Phase = new ChunkedBatchingPhase <ChunkKey, SerializedMeshChunk>(
                stageIdentity,
                phaseIdentity,
                chunkKeys,
                persistableFactory,
                meshChunkStore,
                maxBufferedChunks,
                options);

            this.Completion = this.CompleteAsync();
        }
        public SkyIslandMapAbsolutePhase(
            IStageIdentity stageIdentity,
            IStageBounds stageBounds,
            IRasterChunkConfig <Index2D> chunkConfig,
            IAsyncChunkPopulator <ISkyIslandMapChunk> chunkPopulator,
            IChunkStore <ChunkOverheadKey, SerializedSkyIslandMapChunk> chunkStore,
            int maxBufferedChunks,
            BatchSerializeGenerationOptions options = null)
        {
            Contracts.Requires.That(stageIdentity != null);
            Contracts.Requires.That(stageBounds != null);
            Contracts.Requires.That(chunkConfig != null);
            Contracts.Requires.That(chunkPopulator != null);
            Contracts.Requires.That(chunkStore != null);
            Contracts.Requires.That(maxBufferedChunks > 0);

            var phaseIdentity = new GenerationPhaseIdentity(nameof(SkyIslandMapAbsolutePhase));
            var chunkKeys     = new ChunkOverheadKeyCollection(stageBounds);

            var poolOptions = new PoolOptions <SkyIslandMapChunkResources>()
            {
            };

            this.pool = Pool.WithFactory.New(new SkyIslandMapChunkResourcesFactory(chunkConfig), poolOptions);

            var chunkFactory = new SkyIslandMapChunkPoolingFactory(this.pool, chunkPopulator);
            var serializer   = new SkyIslandMapChunkResourcesSerializer(
                SkyIslandMapsSerializer.Get[options?.SerializationEndianness ?? DefaultSerializationEndianness],
                chunkConfig);
            var persister          = new SkyIslandMapChunkPersister(serializer);
            var persistableFactory = ChunkFactory.Persister.Create(chunkFactory, persister);

            this.Phase = new ChunkedBatchingPhase <ChunkOverheadKey, SerializedSkyIslandMapChunk>(
                stageIdentity,
                phaseIdentity,
                chunkKeys,
                persistableFactory,
                chunkStore,
                maxBufferedChunks,
                options);

            this.Completion = this.CompleteAsync();
        }
        public static SkyIslandMapPopulatorConfig.Builder CreatePreconfigured(
            IStageBounds stageBounds, IRasterChunkConfig chunkConfig)
        {
            Contracts.Requires.That(stageBounds != null);
            Contracts.Requires.That(chunkConfig != null);

            double baselineHeightVariation = 50;
            double halfStageHeight         = stageBounds.InChunks.Dimensions.Y * chunkConfig.SideLength / 2.0;
            double baselineMin             = halfStageHeight - baselineHeightVariation;
            double baselineMax             = halfStageHeight + baselineHeightVariation;
            double scale = 10000;

            return(new SkyIslandMapPopulatorConfig.Builder()
            {
                SelectionGradientStartDistancePercent = .6,
                ShapeDistorter = NoiseDistorter.Combine(
                    NoiseDistorter.New().Frequency(20 / scale, 20 / scale).ConvertRange(-1, 1),
                    NoiseDistorter.New().Frequency(40 / scale, 40 / scale).ConvertRange(-.5, .5),
                    NoiseDistorter.New().Frequency(80 / scale, 80 / scale).ConvertRange(-.3, .3)),
                BaselineHeightDistorter =
                    NoiseDistorter.New().Frequency(10 / scale, 10 / scale).ConvertRange(baselineMin, baselineMax),
                MountainDistorter =
                    NoiseDistorter.New().Frequency(10 / scale, 10 / scale).ConvertRange(-6, 5).Clamp(1, 4),
                TopHeightDistorter = NoiseDistorter.Combine(
                    NoiseDistorter.New().Frequency(20 / scale, 20 / scale).ConvertRange(0, 10),
                    NoiseDistorter.New().Frequency(40 / scale, 40 / scale).ConvertRange(0, 40),
                    NoiseDistorter.New().Frequency(80 / scale, 80 / scale).ConvertRange(0, 20),
                    NoiseDistorter.New().Frequency(160 / scale, 160 / scale).ConvertRange(0, 10)),
                TopHeightNearEdgeDistorter = NoiseDistorter.Combine(
                    NoiseDistorter.New().Frequency(20 / scale, 20 / scale).ConvertRange(0, 7.5),
                    NoiseDistorter.New().Frequency(40 / scale, 40 / scale).ConvertRange(0, 30),
                    NoiseDistorter.New().Frequency(80 / scale, 80 / scale).ConvertRange(0, 15),
                    NoiseDistorter.New().Frequency(160 / scale, 160 / scale).ConvertRange(0, 7.5)),
                BottomHeightDistorter =
                    NoiseDistorter.New().Frequency(200 / scale, 200 / scale).ConvertRange(-200, -100),
                BottomHeightNearEdgeDistorter =
                    NoiseDistorter.New().Frequency(800 / scale, 800 / scale).ConvertRange(-100, -50),
            });
        }
Example #11
0
        public SkyIslandMapChunkPopulator(
            SkyIslandMapPopulatorConfig mapsConfig,
            IStageBounds stageBounds,
            IFactory <int, INoise2D> multiNoise)
        {
            Contracts.Requires.That(mapsConfig != null);
            Contracts.Requires.That(stageBounds != null);
            Contracts.Requires.That(multiNoise != null);

            this.mapsConfig = mapsConfig;

            // using the lesser of the 2 dimensions ensures the radial gradient doesn't clip early out of bounds
            var stageOverheadDimensions = stageBounds.InOverheadChunks.Dimensions;

            this.halfStageLength = Math.Min(stageOverheadDimensions.X, stageOverheadDimensions.Y) / 2.0;
            this.radiusStart     = this.halfStageLength * this.mapsConfig.SelectionGradientStartDistancePercent;

            this.shapeNoise    = multiNoise.Create(SkyIslandNoiseSubSeed.ShapeMap);
            this.baselineNoise = multiNoise.Create(SkyIslandNoiseSubSeed.BaselineMap);
            this.mountainNoise = multiNoise.Create(SkyIslandNoiseSubSeed.MountainMap);
            this.topNoise      = multiNoise.Create(SkyIslandNoiseSubSeed.TopMap);
            this.bottomNoise   = multiNoise.Create(SkyIslandNoiseSubSeed.BottomMap);
        }
    public static bool Contains(this IStageBounds bounds, ChunkOverheadKey key)
    {
        Contracts.Requires.That(bounds != null);

        return(key.Index.IsIn(bounds.InOverheadChunks.LowerBounds, bounds.InOverheadChunks.UpperBounds));
    }
 public ChunkKeyCollection(IStageBounds bounds, OscillationOrder3D order)
     : this(bounds, (start, dimensions) => Index.OscillateRange(start, dimensions, order))
 {
 }
 public ChunkKeyCollection(IStageBounds bounds)
     : this(bounds, GetOscillationOrder(bounds))
 {
 }
Example #15
0
 public static IAsyncFactory <ChunkKey, TChunk> Create <TChunk>(
     IStageBounds bounds,
     IAsyncFactory <ChunkKey, TChunk> interiorFactory,
     IFactory <ChunkKey, TChunk> exteriorFactory) =>
 new StageBoundaryChunkFactory <TChunk>(bounds, interiorFactory, exteriorFactory);