AnotherFoxGuy/polyvox
1
0
Fork 0
Code Issues Pull Requests Activity

Templatized VolumeIterator class.

Browse Source
This commit is contained in:
David Williams 2008-04-20 19:58:37 +00:00
parent 593a26ebd2
commit bc28e240f3
8 changed files with 140 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -7,7 +7,6 @@ SET(SRC_FILES
source/PolyVoxSceneManager.cpp source/PolyVoxSceneManager.cpp
source/RegionGeometry.cpp source/RegionGeometry.cpp
source/SurfaceVertex.cpp source/SurfaceVertex.cpp
source/VolumeIterator.cpp
) )
#Projects headers files #Projects headers files
@ -27,6 +26,7 @@ SET(INC_FILES
include/Volume.h include/Volume.h
include/Volume.inl include/Volume.inl
include/VolumeIterator.h include/VolumeIterator.h
include/VolumeIterator.inl
) )
FIND_PACKAGE(Boost REQUIRED) FIND_PACKAGE(Boost REQUIRED)

3
include/Block.h
View File

@ -26,6 +26,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "boost/cstdint.hpp" #include "boost/cstdint.hpp"
#include "Constants.h" #include "Constants.h"
#include "PolyVoxForwardDeclarations.h"
#include "TypeDef.h" #include "TypeDef.h"
#pragma endregion #pragma endregion
@ -35,7 +36,7 @@ namespace PolyVox
class Block class Block
{ {
//Make VolumeIterator a friend //Make VolumeIterator a friend
friend class VolumeIterator; friend class VolumeIterator<VoxelType>;
//Block interface //Block interface
public: public:

13
include/PolyVoxForwardDeclarations.h
View File

@ -10,9 +10,6 @@ namespace PolyVox
class IntegrealVector3; class IntegrealVector3;
class PolyVoxSceneManager; class PolyVoxSceneManager;
class RegionGeometry; class RegionGeometry;
//class SurfaceEdge;
//class SurfaceTriange;
//class SurfaceTypes;
class SurfaceVertex; class SurfaceVertex;
template <boost::uint32_t Size, typename Type> class Vector; template <boost::uint32_t Size, typename Type> class Vector;
typedef Vector<2,float> Vector2DFloat; typedef Vector<2,float> Vector2DFloat;
@ -23,16 +20,8 @@ namespace PolyVox
typedef Vector<3,double> Vector3DDouble; typedef Vector<3,double> Vector3DDouble;
typedef Vector<3,boost::int32_t> Vector3DInt32; typedef Vector<3,boost::int32_t> Vector3DInt32;
typedef Vector<3,boost::uint32_t> Vector3DUint32; typedef Vector<3,boost::uint32_t> Vector3DUint32;
/*class Vector2DFloat;
class Vector2DDouble;
class Vector2DInt32;
class Vector2DUint32;
class Vector3DFloat;
class Vector3DDouble;
class Vector3DInt32;
class Vector3DUint32;*/
template <typename VoxelType> class Volume; template <typename VoxelType> class Volume;
class VolumeIterator; template <typename VoxelType> class VolumeIterator;
} }
#endif #endif

2
include/Volume.h
View File

@ -32,7 +32,7 @@ namespace PolyVox
class Volume class Volume
{ {
//Make VolumeIterator a friend //Make VolumeIterator a friend
friend class VolumeIterator; friend class VolumeIterator<VoxelType>;
//Volume interface //Volume interface
public: public:

5
include/Volume.inl
View File

@ -22,7 +22,6 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include <queue> #include <queue>
#include "Block.h" #include "Block.h"
#include "Volume.h"
#include "VolumeIterator.h" //Maybe this shouldn't be here? #include "VolumeIterator.h" //Maybe this shouldn't be here?
namespace PolyVox namespace PolyVox
@ -229,7 +228,7 @@ namespace PolyVox
} }
//Write data //Write data
VolumeIterator volIter(*this); VolumeIterator<VoxelType> volIter(*this);
for(boost::uint16_t z = 0; z < POLYVOX_VOLUME_SIDE_LENGTH; ++z) for(boost::uint16_t z = 0; z < POLYVOX_VOLUME_SIDE_LENGTH; ++z)
{ {
for(boost::uint16_t y = 0; y < POLYVOX_VOLUME_SIDE_LENGTH; ++y) for(boost::uint16_t y = 0; y < POLYVOX_VOLUME_SIDE_LENGTH; ++y)
@ -255,7 +254,7 @@ namespace PolyVox
return; return;
} }
VolumeIterator volIter(*this); VolumeIterator<VoxelType> volIter(*this);
const boost::uint8_t uSeedValue = volIter.getVoxelAt(xStart,yStart,zStart); const boost::uint8_t uSeedValue = volIter.getVoxelAt(xStart,yStart,zStart);
if(value == uSeedValue) if(value == uSeedValue)

