More work on removing obscure constants.

include/Block.inl

@@ -97,22 +97,4 @@ namespace PolyVox
 	{
 		return m_uSideLength * m_uSideLength * m_uSideLength;
 	}
-
-	/*void Block::fillWithValue(const VoxelType value)
-	{
-		memset(mData,value,POLYVOX_NO_OF_VOXELS_IN_BLOCK);
-	}*/
-
-	/*bool Block::isHomogeneous(void)
-	{
-		VoxelType uFirstVoxel = mData[0];
-		for(uint32_t ct = 1; ct < POLYVOX_NO_OF_VOXELS_IN_BLOCK; ++ct)
-		{
-			if(mData[ct] != uFirstVoxel)
-			{
-				return false;
-			}
-		}
-		return true;
-	}*/
 }

include/Constants.h

@@ -6,15 +6,15 @@
 namespace PolyVox
 {
 	//FIXME - i think we can define mod using a bitmask which flattens the upper bits. Should define that here.
-	const boost::uint32_t POLYVOX_BLOCK_SIDE_LENGTH_POWER = 5;
+	//const boost::uint32_t POLYVOX_BLOCK_SIDE_LENGTH_POWER = 5;
-	const boost::uint32_t POLYVOX_BLOCK_SIDE_LENGTH = (0x0001 << POLYVOX_BLOCK_SIDE_LENGTH_POWER);
+	//const boost::uint32_t POLYVOX_BLOCK_SIDE_LENGTH = (0x0001 << POLYVOX_BLOCK_SIDE_LENGTH_POWER);
-	const boost::uint32_t POLYVOX_NO_OF_VOXELS_IN_BLOCK = (POLYVOX_BLOCK_SIDE_LENGTH * POLYVOX_BLOCK_SIDE_LENGTH * POLYVOX_BLOCK_SIDE_LENGTH);
+	//const boost::uint32_t POLYVOX_NO_OF_VOXELS_IN_BLOCK = (POLYVOX_BLOCK_SIDE_LENGTH * POLYVOX_BLOCK_SIDE_LENGTH * POLYVOX_BLOCK_SIDE_LENGTH);
 
 	const boost::uint32_t POLYVOX_VOLUME_SIDE_LENGTH_POWER = 8;
 	const boost::uint32_t POLYVOX_VOLUME_SIDE_LENGTH = (0x0001 << POLYVOX_VOLUME_SIDE_LENGTH_POWER);
-	const boost::uint32_t POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS = (POLYVOX_VOLUME_SIDE_LENGTH >> POLYVOX_BLOCK_SIDE_LENGTH_POWER);
+	//const boost::uint32_t POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS = (POLYVOX_VOLUME_SIDE_LENGTH >> POLYVOX_BLOCK_SIDE_LENGTH_POWER);
-	const boost::uint32_t POLYVOX_NO_OF_BLOCKS_IN_VOLUME = (POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS);
+	//const boost::uint32_t POLYVOX_NO_OF_BLOCKS_IN_VOLUME = (POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS);
-	const boost::uint32_t POLYVOX_NO_OF_VOXELS_IN_VOLUME = (POLYVOX_VOLUME_SIDE_LENGTH * POLYVOX_VOLUME_SIDE_LENGTH * POLYVOX_VOLUME_SIDE_LENGTH);
+	//const boost::uint32_t POLYVOX_NO_OF_VOXELS_IN_VOLUME = (POLYVOX_VOLUME_SIDE_LENGTH * POLYVOX_VOLUME_SIDE_LENGTH * POLYVOX_VOLUME_SIDE_LENGTH);
 
 	const boost::uint32_t POLYVOX_REGION_SIDE_LENGTH_POWER = 4;
 	const boost::uint32_t POLYVOX_REGION_SIDE_LENGTH = (0x0001 << POLYVOX_REGION_SIDE_LENGTH_POWER);

include/Volume.h

@@ -36,7 +36,7 @@ namespace PolyVox
 
 		//Volume interface
 	public:		
-		Volume(boost::uint8_t uSideLengthPower, boost::uint8_t uBlockSideLengthPower);
+		Volume(boost::uint8_t uSideLengthPower, boost::uint8_t uBlockSideLengthPower = 5);
 		~Volume();
 
 	private:
@@ -47,15 +47,25 @@ namespace PolyVox
 		bool containsPoint(Vector3DFloat pos, float boundary);
 		bool containsPoint(Vector3DInt32 pos, boost::uint16_t boundary);
 
+		boost::uint16_t getSideLength(void);
+		boost::uint16_t getSideLengthInBlocks(void);
+
+		boost::uint16_t getBlockSideLength(void);
+		boost::uint16_t getBlockSideLengthPower(void);
+
 		void tidy(void);
 
 	private:
 		Block<VoxelType>* getBlock(boost::uint16_t index);
 		Block<VoxelType>** mBlocks;
 		boost::uint32_t m_uNoOfBlocksInVolume;
+		boost::uint16_t m_uSideLengthInBlocks;
 
 		boost::uint16_t m_uSideLengthPower;
 		boost::uint16_t m_uSideLength;
+
+		boost::uint16_t m_uBlockSideLengthPower;
+		boost::uint16_t m_uBlockSideLength;
 	};
 
 	//Some handy typedefs

