GEEKING

App/include/voxel/Region.iterator.inl

@@ -0,0 +1,194 @@
+#pragma once
+
+//
+// Implementation file for Region.iterator
+
+namespace RBX { namespace Voxel {
+
+namespace VoxelIteratorConstants {
+	const Vector3int16 kFaceDirectionToLocationOffset[6] =
+	{
+		Vector3int16( 1, 0, 0),
+		Vector3int16( 0, 0, 1),
+		Vector3int16(-1, 0, 0),
+		Vector3int16( 0, 0,-1),
+		Vector3int16( 0, 1, 0),
+		Vector3int16( 0,-1, 0),
+	};
+}
+
+template<class InternalStorageType>
+Region<InternalStorageType>::iterator::iterator(
+		const Region<InternalStorageType>& owningRegion) :
+	owningRegion(owningRegion),
+	rangeSize((owningRegion.maxCoords - owningRegion.minCoords) + Vector3int16::one()),
+	xCounter(0), zCounter(0), reachedEnd(false) {
+
+	// read min and max coord from owning region to simplify constructor logic
+	Vector3int16 minCoord = owningRegion.minCoords;
+	Vector3int16 maxCoord = owningRegion.maxCoords;
+
+	if (!owningRegion.isGuaranteedAllEmpty()) {
+		// For speed, this implementation keeps a pointer to the current voxel.
+		// In order to implement operator++, we want to keep a "carriage return"
+		// pointer offset, for when the pointer needs to go from the end of
+		// an x line to the beginning of the x line in the next z line, and
+		// another offset for when the pointer needs to go from the end of
+		// an x-z plane to the beginning of the plane in the next y level.
+
+		// The "carriage return" offset for the end of an x line should be
+		// zero in the degenerate case where the z dimension is 1. 
+
+		// skip at end of x line: (minX,minY,minZ+1) - (maxX,minY,minZ)
+		pointerSkipAtEndOfXLine = 0;
+		if (rangeSize.z > 1) {
+			pointerSkipAtEndOfXLine = 
+				owningRegion.internalStorage->voxelCoordToArrayIndex(
+					Vector3int16(minCoord.x, minCoord.y, minCoord.z + 1)) -
+				owningRegion.internalStorage->voxelCoordToArrayIndex(
+					Vector3int16(maxCoord.x, minCoord.y, minCoord.z));
+		}
+
+		// skip at end of x-z plane: (minX,minY+1,minZ) - (maxX,minY,maxZ)
+		pointerSkipAtEndOfZLine = 0;
+		if (rangeSize.y > 1) {
+			pointerSkipAtEndOfZLine = 
+				owningRegion.internalStorage->voxelCoordToArrayIndex(
+					Vector3int16(minCoord.x, minCoord.y + 1, minCoord.z)) -
+				owningRegion.internalStorage->voxelCoordToArrayIndex(
+					Vector3int16(maxCoord.x, minCoord.y, maxCoord.z));
+		}
+
+		currentLocation = minCoord;
+		currentIndex = owningRegion.internalStorage->voxelCoordToArrayIndex(currentLocation);
+		currentCell = &owningRegion.internalStorage->getConstData()[currentIndex];
+		reachedEnd = currentLocation.y > maxCoord.y;
+	} else {
+		reachedEnd = true;
+	}
+}
+
+template<class InternalStorageType>
+const Vector3int16& Region<InternalStorageType>::iterator::getCurrentLocation() const {
+	return currentLocation;
+}
+
+template<class InternalStorageType>
+const Cell& Region<InternalStorageType>::iterator::getCellAtCurrentLocation() const {
+	return *currentCell;
+}
+
+template<class InternalStorageType>
+bool Region<InternalStorageType>::iterator::hasWaterAtCurrentLocation() const {
+	return owningRegion.hasWaterAtSkipAllEmptyCheck(*currentCell, currentLocation);
+}
+
+template<class InternalStorageType>
+CellMaterial Region<InternalStorageType>::iterator::getMaterialAtCurrentLocation() const {
+	return (CellMaterial)readMaterial(
+		&owningRegion.internalStorage->getConstMaterial()[0], currentIndex, *currentCell);
+}
+
+template<class InternalStorageType>
+const Cell& Region<InternalStorageType>::iterator::getNeighborCell(
+		FaceDirection direction) const {
+	RBXASSERT_SLOW(owningRegion.contains(currentLocation + 
+		kFaceDirectionToLocationOffset[direction]));
+	return currentCell[
+		InternalStorageType::kFaceDirectionToPointerOffset[direction]];
+}
+
+template<class InternalStorageType>
+const Cell& Region<InternalStorageType>::iterator::getNeighborCell(
+	FaceDirection direction1, FaceDirection direction2) const {
+		RBXASSERT_SLOW(owningRegion.contains(currentLocation + 
+			kFaceDirectionToLocationOffset[direction1] + kFaceDirectionToLocationOffset[direction2]));
+		return currentCell[
+			InternalStorageType::kFaceDirectionToPointerOffset[direction1] + InternalStorageType::kFaceDirectionToPointerOffset[direction2]];
+}
+
+template<class InternalStorageType>
+CellMaterial Region<InternalStorageType>::iterator::getNeighborMaterial(
+		FaceDirection direction) const {
+	RBXASSERT_SLOW(owningRegion.contains(currentLocation + 
+		kFaceDirectionToLocationOffset[direction]));
+	const int offset(InternalStorageType::kFaceDirectionToPointerOffset[direction]);
+	return (CellMaterial)readMaterial(&owningRegion.internalStorage->getConstMaterial()[0],
+		currentIndex + offset, currentCell[offset]);
+}
+
+template<class InternalStorageType>
+CellMaterial Region<InternalStorageType>::iterator::getNeighborMaterial(
+	FaceDirection direction1, FaceDirection direction2) const {
+		RBXASSERT_SLOW(owningRegion.contains(currentLocation + 
+			kFaceDirectionToLocationOffset[direction1] + kFaceDirectionToLocationOffset[direction2));
+		const int offset(InternalStorageType::kFaceDirectionToPointerOffset[direction1] + InternalStorageType::kFaceDirectionToPointerOffset[direction2]);
+		return (CellMaterial)readMaterial(&owningRegion.internalStorage->getConstMaterial()[0],
+			currentIndex + offset, currentCell[offset]);
+}
+
+
+template<class InternalStorageType>
+const Cell& Region<InternalStorageType>::iterator::getArbitraryNeighborCell(
+		const Vector3int16& neighborOffsets) const {
+	RBXASSERT_SLOW(owningRegion.contains(currentLocation + neighborOffsets));
+	return currentCell[
+		InternalStorageType::voxelCoordOffsetToIndexOffset(neighborOffsets)];
+}
+
+template<class InternalStorageType>
+bool Region<InternalStorageType>::iterator::hasWaterAtNeighbor(
+		const FaceDirection& direction) const {
+	RBXASSERT_SLOW(owningRegion.contains(currentLocation + 
+		kFaceDirectionToLocationOffset[direction]));
+	return owningRegion.hasWaterAtSkipAllEmptyCheck(
+		currentCell[InternalStorageType::kFaceDirectionToPointerOffset[direction]],
+		currentLocation +
+			VoxelIteratorConstants::kFaceDirectionToLocationOffset[direction]);
+}
+
+template<class InternalStorageType>
+typename Region<InternalStorageType>::iterator&
+Region<InternalStorageType>::iterator::operator++() {
+	++xCounter;
+	if (xCounter == rangeSize.x) {
+		xCounter = 0;
+		++zCounter;
+		if (zCounter == rangeSize.z) {
+			zCounter = 0;
+			currentLocation.x = owningRegion.minCoords.x;
+			++currentLocation.y;
+			currentLocation.z = owningRegion.minCoords.z;
+			currentIndex += pointerSkipAtEndOfZLine;
+			currentCell += pointerSkipAtEndOfZLine;
+		} else {
+			currentLocation.x = owningRegion.minCoords.x;
+			++currentLocation.z;
+			currentIndex += pointerSkipAtEndOfXLine;
+			currentCell += pointerSkipAtEndOfXLine;
+		}
+	} else {
+		++currentIndex;
+		++currentCell;
+		++currentLocation.x;
+	}
+
+	reachedEnd = currentLocation.y > owningRegion.maxCoords.y;
+	return *this;
+}
+
+template<class InternalStorageType>
+bool Region<InternalStorageType>::iterator::operator==(const iterator& other) {
+	if (reachedEnd || other.reachedEnd) {
+		return reachedEnd == other.reachedEnd;
+	}
+	return owningRegion == other.owningRegion &&
+		currentLocation == other.currentLocation;
+}
+
+template<class InternalStorageType>
+bool Region<InternalStorageType>::iterator::operator!=(const iterator& other) {
+	return !(this->operator==(other));
+}
+
+} }