73
include/VolumeIterator.h
View File

@ -27,17 +27,18 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
namespace PolyVox namespace PolyVox
{ {
class POLYVOX_API VolumeIterator template <typename VoxelType>
class VolumeIterator
{ {
public: public:
VolumeIterator(Volume<boost::uint8_t>& volume); VolumeIterator(Volume<VoxelType>& volume);
~VolumeIterator(); ~VolumeIterator();
void setVoxel(boost::uint8_t value); void setVoxel(VoxelType value);
boost::uint8_t getVoxel(void); VoxelType getVoxel(void);
boost::uint8_t getVoxelAt(const boost::uint16_t xPosition, const boost::uint16_t yPosition, const boost::uint16_t zPosition) const; VoxelType getVoxelAt(const boost::uint16_t xPosition, const boost::uint16_t yPosition, const boost::uint16_t zPosition) const;
void setVoxelAt(const boost::uint16_t xPosition, const boost::uint16_t yPosition, const boost::uint16_t zPosition, const boost::uint8_t value); void setVoxelAt(const boost::uint16_t xPosition, const boost::uint16_t yPosition, const boost::uint16_t zPosition, const VoxelType value);
float getAveragedVoxelAt(const boost::uint16_t xPosition, const boost::uint16_t yPosition, const boost::uint16_t zPosition, boost::uint16_t size) const; float getAveragedVoxelAt(const boost::uint16_t xPosition, const boost::uint16_t yPosition, const boost::uint16_t zPosition, boost::uint16_t size) const;
@ -56,39 +57,39 @@ namespace PolyVox
bool isValidForRegion(void); bool isValidForRegion(void);
boost::uint8_t peekVoxel1nx1ny1nz(void) const; VoxelType peekVoxel1nx1ny1nz(void) const;
boost::uint8_t peekVoxel1nx1ny0pz(void) const; VoxelType peekVoxel1nx1ny0pz(void) const;
boost::uint8_t peekVoxel1nx1ny1pz(void) const; VoxelType peekVoxel1nx1ny1pz(void) const;
boost::uint8_t peekVoxel1nx0py1nz(void) const; VoxelType peekVoxel1nx0py1nz(void) const;
boost::uint8_t peekVoxel1nx0py0pz(void) const; VoxelType peekVoxel1nx0py0pz(void) const;
boost::uint8_t peekVoxel1nx0py1pz(void) const; VoxelType peekVoxel1nx0py1pz(void) const;
boost::uint8_t peekVoxel1nx1py1nz(void) const; VoxelType peekVoxel1nx1py1nz(void) const;
boost::uint8_t peekVoxel1nx1py0pz(void) const; VoxelType peekVoxel1nx1py0pz(void) const;
boost::uint8_t peekVoxel1nx1py1pz(void) const; VoxelType peekVoxel1nx1py1pz(void) const;
boost::uint8_t peekVoxel0px1ny1nz(void) const; VoxelType peekVoxel0px1ny1nz(void) const;
boost::uint8_t peekVoxel0px1ny0pz(void) const; VoxelType peekVoxel0px1ny0pz(void) const;
boost::uint8_t peekVoxel0px1ny1pz(void) const; VoxelType peekVoxel0px1ny1pz(void) const;
boost::uint8_t peekVoxel0px0py1nz(void) const; VoxelType peekVoxel0px0py1nz(void) const;
boost::uint8_t peekVoxel0px0py0pz(void) const; VoxelType peekVoxel0px0py0pz(void) const;
boost::uint8_t peekVoxel0px0py1pz(void) const; VoxelType peekVoxel0px0py1pz(void) const;
boost::uint8_t peekVoxel0px1py1nz(void) const; VoxelType peekVoxel0px1py1nz(void) const;
boost::uint8_t peekVoxel0px1py0pz(void) const; VoxelType peekVoxel0px1py0pz(void) const;
boost::uint8_t peekVoxel0px1py1pz(void) const; VoxelType peekVoxel0px1py1pz(void) const;
boost::uint8_t peekVoxel1px1ny1nz(void) const; VoxelType peekVoxel1px1ny1nz(void) const;
boost::uint8_t peekVoxel1px1ny0pz(void) const; VoxelType peekVoxel1px1ny0pz(void) const;
boost::uint8_t peekVoxel1px1ny1pz(void) const; VoxelType peekVoxel1px1ny1pz(void) const;
boost::uint8_t peekVoxel1px0py1nz(void) const; VoxelType peekVoxel1px0py1nz(void) const;
boost::uint8_t peekVoxel1px0py0pz(void) const; VoxelType peekVoxel1px0py0pz(void) const;
boost::uint8_t peekVoxel1px0py1pz(void) const; VoxelType peekVoxel1px0py1pz(void) const;
boost::uint8_t peekVoxel1px1py1nz(void) const; VoxelType peekVoxel1px1py1nz(void) const;
boost::uint8_t peekVoxel1px1py0pz(void) const; VoxelType peekVoxel1px1py0pz(void) const;
boost::uint8_t peekVoxel1px1py1pz(void) const; VoxelType peekVoxel1px1py1pz(void) const;
private: private:
//The current volume //The current volume
Volume<boost::uint8_t>& mVolume; Volume<VoxelType>& mVolume;
//The current position in the volume //The current position in the volume
boost::uint16_t mXPosInVolume; boost::uint16_t mXPosInVolume;
@ -106,7 +107,7 @@ namespace PolyVox
boost::uint16_t mZPosInBlock; boost::uint16_t mZPosInBlock;
//Other current position information //Other current position information
boost::uint8_t* mCurrentVoxel; VoxelType* mCurrentVoxel;
boost::uint32_t mBlockIndexInVolume; boost::uint32_t mBlockIndexInVolume;
boost::uint32_t mVoxelIndexInBlock; boost::uint32_t mVoxelIndexInBlock;
@ -128,4 +129,6 @@ namespace PolyVox
}; };
} }
#include "VolumeIterator.inl"
#endif #endif