include/Volume.inl

@@ -29,6 +29,7 @@ namespace PolyVox
 
 	template <typename VoxelType>
 	Volume<VoxelType>::Volume(boost::uint8_t uSideLengthPower, boost::uint8_t uBlockSideLengthPower)
+		:mBlocks(0)
 	{
 		//Check the volume size is sensible. This corresponds to a side length of 65536 voxels
 		assert(uSideLengthPower <= 16);
@@ -38,15 +39,21 @@ namespace PolyVox
 		m_uSideLength = 0x01 << uSideLengthPower;
 
 		//Compute the block side length
-		boost::uint16_t uBlockSideLength = 0x01 << uBlockSideLengthPower;
+		m_uBlockSideLengthPower = uBlockSideLengthPower;
+		m_uBlockSideLength = 0x01 << uBlockSideLengthPower;
 
 		//Compute the side length in blocks
-		boost::uint16_t uSideLengthInBlocks = m_uSideLength / uBlockSideLength;
+		m_uSideLengthInBlocks = m_uSideLength / m_uBlockSideLength;
 
 		//Compute number of blocks in the volume
-		m_uNoOfBlocksInVolume = uSideLengthInBlocks * uSideLengthInBlocks * uSideLengthInBlocks;
+		m_uNoOfBlocksInVolume = m_uSideLengthInBlocks * m_uSideLengthInBlocks * m_uSideLengthInBlocks;
 
 		mBlocks = new Block<VoxelType>*[m_uNoOfBlocksInVolume];
+		for(boost::uint32_t i = 0; i < m_uNoOfBlocksInVolume; ++i)
+		{
+			mBlocks[i] = 0;
+		}
+
 		for(boost::uint32_t i = 0; i < m_uNoOfBlocksInVolume; ++i)
 		{
 			mBlocks[i] = new Block<VoxelType>(uBlockSideLengthPower);
@@ -151,4 +158,28 @@ namespace PolyVox
 			}
 		}*/
 	}
+
+	template <typename VoxelType>
+	boost::uint16_t Volume<VoxelType>::getSideLength(void)
+	{
+		return m_uSideLength;
+	}
+
+	template <typename VoxelType>
+	boost::uint16_t Volume<VoxelType>::getSideLengthInBlocks(void)
+	{
+		return m_uSideLengthInBlocks;
+	}
+
+	template <typename VoxelType>
+	boost::uint16_t Volume<VoxelType>::getBlockSideLength(void)
+	{
+		return m_uBlockSideLength;
+	}
+
+	template <typename VoxelType>
+	boost::uint16_t Volume<VoxelType>::getBlockSideLengthPower(void)
+	{
+		return m_uBlockSideLengthPower;
+	}
 }

