/// <summary> /// Initializes a new instance of the <see cref="OffsetArray2D{TValue}"/> class. /// </summary> /// <param name="array">The array to wrap.</param> /// <param name="offset">The offset of the zero origin.</param> public OffsetArray2D(IBoundedIndexable <Index2D, T> array, Index2D offset) { Contracts.Requires.That(array != null); this.array = array; this.offset = offset; }
public static IReadOnlySet <Index3D> CreateCenteredSpiral(IBoundedIndexable <Index3D, bool> shape) { Contracts.Requires.That(shape != null); shape = OffsetArray.CenterOnZero(shape, RoundUp); return(Create(shape, SpiralColumns(shape.LowerBounds, shape.UpperBounds))); }
/// <summary> /// Initializes a new instance of the <see cref="Composite3By3By3Array3D{TValue}"/> class. /// </summary> /// <param name="arrays">The indexable arrays to make the composite indexable out of.</param> public Composite3By3By3Array3D(IBoundedIndexable <Index3D, T>[,,] arrays) { Contracts.Requires.That(arrays != null); Contracts.Requires.That(arrays.GetLength(0) == 3); Contracts.Requires.That(arrays.GetLength(1) == 3); Contracts.Requires.That(arrays.GetLength(2) == 3); Contracts.Requires.That(CompositeArray.AreAllSameDimensionsAndZeroBounded(arrays)); this.arrays = arrays; IBoundedIndexable <Index3D, T> array = this.arrays[1, 1, 1]; this.singleArrayLengthX = array.GetLength(Axis3D.X); this.singleArrayLengthY = array.GetLength(Axis3D.Y); this.singleArrayLengthZ = array.GetLength(Axis3D.Z); Index3D indexingOffset = new Index3D(this.singleArrayLengthX, this.singleArrayLengthY, this.singleArrayLengthZ); this.dimensions = array.Dimensions + (indexingOffset * 2); this.lowerBounds = array.LowerBounds - indexingOffset; this.upperBounds = array.UpperBounds + indexingOffset; this.lowerLimitX = array.LowerBounds.X; this.lowerLimitY = array.LowerBounds.Y; this.lowerLimitZ = array.LowerBounds.Z; this.upperLimitX = array.UpperBounds.X; this.upperLimitY = array.UpperBounds.Y; this.upperLimitZ = array.UpperBounds.Z; }
/// <summary> /// Initializes a new instance of the <see cref="BoundedIndexableEnumerable{TIndex, TValue}"/> class. /// </summary> /// <param name="bounds">The bounds used to limit the enumeration.</param> /// <param name="enumerable">The enumerable that determines the order in which the indices are enumerated.</param> /// <param name="revisitPolicy">The policy for whether or not to re-yield previously enumerated indices again.</param> public BoundedIndexableEnumerable( IBoundedIndexable <TIndex, TValue> bounds, IEnumerable <TIndex> enumerable, Revisits revisitPolicy = Revisits.Yield) { Contracts.Requires.That(bounds != null); Contracts.Requires.That(enumerable != null); this.bounds = bounds; this.enumerable = enumerable; this.maxCount = this.bounds.LowerBounds.CalculateVolume(this.bounds.UpperBounds); switch (revisitPolicy) { case Revisits.Yield: this.yieldRevisits = true; this.cacheRevisits = false; break; case Revisits.YieldCached: this.yieldRevisits = true; this.cacheRevisits = true; break; case Revisits.DontYield: this.yieldRevisits = false; this.cacheRevisits = false; break; default: throw InvalidEnumArgument.CreateException(nameof(revisitPolicy), revisitPolicy); } }
public ExteriorSkyIslandMapChunkFactory( IRasterChunkConfig <Index2D> config, SkyIslandMaps outOfBoundsValue, bool modifyingThrowsException) { Contracts.Requires.That(config != null); this.outOfBoundsChunk = new ConstantArray2D <SkyIslandMaps>( config.Bounds.Dimensions, outOfBoundsValue, modifyingThrowsException); }
/// <summary> /// Creates an <see cref="IBoundedIndexable{Index3D, TValue}" /> by combing the specified instances into a composite indexable. /// </summary> /// <typeparam name="T">The type of the value.</typeparam> /// <param name="arrays">The indexable arrays to combine into a composite.</param> /// <param name="originOffset">The origin offset for indexing into the composite.</param> /// <returns>The composite indexable array.</returns> public static IBoundedIndexable <Index3D, T> Create <T>( IBoundedIndexable <Index3D, T>[,,] arrays, Index3D originOffset) { Contracts.Requires.That(arrays != null); Contracts.Requires.That(AreAllSameDimensionsAndZeroBounded(arrays)); return(new CompositeArray3D <T>(arrays, originOffset)); }
public ExteriorVoxelGridChunkFactory( IRasterChunkConfig <Index3D> config, TerrainVoxel outOfBoundsValue, bool modifyingThrowsException) { Contracts.Requires.That(config != null); this.outOfBoundsChunk = new ConstantArray3D <TerrainVoxel>( config.Bounds.Dimensions, outOfBoundsValue, modifyingThrowsException); }
public SkyIslandMapChunk(ChunkOverheadKey key, IBoundedIndexable <Index2D, SkyIslandMaps> values) { Contracts.Requires.That(values != null); this.Key = key; this.MapsLocalView = values; this.MapsStageView = new OffsetArray2D <SkyIslandMaps>(values, values.Dimensions * key.Index); }
public VoxelGridChunk(ChunkKey key, IBoundedIndexable <Index3D, TerrainVoxel> voxels) { Contracts.Requires.That(voxels != null); this.Key = key; this.VoxelsLocalView = voxels; this.VoxelsStageView = new OffsetArray3D <TerrainVoxel>(voxels, voxels.Dimensions * key.Index); }
/// <summary> /// Creates an <see cref="IBoundedIndexable{Index3D, TValue}"/> by combing the specified instances into a 3 by 1 by 3 indexable. /// </summary> /// <typeparam name="T">The type of the value.</typeparam> /// <param name="arrays">The indexable arrays to combine into a composite.</param> /// <returns>The composite indexable array.</returns> /// <remarks> /// The resulting composite is 3 times wider in both horizontal directions than it is tall. The (0, 0, 0,) origin of the /// composite is automatically aligned to the (0, 0, 0) origin of the center most indexable in the composite. /// </remarks> public static IBoundedIndexable <Index3D, T> Create <T>(IBoundedIndexable <Index3D, T>[,] arrays) { Contracts.Requires.That(arrays != null); Contracts.Requires.That(arrays.GetLength(0) == 3); Contracts.Requires.That(arrays.GetLength(1) == 3); Contracts.Requires.That(AreAllSameDimensionsAndZeroBounded(arrays)); return(new Composite3By3Array3D <T>(arrays)); }
public static IBoundedIndexable <Index3D, T> CenterOnZero <T>( IBoundedIndexable <Index3D, T> array, bool roundUp = false) { Contracts.Requires.That(array != null); var offset = -array.GetMiddleIndex(roundUp); return(offset != Index3D.Zero ? new OffsetArray3D <T>(array, offset) : array); }
public static IVisiblyDisposable CreateCenteredSpiral <TInterest>( IInterestMap <Index3D, TInterest> map, TInterest interest, IObservable <Index3D> origin, IBoundedIndexable <Index3D, bool> shape) { Contracts.Requires.That(map != null); Contracts.Requires.That(origin != null); Contracts.Requires.That(shape != null); return(new AreaOfInterest3D <TInterest>( map, interest, origin, Keys.CreateCenteredSpiral(shape))); }
/// <summary> /// Initializes a new instance of the <see cref="CompositeArray3D{TValue}" /> class. /// </summary> /// <param name="arrays">The indexable arrays to make the composite indexable out of.</param> /// <param name="originOffset">The origin offset for indexing into the composite.</param> public CompositeArray3D(IBoundedIndexable <Index3D, T>[,,] arrays, Index3D originOffset) { Contracts.Requires.That(arrays != null); Contracts.Requires.That(CompositeArray.AreAllSameDimensionsAndZeroBounded(arrays)); this.arrays = arrays; IBoundedIndexable <Index3D, T> singleArray = this.arrays[0, 0, 0]; this.singleArrayLengthX = singleArray.GetLength(Axis3D.X); this.singleArrayLengthY = singleArray.GetLength(Axis3D.Y); this.singleArrayLengthZ = singleArray.GetLength(Axis3D.Z); this.originOffset = originOffset; this.dimensions = singleArray.Dimensions * this.arrays.GetDimensions(); this.lowerBounds = -this.originOffset; this.upperBounds = this.lowerBounds + this.dimensions; }
public static IReadOnlySet <TIndex> Create <TIndex>( IBoundedIndexable <TIndex, bool> shape, IEnumerable <TIndex> ordering = null, IEqualityComparer <TIndex> comparer = null) where TIndex : struct, IIndex { Contracts.Requires.That(shape != null); if (ordering != null) { ordering = ordering.Where(index => { bool isInsideShape; return(shape.TryGetValue(index, out isInsideShape) && isInsideShape); }); } else { ordering = shape.Where(pair => pair.Value).Select(pair => pair.Key); } return(ReadOnlySet.CreateOrdered(ordering, comparer)); }
/// <inheritdoc /> protected override Index2D GetLowerBounds(IBoundedIndexable <Index2D, T> value) => value.LowerBounds;
public VoxelGridChunkResources(IBoundedIndexable <Index3D, TerrainVoxel> voxels) { Contracts.Requires.That(voxels != null); this.Voxels = voxels; }
/// <inheritdoc /> protected override Index2D GetDimensions(IBoundedIndexable <Index2D, T> value) => value.Dimensions;
public SkyIslandMapChunkResources(IBoundedIndexable <Index2D, SkyIslandMaps> maps) { Contracts.Requires.That(maps != null); this.Maps = maps; }