Renamed some stuff in SurfaceExtractor.

Added functions to move samplers to adjacent voxels.

library/PolyVoxCore/include/SurfaceExtractor.h

@@ -44,16 +44,43 @@ namespace PolyVox
 		POLYVOX_SHARED_PTR<IndexedSurfacePatch> extractSurfaceForRegion(Region region);
 
 	private:
+		//Extract the surface for a particular LOD level
+		template<uint8_t uLodLevel>
+		void extractSurfaceImpl(void);
 
+		//Compute the cell bitmask for a particular slice in z.
+		template<bool isPrevZAvail, uint8_t uLodLevel>
+		uint32_t computeBitmaskForSlice(void);
+
+		//Compute the cell bitmask for a given cell.
+		template<bool isPrevXAvail, bool isPrevYAvail, bool isPrevZAvail, uint8_t uLodLevel>
+		void computeBitmaskForCell(void);
+
+		//Use the cell bitmasks to generate all the vertices needed for that slice
+		void generateVerticesForSlice();
+
+		//Use the cell bitmasks to generate all the indices needed for that slice
+		void generateIndicesForSlice();
+
+		//Converts a position into an index for accessing scratch areas.
+		inline uint32_t getIndex(uint32_t x, uint32_t y)
+		{
+			return x + (y * m_uScratchPadWidth);
+		}
+
+		//The lod level can step size.
 		uint8_t m_uLodLevel;
 		uint8_t m_uStepSize;
 
+		//The volume data and a sampler to access it.
 		Volume<uint8_t> m_volData;
 		VolumeSampler<uint8_t> m_sampVolume;
 
+		//Cell bitmasks for the current and previous slices.
 		uint8_t* m_pPreviousBitmask;
 		uint8_t* m_pCurrentBitmask;
 
+		//Used to keep track of where generated vertices have been placed.
 		int32_t* m_pPreviousVertexIndicesX;
 		int32_t* m_pPreviousVertexIndicesY; 
 		int32_t* m_pPreviousVertexIndicesZ; 
@@ -61,57 +88,40 @@ namespace PolyVox
 		int32_t* m_pCurrentVertexIndicesY; 
 		int32_t* m_pCurrentVertexIndicesZ;
 
-		uint8_t v000;
+		//Holds a position in volume space.
-		uint8_t v100;
-		uint8_t v010;
-		uint8_t v110;
-		uint8_t v001;
-		uint8_t v101;
-		uint8_t v011;
-		uint8_t v111;
-
 		uint16_t uXVolSpace;
 		uint16_t uYVolSpace;
 		uint16_t uZVolSpace;
 
+		//Holds a position in region space.
 		uint16_t uXRegSpace;
 		uint16_t uYRegSpace;
 		uint16_t uZRegSpace;
 
+		//Used to return the number of cells in a slice which contain triangles.
 		uint32_t m_uNoOfOccupiedCells;
 
+		//The surface patch we are currently filling.
 		IndexedSurfacePatch* m_ispCurrent;
 
+		//Remove this?
 		Vector3DFloat m_v3dRegionOffset;
 
-		uint16_t m_uScratchPadWidth;
+		//Information about the region we a re currently processing
-		uint16_t m_uScratchPadHeight;
-
 		Region m_Region;
 		Region m_UncroppedRegion;
 		Region m_croppedVolume;
-		Region regSlice0;
+		Region m_regSlicePrevious;
-		Region regSlice1;
+		Region m_regSliceCurrent;
 
+		//Store the width and height because they are frequently
+		//used and have some overhead to compute.
 		uint16_t m_uRegionWidth;
 		uint16_t m_uRegionHeight;
 