include/VolumeIterator.inl

@@ -30,15 +30,15 @@ namespace PolyVox
 		,mXRegionFirst(0)
 		,mYRegionFirst(0)
 		,mZRegionFirst(0)
-		,mXRegionLast(POLYVOX_VOLUME_SIDE_LENGTH-1)
+		,mXRegionLast(volume.getSideLength()-1)
-		,mYRegionLast(POLYVOX_VOLUME_SIDE_LENGTH-1)
+		,mYRegionLast(volume.getSideLength()-1)
-		,mZRegionLast(POLYVOX_VOLUME_SIDE_LENGTH-1)
+		,mZRegionLast(volume.getSideLength()-1)
 		,mXRegionFirstBlock(0)
 		,mYRegionFirstBlock(0)
 		,mZRegionFirstBlock(0)
-		,mXRegionLastBlock(POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS-1)
+		,mXRegionLastBlock(volume.getSideLengthInBlocks()-1)
-		,mYRegionLastBlock(POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS-1)
+		,mYRegionLastBlock(volume.getSideLengthInBlocks()-1)
-		,mZRegionLastBlock(POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS-1)
+		,mZRegionLastBlock(volume.getSideLengthInBlocks()-1)
 		,mXPosInVolume(0)
 		,mYPosInVolume(0)
 		,mZPosInVolume(0)
@@ -87,19 +87,19 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::getVoxelAt(const uint16_t xPosition, const uint16_t yPosition, const uint16_t zPosition) const
 	{
-		const uint16_t blockX = xPosition >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
+		const uint16_t blockX = xPosition >> mVolume.getBlockSideLengthPower();
-		const uint16_t blockY = yPosition >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
+		const uint16_t blockY = yPosition >> mVolume.getBlockSideLengthPower();
-		const uint16_t blockZ = zPosition >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
+		const uint16_t blockZ = zPosition >> mVolume.getBlockSideLengthPower();
 
-		const uint16_t xOffset = xPosition - (blockX << POLYVOX_BLOCK_SIDE_LENGTH_POWER);
+		const uint16_t xOffset = xPosition - (blockX << mVolume.getBlockSideLengthPower());
-		const uint16_t yOffset = yPosition - (blockY << POLYVOX_BLOCK_SIDE_LENGTH_POWER);
+		const uint16_t yOffset = yPosition - (blockY << mVolume.getBlockSideLengthPower());
-		const uint16_t zOffset = zPosition - (blockZ << POLYVOX_BLOCK_SIDE_LENGTH_POWER);
+		const uint16_t zOffset = zPosition - (blockZ << mVolume.getBlockSideLengthPower());
 
 		const Block<VoxelType>* block = mVolume.mBlocks
 			[
 				blockX + 
-				blockY * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS + 
+				blockY * mVolume.getSideLengthInBlocks() + 
-				blockZ * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS
+				blockZ * mVolume.getSideLengthInBlocks() * mVolume.getSideLengthInBlocks()
 			];
 
 		return block->getVoxelAt(xOffset,yOffset,zOffset);
@@ -155,22 +155,22 @@ namespace PolyVox
 		mYPosInVolume = yPos;
 		mZPosInVolume = zPos;
 
-		mXBlock = mXPosInVolume >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
+		mXBlock = mXPosInVolume >> mVolume.getBlockSideLengthPower();
-		mYBlock = mYPosInVolume >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
+		mYBlock = mYPosInVolume >> mVolume.getBlockSideLengthPower();
-		mZBlock = mZPosInVolume >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
+		mZBlock = mZPosInVolume >> mVolume.getBlockSideLengthPower();
 
-		mXPosInBlock = mXPosInVolume - (mXBlock << POLYVOX_BLOCK_SIDE_LENGTH_POWER);
+		mXPosInBlock = mXPosInVolume - (mXBlock << mVolume.getBlockSideLengthPower());
-		mYPosInBlock = mYPosInVolume - (mYBlock << POLYVOX_BLOCK_SIDE_LENGTH_POWER);
+		mYPosInBlock = mYPosInVolume - (mYBlock << mVolume.getBlockSideLengthPower());
-		mZPosInBlock = mZPosInVolume - (mZBlock << POLYVOX_BLOCK_SIDE_LENGTH_POWER);
+		mZPosInBlock = mZPosInVolume - (mZBlock << mVolume.getBlockSideLengthPower());
 
 		mBlockIndexInVolume = mXBlock + 
-			mYBlock * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS + 
+			mYBlock * mVolume.getSideLengthInBlocks() + 
-			mZBlock * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS;
+			mZBlock * mVolume.getSideLengthInBlocks() * mVolume.getSideLengthInBlocks();
 		Block<VoxelType>* currentBlock = mVolume.mBlocks[mBlockIndexInVolume];
 
 		mVoxelIndexInBlock = mXPosInBlock + 
-			mYPosInBlock * POLYVOX_BLOCK_SIDE_LENGTH + 
+			mYPosInBlock * mVolume.getBlockSideLength() + 
-			mZPosInBlock * POLYVOX_BLOCK_SIDE_LENGTH * POLYVOX_BLOCK_SIDE_LENGTH;
+			mZPosInBlock * mVolume.getBlockSideLength() * mVolume.getBlockSideLength();
 
 		mCurrentVoxel = currentBlock->m_tData + mVoxelIndexInBlock;
 	}
