More tidying up.

examples/Basic/main.cpp

@@ -514,7 +514,9 @@ int main(int argc, char *argv[])
 	//createSphereInVolume(volData, 30);
 	//createPerlinTerrain(volData);
 	createPerlinVolumeSlow(volData);
+	std::cout << "Memory usage: " << volData.sizeInBytes() << std::endl;
 	volData.setBlockCacheSize(8);
+	std::cout << "Memory usage: " << volData.sizeInBytes() << std::endl;
 
 	/*srand(12345);
 	for(int ct = 0; ct < 1000; ct++)

library/PolyVoxCore/include/PolyVoxImpl/Block.h

@@ -70,10 +70,6 @@ namespace PolyVox
 		uint8_t m_uSideLengthPower;	
 		bool m_bIsCompressed;
 		bool m_bIsUncompressedDataModified;		
-
-	private:
-		Block(const Block& rhs);
-		Block& operator=(const Block& rhs);
 		
 	};
 }

library/PolyVoxCore/include/PolyVoxImpl/Block.inl

@@ -46,19 +46,6 @@ namespace PolyVox
 		}
 	}
 
-	template <typename VoxelType>
-	Block<VoxelType>::Block(const Block<VoxelType>& rhs)
-	{
-		assert(false);
-	}
-
-	template <typename VoxelType>
-	Block<VoxelType>& Block<VoxelType>::operator=(const Block<VoxelType>& rhs)
-	{
-		assert(false);
-		return 0;
-	}
-
 	template <typename VoxelType>
 	uint16_t Block<VoxelType>::getSideLength(void) const
 	{
@@ -147,7 +134,7 @@ namespace PolyVox
 	uint32_t Block<VoxelType>::sizeInBytes(void)
 	{
 		uint32_t uSizeInBytes = sizeof(Block<VoxelType>);
-		uSizeInBytes += m_vecCompressedData.capacity() * sizeof(RunlengthEntry);
+		uSizeInBytes += m_vecCompressedData.capacity() * sizeof(RunlengthEntry<uint16_t>);
 		return  uSizeInBytes;
 	}
 

library/PolyVoxCore/include/Volume.h

@@ -170,11 +170,10 @@ namespace PolyVox
 	public:
 		Block<VoxelType>* getUncompressedBlock(uint16_t uBlockX, uint16_t uBlockY, uint16_t uBlockZ) const;
 
-		//Block<VoxelType> m_pBorderBlock;
 		VoxelType* m_pUncompressedBorderData;
 
-		Block<VoxelType>* m_pBlocks;
+		mutable std::vector< Block<VoxelType> > m_pBlocks;
-		uint32_t* m_pUncompressedTimestamps;
+		mutable std::vector<uint32_t> m_pUncompressedTimestamps;
 		mutable std::vector< UncompressedBlock > m_vecUncompressedBlockCache;
 		uint16_t m_uMaxUncompressedBlockCacheSize;
 		uint32_t m_ulastAccessedBlockIndex;

library/PolyVoxCore/include/Volume.inl

@@ -53,8 +53,6 @@ namespace PolyVox
 		,m_uCompressions(0)
 		,m_uUncompressions(0)
 		,m_uBlockSideLength(uBlockSideLength)
-		,m_pBlocks(0)
-		,m_pUncompressedTimestamps(0)
 		,m_pUncompressedBorderData(0)
 		,m_ulastAccessedBlockIndex((std::numeric_limits<uint32_t>::max)()) //An invalid index
 	{
@@ -182,13 +180,6 @@ namespace PolyVox
 			const uint16_t yOffset = uYPos - (blockY << m_uBlockSideLengthPower);
 			const uint16_t zOffset = uZPos - (blockZ << m_uBlockSideLengthPower);
 
-			/*const Block<VoxelType>& block = m_pBlocks
-				[
-					blockX + 
-					blockY * m_uWidthInBlocks + 
-					blockZ * m_uWidthInBlocks * m_uHeightInBlocks
-				];*/
-
 			Block<VoxelType>* pUncompressedBlock = getUncompressedBlock(blockX, blockY, blockZ);
 
 			return pUncompressedBlock->getVoxelAt(xOffset,yOffset,zOffset);
@@ -242,13 +233,6 @@ namespace PolyVox
 			const uint16_t yOffset = uYPos - (blockY << m_uBlockSideLengthPower);
 			const uint16_t zOffset = uZPos - (blockZ << m_uBlockSideLengthPower);
 
-			/*uint32_t uBlockIndex =
-				blockX + 
-				blockY * m_uWidthInBlocks + 
-				blockZ * m_uWidthInBlocks * m_uHeightInBlocks;
-
-			Block<VoxelType>& block = m_pBlocks[uBlockIndex];*/
-
 			Block<VoxelType>* pUncompressedBlock = getUncompressedBlock(blockX, blockY, blockZ);
 
 			pUncompressedBlock->setVoxelAt(xOffset,yOffset,zOffset, tValue);