-		inline uint32_t getIndex(uint32_t x, uint32_t y)
+		//These are used in several places so best stored.
-		{
+		uint16_t m_uScratchPadWidth;
-			return x + (y * m_uScratchPadWidth);
+		uint16_t m_uScratchPadHeight;		
-		}
-
-		template<uint8_t uLodLevel>
-		void extractSurfaceImpl(void);
-
-		template<bool isPrevZAvail, uint8_t uLodLevel>
-		uint32_t computeBitmaskForSlice(void);
-
-		template<bool isPrevXAvail, bool isPrevYAvail, bool isPrevZAvail, uint8_t uLodLevel>
-		void computeBitmaskForCell(void);
-
-		void generateIndicesForSlice();
-		void generateVerticesForSlice();
 	};
 }
 

library/PolyVoxCore/include/VolumeSampler.h

@@ -54,6 +54,12 @@ namespace PolyVox
 		void setPosition(uint16_t xPos, uint16_t yPos, uint16_t zPos);
 
 		void movePositiveX(void);
+		void movePositiveY(void);
+		void movePositiveZ(void);
+
+		void moveNegativeX(void);
+		void moveNegativeY(void);
+		void moveNegativeZ(void);
 
 		inline VoxelType peekVoxel1nx1ny1nz(void) const;
 		inline VoxelType peekVoxel1nx1ny0pz(void) const;
@@ -95,20 +101,8 @@ namespace PolyVox
 		uint16_t mYPosInVolume;
 		uint16_t mZPosInVolume;
 
-		//The position of the current block
-		uint16_t mXBlock;
-		uint16_t mYBlock;
-		uint16_t mZBlock;
-
-		//The offset into the current block
-		uint16_t mXPosInBlock;
-		uint16_t mYPosInBlock;
-		uint16_t mZPosInBlock;
-
 		//Other current position information
 		VoxelType* mCurrentVoxel;
-		uint32_t mBlockIndexInVolume;
-		uint32_t mVoxelIndexInBlock;
 	};
 }
 

library/PolyVoxCore/include/VolumeSampler.inl

@@ -190,24 +190,23 @@ namespace PolyVox
 		mYPosInVolume = yPos;
 		mZPosInVolume = zPos;
 
-		mXBlock = mXPosInVolume >> mVolume.m_uBlockSideLengthPower;
+		uint16_t uXBlock = mXPosInVolume >> mVolume.m_uBlockSideLengthPower;
-		mYBlock = mYPosInVolume >> mVolume.m_uBlockSideLengthPower;
+		uint16_t uYBlock = mYPosInVolume >> mVolume.m_uBlockSideLengthPower;
-		mZBlock = mZPosInVolume >> mVolume.m_uBlockSideLengthPower;
+		uint16_t uZBlock = mZPosInVolume >> mVolume.m_uBlockSideLengthPower;
 
-		mXPosInBlock = mXPosInVolume - (mXBlock << mVolume.m_uBlockSideLengthPower);
+		uint16_t uXPosInBlock = mXPosInVolume - (uXBlock << mVolume.m_uBlockSideLengthPower);
-		mYPosInBlock = mYPosInVolume - (mYBlock << mVolume.m_uBlockSideLengthPower);
+		uint16_t uYPosInBlock = mYPosInVolume - (uYBlock << mVolume.m_uBlockSideLengthPower);
-		mZPosInBlock = mZPosInVolume - (mZBlock << mVolume.m_uBlockSideLengthPower);
+		uint16_t uZPosInBlock = mZPosInVolume - (uZBlock << mVolume.m_uBlockSideLengthPower);
 
-		mBlockIndexInVolume = mXBlock + 
+		uint32_t uBlockIndexInVolume = uXBlock + 
-			mYBlock * mVolume.m_uWidthInBlocks + 
+			uYBlock * mVolume.m_uWidthInBlocks + 
-			mZBlock * mVolume.m_uWidthInBlocks * mVolume.m_uHeightInBlocks;
+			uZBlock * mVolume.m_uWidthInBlocks * mVolume.m_uHeightInBlocks;
-		POLYVOX_SHARED_PTR< Block<VoxelType> > currentBlock = mVolume.m_pBlocks[mBlockIndexInVolume];
+		POLYVOX_SHARED_PTR< Block<VoxelType> > currentBlock = mVolume.m_pBlocks[uBlockIndexInVolume];
 