@@ -194,13 +194,13 @@ namespace PolyVox
 		mYRegionLast = (std::min)(POLYVOX_VOLUME_SIDE_LENGTH-1, yLast);
 		mZRegionLast = (std::min)(POLYVOX_VOLUME_SIDE_LENGTH-1, zLast);*/
 
-		mXRegionFirstBlock = mXRegionFirst >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
+		mXRegionFirstBlock = mXRegionFirst >> mVolume.getBlockSideLengthPower();
-		mYRegionFirstBlock = mYRegionFirst >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
+		mYRegionFirstBlock = mYRegionFirst >> mVolume.getBlockSideLengthPower();
-		mZRegionFirstBlock = mZRegionFirst >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
+		mZRegionFirstBlock = mZRegionFirst >> mVolume.getBlockSideLengthPower();
 
-		mXRegionLastBlock = mXRegionLast >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
+		mXRegionLastBlock = mXRegionLast >> mVolume.getBlockSideLengthPower();
-		mYRegionLastBlock = mYRegionLast >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
+		mYRegionLastBlock = mYRegionLast >> mVolume.getBlockSideLengthPower();
-		mZRegionLastBlock = mZRegionLast >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
+		mZRegionLastBlock = mZRegionLast >> mVolume.getBlockSideLengthPower();
 	}
 
 	template <typename VoxelType>
@@ -209,34 +209,34 @@ namespace PolyVox
 		mXPosInBlock++;
 		mCurrentVoxel++;
 		mXPosInVolume++;