135
source/VolumeIterator.cpp → include/VolumeIterator.inl
View File

@ -19,13 +19,13 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "block.h" #include "block.h"
#include "Volume.h" #include "Volume.h"
#include "VolumeIterator.h"
using namespace boost; using namespace boost;
namespace PolyVox namespace PolyVox
{ {
VolumeIterator::VolumeIterator(Volume<boost::uint8_t>& volume) template <typename VoxelType>
VolumeIterator<VoxelType>::VolumeIterator(Volume<VoxelType>& volume)
:mVolume(volume) :mVolume(volume)
,mXRegionFirst(0) ,mXRegionFirst(0)
,mYRegionFirst(0) ,mYRegionFirst(0)
@ -56,13 +56,15 @@ namespace PolyVox
{ {
} }
VolumeIterator::~VolumeIterator() template <typename VoxelType>
VolumeIterator<VoxelType>::~VolumeIterator()
{ {
} }
void VolumeIterator::setVoxel(uint8_t value) template <typename VoxelType>
void VolumeIterator<VoxelType>::setVoxel(VoxelType value)
{ {
Block<boost::uint8_t>* currentBlock = mVolume.mBlocks[mBlockIndexInVolume]; Block<VoxelType>* currentBlock = mVolume.mBlocks[mBlockIndexInVolume];
/*if(!currentBlock.unique()) /*if(!currentBlock.unique())
{ {
@ -75,13 +77,15 @@ namespace PolyVox
*mCurrentVoxel = value; *mCurrentVoxel = value;
} }
uint8_t VolumeIterator::getVoxel(void) template <typename VoxelType>
VoxelType VolumeIterator<VoxelType>::getVoxel(void)
{ {
//return getVoxelAt(mXPosInVolume,mYPosInVolume,mZPosInVolume); //return getVoxelAt(mXPosInVolume,mYPosInVolume,mZPosInVolume);
return *mCurrentVoxel; return *mCurrentVoxel;
} }
uint8_t VolumeIterator::getVoxelAt(const uint16_t xPosition, const uint16_t yPosition, const uint16_t zPosition) const 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 >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
const uint16_t blockY = yPosition >> POLYVOX_BLOCK_SIDE_LENGTH_POWER; const uint16_t blockY = yPosition >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
@ -101,7 +105,8 @@ namespace PolyVox
return block->getVoxelAt(xOffset,yOffset,zOffset); return block->getVoxelAt(xOffset,yOffset,zOffset);
} }
float VolumeIterator::getAveragedVoxelAt(const uint16_t xPosition, const uint16_t yPosition, const uint16_t zPosition, uint16_t size) const template <typename VoxelType>
float VolumeIterator<VoxelType>::getAveragedVoxelAt(const uint16_t xPosition, const uint16_t yPosition, const uint16_t zPosition, uint16_t size) const
{ {
float sum = 0.0; float sum = 0.0;
for(uint16_t z = zPosition-size; z <= zPosition+size; ++z) for(uint16_t z = zPosition-size; z <= zPosition+size; ++z)
@ -125,7 +130,8 @@ namespace PolyVox
return sum; return sum;
} }
void VolumeIterator::setVoxelAt(const uint16_t xPosition, const uint16_t yPosition, const uint16_t zPosition, const uint8_t value) template <typename VoxelType>
void VolumeIterator<VoxelType>::setVoxelAt(const uint16_t xPosition, const uint16_t yPosition, const uint16_t zPosition, const VoxelType value)
{ {
const uint16_t blockX = xPosition >> POLYVOX_BLOCK_SIDE_LENGTH_POWER; const uint16_t blockX = xPosition >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
const uint16_t blockY = yPosition >> POLYVOX_BLOCK_SIDE_LENGTH_POWER; const uint16_t blockY = yPosition >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
@ -153,7 +159,8 @@ namespace PolyVox
block->setVoxelAt(xOffset,yOffset,zOffset, value); block->setVoxelAt(xOffset,yOffset,zOffset, value);
} }
Vector3DFloat VolumeIterator::getCentralDifferenceGradient(void) const template <typename VoxelType>
Vector3DFloat VolumeIterator<VoxelType>::getCentralDifferenceGradient(void) const
{ {
//FIXME - should this test be here? //FIXME - should this test be here?
if((mXPosInVolume < 1) || (mXPosInVolume > POLYVOX_VOLUME_SIDE_LENGTH-2) || if((mXPosInVolume < 1) || (mXPosInVolume > POLYVOX_VOLUME_SIDE_LENGTH-2) ||
@ -177,7 +184,8 @@ namespace PolyVox
return Vector3DFloat(int(voxel1px) - int(voxel1nx),int(voxel1py) - int(voxel1ny),int(voxel1pz) - int(voxel1nz)); return Vector3DFloat(int(voxel1px) - int(voxel1nx),int(voxel1py) - int(voxel1ny),int(voxel1pz) - int(voxel1nz));
} }
Vector3DFloat VolumeIterator::getAveragedCentralDifferenceGradient(void) const template <typename VoxelType>
Vector3DFloat VolumeIterator<VoxelType>::getAveragedCentralDifferenceGradient(void) const
{ {
//FIXME - should this test be here? //FIXME - should this test be here?
if((mXPosInVolume < 2) || (mXPosInVolume > POLYVOX_VOLUME_SIDE_LENGTH-3) || if((mXPosInVolume < 2) || (mXPosInVolume > POLYVOX_VOLUME_SIDE_LENGTH-3) ||
@ -201,7 +209,8 @@ namespace PolyVox
return Vector3DFloat(voxel1px - voxel1nx,voxel1py - voxel1ny,voxel1pz - voxel1nz); return Vector3DFloat(voxel1px - voxel1nx,voxel1py - voxel1ny,voxel1pz - voxel1nz);
} }
Vector3DFloat VolumeIterator::getSobelGradient(void) const template <typename VoxelType>
Vector3DFloat VolumeIterator<VoxelType>::getSobelGradient(void) const
{ {
//FIXME - should this test be here? //FIXME - should this test be here?
if((mXPosInVolume < 1) || (mXPosInVolume > POLYVOX_VOLUME_SIDE_LENGTH-2) || if((mXPosInVolume < 1) || (mXPosInVolume > POLYVOX_VOLUME_SIDE_LENGTH-2) ||
@ -292,22 +301,26 @@ namespace PolyVox
return Vector3DFloat(xGrad,yGrad,zGrad); return Vector3DFloat(xGrad,yGrad,zGrad);
} }
uint16_t VolumeIterator::getPosX(void) template <typename VoxelType>
uint16_t VolumeIterator<VoxelType>::getPosX(void)
{ {
return mXPosInVolume; return mXPosInVolume;
} }
uint16_t VolumeIterator::getPosY(void) template <typename VoxelType>
uint16_t VolumeIterator<VoxelType>::getPosY(void)
{ {
return mYPosInVolume; return mYPosInVolume;
} }
uint16_t VolumeIterator::getPosZ(void) template <typename VoxelType>
uint16_t VolumeIterator<VoxelType>::getPosZ(void)
{ {
return mZPosInVolume; return mZPosInVolume;
} }
void VolumeIterator::setPosition(uint16_t xPos, uint16_t yPos, uint16_t zPos) template <typename VoxelType>
void VolumeIterator<VoxelType>::setPosition(uint16_t xPos, uint16_t yPos, uint16_t zPos)
{ {
mXPosInVolume = xPos; mXPosInVolume = xPos;
mYPosInVolume = yPos; mYPosInVolume = yPos;
@ -333,7 +346,8 @@ namespace PolyVox
mCurrentVoxel = currentBlock->mData + mVoxelIndexInBlock; mCurrentVoxel = currentBlock->mData + mVoxelIndexInBlock;
} }
void VolumeIterator::setValidRegion(uint16_t xFirst, uint16_t yFirst, uint16_t zFirst, uint16_t xLast, uint16_t yLast, uint16_t zLast) template <typename VoxelType>
void VolumeIterator<VoxelType>::setValidRegion(uint16_t xFirst, uint16_t yFirst, uint16_t zFirst, uint16_t xLast, uint16_t yLast, uint16_t zLast)
{ {
mXRegionFirst = xFirst; mXRegionFirst = xFirst;
mYRegionFirst = yFirst; mYRegionFirst = yFirst;
@ -360,7 +374,8 @@ namespace PolyVox
mZRegionLastBlock = mZRegionLast >> POLYVOX_BLOCK_SIDE_LENGTH_POWER; mZRegionLastBlock = mZRegionLast >> POLYVOX_BLOCK_SIDE_LENGTH_POWER;
} }
void VolumeIterator::moveForwardInRegion(void) template <typename VoxelType>
void VolumeIterator<VoxelType>::moveForwardInRegion(void)
{ {
mXPosInBlock++; mXPosInBlock++;
mCurrentVoxel++; mCurrentVoxel++;
@ -445,12 +460,14 @@ namespace PolyVox
} }
} }
bool VolumeIterator::isValidForRegion(void) template <typename VoxelType>
bool VolumeIterator<VoxelType>::isValidForRegion(void)
{ {
return mIsValidForRegion; return mIsValidForRegion;
} }
uint8_t VolumeIterator::peekVoxel1nx1ny1nz(void) const 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%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
{ {
@ -459,7 +476,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume-1); return getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume-1);
} }
uint8_t VolumeIterator::peekVoxel1nx1ny0pz(void) const template <typename VoxelType>
VoxelType VolumeIterator<VoxelType>::peekVoxel1nx1ny0pz(void) const
{ {
if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0)) if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
{ {
@ -468,7 +486,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume); return getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume);
} }
uint8_t VolumeIterator::peekVoxel1nx1ny1pz(void) const 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%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
{ {
@ -477,7 +496,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume+1); return getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume+1);
} }
uint8_t VolumeIterator::peekVoxel1nx0py1nz(void) const template <typename VoxelType>
VoxelType VolumeIterator<VoxelType>::peekVoxel1nx0py1nz(void) const
{ {
if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0)) if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
{ {
@ -486,7 +506,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume-1); return getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume-1);
} }
uint8_t VolumeIterator::peekVoxel1nx0py0pz(void) const template <typename VoxelType>
VoxelType VolumeIterator<VoxelType>::peekVoxel1nx0py0pz(void) const
{ {
if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0)) if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
{ {
@ -495,7 +516,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume); return getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume);
} }
uint8_t VolumeIterator::peekVoxel1nx0py1pz(void) const 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%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
{ {
@ -504,7 +526,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume+1); return getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume+1);
} }
uint8_t VolumeIterator::peekVoxel1nx1py1nz(void) const 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%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
{ {
@ -513,7 +536,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume-1,mYPosInVolume+1,mZPosInVolume-1); return getVoxelAt(mXPosInVolume-1,mYPosInVolume+1,mZPosInVolume-1);
} }
uint8_t VolumeIterator::peekVoxel1nx1py0pz(void) const 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%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
{ {
@ -522,7 +546,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume-1,mYPosInVolume+1,mZPosInVolume); return getVoxelAt(mXPosInVolume-1,mYPosInVolume+1,mZPosInVolume);
} }
uint8_t VolumeIterator::peekVoxel1nx1py1pz(void) const 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%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))
{ {
@ -533,7 +558,8 @@ namespace PolyVox
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
uint8_t VolumeIterator::peekVoxel0px1ny1nz(void) const template <typename VoxelType>
VoxelType VolumeIterator<VoxelType>::peekVoxel0px1ny1nz(void) const
{ {
if((mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0)) if((mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
{ {
@ -542,7 +568,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume-1); return getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume-1);
} }
uint8_t VolumeIterator::peekVoxel0px1ny0pz(void) const template <typename VoxelType>
VoxelType VolumeIterator<VoxelType>::peekVoxel0px1ny0pz(void) const
{ {
if((mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0)) if((mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
{ {
@ -551,7 +578,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume); return getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume);
} }
uint8_t VolumeIterator::peekVoxel0px1ny1pz(void) const 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%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
{ {
@ -560,7 +588,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume+1); return getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume+1);
} }
uint8_t VolumeIterator::peekVoxel0px0py1nz(void) const template <typename VoxelType>
VoxelType VolumeIterator<VoxelType>::peekVoxel0px0py1nz(void) const
{ {
if((mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0)) if((mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
{ {
@ -569,12 +598,14 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume,mYPosInVolume,mZPosInVolume-1); return getVoxelAt(mXPosInVolume,mYPosInVolume,mZPosInVolume-1);
} }
uint8_t VolumeIterator::peekVoxel0px0py0pz(void) const template <typename VoxelType>
VoxelType VolumeIterator<VoxelType>::peekVoxel0px0py0pz(void) const
{ {
return *mCurrentVoxel; return *mCurrentVoxel;
} }
uint8_t VolumeIterator::peekVoxel0px0py1pz(void) const template <typename VoxelType>
VoxelType VolumeIterator<VoxelType>::peekVoxel0px0py1pz(void) const
{ {
if((mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1)) if((mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
{ {
@ -583,7 +614,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume,mYPosInVolume,mZPosInVolume+1); return getVoxelAt(mXPosInVolume,mYPosInVolume,mZPosInVolume+1);
} }
uint8_t VolumeIterator::peekVoxel0px1py1nz(void) const 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%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
{ {
@ -592,7 +624,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume,mYPosInVolume+1,mZPosInVolume-1); return getVoxelAt(mXPosInVolume,mYPosInVolume+1,mZPosInVolume-1);
} }
uint8_t VolumeIterator::peekVoxel0px1py0pz(void) const template <typename VoxelType>
VoxelType VolumeIterator<VoxelType>::peekVoxel0px1py0pz(void) const
{ {
if((mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1)) if((mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
{ {
@ -601,7 +634,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume,mYPosInVolume+1,mZPosInVolume); return getVoxelAt(mXPosInVolume,mYPosInVolume+1,mZPosInVolume);
} }
uint8_t VolumeIterator::peekVoxel0px1py1pz(void) const 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%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
{ {
@ -612,7 +646,8 @@ namespace PolyVox
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
uint8_t VolumeIterator::peekVoxel1px1ny1nz(void) const 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%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
{ {
@ -621,7 +656,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume-1); return getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume-1);
} }
uint8_t VolumeIterator::peekVoxel1px1ny0pz(void) const 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%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
{ {
@ -630,7 +666,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume); return getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume);
} }
uint8_t VolumeIterator::peekVoxel1px1ny1pz(void) const 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%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))
{ {
@ -639,7 +676,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume+1); return getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume+1);
} }
uint8_t VolumeIterator::peekVoxel1px0py1nz(void) const 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%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != 0))
{ {
@ -648,7 +686,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume-1); return getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume-1);
} }
uint8_t VolumeIterator::peekVoxel1px0py0pz(void) const template <typename VoxelType>
VoxelType VolumeIterator<VoxelType>::peekVoxel1px0py0pz(void) const
{ {
if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1)) if((mXPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
{ {
@ -657,7 +696,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume); return getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume);
} }
uint8_t VolumeIterator::peekVoxel1px0py1pz(void) const 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%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mZPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
{ {
@ -666,7 +706,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume+1); return getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume+1);
} }
uint8_t VolumeIterator::peekVoxel1px1py1nz(void) const 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%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))
{ {
@ -675,7 +716,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume+1,mYPosInVolume+1,mZPosInVolume-1); return getVoxelAt(mXPosInVolume+1,mYPosInVolume+1,mZPosInVolume-1);
} }
uint8_t VolumeIterator::peekVoxel1px1py0pz(void) const 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%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1) && (mYPosInVolume%POLYVOX_BLOCK_SIDE_LENGTH != POLYVOX_BLOCK_SIDE_LENGTH-1))
{ {
@ -684,7 +726,8 @@ namespace PolyVox
return getVoxelAt(mXPosInVolume+1,mYPosInVolume+1,mZPosInVolume); return getVoxelAt(mXPosInVolume+1,mYPosInVolume+1,mZPosInVolume);
} }
uint8_t VolumeIterator::peekVoxel1px1py1pz(void) const 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%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))
{ {

10
source/PolyVoxSceneManager.cpp
View File

@ -120,7 +120,7 @@ namespace PolyVox
lastY = std::min(lastY,int(POLYVOX_VOLUME_SIDE_LENGTH-1)); lastY = std::min(lastY,int(POLYVOX_VOLUME_SIDE_LENGTH-1));
lastZ = std::min(lastZ,int(POLYVOX_VOLUME_SIDE_LENGTH-1)); lastZ = std::min(lastZ,int(POLYVOX_VOLUME_SIDE_LENGTH-1));
VolumeIterator volIter(*volumeData); VolumeIterator<boost::uint8_t> volIter(*volumeData);
volIter.setValidRegion(firstX,firstY,firstZ,lastX,lastY,lastZ); volIter.setValidRegion(firstX,firstY,firstZ,lastX,lastY,lastZ);
volIter.setPosition(firstX,firstY,firstZ); volIter.setPosition(firstX,firstY,firstZ);
while(volIter.isValidForRegion()) while(volIter.isValidForRegion())
@ -152,7 +152,7 @@ namespace PolyVox
{ {
//volumeData = VolumePtr(new Volume); //volumeData = VolumePtr(new Volume);
volumeData = new Volume<boost::uint8_t>(); volumeData = new Volume<boost::uint8_t>();
VolumeIterator volIter(*volumeData); VolumeIterator<boost::uint8_t> volIter(*volumeData);
for(uint16_t z = 0; z < POLYVOX_VOLUME_SIDE_LENGTH; ++z) for(uint16_t z = 0; z < POLYVOX_VOLUME_SIDE_LENGTH; ++z)
{ {
for(uint16_t y = 0; y < POLYVOX_VOLUME_SIDE_LENGTH; ++y) for(uint16_t y = 0; y < POLYVOX_VOLUME_SIDE_LENGTH; ++y)
@ -248,7 +248,7 @@ namespace PolyVox
Vector3DUint32 vertlist[12]; Vector3DUint32 vertlist[12];
uint8_t vertMaterials[12]; uint8_t vertMaterials[12];
VolumeIterator volIter(*volumeData); VolumeIterator<boost::uint8_t> volIter(*volumeData);
volIter.setValidRegion(firstX,firstY,firstZ,lastX,lastY,lastZ); volIter.setValidRegion(firstX,firstY,firstZ,lastX,lastY,lastZ);
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
@ -541,7 +541,7 @@ namespace PolyVox
Vector3DFloat PolyVoxSceneManager::computeNormal(const Vector3DFloat& position, NormalGenerationMethod normalGenerationMethod) const Vector3DFloat PolyVoxSceneManager::computeNormal(const Vector3DFloat& position, NormalGenerationMethod normalGenerationMethod) const
{ {
VolumeIterator volIter(*volumeData); //FIXME - save this somewhere - could be expensive to create? VolumeIterator<boost::uint8_t> volIter(*volumeData); //FIXME - save this somewhere - could be expensive to create?
const float posX = position.x(); const float posX = position.x();
const float posY = position.y(); const float posY = position.y();
@ -695,7 +695,7 @@ namespace PolyVox
{ {
if(volumeData->containsPoint(Vector3DInt32(uX,uY,uZ),0)) if(volumeData->containsPoint(Vector3DInt32(uX,uY,uZ),0))
{ {
VolumeIterator volIter(*volumeData); VolumeIterator<boost::uint8_t> volIter(*volumeData);
return volIter.getVoxelAt(uX,uY,uZ); return volIter.getVoxelAt(uX,uY,uZ);
} }
else else