More cutting down SimpleVolume.

library/PolyVoxCore/include/SimpleVolume.h

@@ -176,37 +176,18 @@ namespace PolyVox
 		/// Sets the voxel at the position given by a 3D vector
 		bool setVoxelAt(const Vector3DInt32& v3dPos, VoxelType tValue);
 
-		/// Empties the cache of uncompressed blocks
-		void clearBlockCache(void);
-		/// Calculates the approximate compression ratio of the store volume data
-		float calculateCompressionRatio(void);
 		/// Calculates approximatly how many bytes of memory the volume is currently using.
 		uint32_t calculateSizeInBytes(void);
 
 		/// Deprecated - I don't think we should expose this function? Let us know if you disagree...
 		void resize(const Region& regValidRegion, uint16_t uBlockSideLength);
 
-private:
+private:	
-		/// gets called when a new region is allocated and needs to be filled
-		/// NOTE: accessing ANY voxels outside this region during the process of this function
-		/// is absolutely unsafe
-		polyvox_function<void(const ConstVolumeProxy<VoxelType>&, const Region&)> m_funcDataRequiredHandler;
-		/// gets called when a Region needs to be stored by the user, because SimpleVolume will erase it right after
-		/// this function returns
-		/// NOTE: accessing ANY voxels outside this region during the process of this function
-		/// is absolutely unsafe
-		polyvox_function<void(const ConstVolumeProxy<VoxelType>&, const Region&)> m_funcDataOverflowHandler;
-	
 		Block* getUncompressedBlock(int32_t uBlockX, int32_t uBlockY, int32_t uBlockZ) const;
-		/// this function can be called by m_funcDataRequiredHandler without causing any weird effects
-		bool setVoxelAtConst(int32_t uXPos, int32_t uYPos, int32_t uZPos, VoxelType tValue) const;
 
 		//The block data
 		mutable std::map<Vector3DInt32, Block > m_pBlocks;
 
-		mutable Vector3DInt32 m_v3dLastAccessedBlockPos;
-		mutable Block* m_pLastAccessedBlock;
-
 		//We don't store an actual Block for the border, just the uncompressed data. This is partly because the border
 		//block does not have a position (so can't be passed to getUncompressedBlock()) and partly because there's a
 		//good chance we'll often hit it anyway. It's a chunk of homogenous data (rather than a single value) so that

library/PolyVoxCore/include/SimpleVolume.inl

@@ -257,14 +257,6 @@ namespace PolyVox
 		return setVoxelAt(v3dPos.getX(), v3dPos.getY(), v3dPos.getZ(), tValue);
 	}
 
-	////////////////////////////////////////////////////////////////////////////////
-	///
-	////////////////////////////////////////////////////////////////////////////////
-	template <typename VoxelType>
-	void SimpleVolume<VoxelType>::clearBlockCache(void)
-	{
-	}
-
 	////////////////////////////////////////////////////////////////////////////////
 	/// This function should probably be made internal...
 	////////////////////////////////////////////////////////////////////////////////
@@ -312,30 +304,6 @@ namespace PolyVox
 		m_fDiagonalLength = sqrtf(static_cast<float>(getWidth() * getWidth() + getHeight() * getHeight() + getDepth() * getDepth()));
 	}
 
-	template <typename VoxelType>
-	bool SimpleVolume<VoxelType>::setVoxelAtConst(int32_t uXPos, int32_t uYPos, int32_t uZPos, VoxelType tValue) const
-	{
-		//We don't have any range checks in this function because it
-		//is a private function only called by the ConstVolumeProxy. The
-		//ConstVolumeProxy takes care of ensuring the range is appropriate.
-
-		const int32_t blockX = uXPos >> m_uBlockSideLengthPower;
-		const int32_t blockY = uYPos >> m_uBlockSideLengthPower;
-		const int32_t blockZ = uZPos >> m_uBlockSideLengthPower;
-
-		const uint16_t xOffset = uXPos - (blockX << m_uBlockSideLengthPower);
-		const uint16_t yOffset = uYPos - (blockY << m_uBlockSideLengthPower);
-		const uint16_t zOffset = uZPos - (blockZ << m_uBlockSideLengthPower);
-
-		Block<VoxelType>* pUncompressedBlock = getUncompressedBlock(blockX, blockY, blockZ);
-
-		pUncompressedBlock->setVoxelAt(xOffset,yOffset,zOffset, tValue);
-
-		//Return true to indicate that we modified a voxel.
-		return true;
-	}
-
-
 	template <typename VoxelType>
 	typename SimpleVolume<VoxelType>::Block* SimpleVolume<VoxelType>::getUncompressedBlock(int32_t uBlockX, int32_t uBlockY, int32_t uBlockZ) const
 	{
@@ -354,17 +322,6 @@ namespace PolyVox
 		return &block;
 	}
 
-	////////////////////////////////////////////////////////////////////////////////
-	/// Note: This function needs reviewing for accuracy...
-	////////////////////////////////////////////////////////////////////////////////
-	template <typename VoxelType>
-	float SimpleVolume<VoxelType>::calculateCompressionRatio(void)
-	{
-		float fRawSize = m_pBlocks.size() * m_uBlockSideLength * m_uBlockSideLength* m_uBlockSideLength * sizeof(VoxelType);
-		float fCompressedSize = calculateSizeInBytes();
-		return fCompressedSize/fRawSize;
-	}
-
 	////////////////////////////////////////////////////////////////////////////////
 	/// Note: This function needs reviewing for accuracy...
 	////////////////////////////////////////////////////////////////////////////////