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

Renamed BlockData to Block

Browse Source
This commit is contained in:
David Williams 2009-04-26 21:09:01 +00:00
parent ed5bff9ee1
commit b7ea308897
6 changed files with 42 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
library/PolyVoxCore/include/Block.h
View File

@ -31,16 +31,16 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
namespace PolyVox
{
template <typename VoxelType>
class BlockData
class Block
{
//Make VolumeIterator a friend
friend class VolumeIterator<VoxelType>;
public:
BlockData(uint16_t uSideLength);
BlockData(const BlockData& rhs);
~BlockData();
Block(uint16_t uSideLength);
Block(const Block& rhs);
~Block();
BlockData& operator=(const BlockData& rhs);
Block& operator=(const Block& rhs);
uint16_t getSideLength(void) const;
VoxelType getVoxelAt(uint16_t uXPos, uint16_t uYPos, uint16_t uZPos) const;

24
library/PolyVoxCore/include/Block.inl
View File

@ -33,7 +33,7 @@ namespace PolyVox
{
#pragma region Constructors/Destructors
template <typename VoxelType>
BlockData<VoxelType>::BlockData(uint16_t uSideLength)
Block<VoxelType>::Block(uint16_t uSideLength)
:m_tData(0)
{
//Debug mode validation
@ -42,7 +42,7 @@ namespace PolyVox
//Release mode validation
if(!isPowerOf2(uSideLength))
{
throw std::invalid_argument("BlockData side length must be a power of two.");
throw std::invalid_argument("Block side length must be a power of two.");
}
//Compute the side length
@ -55,13 +55,13 @@ namespace PolyVox
}
template <typename VoxelType>
BlockData<VoxelType>::BlockData(const BlockData<VoxelType>& rhs)
Block<VoxelType>::Block(const Block<VoxelType>& rhs)
{
*this = rhs;
}
template <typename VoxelType>
BlockData<VoxelType>::~BlockData()
Block<VoxelType>::~Block()
{
delete[] m_tData;
m_tData = 0;
@ -70,7 +70,7 @@ namespace PolyVox
#pragma region Operators
template <typename VoxelType>
BlockData<VoxelType>& BlockData<VoxelType>::operator=(const BlockData<VoxelType>& rhs)
Block<VoxelType>& Block<VoxelType>::operator=(const Block<VoxelType>& rhs)
{
if (this == &rhs)
{
@ -92,13 +92,13 @@ namespace PolyVox
#pragma region Getters
template <typename VoxelType>
uint16_t BlockData<VoxelType>::getSideLength(void) const
uint16_t Block<VoxelType>::getSideLength(void) const
{
return m_uSideLength;
}
template <typename VoxelType>
VoxelType BlockData<VoxelType>::getVoxelAt(uint16_t uXPos, uint16_t uYPos, uint16_t uZPos) const
VoxelType Block<VoxelType>::getVoxelAt(uint16_t uXPos, uint16_t uYPos, uint16_t uZPos) const
{
assert(uXPos < m_uSideLength);
assert(uYPos < m_uSideLength);
@ -113,7 +113,7 @@ namespace PolyVox
}
template <typename VoxelType>
VoxelType BlockData<VoxelType>::getVoxelAt(const Vector3DUint16& v3dPos) const
VoxelType Block<VoxelType>::getVoxelAt(const Vector3DUint16& v3dPos) const
{
return getVoxelAt(v3dPos.getX(), v3dPos.getY(), v3dPos.getZ());
}
@ -121,7 +121,7 @@ namespace PolyVox
#pragma region Setters
template <typename VoxelType>
void BlockData<VoxelType>::setVoxelAt(uint16_t uXPos, uint16_t uYPos, uint16_t uZPos, VoxelType tValue)
void Block<VoxelType>::setVoxelAt(uint16_t uXPos, uint16_t uYPos, uint16_t uZPos, VoxelType tValue)
{
assert(uXPos < m_uSideLength);
assert(uYPos < m_uSideLength);
@ -136,7 +136,7 @@ namespace PolyVox
}
template <typename VoxelType>
void BlockData<VoxelType>::setVoxelAt(const Vector3DUint16& v3dPos, VoxelType tValue)
void Block<VoxelType>::setVoxelAt(const Vector3DUint16& v3dPos, VoxelType tValue)
{
setVoxelAt(v3dPos.getX(), v3dPos.getY(), v3dPos.getZ(), tValue);
}
@ -144,13 +144,13 @@ namespace PolyVox
#pragma region Other
template <typename VoxelType>
void BlockData<VoxelType>::fill(VoxelType tValue)
void Block<VoxelType>::fill(VoxelType tValue)
{
memset(m_tData, (int)tValue, m_uSideLength * m_uSideLength * m_uSideLength * sizeof(VoxelType));
}
template <typename VoxelType>
bool BlockData<VoxelType>::isHomogeneous(void)
bool Block<VoxelType>::isHomogeneous(void)
{
const VoxelType tFirstVoxel = m_tData[0];
const uint32_t uNoOfVoxels = m_uSideLength * m_uSideLength * m_uSideLength;

2
library/PolyVoxCore/include/PolyVoxForwardDeclarations.h
View File

@ -26,7 +26,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
namespace PolyVox
{
template <typename VoxelType> class BlockData;
template <typename VoxelType> class Block;
//---------- Volume ----------
template <typename VoxelType> class Volume;

8
library/PolyVoxCore/include/Volume.h
View File

@ -66,9 +66,9 @@ namespace PolyVox
bool isRegionHomogenous(const Region& region);
private:
POLYVOX_SHARED_PTR< BlockData<VoxelType> > getHomogenousBlockData(VoxelType tHomogenousValue) const;
POLYVOX_SHARED_PTR< Block<VoxelType> > getHomogenousBlock(VoxelType tHomogenousValue) const;
std::vector< POLYVOX_SHARED_PTR< BlockData<VoxelType> > > m_pBlocks;
std::vector< POLYVOX_SHARED_PTR< Block<VoxelType> > > m_pBlocks;
std::vector<bool> m_vecBlockIsPotentiallyHomogenous;
//Note: We were once storing weak_ptr's in this map, so that the blocks would be deleted once they
@ -76,7 +76,7 @@ namespace PolyVox
//shared. A call to shared_ptr::unique() from within setVoxel was not sufficient as weak_ptr's did
//not contribute to the reference count. Instead we store shared_ptr's here, and check if they
//are used by anyone else (i.e are non-unique) when we tidy the volume.
static std::map<VoxelType, POLYVOX_SHARED_PTR< BlockData<VoxelType> > > m_pHomogenousBlockData;
static std::map<VoxelType, POLYVOX_SHARED_PTR< Block<VoxelType> > > m_pHomogenousBlock;
uint32_t m_uNoOfBlocksInVolume;
@ -105,7 +105,7 @@ namespace PolyVox
};
//Required for the static member
template <class VoxelType> std::map<VoxelType, POLYVOX_SHARED_PTR< BlockData<VoxelType> > > Volume<VoxelType>::m_pHomogenousBlockData;
template <class VoxelType> std::map<VoxelType, POLYVOX_SHARED_PTR< Block<VoxelType> > > Volume<VoxelType>::m_pHomogenousBlock;
//Some handy typedefs

32
library/PolyVoxCore/include/Volume.inl
View File

@ -109,7 +109,7 @@ namespace PolyVox
m_vecBlockIsPotentiallyHomogenous.resize(m_uNoOfBlocksInVolume);
for(uint32_t i = 0; i < m_uNoOfBlocksInVolume; ++i)
{
m_pBlocks[i] = getHomogenousBlockData(0);
m_pBlocks[i] = getHomogenousBlock(0);
m_vecBlockIsPotentiallyHomogenous[i] = false;
}
@ -197,7 +197,7 @@ namespace PolyVox
const uint16_t yOffset = uYPos - (blockY << m_uBlockSideLengthPower);
const uint16_t zOffset = uZPos - (blockZ << m_uBlockSideLengthPower);
const POLYVOX_SHARED_PTR< BlockData< VoxelType > >& block = m_pBlocks
const POLYVOX_SHARED_PTR< Block< VoxelType > >& block = m_pBlocks
[
blockX +
blockY * m_uWidthInBlocks +
@ -235,7 +235,7 @@ namespace PolyVox
blockY * m_uWidthInBlocks +
blockZ * m_uWidthInBlocks * m_uHeightInBlocks;
POLYVOX_SHARED_PTR< BlockData<VoxelType> >& block = m_pBlocks[uBlockIndex];
POLYVOX_SHARED_PTR< Block<VoxelType> >& block = m_pBlocks[uBlockIndex];
//It's quite possible that the user might attempt to set a voxel to it's current value.
//We test for this case firstly because it could help performance, but more importantly
@ -251,8 +251,8 @@ namespace PolyVox
}
else
{
POLYVOX_SHARED_PTR< BlockData<VoxelType> > pNewBlockData(new BlockData<VoxelType>(*(block)));
block = pNewBlockData;
POLYVOX_SHARED_PTR< Block<VoxelType> > pNewBlock(new Block<VoxelType>(*(block)));
block = pNewBlock;
m_vecBlockIsPotentiallyHomogenous[uBlockIndex] = false;
block->setVoxelAt(xOffset,yOffset,zOffset, tValue);
}
@ -291,7 +291,7 @@ namespace PolyVox
{
//If so, replace is with a block from out homogeneous collection.
VoxelType homogeneousValue = m_pBlocks[m_uCurrentBlockForTidying]->getVoxelAt(0,0,0);
m_pBlocks[m_uCurrentBlockForTidying] = getHomogenousBlockData(homogeneousValue);
m_pBlocks[m_uCurrentBlockForTidying] = getHomogenousBlock(homogeneousValue);
}
//Either way, we have now determined whether the block was sharable. So it's not *potentially* sharable.
@ -307,12 +307,12 @@ namespace PolyVox
}
//Identify and remove any homogeneous blocks which are not actually in use.
typename std::map<VoxelType, POLYVOX_SHARED_PTR< BlockData<VoxelType> > >::iterator iter = m_pHomogenousBlockData.begin();
while(iter != m_pHomogenousBlockData.end())
typename std::map<VoxelType, POLYVOX_SHARED_PTR< Block<VoxelType> > >::iterator iter = m_pHomogenousBlock.begin();
while(iter != m_pHomogenousBlock.end())
{
if(iter->second.unique())
{
m_pHomogenousBlockData.erase(iter++); //Increments the iterator and returns the previous position to be erased.
m_pHomogenousBlock.erase(iter++); //Increments the iterator and returns the previous position to be erased.
}
else
{
@ -346,23 +346,23 @@ namespace PolyVox
#pragma region Private Implementation
template <typename VoxelType>
POLYVOX_SHARED_PTR< BlockData<VoxelType> > Volume<VoxelType>::getHomogenousBlockData(VoxelType tHomogenousValue) const
POLYVOX_SHARED_PTR< Block<VoxelType> > Volume<VoxelType>::getHomogenousBlock(VoxelType tHomogenousValue) const
{
typename std::map<VoxelType, POLYVOX_SHARED_PTR< BlockData<VoxelType> > >::iterator iterResult = m_pHomogenousBlockData.find(tHomogenousValue);
if(iterResult == m_pHomogenousBlockData.end())
typename std::map<VoxelType, POLYVOX_SHARED_PTR< Block<VoxelType> > >::iterator iterResult = m_pHomogenousBlock.find(tHomogenousValue);
if(iterResult == m_pHomogenousBlock.end())
{
//Block<VoxelType> block;
POLYVOX_SHARED_PTR< BlockData<VoxelType> > pHomogeneousBlock(new BlockData<VoxelType>(m_uBlockSideLength));
//block.m_pBlockData = temp;
POLYVOX_SHARED_PTR< Block<VoxelType> > pHomogeneousBlock(new Block<VoxelType>(m_uBlockSideLength));
//block.m_pBlock = temp;
//block.m_uReferenceCount++;
pHomogeneousBlock->fill(tHomogenousValue);
m_pHomogenousBlockData.insert(std::make_pair(tHomogenousValue, pHomogeneousBlock));
m_pHomogenousBlock.insert(std::make_pair(tHomogenousValue, pHomogeneousBlock));
return pHomogeneousBlock;
}
else
{
//iterResult->second.m_uReferenceCount++;
//POLYVOX_SHARED_PTR< BlockData<VoxelType> > result(iterResult->second);
//POLYVOX_SHARED_PTR< Block<VoxelType> > result(iterResult->second);
return iterResult->second;
}
}

8
library/PolyVoxCore/include/VolumeIterator.inl
View File

@ -201,7 +201,7 @@ namespace PolyVox
mBlockIndexInVolume = mXBlock +
mYBlock * mVolume.m_uWidthInBlocks +
mZBlock * mVolume.m_uWidthInBlocks * mVolume.m_uHeightInBlocks;
POLYVOX_SHARED_PTR< BlockData<VoxelType> > currentBlock = mVolume.m_pBlocks[mBlockIndexInVolume];
POLYVOX_SHARED_PTR< Block<VoxelType> > currentBlock = mVolume.m_pBlocks[mBlockIndexInVolume];
mVoxelIndexInBlock = mXPosInBlock +
mYPosInBlock * mVolume.m_uBlockSideLength +
@ -257,7 +257,7 @@ namespace PolyVox
mVoxelIndexInBlock = mXPosInBlock +
mYPosInBlock * mVolume.m_uBlockSideLength +
mZPosInBlock * mVolume.m_uBlockSideLength * mVolume.m_uBlockSideLength;
boost::shared_ptr< BlockData<VoxelType> > currentBlock = mVolume.m_pBlocks[mBlockIndexInVolume];
boost::shared_ptr< Block<VoxelType> > currentBlock = mVolume.m_pBlocks[mBlockIndexInVolume];
mCurrentVoxel = currentBlock->m_tData + mVoxelIndexInBlock;
mYPosInBlock++;
@ -270,7 +270,7 @@ namespace PolyVox
mVoxelIndexInBlock = mXPosInBlock +
mYPosInBlock * mVolume.m_uBlockSideLength +
mZPosInBlock * mVolume.m_uBlockSideLength * mVolume.m_uBlockSideLength;
BlockData<VoxelType>* currentBlock = mVolume.m_pBlocks[mBlockIndexInVolume];
Block<VoxelType>* currentBlock = mVolume.m_pBlocks[mBlockIndexInVolume];
mCurrentVoxel = currentBlock->m_tData + mVoxelIndexInBlock;
mZPosInBlock++;
@ -309,7 +309,7 @@ namespace PolyVox
}
}
BlockData<VoxelType>* currentBlock = mVolume.m_pBlocks[mBlockIndexInVolume];
Block<VoxelType>* currentBlock = mVolume.m_pBlocks[mBlockIndexInVolume];
//mCurrentBlock = mVolume->m_pBlocks[mBlockIndexInVolume];
mXPosInVolume = (std::max)(mXRegionFirst,uint16_t(mXBlock * mVolume.m_uBlockSideLength));