-		if((mXPosInBlock == POLYVOX_BLOCK_SIDE_LENGTH) || (mXPosInVolume > mXRegionLast))
+		if((mXPosInBlock == mVolume.getBlockSideLength()) || (mXPosInVolume > mXRegionLast))
 		{
-			mXPosInVolume = (std::max)(mXRegionFirst,uint16_t(mXBlock * POLYVOX_BLOCK_SIDE_LENGTH));
+			mXPosInVolume = (std::max)(mXRegionFirst,uint16_t(mXBlock * mVolume.getBlockSideLength()));
-			mXPosInBlock = mXPosInVolume - (mXBlock << POLYVOX_BLOCK_SIDE_LENGTH_POWER);
+			mXPosInBlock = mXPosInVolume - (mXBlock << mVolume.getBlockSideLengthPower());
 			mVoxelIndexInBlock = mXPosInBlock + 
-				mYPosInBlock * POLYVOX_BLOCK_SIDE_LENGTH + 
+				mYPosInBlock * mVolume.getBlockSideLength() + 
-				mZPosInBlock * POLYVOX_BLOCK_SIDE_LENGTH * POLYVOX_BLOCK_SIDE_LENGTH;
+				mZPosInBlock * mVolume.getBlockSideLength() * mVolume.getBlockSideLength();
 			Block<VoxelType>* currentBlock = mVolume.mBlocks[mBlockIndexInVolume];
 			mCurrentVoxel = currentBlock->m_tData + mVoxelIndexInBlock;
 
 			mYPosInBlock++;
 			mYPosInVolume++;
-			mCurrentVoxel += POLYVOX_BLOCK_SIDE_LENGTH;
+			mCurrentVoxel += mVolume.getBlockSideLength();
-			if((mYPosInBlock == POLYVOX_BLOCK_SIDE_LENGTH) || (mYPosInVolume > mYRegionLast))
+			if((mYPosInBlock == mVolume.getBlockSideLength()) || (mYPosInVolume > mYRegionLast))
 			{
-				mYPosInVolume = (std::max)(mYRegionFirst,uint16_t(mYBlock * POLYVOX_BLOCK_SIDE_LENGTH));
+				mYPosInVolume = (std::max)(mYRegionFirst,uint16_t(mYBlock * mVolume.getBlockSideLength()));
-				mYPosInBlock = mYPosInVolume - (mYBlock << POLYVOX_BLOCK_SIDE_LENGTH_POWER);
+				mYPosInBlock = mYPosInVolume - (mYBlock << mVolume.getBlockSideLengthPower());
 				mVoxelIndexInBlock = mXPosInBlock + 
-					mYPosInBlock * POLYVOX_BLOCK_SIDE_LENGTH + 
+					mYPosInBlock * mVolume.getBlockSideLength() + 
-					mZPosInBlock * POLYVOX_BLOCK_SIDE_LENGTH * POLYVOX_BLOCK_SIDE_LENGTH;
+					mZPosInBlock * mVolume.getBlockSideLength() * mVolume.getBlockSideLength();
 				Block<VoxelType>* currentBlock = mVolume.mBlocks[mBlockIndexInVolume];
 				mCurrentVoxel = currentBlock->m_tData + mVoxelIndexInBlock;
 
 				mZPosInBlock++;
 				mZPosInVolume++;
-				mCurrentVoxel += POLYVOX_BLOCK_SIDE_LENGTH * POLYVOX_BLOCK_SIDE_LENGTH;
+				mCurrentVoxel += mVolume.getBlockSideLength() * mVolume.getBlockSideLength();
 
-				if((mZPosInBlock == POLYVOX_BLOCK_SIDE_LENGTH) || (mZPosInVolume > mZRegionLast))
+				if((mZPosInBlock == mVolume.getBlockSideLength()) || (mZPosInVolume > mZRegionLast))
 				{
 					//At this point we've left the current block. Find a new one...
 
@@ -246,20 +246,20 @@ namespace PolyVox
 					{
 						mXBlock = mXRegionFirstBlock;
 						mBlockIndexInVolume = mXBlock + 
-							mYBlock * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS + 
+							mYBlock * mVolume.getSideLengthInBlocks() + 
-							mZBlock * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS;
+							mZBlock * mVolume.getSideLengthInBlocks() * mVolume.getSideLengthInBlocks();
 
 						++mYBlock;
-						mBlockIndexInVolume += POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS;
+						mBlockIndexInVolume += mVolume.getSideLengthInBlocks();
 						if(mYBlock > mYRegionLastBlock)
 						{
 							mYBlock = mYRegionFirstBlock;
 							mBlockIndexInVolume = mXBlock + 
-								mYBlock * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS + 
+								mYBlock * mVolume.getSideLengthInBlocks() + 
-								mZBlock * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS;
+								mZBlock * mVolume.getSideLengthInBlocks() * mVolume.getSideLengthInBlocks();
 
 							++mZBlock;
-							mBlockIndexInVolume += POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS * POLYVOX_VOLUME_SIDE_LENGTH_IN_BLOCKS;
+							mBlockIndexInVolume += mVolume.getSideLengthInBlocks() * mVolume.getSideLengthInBlocks();
 							if(mZBlock > mZRegionLastBlock)
 							{
 								mIsValidForRegion = false;
@@ -271,17 +271,17 @@ namespace PolyVox
 					Block<VoxelType>* currentBlock = mVolume.mBlocks[mBlockIndexInVolume];
 					//mCurrentBlock = mVolume->mBlocks[mBlockIndexInVolume];					
 
-					mXPosInVolume = (std::max)(mXRegionFirst,uint16_t(mXBlock * POLYVOX_BLOCK_SIDE_LENGTH));					
+					mXPosInVolume = (std::max)(mXRegionFirst,uint16_t(mXBlock * mVolume.getBlockSideLength()));					
-					mYPosInVolume = (std::max)(mYRegionFirst,uint16_t(mYBlock * POLYVOX_BLOCK_SIDE_LENGTH));					
+					mYPosInVolume = (std::max)(mYRegionFirst,uint16_t(mYBlock * mVolume.getBlockSideLength()));					
-					mZPosInVolume = (std::max)(mZRegionFirst,uint16_t(mZBlock * POLYVOX_BLOCK_SIDE_LENGTH));					
+					mZPosInVolume = (std::max)(mZRegionFirst,uint16_t(mZBlock * mVolume.getBlockSideLength()));					
 
-					mXPosInBlock = mXPosInVolume - (mXBlock << POLYVOX_BLOCK_SIDE_LENGTH_POWER);
+					mXPosInBlock = mXPosInVolume - (mXBlock << mVolume.getBlockSideLengthPower());
-					mYPosInBlock = mYPosInVolume - (mYBlock << POLYVOX_BLOCK_SIDE_LENGTH_POWER);
+					mYPosInBlock = mYPosInVolume - (mYBlock << mVolume.getBlockSideLengthPower());
-					mZPosInBlock = mZPosInVolume - (mZBlock << POLYVOX_BLOCK_SIDE_LENGTH_POWER);
+					mZPosInBlock = mZPosInVolume - (mZBlock << mVolume.getBlockSideLengthPower());
 
 					mVoxelIndexInBlock = mXPosInBlock + 
-						mYPosInBlock * POLYVOX_BLOCK_SIDE_LENGTH + 
+						mYPosInBlock * mVolume.getBlockSideLength() + 
-						mZPosInBlock * POLYVOX_BLOCK_SIDE_LENGTH * POLYVOX_BLOCK_SIDE_LENGTH;
+						mZPosInBlock * mVolume.getBlockSideLength() * mVolume.getBlockSideLength();
 
 					mCurrentVoxel = currentBlock->m_tData + mVoxelIndexInBlock;
 				}
@@ -298,9 +298,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1nx1ny1nz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != 0) && (mYPosInVolume%mVolume.getBlockSideLength() != 0) && (mZPosInVolume%mVolume.getBlockSideLength() != 0))
 		{
-			return *(mCurrentVoxel - 1 - POLYVOX_BLOCK_SIDE_LENGTH - POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel - 1 - mVolume.getBlockSideLength() - mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume-1);
 	}
@@ -308,9 +308,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1nx1ny0pz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != 0) && (mYPosInVolume%mVolume.getBlockSideLength() != 0))
 		{
-			return *(mCurrentVoxel - 1 - POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel - 1 - mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume);
 	}
@@ -318,9 +318,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1nx1ny1pz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != 0) && (mYPosInVolume%mVolume.getBlockSideLength() != 0) && (mZPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1))
 		{
-			return *(mCurrentVoxel - 1 - POLYVOX_BLOCK_SIDE_LENGTH + POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel - 1 - mVolume.getBlockSideLength() + mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume+1);
 	}
