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

GCC compile fixes.

Browse Source
This commit is contained in:
David Williams 2011-07-31 08:08:00 +01:00
parent 53ae3de413
commit fb0a2d0dac
3 changed files with 204 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

160
library/PolyVoxCore/include/PolyVoxCore/LargeVolumeSampler.inl
View File

@ -53,9 +53,9 @@ namespace PolyVox
return *this; return *this;
} }
this->mVolume = rhs.mVolume; this->mVolume = rhs.mVolume;
mXPosInVolume = rhs.mXPosInVolume; this->mXPosInVolume = rhs.mXPosInVolume;
mYPosInVolume = rhs.mYPosInVolume; this->mYPosInVolume = rhs.mYPosInVolume;
mZPosInVolume = rhs.mZPosInVolume; this->mZPosInVolume = rhs.mZPosInVolume;
mCurrentVoxel = rhs.mCurrentVoxel; mCurrentVoxel = rhs.mCurrentVoxel;
return *this; return *this;
} }
@ -63,19 +63,19 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
int32_t LargeVolume<VoxelType>::Sampler::getPosX(void) const int32_t LargeVolume<VoxelType>::Sampler::getPosX(void) const
{ {
return mXPosInVolume; return this->mXPosInVolume;
} }
template <typename VoxelType> template <typename VoxelType>
int32_t LargeVolume<VoxelType>::Sampler::getPosY(void) const int32_t LargeVolume<VoxelType>::Sampler::getPosY(void) const
{ {
return mYPosInVolume; return this->mYPosInVolume;
} }
template <typename VoxelType> template <typename VoxelType>
int32_t LargeVolume<VoxelType>::Sampler::getPosZ(void) const int32_t LargeVolume<VoxelType>::Sampler::getPosZ(void) const
{ {
return mZPosInVolume; return this->mZPosInVolume;
} }
template <typename VoxelType> template <typename VoxelType>
@ -108,7 +108,7 @@ namespace PolyVox
{ {
for(uint8_t x = 0; x < uSize; ++x) for(uint8_t x = 0; x < uSize; ++x)
{ {
tValue = (std::min)(tValue, this->mVolume->getVoxelAt(mXPosInVolume + x, mYPosInVolume + y, mZPosInVolume + z)); tValue = (std::min)(tValue, this->mVolume->getVoxelAt(this->mXPosInVolume + x, this->mYPosInVolume + y, this->mZPosInVolume + z));
} }
} }
} }
@ -131,17 +131,17 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
void LargeVolume<VoxelType>::Sampler::setPosition(int32_t xPos, int32_t yPos, int32_t zPos) void LargeVolume<VoxelType>::Sampler::setPosition(int32_t xPos, int32_t yPos, int32_t zPos)
{ {
mXPosInVolume = xPos; this->mXPosInVolume = xPos;
mYPosInVolume = yPos; this->mYPosInVolume = yPos;
mZPosInVolume = zPos; this->mZPosInVolume = zPos;
const int32_t uXBlock = mXPosInVolume >> this->mVolume->m_uBlockSideLengthPower; const int32_t uXBlock = this->mXPosInVolume >> this->mVolume->m_uBlockSideLengthPower;
const int32_t uYBlock = mYPosInVolume >> this->mVolume->m_uBlockSideLengthPower; const int32_t uYBlock = this->mYPosInVolume >> this->mVolume->m_uBlockSideLengthPower;
const int32_t uZBlock = mZPosInVolume >> this->mVolume->m_uBlockSideLengthPower; const int32_t uZBlock = this->mZPosInVolume >> this->mVolume->m_uBlockSideLengthPower;
const uint16_t uXPosInBlock = mXPosInVolume - (uXBlock << this->mVolume->m_uBlockSideLengthPower); const uint16_t uXPosInBlock = this->mXPosInVolume - (uXBlock << this->mVolume->m_uBlockSideLengthPower);
const uint16_t uYPosInBlock = mYPosInVolume - (uYBlock << this->mVolume->m_uBlockSideLengthPower); const uint16_t uYPosInBlock = this->mYPosInVolume - (uYBlock << this->mVolume->m_uBlockSideLengthPower);
const uint16_t uZPosInBlock = mZPosInVolume - (uZBlock << this->mVolume->m_uBlockSideLengthPower); const uint16_t uZPosInBlock = this->mZPosInVolume - (uZBlock << this->mVolume->m_uBlockSideLengthPower);
const uint32_t uVoxelIndexInBlock = uXPosInBlock + const uint32_t uVoxelIndexInBlock = uXPosInBlock +
uYPosInBlock * this->mVolume->m_uBlockSideLength + uYPosInBlock * this->mVolume->m_uBlockSideLength +
@ -163,7 +163,7 @@ namespace PolyVox
void LargeVolume<VoxelType>::Sampler::movePositiveX(void) void LargeVolume<VoxelType>::Sampler::movePositiveX(void)
{ {
//Note the *pre* increament here //Note the *pre* increament here
if((++mXPosInVolume) % this->mVolume->m_uBlockSideLength != 0) if((++this->mXPosInVolume) % this->mVolume->m_uBlockSideLength != 0)
{ {
//No need to compute new block. //No need to compute new block.
++mCurrentVoxel; ++mCurrentVoxel;
@ -171,7 +171,7 @@ namespace PolyVox
else else
{ {
//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this. //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume); setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
} }
} }
@ -179,7 +179,7 @@ namespace PolyVox
void LargeVolume<VoxelType>::Sampler::movePositiveY(void) void LargeVolume<VoxelType>::Sampler::movePositiveY(void)
{ {
//Note the *pre* increament here //Note the *pre* increament here
if((++mYPosInVolume) % this->mVolume->m_uBlockSideLength != 0) if((++this->mYPosInVolume) % this->mVolume->m_uBlockSideLength != 0)
{ {
//No need to compute new block. //No need to compute new block.
mCurrentVoxel += this->mVolume->m_uBlockSideLength; mCurrentVoxel += this->mVolume->m_uBlockSideLength;
@ -187,7 +187,7 @@ namespace PolyVox
else else
{ {
//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this. //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume); setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
} }
} }
@ -195,7 +195,7 @@ namespace PolyVox
void LargeVolume<VoxelType>::Sampler::movePositiveZ(void) void LargeVolume<VoxelType>::Sampler::movePositiveZ(void)
{ {
//Note the *pre* increament here //Note the *pre* increament here
if((++mZPosInVolume) % this->mVolume->m_uBlockSideLength != 0) if((++this->mZPosInVolume) % this->mVolume->m_uBlockSideLength != 0)
{ {
//No need to compute new block. //No need to compute new block.
mCurrentVoxel += this->mVolume->m_uBlockSideLength * this->mVolume->m_uBlockSideLength; mCurrentVoxel += this->mVolume->m_uBlockSideLength * this->mVolume->m_uBlockSideLength;
@ -203,7 +203,7 @@ namespace PolyVox
else else
{ {
//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this. //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume); setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
} }
} }
@ -211,7 +211,7 @@ namespace PolyVox
void LargeVolume<VoxelType>::Sampler::moveNegativeX(void) void LargeVolume<VoxelType>::Sampler::moveNegativeX(void)
{ {
//Note the *post* decreament here //Note the *post* decreament here
if((mXPosInVolume--) % this->mVolume->m_uBlockSideLength != 0) if((this->mXPosInVolume--) % this->mVolume->m_uBlockSideLength != 0)
{ {
//No need to compute new block. //No need to compute new block.
--mCurrentVoxel; --mCurrentVoxel;
@ -219,7 +219,7 @@ namespace PolyVox
else else
{ {
//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this. //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume); setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
} }
} }
@ -227,7 +227,7 @@ namespace PolyVox
void LargeVolume<VoxelType>::Sampler::moveNegativeY(void) void LargeVolume<VoxelType>::Sampler::moveNegativeY(void)
{ {
//Note the *post* decreament here //Note the *post* decreament here
if((mYPosInVolume--) % this->mVolume->m_uBlockSideLength != 0) if((this->mYPosInVolume--) % this->mVolume->m_uBlockSideLength != 0)
{ {
//No need to compute new block. //No need to compute new block.
mCurrentVoxel -= this->mVolume->m_uBlockSideLength; mCurrentVoxel -= this->mVolume->m_uBlockSideLength;
@ -235,7 +235,7 @@ namespace PolyVox
else else
{ {
//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this. //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume); setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
} }
} }
@ -243,7 +243,7 @@ namespace PolyVox
void LargeVolume<VoxelType>::Sampler::moveNegativeZ(void) void LargeVolume<VoxelType>::Sampler::moveNegativeZ(void)
{ {
//Note the *post* decreament here //Note the *post* decreament here
if((mZPosInVolume--) % this->mVolume->m_uBlockSideLength != 0) if((this->mZPosInVolume--) % this->mVolume->m_uBlockSideLength != 0)
{ {
//No need to compute new block. //No need to compute new block.
mCurrentVoxel -= this->mVolume->m_uBlockSideLength * this->mVolume->m_uBlockSideLength; mCurrentVoxel -= this->mVolume->m_uBlockSideLength * this->mVolume->m_uBlockSideLength;
@ -251,98 +251,98 @@ namespace PolyVox
else else
{ {
//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this. //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume); setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
} }
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1ny1nz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1ny1nz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) && BORDER_LOW(mYPosInVolume) && BORDER_LOW(mZPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) && BORDER_LOW(this->mYPosInVolume) && BORDER_LOW(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume-1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1ny0pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1ny0pz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) && BORDER_LOW(mYPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) && BORDER_LOW(this->mYPosInVolume) )
{ {
return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume-1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1ny1pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1ny1pz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) && BORDER_LOW(mYPosInVolume) && BORDER_HIGH(mZPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) && BORDER_LOW(this->mYPosInVolume) && BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume-1,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx0py1nz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx0py1nz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) && BORDER_LOW(mZPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) && BORDER_LOW(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx0py0pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx0py0pz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) )
{ {
return *(mCurrentVoxel - 1); return *(mCurrentVoxel - 1);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx0py1pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx0py1pz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) && BORDER_HIGH(mZPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) && BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1py1nz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1py1nz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) && BORDER_HIGH(mYPosInVolume) && BORDER_LOW(mYPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) && BORDER_HIGH(this->mYPosInVolume) && BORDER_LOW(this->mYPosInVolume) )
{ {
return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume+1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume+1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1py0pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1py0pz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) && BORDER_HIGH(mYPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) && BORDER_HIGH(this->mYPosInVolume) )
{ {
return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume+1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume+1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1py1pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1py1pz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) && BORDER_HIGH(mYPosInVolume) && BORDER_HIGH(mZPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) && BORDER_HIGH(this->mYPosInVolume) && BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume+1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume+1,this->mZPosInVolume+1);
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
@ -350,41 +350,41 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1ny1nz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1ny1nz(void) const
{ {
if( BORDER_LOW(mYPosInVolume) && BORDER_LOW(mZPosInVolume) ) if( BORDER_LOW(this->mYPosInVolume) && BORDER_LOW(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume-1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1ny0pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1ny0pz(void) const
{ {
if( BORDER_LOW(mYPosInVolume) ) if( BORDER_LOW(this->mYPosInVolume) )
{ {
return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume-1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1ny1pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1ny1pz(void) const
{ {
if( BORDER_LOW(mYPosInVolume) && BORDER_HIGH(mZPosInVolume) ) if( BORDER_LOW(this->mYPosInVolume) && BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume-1,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px0py1nz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px0py1nz(void) const
{ {
if( BORDER_LOW(mZPosInVolume) ) if( BORDER_LOW(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
@ -396,41 +396,41 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px0py1pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px0py1pz(void) const
{ {
if( BORDER_HIGH(mZPosInVolume) ) if( BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1py1nz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1py1nz(void) const
{ {
if( BORDER_HIGH(mYPosInVolume) && BORDER_LOW(mZPosInVolume) ) if( BORDER_HIGH(this->mYPosInVolume) && BORDER_LOW(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume+1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume+1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1py0pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1py0pz(void) const
{ {
if( BORDER_HIGH(mYPosInVolume) ) if( BORDER_HIGH(this->mYPosInVolume) )
{ {
return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume+1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume+1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1py1pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1py1pz(void) const
{ {
if( BORDER_HIGH(mYPosInVolume) && BORDER_HIGH(mZPosInVolume) ) if( BORDER_HIGH(this->mYPosInVolume) && BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume+1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume+1,this->mZPosInVolume+1);
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
@ -438,90 +438,90 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1ny1nz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1ny1nz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) && BORDER_LOW(mYPosInVolume) && BORDER_LOW(mZPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) && BORDER_LOW(this->mYPosInVolume) && BORDER_LOW(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume-1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1ny0pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1ny0pz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) && BORDER_LOW(mYPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) && BORDER_LOW(this->mYPosInVolume) )
{ {
return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume-1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1ny1pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1ny1pz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) && BORDER_LOW(mYPosInVolume) && BORDER_HIGH(mZPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) && BORDER_LOW(this->mYPosInVolume) && BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume-1,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px0py1nz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px0py1nz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) && BORDER_LOW(mZPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) && BORDER_LOW(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px0py0pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px0py0pz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) )
{ {
return *(mCurrentVoxel + 1); return *(mCurrentVoxel + 1);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px0py1pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px0py1pz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) && BORDER_HIGH(mZPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) && BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1py1nz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1py1nz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) && BORDER_HIGH(mYPosInVolume) && BORDER_LOW(mZPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) && BORDER_HIGH(this->mYPosInVolume) && BORDER_LOW(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume+1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume+1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1py0pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1py0pz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) && BORDER_HIGH(mYPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) && BORDER_HIGH(this->mYPosInVolume) )
{ {
return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume+1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume+1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1py1pz(void) const VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1py1pz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) && BORDER_HIGH(mYPosInVolume) && BORDER_HIGH(mZPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) && BORDER_HIGH(this->mYPosInVolume) && BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume+1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume+1,this->mZPosInVolume+1);
} }
} }

88
library/PolyVoxCore/include/PolyVoxCore/RawVolumeSampler.inl
View File

@ -45,19 +45,19 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
int32_t RawVolume<VoxelType>::Sampler::getPosX(void) const int32_t RawVolume<VoxelType>::Sampler::getPosX(void) const
{ {
return mXPosInVolume; return this->mXPosInVolume;
} }
template <typename VoxelType> template <typename VoxelType>
int32_t RawVolume<VoxelType>::Sampler::getPosY(void) const int32_t RawVolume<VoxelType>::Sampler::getPosY(void) const
{ {
return mYPosInVolume; return this->mYPosInVolume;
} }
template <typename VoxelType> template <typename VoxelType>
int32_t RawVolume<VoxelType>::Sampler::getPosZ(void) const int32_t RawVolume<VoxelType>::Sampler::getPosZ(void) const
{ {
return mZPosInVolume; return this->mZPosInVolume;
} }
template <typename VoxelType> template <typename VoxelType>
@ -75,9 +75,9 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
void RawVolume<VoxelType>::Sampler::setPosition(int32_t xPos, int32_t yPos, int32_t zPos) void RawVolume<VoxelType>::Sampler::setPosition(int32_t xPos, int32_t yPos, int32_t zPos)
{ {
mXPosInVolume = xPos; this->mXPosInVolume = xPos;
mYPosInVolume = yPos; this->mYPosInVolume = yPos;
mZPosInVolume = zPos; this->mZPosInVolume = zPos;
const uint32_t uVoxelIndex = xPos + const uint32_t uVoxelIndex = xPos +
yPos * this->mVolume->getWidth() + yPos * this->mVolume->getWidth() +
@ -91,103 +91,103 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
void RawVolume<VoxelType>::Sampler::movePositiveX(void) void RawVolume<VoxelType>::Sampler::movePositiveX(void)
{ {
mXPosInVolume++; this->mXPosInVolume++;
++mCurrentVoxel; ++mCurrentVoxel;
m_bIsCurrentPositionValid = mXPosInVolume <= this->mVolume->getEnclosingRegion().getUpperCorner().getX(); m_bIsCurrentPositionValid = this->mXPosInVolume <= this->mVolume->getEnclosingRegion().getUpperCorner().getX();
} }
template <typename VoxelType> template <typename VoxelType>
void RawVolume<VoxelType>::Sampler::movePositiveY(void) void RawVolume<VoxelType>::Sampler::movePositiveY(void)
{ {
mYPosInVolume++; this->mYPosInVolume++;
mCurrentVoxel += this->mVolume->getWidth(); mCurrentVoxel += this->mVolume->getWidth();
m_bIsCurrentPositionValid = mYPosInVolume <= this->mVolume->getEnclosingRegion().getUpperCorner().getY(); m_bIsCurrentPositionValid = this->mYPosInVolume <= this->mVolume->getEnclosingRegion().getUpperCorner().getY();
} }
template <typename VoxelType> template <typename VoxelType>
void RawVolume<VoxelType>::Sampler::movePositiveZ(void) void RawVolume<VoxelType>::Sampler::movePositiveZ(void)
{ {
mZPosInVolume++; this->mZPosInVolume++;
mCurrentVoxel += this->mVolume->getWidth() * this->mVolume->getHeight(); mCurrentVoxel += this->mVolume->getWidth() * this->mVolume->getHeight();
m_bIsCurrentPositionValid = mZPosInVolume <= this->mVolume->getEnclosingRegion().getUpperCorner().getZ(); m_bIsCurrentPositionValid = this->mZPosInVolume <= this->mVolume->getEnclosingRegion().getUpperCorner().getZ();
} }
template <typename VoxelType> template <typename VoxelType>
void RawVolume<VoxelType>::Sampler::moveNegativeX(void) void RawVolume<VoxelType>::Sampler::moveNegativeX(void)
{ {
mXPosInVolume--; this->mXPosInVolume--;
--mCurrentVoxel; --mCurrentVoxel;
m_bIsCurrentPositionValid = mXPosInVolume >= this->mVolume->getEnclosingRegion().getLowerCorner().getX(); m_bIsCurrentPositionValid = this->mXPosInVolume >= this->mVolume->getEnclosingRegion().getLowerCorner().getX();
} }
template <typename VoxelType> template <typename VoxelType>
void RawVolume<VoxelType>::Sampler::moveNegativeY(void) void RawVolume<VoxelType>::Sampler::moveNegativeY(void)
{ {
mYPosInVolume--; this->mYPosInVolume--;
mCurrentVoxel -= this->mVolume->getWidth(); mCurrentVoxel -= this->mVolume->getWidth();
m_bIsCurrentPositionValid = mYPosInVolume >= this->mVolume->getEnclosingRegion().getLowerCorner().getY(); m_bIsCurrentPositionValid = this->mYPosInVolume >= this->mVolume->getEnclosingRegion().getLowerCorner().getY();
} }
template <typename VoxelType> template <typename VoxelType>
void RawVolume<VoxelType>::Sampler::moveNegativeZ(void) void RawVolume<VoxelType>::Sampler::moveNegativeZ(void)
{ {
mZPosInVolume--; this->mZPosInVolume--;
mCurrentVoxel -= this->mVolume->getWidth() * this->mVolume->getHeight(); mCurrentVoxel -= this->mVolume->getWidth() * this->mVolume->getHeight();
m_bIsCurrentPositionValid =mZPosInVolume >= this->mVolume->getEnclosingRegion().getLowerCorner().getZ(); m_bIsCurrentPositionValid =this->mZPosInVolume >= this->mVolume->getEnclosingRegion().getLowerCorner().getZ();
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx1ny1nz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx1ny1nz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume-1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx1ny0pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx1ny0pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume-1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx1ny1pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx1ny1pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume-1,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx0py1nz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx0py1nz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx0py0pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx0py0pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx0py1pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx0py1pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx1py1nz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx1py1nz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume+1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume+1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx1py0pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx1py0pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume+1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume+1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx1py1pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1nx1py1pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume+1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume+1,this->mZPosInVolume+1);
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
@ -195,25 +195,25 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel0px1ny1nz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel0px1ny1nz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume-1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel0px1ny0pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel0px1ny0pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume-1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel0px1ny1pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel0px1ny1pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume-1,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel0px0py1nz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel0px0py1nz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
@ -225,25 +225,25 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel0px0py1pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel0px0py1pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel0px1py1nz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel0px1py1nz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume+1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume+1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel0px1py0pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel0px1py0pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume+1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume+1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel0px1py1pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel0px1py1pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume+1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume+1,this->mZPosInVolume+1);
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
@ -251,54 +251,54 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px1ny1nz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px1ny1nz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume-1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px1ny0pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px1ny0pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume-1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px1ny1pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px1ny1pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume-1,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px0py1nz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px0py1nz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px0py0pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px0py0pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px0py1pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px0py1pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px1py1nz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px1py1nz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume+1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume+1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px1py0pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px1py0pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume+1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume+1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px1py1pz(void) const VoxelType RawVolume<VoxelType>::Sampler::peekVoxel1px1py1pz(void) const
{ {
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume+1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume+1,this->mZPosInVolume+1);
} }
} }

160
library/PolyVoxCore/include/PolyVoxCore/SimpleVolumeSampler.inl
View File

@ -53,9 +53,9 @@ namespace PolyVox
return *this; return *this;
} }
this->mVolume = rhs.mVolume; this->mVolume = rhs.mVolume;
mXPosInVolume = rhs.mXPosInVolume; this->mXPosInVolume = rhs.mXPosInVolume;
mYPosInVolume = rhs.mYPosInVolume; this->mYPosInVolume = rhs.mYPosInVolume;
mZPosInVolume = rhs.mZPosInVolume; this->mZPosInVolume = rhs.mZPosInVolume;
mCurrentVoxel = rhs.mCurrentVoxel; mCurrentVoxel = rhs.mCurrentVoxel;
return *this; return *this;
} }
@ -63,19 +63,19 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
int32_t SimpleVolume<VoxelType>::Sampler::getPosX(void) const int32_t SimpleVolume<VoxelType>::Sampler::getPosX(void) const
{ {
return mXPosInVolume; return this->mXPosInVolume;
} }
template <typename VoxelType> template <typename VoxelType>
int32_t SimpleVolume<VoxelType>::Sampler::getPosY(void) const int32_t SimpleVolume<VoxelType>::Sampler::getPosY(void) const
{ {
return mYPosInVolume; return this->mYPosInVolume;
} }
template <typename VoxelType> template <typename VoxelType>
int32_t SimpleVolume<VoxelType>::Sampler::getPosZ(void) const int32_t SimpleVolume<VoxelType>::Sampler::getPosZ(void) const
{ {
return mZPosInVolume; return this->mZPosInVolume;
} }
template <typename VoxelType> template <typename VoxelType>
@ -108,7 +108,7 @@ namespace PolyVox
{ {
for(uint8_t x = 0; x < uSize; ++x) for(uint8_t x = 0; x < uSize; ++x)
{ {
tValue = (std::min)(tValue, this->mVolume->getVoxelAt(mXPosInVolume + x, mYPosInVolume + y, mZPosInVolume + z)); tValue = (std::min)(tValue, this->mVolume->getVoxelAt(this->mXPosInVolume + x, this->mYPosInVolume + y, this->mZPosInVolume + z));
} }
} }
} }
@ -131,17 +131,17 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
void SimpleVolume<VoxelType>::Sampler::setPosition(int32_t xPos, int32_t yPos, int32_t zPos) void SimpleVolume<VoxelType>::Sampler::setPosition(int32_t xPos, int32_t yPos, int32_t zPos)
{ {
mXPosInVolume = xPos; this->mXPosInVolume = xPos;
mYPosInVolume = yPos; this->mYPosInVolume = yPos;
mZPosInVolume = zPos; this->mZPosInVolume = zPos;
const int32_t uXBlock = mXPosInVolume >> this->mVolume->m_uBlockSideLengthPower; const int32_t uXBlock = this->mXPosInVolume >> this->mVolume->m_uBlockSideLengthPower;
const int32_t uYBlock = mYPosInVolume >> this->mVolume->m_uBlockSideLengthPower; const int32_t uYBlock = this->mYPosInVolume >> this->mVolume->m_uBlockSideLengthPower;
const int32_t uZBlock = mZPosInVolume >> this->mVolume->m_uBlockSideLengthPower; const int32_t uZBlock = this->mZPosInVolume >> this->mVolume->m_uBlockSideLengthPower;
const uint16_t uXPosInBlock = mXPosInVolume - (uXBlock << this->mVolume->m_uBlockSideLengthPower); const uint16_t uXPosInBlock = this->mXPosInVolume - (uXBlock << this->mVolume->m_uBlockSideLengthPower);
const uint16_t uYPosInBlock = mYPosInVolume - (uYBlock << this->mVolume->m_uBlockSideLengthPower); const uint16_t uYPosInBlock = this->mYPosInVolume - (uYBlock << this->mVolume->m_uBlockSideLengthPower);
const uint16_t uZPosInBlock = mZPosInVolume - (uZBlock << this->mVolume->m_uBlockSideLengthPower); const uint16_t uZPosInBlock = this->mZPosInVolume - (uZBlock << this->mVolume->m_uBlockSideLengthPower);
const uint32_t uVoxelIndexInBlock = uXPosInBlock + const uint32_t uVoxelIndexInBlock = uXPosInBlock +
uYPosInBlock * this->mVolume->m_uBlockSideLength + uYPosInBlock * this->mVolume->m_uBlockSideLength +
@ -163,7 +163,7 @@ namespace PolyVox
void SimpleVolume<VoxelType>::Sampler::movePositiveX(void) void SimpleVolume<VoxelType>::Sampler::movePositiveX(void)
{ {
//Note the *pre* increament here //Note the *pre* increament here
if((++mXPosInVolume) % this->mVolume->m_uBlockSideLength != 0) if((++this->mXPosInVolume) % this->mVolume->m_uBlockSideLength != 0)
{ {
//No need to compute new block. //No need to compute new block.
++mCurrentVoxel; ++mCurrentVoxel;
@ -171,7 +171,7 @@ namespace PolyVox
else else
{ {
//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this. //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume); setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
} }
} }
@ -179,7 +179,7 @@ namespace PolyVox
void SimpleVolume<VoxelType>::Sampler::movePositiveY(void) void SimpleVolume<VoxelType>::Sampler::movePositiveY(void)
{ {
//Note the *pre* increament here //Note the *pre* increament here
if((++mYPosInVolume) % this->mVolume->m_uBlockSideLength != 0) if((++this->mYPosInVolume) % this->mVolume->m_uBlockSideLength != 0)
{ {
//No need to compute new block. //No need to compute new block.
mCurrentVoxel += this->mVolume->m_uBlockSideLength; mCurrentVoxel += this->mVolume->m_uBlockSideLength;
@ -187,7 +187,7 @@ namespace PolyVox
else else
{ {
//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this. //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume); setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
} }
} }
@ -195,7 +195,7 @@ namespace PolyVox
void SimpleVolume<VoxelType>::Sampler::movePositiveZ(void) void SimpleVolume<VoxelType>::Sampler::movePositiveZ(void)
{ {
//Note the *pre* increament here //Note the *pre* increament here
if((++mZPosInVolume) % this->mVolume->m_uBlockSideLength != 0) if((++this->mZPosInVolume) % this->mVolume->m_uBlockSideLength != 0)
{ {
//No need to compute new block. //No need to compute new block.
mCurrentVoxel += this->mVolume->m_uBlockSideLength * this->mVolume->m_uBlockSideLength; mCurrentVoxel += this->mVolume->m_uBlockSideLength * this->mVolume->m_uBlockSideLength;
@ -203,7 +203,7 @@ namespace PolyVox
else else
{ {
//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this. //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume); setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
} }
} }
@ -211,7 +211,7 @@ namespace PolyVox
void SimpleVolume<VoxelType>::Sampler::moveNegativeX(void) void SimpleVolume<VoxelType>::Sampler::moveNegativeX(void)
{ {
//Note the *post* decreament here //Note the *post* decreament here
if((mXPosInVolume--) % this->mVolume->m_uBlockSideLength != 0) if((this->mXPosInVolume--) % this->mVolume->m_uBlockSideLength != 0)
{ {
//No need to compute new block. //No need to compute new block.
--mCurrentVoxel; --mCurrentVoxel;
@ -219,7 +219,7 @@ namespace PolyVox
else else
{ {
//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this. //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume); setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
} }
} }
@ -227,7 +227,7 @@ namespace PolyVox
void SimpleVolume<VoxelType>::Sampler::moveNegativeY(void) void SimpleVolume<VoxelType>::Sampler::moveNegativeY(void)
{ {
//Note the *post* decreament here //Note the *post* decreament here
if((mYPosInVolume--) % this->mVolume->m_uBlockSideLength != 0) if((this->mYPosInVolume--) % this->mVolume->m_uBlockSideLength != 0)
{ {
//No need to compute new block. //No need to compute new block.
mCurrentVoxel -= this->mVolume->m_uBlockSideLength; mCurrentVoxel -= this->mVolume->m_uBlockSideLength;
@ -235,7 +235,7 @@ namespace PolyVox
else else
{ {
//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this. //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume); setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
} }
} }
@ -243,7 +243,7 @@ namespace PolyVox
void SimpleVolume<VoxelType>::Sampler::moveNegativeZ(void) void SimpleVolume<VoxelType>::Sampler::moveNegativeZ(void)
{ {
//Note the *post* decreament here //Note the *post* decreament here
if((mZPosInVolume--) % this->mVolume->m_uBlockSideLength != 0) if((this->mZPosInVolume--) % this->mVolume->m_uBlockSideLength != 0)
{ {
//No need to compute new block. //No need to compute new block.
mCurrentVoxel -= this->mVolume->m_uBlockSideLength * this->mVolume->m_uBlockSideLength; mCurrentVoxel -= this->mVolume->m_uBlockSideLength * this->mVolume->m_uBlockSideLength;
@ -251,98 +251,98 @@ namespace PolyVox
else else
{ {
//We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this. //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
setPosition(mXPosInVolume, mYPosInVolume, mZPosInVolume); setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
} }
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx1ny1nz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx1ny1nz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) && BORDER_LOW(mYPosInVolume) && BORDER_LOW(mZPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) && BORDER_LOW(this->mYPosInVolume) && BORDER_LOW(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume-1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx1ny0pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx1ny0pz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) && BORDER_LOW(mYPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) && BORDER_LOW(this->mYPosInVolume) )
{ {
return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume-1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx1ny1pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx1ny1pz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) && BORDER_LOW(mYPosInVolume) && BORDER_HIGH(mZPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) && BORDER_LOW(this->mYPosInVolume) && BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume-1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume-1,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx0py1nz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx0py1nz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) && BORDER_LOW(mZPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) && BORDER_LOW(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx0py0pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx0py0pz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) )
{ {
return *(mCurrentVoxel - 1); return *(mCurrentVoxel - 1);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx0py1pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx0py1pz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) && BORDER_HIGH(mZPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) && BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx1py1nz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx1py1nz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) && BORDER_HIGH(mYPosInVolume) && BORDER_LOW(mYPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) && BORDER_HIGH(this->mYPosInVolume) && BORDER_LOW(this->mYPosInVolume) )
{ {
return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume+1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume+1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx1py0pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx1py0pz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) && BORDER_HIGH(mYPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) && BORDER_HIGH(this->mYPosInVolume) )
{ {
return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume+1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume+1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx1py1pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1nx1py1pz(void) const
{ {
if( BORDER_LOW(mXPosInVolume) && BORDER_HIGH(mYPosInVolume) && BORDER_HIGH(mZPosInVolume) ) if( BORDER_LOW(this->mXPosInVolume) && BORDER_HIGH(this->mYPosInVolume) && BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume-1,mYPosInVolume+1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume-1,this->mYPosInVolume+1,this->mZPosInVolume+1);
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
@ -350,41 +350,41 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel0px1ny1nz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel0px1ny1nz(void) const
{ {
if( BORDER_LOW(mYPosInVolume) && BORDER_LOW(mZPosInVolume) ) if( BORDER_LOW(this->mYPosInVolume) && BORDER_LOW(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume-1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel0px1ny0pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel0px1ny0pz(void) const
{ {
if( BORDER_LOW(mYPosInVolume) ) if( BORDER_LOW(this->mYPosInVolume) )
{ {
return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume-1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel0px1ny1pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel0px1ny1pz(void) const
{ {
if( BORDER_LOW(mYPosInVolume) && BORDER_HIGH(mZPosInVolume) ) if( BORDER_LOW(this->mYPosInVolume) && BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume-1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume-1,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel0px0py1nz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel0px0py1nz(void) const
{ {
if( BORDER_LOW(mZPosInVolume) ) if( BORDER_LOW(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
@ -396,41 +396,41 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel0px0py1pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel0px0py1pz(void) const
{ {
if( BORDER_HIGH(mZPosInVolume) ) if( BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel0px1py1nz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel0px1py1nz(void) const
{ {
if( BORDER_HIGH(mYPosInVolume) && BORDER_LOW(mZPosInVolume) ) if( BORDER_HIGH(this->mYPosInVolume) && BORDER_LOW(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume+1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume+1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel0px1py0pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel0px1py0pz(void) const
{ {
if( BORDER_HIGH(mYPosInVolume) ) if( BORDER_HIGH(this->mYPosInVolume) )
{ {
return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume+1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume+1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel0px1py1pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel0px1py1pz(void) const
{ {
if( BORDER_HIGH(mYPosInVolume) && BORDER_HIGH(mZPosInVolume) ) if( BORDER_HIGH(this->mYPosInVolume) && BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume,mYPosInVolume+1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume,this->mYPosInVolume+1,this->mZPosInVolume+1);
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
@ -438,90 +438,90 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px1ny1nz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px1ny1nz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) && BORDER_LOW(mYPosInVolume) && BORDER_LOW(mZPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) && BORDER_LOW(this->mYPosInVolume) && BORDER_LOW(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume-1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px1ny0pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px1ny0pz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) && BORDER_LOW(mYPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) && BORDER_LOW(this->mYPosInVolume) )
{ {
return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume-1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px1ny1pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px1ny1pz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) && BORDER_LOW(mYPosInVolume) && BORDER_HIGH(mZPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) && BORDER_LOW(this->mYPosInVolume) && BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume-1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume-1,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px0py1nz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px0py1nz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) && BORDER_LOW(mZPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) && BORDER_LOW(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px0py0pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px0py0pz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) )
{ {
return *(mCurrentVoxel + 1); return *(mCurrentVoxel + 1);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px0py1pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px0py1pz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) && BORDER_HIGH(mZPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) && BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume,this->mZPosInVolume+1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px1py1nz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px1py1nz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) && BORDER_HIGH(mYPosInVolume) && BORDER_LOW(mZPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) && BORDER_HIGH(this->mYPosInVolume) && BORDER_LOW(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume+1,mZPosInVolume-1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume+1,this->mZPosInVolume-1);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px1py0pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px1py0pz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) && BORDER_HIGH(mYPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) && BORDER_HIGH(this->mYPosInVolume) )
{ {
return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume+1,mZPosInVolume); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume+1,this->mZPosInVolume);
} }
template <typename VoxelType> template <typename VoxelType>
VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px1py1pz(void) const VoxelType SimpleVolume<VoxelType>::Sampler::peekVoxel1px1py1pz(void) const
{ {
if( BORDER_HIGH(mXPosInVolume) && BORDER_HIGH(mYPosInVolume) && BORDER_HIGH(mZPosInVolume) ) if( BORDER_HIGH(this->mXPosInVolume) && BORDER_HIGH(this->mYPosInVolume) && BORDER_HIGH(this->mZPosInVolume) )
{ {
return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength); return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
} }
return this->mVolume->getVoxelAt(mXPosInVolume+1,mYPosInVolume+1,mZPosInVolume+1); return this->mVolume->getVoxelAt(this->mXPosInVolume+1,this->mYPosInVolume+1,this->mZPosInVolume+1);
} }
} }