-		mVoxelIndexInBlock = mXPosInBlock + 
+		uint32_t uVoxelIndexInBlock = uXPosInBlock + 
-			mYPosInBlock * mVolume.m_uBlockSideLength + 
+			uYPosInBlock * mVolume.m_uBlockSideLength + 
-			mZPosInBlock * mVolume.m_uBlockSideLength * mVolume.m_uBlockSideLength;
+			uZPosInBlock * mVolume.m_uBlockSideLength * mVolume.m_uBlockSideLength;
-
+		mCurrentVoxel = currentBlock->m_tData + uVoxelIndexInBlock;
-		mCurrentVoxel = currentBlock->m_tData + mVoxelIndexInBlock;
 	}
 	#pragma endregion
 
@@ -215,17 +214,108 @@ namespace PolyVox
 	template <typename VoxelType>
 	void VolumeSampler<VoxelType>::movePositiveX(void)
 	{
-		++mXPosInVolume;
+		assert(mXPosInVolume < mVolume.m_uWidth - 1);
-		if(mXPosInVolume % mVolume.m_uBlockSideLength == 0)
+
+		//Note the *post* increament here
+		if((mXPosInVolume++) % mVolume.m_uBlockSideLength == 0)
+		{
+			//No need to compute new block.
+			++mCurrentVoxel;			
+		}
+		else
 		{
 			//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
 			setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume);
 		}
-		else
+	}
+
+	template <typename VoxelType>
+	void VolumeSampler<VoxelType>::movePositiveY(void)
+	{
+		assert(mYPosInVolume < mVolume.m_uHeight - 1);
+
+		//Note the *post* increament here
+		if((mYPosInVolume++) % mVolume.m_uBlockSideLength == 0)
 		{
 			//No need to compute new block.
-			++mVoxelIndexInBlock;
+			mCurrentVoxel += mVolume.m_uBlockSideLength;
-			++mCurrentVoxel;
+		}
+		else
+		{
+			//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
+			setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume);
+		}
+	}
+
+	template <typename VoxelType>
+	void VolumeSampler<VoxelType>::movePositiveZ(void)
+	{
+		assert(mZPosInVolume < mVolume.m_uDepth - 1);
+
+		//Note the *post* increament here
+		if((mZPosInVolume++) % mVolume.m_uBlockSideLength == 0)
+		{
+			//No need to compute new block.
+			mCurrentVoxel += mVolume.m_uBlockSideLength * mVolume.m_uBlockSideLength;
+		}
+		else
+		{
+			//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
+			setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume);
+		}
+	}
+
+	template <typename VoxelType>
+	void VolumeSampler<VoxelType>::moveNegativeX(void)
+	{
+		assert(mXPosInVolume > 0);
+
+		//Note the *pre* increament here
+		if((--mXPosInVolume) % mVolume.m_uBlockSideLength == 0)
+		{
+			//No need to compute new block.
+			++mCurrentVoxel;			
+		}
+		else
+		{
+			//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
+			setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume);
+		}
+	}
+
+	template <typename VoxelType>
+	void VolumeSampler<VoxelType>::moveNegativeY(void)
+	{
+		assert(mYPosInVolume > 0);
+
+		//Note the *pre* increament here
+		if((--mYPosInVolume) % mVolume.m_uBlockSideLength == 0)
+		{
+			//No need to compute new block.
+			mCurrentVoxel += mVolume.m_uBlockSideLength;
+		}
+		else
+		{
+			//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
+			setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume);
+		}
+	}
+
+	template <typename VoxelType>
+	void VolumeSampler<VoxelType>::moveNegativeZ(void)
+	{
+		assert(mZPosInVolume > 0);
+
+		//Note the *pre* increament here
+		if((--mZPosInVolume) % mVolume.m_uBlockSideLength == 0)
+		{
+			//No need to compute new block.
+			mCurrentVoxel += mVolume.m_uBlockSideLength * mVolume.m_uBlockSideLength;
+		}
+		else
+		{
+			//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
+			setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume);
 		}
 	}
 	#pragma endregion