@@ -328,9 +328,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1nx0py1nz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != 0) && (mZPosInVolume%mVolume.getBlockSideLength() != 0))
 		{
-			return *(mCurrentVoxel - 1 - POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel - 1 - mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume-1);
 	}
@@ -338,7 +338,7 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1nx0py0pz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != 0))
 		{
 			return *(mCurrentVoxel - 1);
 		}
@@ -348,9 +348,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1nx0py1pz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != 0) && (mZPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1))
 		{
-			return *(mCurrentVoxel - 1 + POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel - 1 + mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume+1);
 	}
@@ -358,9 +358,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1nx1py1nz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != 0) && (mYPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1) && (mZPosInVolume%mVolume.getBlockSideLength() != 0))
 		{
-			return *(mCurrentVoxel - 1 + POLYVOX_BLOCK_SIDE_LENGTH - POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel - 1 + mVolume.getBlockSideLength() - mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume-1,mYPosInVolume+1,mZPosInVolume-1);
 	}
@@ -368,9 +368,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1nx1py0pz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != 0) && (mYPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1))
 		{
-			return *(mCurrentVoxel - 1 + POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel - 1 + mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume-1,mYPosInVolume+1,mZPosInVolume);
 	}
@@ -378,9 +378,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1nx1py1pz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != 0) && (mYPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1) && (mZPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1))
 		{
-			return *(mCurrentVoxel - 1 + POLYVOX_BLOCK_SIDE_LENGTH + POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel - 1 + mVolume.getBlockSideLength() + mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume-1,mYPosInVolume+1,mZPosInVolume+1);
 	}
