public SkyIslandMapChunkStorePopulator(
IChunkStore <ChunkOverheadKey, SerializedSkyIslandMapChunk> store,
IChunkPersister <ISkyIslandMapChunk, SerializedSkyIslandMapChunk> persister,
IChunkPopulator <ISkyIslandMapChunk> fallback)
{
Contracts.Requires.That(store != null);
Contracts.Requires.That(persister != null);
Contracts.Requires.That(fallback != null);
this.store = store;
this.persister = persister;
this.fallback = fallback;
}
public VoxelGridChunkStorePopulator(
IChunkStore <ChunkKey, SerializedVoxelGridChunk> store,
IChunkPersister <IVoxelGridChunk, SerializedVoxelGridChunk> persister,
IChunkPopulator <IVoxelGridChunk> fallback)
{
Contracts.Requires.That(store != null);
Contracts.Requires.That(persister != null);
Contracts.Requires.That(fallback != null);
this.store = store;
this.persister = persister;
this.fallback = fallback;
}
public ChunkedBatchingPhase(
IStageIdentity stageIdentity,
IGenerationPhaseIdentity phaseIdentity,
IReadOnlyLargeCollection <TKey> chunkKeys,
IAsyncFactory <TKey, TPersistable> chunkFactory,
IChunkStore <TKey, TPersistable> chunkStore,
int maxBatchedChunks,
BatchGenerationOptions options = null)
: base(options?.CancellationToken ?? DefaultCancellationToken)
{
Contracts.Requires.That(stageIdentity != null);
Contracts.Requires.That(phaseIdentity != null);
Contracts.Requires.That(chunkKeys != null);
Contracts.Requires.That(chunkFactory != null);
Contracts.Requires.That(chunkStore != null);
Contracts.Requires.That(maxBatchedChunks > 0);
this.StageIdentity = stageIdentity;
this.PhaseIdentity = phaseIdentity;
this.chunkKeys = chunkKeys;
this.chunkFactory = chunkFactory;
this.chunkStore = chunkStore;
this.Progress = this.progress.AsObservable();
var dataflowOptions = new ExecutionDataflowBlockOptions()
{
MaxDegreeOfParallelism = options?.MaxDegreeOfParallelism ?? DefaultMaxDegreeOfParallelism,
BoundedCapacity = maxBatchedChunks,
CancellationToken = this.CancellationToken,
};
this.generateChunks = new TransformBlock <TKey, TPersistable>(
chunkIndex => this.chunkFactory.CreateAsync(chunkIndex), dataflowOptions);
this.saveChunks = BatchActionBlock.Create <TPersistable>(
this.SaveChunks,
maxBatchedChunks,
options?.Batching ?? DefaultBatching,
dataflowOptions);
var linkOptions = new DataflowLinkOptions()
{
PropagateCompletion = true
};
this.generateChunks.LinkTo(this.saveChunks, linkOptions);
this.chunksCompleted = new AsyncLongCountdownEvent(this.ProgressTotalCount);
}
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 Pv2ServerDeviceBase(IMavlinkV2Connection connection, IConfiguration cfgSvc,
IEnumerable <Pv2ParamType> paramList, Pv2DeviceClass @class, IEnumerable <IWorkModeFactory> workModes,
IChunkStore rttStore,
IEnumerable <Pv2RttRecordDesc> rttRecords,
IEnumerable <Pv2RttFieldDesc> rttFields, string configSuffix = "PV2")
{
var systemId = (byte)Pv2DeviceParams.SystemId.ReadFromConfigValue(cfgSvc, configSuffix);
var componentId = (byte)Pv2DeviceParams.ComponentId.ReadFromConfigValue(cfgSvc, configSuffix);
var networkId = (byte)Pv2DeviceParams.NetworkId.ReadFromConfigValue(cfgSvc, configSuffix);
Seq = new PacketSequenceCalculator();
var mavlinkServer = new MavlinkServerBase(connection, new MavlinkServerIdentity
{
ComponentId = componentId,
SystemId = systemId
}, Seq).DisposeItWith(Disposable);
_payloadServer = new PayloadV2Server(mavlinkServer, networkId).DisposeItWith(Disposable);
var defaultParamsList =
Pv2DeviceParams.Params.Concat(paramList)
.Concat(Pv2BaseInterface.Params)
.Concat(Pv2PowerInterface.Params)
.Concat(Pv2RttInterface.Params)
.Concat(Pv2MissionInterface.Params);
_params = new Pv2ServerParamsInterface(_payloadServer, cfgSvc, defaultParamsList, configSuffix)
.DisposeItWith(Disposable);
_base = new Pv2ServerBaseInterface(_payloadServer, @class, workModes).DisposeItWith(Disposable);
_power = new Pv2ServerPowerInterface(_payloadServer, _params).DisposeItWith(Disposable);
_rtt = new Pv2ServerRttInterface(_payloadServer, _base, _params, rttStore, rttRecords, rttFields)
.DisposeItWith(Disposable);
_mission = new Pv2ServerMissionInterface(_payloadServer, _rtt, _base).DisposeItWith(Disposable);
_base.OnLogMessage.Merge(_params.OnLogMessage).Merge(_power.OnLogMessage).Merge(_mission.OnLogMessage)
.Subscribe(_ => Server.Server.StatusText.Log(_)).DisposeItWith(Disposable);
}
public ChunkConsumer(IChunkStore store)
{
_store = store;
}