library/PolyVoxCore/source/SurfaceExtractor.cpp

@@ -63,11 +63,11 @@ namespace PolyVox
 		m_v3dRegionOffset = static_cast<Vector3DFloat>(m_Region.getLowerCorner());
 
 		//Create a region corresponding to the first slice
-		regSlice0 = m_Region;
+		m_regSlicePrevious = m_Region;
-		Vector3DInt32 v3dUpperCorner = regSlice0.getUpperCorner();
+		Vector3DInt32 v3dUpperCorner = m_regSlicePrevious.getUpperCorner();
-		v3dUpperCorner.setZ(regSlice0.getLowerCorner().getZ()); //Set the upper z to the lower z to make it one slice thick.
+		v3dUpperCorner.setZ(m_regSlicePrevious.getLowerCorner().getZ()); //Set the upper z to the lower z to make it one slice thick.
-		regSlice0.setUpperCorner(v3dUpperCorner);
+		m_regSlicePrevious.setUpperCorner(v3dUpperCorner);
-		regSlice1 = regSlice0;	
+		m_regSliceCurrent = m_regSlicePrevious;	
 
 		switch(m_uLodLevel)
 		{
@@ -120,8 +120,8 @@ namespace PolyVox
 		std::swap(m_pPreviousVertexIndicesY, m_pCurrentVertexIndicesY);
 		std::swap(m_pPreviousVertexIndicesZ, m_pCurrentVertexIndicesZ);
 
-		regSlice0 = regSlice1;
+		m_regSlicePrevious = m_regSliceCurrent;
-		regSlice1.shift(Vector3DInt32(0,0,m_uStepSize));
+		m_regSliceCurrent.shift(Vector3DInt32(0,0,m_uStepSize));
 
 		//Process the other slices (previous slice is available)
 		for(uint32_t uSlice = 1; uSlice <= m_Region.depth(); uSlice += m_uStepSize)
@@ -148,13 +148,13 @@ namespace PolyVox
 			std::swap(m_pPreviousVertexIndicesY, m_pCurrentVertexIndicesY);
 			std::swap(m_pPreviousVertexIndicesZ, m_pCurrentVertexIndicesZ);
 
-			regSlice0 = regSlice1;
+			m_regSlicePrevious = m_regSliceCurrent;
-			regSlice1.shift(Vector3DInt32(0,0,m_uStepSize));
+			m_regSliceCurrent.shift(Vector3DInt32(0,0,m_uStepSize));
 		}
 
 		//A final slice just to close of the volume