@@ -390,9 +390,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel0px1ny1nz(void) const
 	{
-		if((mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
+		if((mYPosInVolume%mVolume.getBlockSideLength() != 0) && (mZPosInVolume%mVolume.getBlockSideLength() != 0))
 		{
-			return *(mCurrentVoxel - POLYVOX_BLOCK_SIDE_LENGTH - POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel - mVolume.getBlockSideLength() - mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume-1);
 	}
@@ -400,9 +400,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel0px1ny0pz(void) const
 	{
-		if((mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
+		if((mYPosInVolume%mVolume.getBlockSideLength() != 0))
 		{
-			return *(mCurrentVoxel - POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel - mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume);
 	}
@@ -410,9 +410,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel0px1ny1pz(void) const
 	{
-		if((mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
+		if((mYPosInVolume%mVolume.getBlockSideLength() != 0) && (mZPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1))
 		{
-			return *(mCurrentVoxel - POLYVOX_BLOCK_SIDE_LENGTH + POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel - mVolume.getBlockSideLength() + mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume+1);
 	}
@@ -420,9 +420,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel0px0py1nz(void) const
 	{
-		if((mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
+		if((mZPosInVolume%mVolume.getBlockSideLength() != 0))
 		{
-			return *(mCurrentVoxel - POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel - mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume,mYPosInVolume,mZPosInVolume-1);
 	}
@@ -436,9 +436,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel0px0py1pz(void) const
 	{
-		if((mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
+		if((mZPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1))
 		{
-			return *(mCurrentVoxel + POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel + mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume,mYPosInVolume,mZPosInVolume+1);
 	}
@@ -446,9 +446,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel0px1py1nz(void) const
 	{
-		if((mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
+		if((mYPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1) && (mZPosInVolume%mVolume.getBlockSideLength() != 0))
 		{
-			return *(mCurrentVoxel + POLYVOX_BLOCK_SIDE_LENGTH - POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel + mVolume.getBlockSideLength() - mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume,mYPosInVolume+1,mZPosInVolume-1);
 	}
@@ -456,9 +456,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel0px1py0pz(void) const
 	{
-		if((mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
+		if((mYPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1))
 		{
-			return *(mCurrentVoxel + POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel + mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume,mYPosInVolume+1,mZPosInVolume);
 	}
@@ -466,9 +466,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel0px1py1pz(void) const
 	{
-		if((mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
+		if((mYPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1) && (mZPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1))
 		{
-			return *(mCurrentVoxel + POLYVOX_BLOCK_SIDE_LENGTH + POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel + mVolume.getBlockSideLength() + mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume,mYPosInVolume+1,mZPosInVolume+1);
 	}
@@ -478,9 +478,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1px1ny1nz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1) && (mYPosInVolume%mVolume.getBlockSideLength() != 0) && (mZPosInVolume%mVolume.getBlockSideLength() != 0))
 		{
-			return *(mCurrentVoxel + 1 - POLYVOX_BLOCK_SIDE_LENGTH - POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel + 1 - mVolume.getBlockSideLength() - mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume-1);
 	}
@@ -488,9 +488,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1px1ny0pz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1) && (mYPosInVolume%mVolume.getBlockSideLength() != 0))
 		{
-			return *(mCurrentVoxel + 1 - POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel + 1 - mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume);
 	}
@@ -498,9 +498,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1px1ny1pz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1) && (mYPosInVolume%mVolume.getBlockSideLength() != 0) && (mZPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1))
 		{
-			return *(mCurrentVoxel + 1 - POLYVOX_BLOCK_SIDE_LENGTH + POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel + 1 - mVolume.getBlockSideLength() + mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume+1);
 	}
@@ -508,9 +508,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1px0py1nz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1) && (mZPosInVolume%mVolume.getBlockSideLength() != 0))
 		{
-			return *(mCurrentVoxel + 1 - POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel + 1 - mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume-1);
 	}
@@ -518,7 +518,7 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1px0py0pz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1))
 		{
 			return *(mCurrentVoxel + 1);
 		}
@@ -528,9 +528,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1px0py1pz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1) && (mZPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1))
 		{
-			return *(mCurrentVoxel + 1 + POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel + 1 + mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume+1);
 	}
@@ -538,9 +538,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1px1py1nz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1) && (mYPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1) && (mZPosInVolume%mVolume.getBlockSideLength() != 0))
 		{
-			return *(mCurrentVoxel + 1 + POLYVOX_BLOCK_SIDE_LENGTH - POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel + 1 + mVolume.getBlockSideLength() - mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume+1,mYPosInVolume+1,mZPosInVolume-1);
 	}
@@ -548,9 +548,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1px1py0pz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1) && (mYPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1))
 		{
-			return *(mCurrentVoxel + 1 + POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel + 1 + mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume+1,mYPosInVolume+1,mZPosInVolume);
 	}
@@ -558,9 +558,9 @@ namespace PolyVox
 	template <typename VoxelType>
 	VoxelType VolumeIterator<VoxelType>::peekVoxel1px1py1pz(void) const
 	{
-		if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
+		if((mXPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1) && (mYPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1) && (mZPosInVolume%mVolume.getBlockSideLength() != mVolume.getBlockSideLength()-1))
 		{
-			return *(mCurrentVoxel + 1 + POLYVOX_BLOCK_SIDE_LENGTH + POLYVOX_BLOCK_SIDE_LENGTH*POLYVOX_BLOCK_SIDE_LENGTH);
+			return *(mCurrentVoxel + 1 + mVolume.getBlockSideLength() + mVolume.getBlockSideLength()*mVolume.getBlockSideLength());
 		}
 		return getVoxelAt(mXPosInVolume+1,mYPosInVolume+1,mZPosInVolume+1);
 	}

source/PolyVoxSceneManager.cpp

@@ -152,7 +152,7 @@ namespace PolyVox
 	void PolyVoxSceneManager::generateLevelVolume(void)
 	{
 		//volumeData = VolumePtr(new Volume);
-		volumeData = new Volume<boost::uint8_t>(POLYVOX_VOLUME_SIDE_LENGTH_POWER, POLYVOX_BLOCK_SIDE_LENGTH_POWER);
+		volumeData = new Volume<boost::uint8_t>(POLYVOX_VOLUME_SIDE_LENGTH_POWER);
 		VolumeIterator<boost::uint8_t> volIter(*volumeData);
 		for(uint16_t z = 0; z < POLYVOX_VOLUME_SIDE_LENGTH; ++z)
 		{