@@ -331,11 +315,8 @@ namespace PolyVox
 		}
 
 		//Clear the previous data
-		delete[] m_pBlocks;
+		m_pBlocks.clear();
-		m_pBlocks = 0;
+		m_pUncompressedTimestamps.clear();
-
-		delete[] m_pUncompressedTimestamps;
-		m_pUncompressedTimestamps = 0;
 
 		//Compute the volume side lengths
 		m_uWidth = uWidth;
@@ -355,18 +336,16 @@ namespace PolyVox
 		m_uNoOfBlocksInVolume = m_uWidthInBlocks * m_uHeightInBlocks * m_uDepthInBlocks;
 
 		//Create the blocks
-		m_pBlocks = new Block<VoxelType>[m_uNoOfBlocksInVolume];
+		m_pBlocks.resize(m_uNoOfBlocksInVolume);
-		m_pUncompressedTimestamps = new uint32_t[m_uNoOfBlocksInVolume];
 		for(uint32_t i = 0; i < m_uNoOfBlocksInVolume; ++i)
 		{
 			m_pBlocks[i].initialise(m_uBlockSideLength);
-			m_pUncompressedTimestamps[i] = 0; //Use memset/std::fill
 		}
 
+		m_pUncompressedTimestamps.resize(m_uNoOfBlocksInVolume);
+		std::fill(m_pUncompressedTimestamps.begin(), m_pUncompressedTimestamps.end(), 0);
+
 		//Create the border block
-		/*m_pBorderBlock.initialise(uBlockSideLength);
-		Block<VoxelType>* pUncompressedBorderBlock = getUncompressedBlock(&m_pBorderBlock);
-		pUncompressedBorderBlock->fill(VoxelType());*/
 		m_pUncompressedBorderData = new VoxelType[m_uBlockSideLength * m_uBlockSideLength * m_uBlockSideLength];
 		std::fill(m_pUncompressedBorderData, m_pUncompressedBorderData + m_uBlockSideLength * m_uBlockSideLength * m_uBlockSideLength, VoxelType());
 
@@ -421,10 +400,8 @@ namespace PolyVox
 			for(uint32_t ct = 0; ct < m_vecUncompressedBlockCache.size(); ct++)
 			{
 				if(m_pUncompressedTimestamps[m_vecUncompressedBlockCache[ct].uBlockIndex] < uLeastRecentTimestamp)
-				//if(m_pBlocks[m_vecUncompressedBlockCache[ct].uBlockIndex].m_uTimestamp < uLeastRecentTimestamp)
 				{
 					uLeastRecentTimestamp = m_pUncompressedTimestamps[m_vecUncompressedBlockCache[ct].uBlockIndex];
-					//uLeastRecentTimestamp = m_pBlocks[m_vecUncompressedBlockCache[ct].uBlockIndex].m_uTimestamp;
 					leastRecentlyUsedBlockIndex = ct;
 				}
 			}
@@ -457,11 +434,25 @@ namespace PolyVox
 	template <typename VoxelType>
 	uint32_t Volume<VoxelType>::sizeInBytes(void)
 	{
-		uint32_t uSizeInBytes = 0;
+		uint32_t uSizeInBytes = sizeof(Volume);
+
+		//Memory used by the blocks
 		for(uint32_t i = 0; i < m_uNoOfBlocksInVolume; ++i)
 		{
 			uSizeInBytes += m_pBlocks[i].sizeInBytes();
 		}
+
+		//Memory used by the block cache.
+		uSizeInBytes += m_vecUncompressedBlockCache.capacity() * sizeof(UncompressedBlock);
+		uSizeInBytes += m_vecUncompressedBlockCache.size() * m_uBlockSideLength * m_uBlockSideLength * m_uBlockSideLength * sizeof(VoxelType);
+		uSizeInBytes += m_pUncompressedTimestamps.capacity() * sizeof(uint32_t);
+
+		//Memory used by border data.
+		if(m_pUncompressedBorderData)
+		{
+			uSizeInBytes += m_uBlockSideLength * m_uBlockSideLength * m_uBlockSideLength * sizeof(VoxelType);
+		}
+
 		return uSizeInBytes;
 	}
 }

library/PolyVoxCore/include/VolumeSampler.inl

@@ -161,9 +161,6 @@ namespace PolyVox
 		}
 		else
 		{
-			/*Block<VoxelType>* pUncompressedBorderBlock = mVolume->getUncompressedBlock(&(mVolume->m_pBorderBlock));
-			mCurrentVoxel = pUncompressedBorderBlock->m_tUncompressedData + uVoxelIndexInBlock;*/
-
 			mCurrentVoxel = mVolume->m_pUncompressedBorderData + uVoxelIndexInBlock;
 		}
 	}