-		regSlice1.shift(Vector3DInt32(0,0,-m_uStepSize));
+		m_regSliceCurrent.shift(Vector3DInt32(0,0,-m_uStepSize));
-		if(regSlice1.getLowerCorner().getZ() == m_croppedVolume.getUpperCorner().getZ())
+		if(m_regSliceCurrent.getLowerCorner().getZ() == m_croppedVolume.getUpperCorner().getZ())
 		{
 			memset(m_pCurrentVertexIndicesX, 0xff, m_uScratchPadWidth * m_uScratchPadHeight * 4);
 			memset(m_pCurrentVertexIndicesY, 0xff, m_uScratchPadWidth * m_uScratchPadHeight * 4);
@@ -168,15 +168,15 @@ namespace PolyVox
 	{
 		m_uNoOfOccupiedCells = 0;
 
-		const uint16_t uMaxXVolSpace = regSlice1.getUpperCorner().getX();
+		const uint16_t uMaxXVolSpace = m_regSliceCurrent.getUpperCorner().getX();
-		const uint16_t uMaxYVolSpace = regSlice1.getUpperCorner().getY();
+		const uint16_t uMaxYVolSpace = m_regSliceCurrent.getUpperCorner().getY();
 
-		uZVolSpace = regSlice1.getLowerCorner().getZ();
+		uZVolSpace = m_regSliceCurrent.getLowerCorner().getZ();
 		uZRegSpace = uZVolSpace - m_v3dRegionOffset.getZ();
 
 		//Process the lower left corner
-		uYVolSpace = regSlice1.getLowerCorner().getY();
+		uYVolSpace = m_regSliceCurrent.getLowerCorner().getY();
-		uXVolSpace = regSlice1.getLowerCorner().getX();
+		uXVolSpace = m_regSliceCurrent.getLowerCorner().getX();
 
 		uXRegSpace = uXVolSpace - m_v3dRegionOffset.getX();
 		uYRegSpace = uYVolSpace - m_v3dRegionOffset.getY();
@@ -186,8 +186,8 @@ namespace PolyVox
 
 
 		//Process the edge where x is minimal.
-		uXVolSpace = regSlice1.getLowerCorner().getX();
+		uXVolSpace = m_regSliceCurrent.getLowerCorner().getX();
-		for(uYVolSpace = regSlice1.getLowerCorner().getY() + m_uStepSize; uYVolSpace <= uMaxYVolSpace; uYVolSpace += m_uStepSize)
+		for(uYVolSpace = m_regSliceCurrent.getLowerCorner().getY() + m_uStepSize; uYVolSpace <= uMaxYVolSpace; uYVolSpace += m_uStepSize)
 		{
 			uXRegSpace = uXVolSpace - m_v3dRegionOffset.getX();
 			uYRegSpace = uYVolSpace - m_v3dRegionOffset.getY();
@@ -197,8 +197,8 @@ namespace PolyVox
 		}
 
 		//Process the edge where y is minimal.
-		uYVolSpace = regSlice1.getLowerCorner().getY();
+		uYVolSpace = m_regSliceCurrent.getLowerCorner().getY();
-		for(uXVolSpace = regSlice1.getLowerCorner().getX() + m_uStepSize; uXVolSpace <= uMaxXVolSpace; uXVolSpace += m_uStepSize)
+		for(uXVolSpace = m_regSliceCurrent.getLowerCorner().getX() + m_uStepSize; uXVolSpace <= uMaxXVolSpace; uXVolSpace += m_uStepSize)
 		{	
 			uXRegSpace = uXVolSpace - m_v3dRegionOffset.getX();
 			uYRegSpace = uYVolSpace - m_v3dRegionOffset.getY();
@@ -208,9 +208,9 @@ namespace PolyVox
 		}
 
 		//Process all remaining elemnents of the slice. In this case, previous x and y values are always available
-		for(uYVolSpace = regSlice1.getLowerCorner().getY() + m_uStepSize; uYVolSpace <= uMaxYVolSpace; uYVolSpace += m_uStepSize)
+		for(uYVolSpace = m_regSliceCurrent.getLowerCorner().getY() + m_uStepSize; uYVolSpace <= uMaxYVolSpace; uYVolSpace += m_uStepSize)
 		{
-			for(uXVolSpace = regSlice1.getLowerCorner().getX() + m_uStepSize; uXVolSpace <= uMaxXVolSpace; uXVolSpace += m_uStepSize)
+			for(uXVolSpace = m_regSliceCurrent.getLowerCorner().getX() + m_uStepSize; uXVolSpace <= uMaxXVolSpace; uXVolSpace += m_uStepSize)
 			{	
 				uXRegSpace = uXVolSpace - m_v3dRegionOffset.getX();
 				uYRegSpace = uYVolSpace - m_v3dRegionOffset.getY();
@@ -228,6 +228,15 @@ namespace PolyVox
 	{
 		uint8_t iCubeIndex = 0;
 
+		uint8_t v000 = 0;
+		uint8_t v100 = 0;
+		uint8_t v010 = 0;
+		uint8_t v110 = 0;
+		uint8_t v001 = 0;
+		uint8_t v101 = 0;
+		uint8_t v011 = 0;
+		uint8_t v111 = 0;
+
 		if(isPrevZAvail)
 		{
 			if(isPrevYAvail)
@@ -524,11 +533,11 @@ namespace PolyVox
 	void SurfaceExtractor::generateVerticesForSlice()
 	{
 		//Iterate over each cell in the region
-		for(uint16_t uYVolSpace = regSlice1.getLowerCorner().getY(); uYVolSpace <= regSlice1.getUpperCorner().getY(); uYVolSpace += m_uStepSize)
+		for(uint16_t uYVolSpace = m_regSliceCurrent.getLowerCorner().getY(); uYVolSpace <= m_regSliceCurrent.getUpperCorner().getY(); uYVolSpace += m_uStepSize)
 		{
-			for(uint16_t uXVolSpace = regSlice1.getLowerCorner().getX(); uXVolSpace <= regSlice1.getUpperCorner().getX(); uXVolSpace += m_uStepSize)
+			for(uint16_t uXVolSpace = m_regSliceCurrent.getLowerCorner().getX(); uXVolSpace <= m_regSliceCurrent.getUpperCorner().getX(); uXVolSpace += m_uStepSize)
 			{		
-				uint16_t uZVolSpace = regSlice1.getLowerCorner().getZ();
+				uint16_t uZVolSpace = m_regSliceCurrent.getLowerCorner().getZ();
 
 				//Current position
 				const uint16_t uXRegSpace = uXVolSpace - m_v3dRegionOffset.getX();
@@ -553,7 +562,7 @@ namespace PolyVox
 				/* Find the vertices where the surface intersects the cube */
 				if (edgeTable[iCubeIndex] & 1)
 				{
-					//if(uXVolSpace != regSlice1.getUpperCorner().getX())
+					//if(uXVolSpace != m_regSliceCurrent.getUpperCorner().getX())
 					{
 						m_sampVolume.setPosition(uXVolSpace + m_uStepSize,uYVolSpace,uZVolSpace);
 						const uint8_t v100 = m_sampVolume.getSubSampledVoxel(m_uLodLevel);
@@ -567,7 +576,7 @@ namespace PolyVox
 				}
 				if (edgeTable[iCubeIndex] & 8)
 				{
-					//if(uYVolSpace != regSlice1.getUpperCorner().getY())
+					//if(uYVolSpace != m_regSliceCurrent.getUpperCorner().getY())
 					{
 						m_sampVolume.setPosition(uXVolSpace,uYVolSpace + m_uStepSize,uZVolSpace);
 						const uint8_t v010 = m_sampVolume.getSubSampledVoxel(m_uLodLevel);
@@ -605,11 +614,11 @@ namespace PolyVox
 			indlist[i] = -1;
 		}
 
-		for(uint16_t uYVolSpace = regSlice0.getLowerCorner().getY(); uYVolSpace < m_UncroppedRegion.getUpperCorner().getY(); uYVolSpace += m_uStepSize)
+		for(uint16_t uYVolSpace = m_regSlicePrevious.getLowerCorner().getY(); uYVolSpace < m_UncroppedRegion.getUpperCorner().getY(); uYVolSpace += m_uStepSize)
 		{
-			for(uint16_t uXVolSpace = regSlice0.getLowerCorner().getX(); uXVolSpace < m_UncroppedRegion.getUpperCorner().getX(); uXVolSpace += m_uStepSize)
+			for(uint16_t uXVolSpace = m_regSlicePrevious.getLowerCorner().getX(); uXVolSpace < m_UncroppedRegion.getUpperCorner().getX(); uXVolSpace += m_uStepSize)
 			{		
-				uint16_t uZVolSpace = regSlice0.getLowerCorner().getZ();
+				uint16_t uZVolSpace = m_regSlicePrevious.getLowerCorner().getZ();
 				m_sampVolume.setPosition(uXVolSpace,uYVolSpace,uZVolSpace);	
 
 				//Current position