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

More tidying up.

Browse Source
This commit is contained in:
David Williams
2011-02-12 20:47:01 +00:00
parent 9b3deca7f0
commit ed355b856f
6 changed files with 80 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
examples/Basic/main.cpp
View File

@ -356,8 +356,16 @@ void createPerlinVolumeSlow(Volume<MaterialDensityPair44>& volData)
{ {
float perlinVal = perlin.Get3D(x /static_cast<float>(volData.getWidth()-1), (y) / static_cast<float>(volData.getHeight()-1), z / static_cast<float>(volData.getDepth()-1)); float perlinVal = perlin.Get3D(x /static_cast<float>(volData.getWidth()-1), (y) / static_cast<float>(volData.getHeight()-1), z / static_cast<float>(volData.getDepth()-1));
perlinVal += 1.0f;
perlinVal *= 0.5f;
perlinVal *= MaterialDensityPair44::getMaxDensity();
MaterialDensityPair44 voxel; MaterialDensityPair44 voxel;
if(perlinVal < 0.0f)
voxel.setMaterial(245);
voxel.setDensity(perlinVal);
/*if(perlinVal < 0.0f)
{ {
voxel.setMaterial(245); voxel.setMaterial(245);
voxel.setDensity(MaterialDensityPair44::getMaxDensity()); voxel.setDensity(MaterialDensityPair44::getMaxDensity());
@ -366,7 +374,7 @@ void createPerlinVolumeSlow(Volume<MaterialDensityPair44>& volData)
{ {
voxel.setMaterial(0); voxel.setMaterial(0);
voxel.setDensity(MaterialDensityPair44::getMinDensity()); voxel.setDensity(MaterialDensityPair44::getMinDensity());
} }*/
volData.setVoxelAt(x, y, z, voxel); volData.setVoxelAt(x, y, z, voxel);
} }
@ -504,8 +512,8 @@ int main(int argc, char *argv[])
//Create an empty volume and then place a sphere in it //Create an empty volume and then place a sphere in it
Volume<MaterialDensityPair44> volData(256, 256, 256); Volume<MaterialDensityPair44> volData(256, 256, 256);
//createSphereInVolume(volData, 30); //createSphereInVolume(volData, 30);
createPerlinTerrain(volData); //createPerlinTerrain(volData);
//createPerlinVolumeSlow(volData); createPerlinVolumeSlow(volData);
volData.setBlockCacheSize(8); volData.setBlockCacheSize(8);
/*srand(12345); /*srand(12345);

1
library/PolyVoxCore/include/PolyVoxImpl/Block.h
View File

@ -65,7 +65,6 @@ namespace PolyVox
void uncompress(VoxelType* pData); void uncompress(VoxelType* pData);
std::vector< RunlengthEntry<uint16_t> > m_vecCompressedData; std::vector< RunlengthEntry<uint16_t> > m_vecCompressedData;
uint64_t m_uTimestamp;
VoxelType* m_tUncompressedData; VoxelType* m_tUncompressedData;
uint16_t m_uSideLength; uint16_t m_uSideLength;
uint8_t m_uSideLengthPower; uint8_t m_uSideLengthPower;

10
library/PolyVoxCore/include/PolyVoxImpl/Block.inl
View File

@ -39,7 +39,6 @@ namespace PolyVox
,m_tUncompressedData(0) ,m_tUncompressedData(0)
,m_bIsCompressed(true) ,m_bIsCompressed(true)
,m_bIsUncompressedDataModified(true) ,m_bIsUncompressedDataModified(true)
,m_uTimestamp(0)
{ {
if(uSideLength != 0) if(uSideLength != 0)
{ {
@ -148,7 +147,7 @@ namespace PolyVox
uint32_t Block<VoxelType>::sizeInBytes(void) uint32_t Block<VoxelType>::sizeInBytes(void)
{ {
uint32_t uSizeInBytes = sizeof(Block<VoxelType>); uint32_t uSizeInBytes = sizeof(Block<VoxelType>);
uSizeInBytes += m_vecCompressedData.size() * sizeof(RunlengthEntry); uSizeInBytes += m_vecCompressedData.capacity() * sizeof(RunlengthEntry);
return uSizeInBytes; return uSizeInBytes;
} }
@ -207,11 +206,8 @@ namespace PolyVox
VoxelType* pUncompressedData = m_tUncompressedData; VoxelType* pUncompressedData = m_tUncompressedData;
for(uint32_t ct = 0; ct < m_vecCompressedData.size(); ++ct) for(uint32_t ct = 0; ct < m_vecCompressedData.size(); ++ct)
{ {
for(uint32_t i = 0; i < m_vecCompressedData[ct].length; ++i) std::fill(pUncompressedData, pUncompressedData + m_vecCompressedData[ct].length, m_vecCompressedData[ct].value);
{ pUncompressedData += m_vecCompressedData[ct].length;
*pUncompressedData = m_vecCompressedData[ct].value;
++pUncompressedData;
}
} }
m_bIsCompressed = false; m_bIsCompressed = false;

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

@ -120,7 +120,7 @@ namespace PolyVox
struct UncompressedBlock struct UncompressedBlock
{ {
Block<VoxelType>* block; uint32_t uBlockIndex;
VoxelType* data; VoxelType* data;
}; };
@ -168,15 +168,16 @@ namespace PolyVox
uint32_t sizeInBytes(void); uint32_t sizeInBytes(void);
public: public:
Block<VoxelType>* getUncompressedBlock(Block<VoxelType>* block) const; Block<VoxelType>* getUncompressedBlock(uint16_t uBlockX, uint16_t uBlockY, uint16_t uBlockZ) const;
//Block<VoxelType> m_pBorderBlock;
VoxelType* m_pUncompressedBorderData;
Block<VoxelType> m_pBorderBlock;
Block<VoxelType>* m_pBlocks; Block<VoxelType>* m_pBlocks;
//mutable std::vector<Block<VoxelType>*> m_pUncompressedBlocks; uint32_t* m_pUncompressedTimestamps;
//mutable std::vector< std::vector<VoxelType> > m_pUncompressedBlockData;
//mutable VoxelType* m_pUncompressedBlockData;
mutable std::vector< UncompressedBlock > m_vecUncompressedBlockCache; mutable std::vector< UncompressedBlock > m_vecUncompressedBlockCache;
uint16_t m_uMaxUncompressedBlockCacheSize; uint16_t m_uMaxUncompressedBlockCacheSize;
uint32_t m_ulastAccessedBlockIndex;
uint32_t m_uNoOfBlocksInVolume; uint32_t m_uNoOfBlocksInVolume;

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

@ -54,6 +54,9 @@ namespace PolyVox
,m_uUncompressions(0) ,m_uUncompressions(0)
,m_uBlockSideLength(uBlockSideLength) ,m_uBlockSideLength(uBlockSideLength)
,m_pBlocks(0) ,m_pBlocks(0)
,m_pUncompressedTimestamps(0)
,m_pUncompressedBorderData(0)
,m_ulastAccessedBlockIndex((std::numeric_limits<uint32_t>::max)()) //An invalid index
{ {
setBlockCacheSize(m_uMaxUncompressedBlockCacheSize); setBlockCacheSize(m_uMaxUncompressedBlockCacheSize);
@ -77,8 +80,9 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
VoxelType Volume<VoxelType>::getBorderValue(void) const VoxelType Volume<VoxelType>::getBorderValue(void) const
{ {
Block<VoxelType>* pUncompressedBorderBlock = getUncompressedBlock(const_cast<Block<VoxelType>*>(&m_pBorderBlock)); /*Block<VoxelType>* pUncompressedBorderBlock = getUncompressedBlock(const_cast<Block<VoxelType>*>(&m_pBorderBlock));
return pUncompressedBorderBlock->getVoxelAt(0,0,0); return pUncompressedBorderBlock->getVoxelAt(0,0,0);*/
return *m_pUncompressedBorderData;
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@ -178,14 +182,14 @@ namespace PolyVox
const uint16_t yOffset = uYPos - (blockY << m_uBlockSideLengthPower); const uint16_t yOffset = uYPos - (blockY << m_uBlockSideLengthPower);
const uint16_t zOffset = uZPos - (blockZ << m_uBlockSideLengthPower); const uint16_t zOffset = uZPos - (blockZ << m_uBlockSideLengthPower);
const Block<VoxelType>& block = m_pBlocks /*const Block<VoxelType>& block = m_pBlocks
[ [
blockX + blockX +
blockY * m_uWidthInBlocks + blockY * m_uWidthInBlocks +
blockZ * m_uWidthInBlocks * m_uHeightInBlocks blockZ * m_uWidthInBlocks * m_uHeightInBlocks
]; ];*/
Block<VoxelType>* pUncompressedBlock = getUncompressedBlock(const_cast<Block<VoxelType>*>(&block)); Block<VoxelType>* pUncompressedBlock = getUncompressedBlock(blockX, blockY, blockZ);
return pUncompressedBlock->getVoxelAt(xOffset,yOffset,zOffset); return pUncompressedBlock->getVoxelAt(xOffset,yOffset,zOffset);
} }
@ -211,8 +215,9 @@ namespace PolyVox
template <typename VoxelType> template <typename VoxelType>
void Volume<VoxelType>::setBorderValue(const VoxelType& tBorder) void Volume<VoxelType>::setBorderValue(const VoxelType& tBorder)
{ {
Block<VoxelType>* pUncompressedBorderBlock = getUncompressedBlock(&m_pBorderBlock); /*Block<VoxelType>* pUncompressedBorderBlock = getUncompressedBlock(&m_pBorderBlock);
return pUncompressedBorderBlock->fill(tBorder); return pUncompressedBorderBlock->fill(tBorder);*/
std::fill(m_pUncompressedBorderData, m_pUncompressedBorderData + m_uBlockSideLength * m_uBlockSideLength * m_uBlockSideLength, tBorder);
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@ -237,14 +242,14 @@ namespace PolyVox
const uint16_t yOffset = uYPos - (blockY << m_uBlockSideLengthPower); const uint16_t yOffset = uYPos - (blockY << m_uBlockSideLengthPower);
const uint16_t zOffset = uZPos - (blockZ << m_uBlockSideLengthPower); const uint16_t zOffset = uZPos - (blockZ << m_uBlockSideLengthPower);
uint32_t uBlockIndex = /*uint32_t uBlockIndex =
blockX + blockX +
blockY * m_uWidthInBlocks + blockY * m_uWidthInBlocks +
blockZ * m_uWidthInBlocks * m_uHeightInBlocks; blockZ * m_uWidthInBlocks * m_uHeightInBlocks;
Block<VoxelType>& block = m_pBlocks[uBlockIndex]; Block<VoxelType>& block = m_pBlocks[uBlockIndex];*/
Block<VoxelType>* pUncompressedBlock = getUncompressedBlock(&block); Block<VoxelType>* pUncompressedBlock = getUncompressedBlock(blockX, blockY, blockZ);
pUncompressedBlock->setVoxelAt(xOffset,yOffset,zOffset, tValue); pUncompressedBlock->setVoxelAt(xOffset,yOffset,zOffset, tValue);
@ -274,7 +279,7 @@ namespace PolyVox
{ {
for(uint32_t ct = 0; ct < m_vecUncompressedBlockCache.size(); ct++) for(uint32_t ct = 0; ct < m_vecUncompressedBlockCache.size(); ct++)
{ {
m_vecUncompressedBlockCache[ct].block->compress(); m_pBlocks[m_vecUncompressedBlockCache[ct].uBlockIndex].compress();
delete[] m_vecUncompressedBlockCache[ct].data; delete[] m_vecUncompressedBlockCache[ct].data;
m_uCompressions++; m_uCompressions++;
} }
@ -329,6 +334,9 @@ namespace PolyVox
delete[] m_pBlocks; delete[] m_pBlocks;
m_pBlocks = 0; m_pBlocks = 0;
delete[] m_pUncompressedTimestamps;
m_pUncompressedTimestamps = 0;
//Compute the volume side lengths //Compute the volume side lengths
m_uWidth = uWidth; m_uWidth = uWidth;
m_uHeight = uHeight; m_uHeight = uHeight;
@ -348,15 +356,19 @@ namespace PolyVox
//Create the blocks //Create the blocks
m_pBlocks = new Block<VoxelType>[m_uNoOfBlocksInVolume]; m_pBlocks = new Block<VoxelType>[m_uNoOfBlocksInVolume];
m_pUncompressedTimestamps = new uint32_t[m_uNoOfBlocksInVolume];
for(uint32_t i = 0; i < m_uNoOfBlocksInVolume; ++i) for(uint32_t i = 0; i < m_uNoOfBlocksInVolume; ++i)
{ {
m_pBlocks[i].initialise(m_uBlockSideLength); m_pBlocks[i].initialise(m_uBlockSideLength);
m_pUncompressedTimestamps[i] = 0; //Use memset/std::fill
} }
//Create the border block //Create the border block
m_pBorderBlock.initialise(uBlockSideLength); /*m_pBorderBlock.initialise(uBlockSideLength);
Block<VoxelType>* pUncompressedBorderBlock = getUncompressedBlock(&m_pBorderBlock); Block<VoxelType>* pUncompressedBorderBlock = getUncompressedBlock(&m_pBorderBlock);
pUncompressedBorderBlock->fill(VoxelType()); pUncompressedBorderBlock->fill(VoxelType());*/
m_pUncompressedBorderData = new VoxelType[m_uBlockSideLength * m_uBlockSideLength * m_uBlockSideLength];
std::fill(m_pUncompressedBorderData, m_pUncompressedBorderData + m_uBlockSideLength * m_uBlockSideLength * m_uBlockSideLength, VoxelType());
//Other properties we might find useful later //Other properties we might find useful later
m_uLongestSideLength = (std::max)((std::max)(m_uWidth,m_uHeight),m_uDepth); m_uLongestSideLength = (std::max)((std::max)(m_uWidth,m_uHeight),m_uDepth);
@ -370,24 +382,29 @@ namespace PolyVox
clearBlockCache(); clearBlockCache();
m_uMaxUncompressedBlockCacheSize = uBlockCacheSize; m_uMaxUncompressedBlockCacheSize = uBlockCacheSize;
/*m_pUncompressedBlockCache.resize(uBlockCacheSize);
for(uint32_t ct = 0; ct < m_pUncompressedBlockData.size(); ct++)
{
m_pUncompressedBlockData[ct].data
VoxelType empty;
empty.setMaterial(0);
empty.setDensity(0);
std::fill(m_pUncompressedBlockData[ct].begin(), m_pUncompressedBlockData[ct].end(), empty);
}
m_pUncompressedBlockData = new VoxelType[m_uBlockSideLength * m_uBlockSideLength * m_uBlockSideLength * m_uBlockCacheSize];
memset(m_pUncompressedBlockData, 0, m_uBlockSideLength * m_uBlockSideLength * m_uBlockSideLength * m_uBlockCacheSize);*/
} }
template <typename VoxelType> template <typename VoxelType>
Block<VoxelType>* Volume<VoxelType>::getUncompressedBlock(Block<VoxelType>* block) const Block<VoxelType>* Volume<VoxelType>::getUncompressedBlock(uint16_t uBlockX, uint16_t uBlockY, uint16_t uBlockZ) const
{ {
block->m_uTimestamp = ++m_uTimestamper; //Compute the block's index from it's position.
uint32_t uBlockIndex =
uBlockX +
uBlockY * m_uWidthInBlocks +
uBlockZ * m_uWidthInBlocks * m_uHeightInBlocks;
//Get the block
Block<VoxelType>* block = &(m_pBlocks[uBlockIndex]);
//Check if we have the same block as last time, if so there's no need to even update
//the time stamp. If we updated it everytime then that would be every time we touched
//a voxel, which would overflow a uint32_t and require us to use a uint64_t instead.
if(uBlockIndex == m_ulastAccessedBlockIndex)
{
return block;
}
m_pUncompressedTimestamps[uBlockIndex] = ++m_uTimestamper;
if(block->m_bIsCompressed == false) if(block->m_bIsCompressed == false)
{ {
@ -403,23 +420,26 @@ namespace PolyVox
uint64_t uLeastRecentTimestamp = 1000000000000000; uint64_t uLeastRecentTimestamp = 1000000000000000;
for(uint32_t ct = 0; ct < m_vecUncompressedBlockCache.size(); ct++) for(uint32_t ct = 0; ct < m_vecUncompressedBlockCache.size(); ct++)
{ {
if(m_vecUncompressedBlockCache[ct].block->m_uTimestamp < uLeastRecentTimestamp) if(m_pUncompressedTimestamps[m_vecUncompressedBlockCache[ct].uBlockIndex] < uLeastRecentTimestamp)
//if(m_pBlocks[m_vecUncompressedBlockCache[ct].uBlockIndex].m_uTimestamp < uLeastRecentTimestamp)
{ {
uLeastRecentTimestamp = m_vecUncompressedBlockCache[ct].block->m_uTimestamp; uLeastRecentTimestamp = m_pUncompressedTimestamps[m_vecUncompressedBlockCache[ct].uBlockIndex];
//uLeastRecentTimestamp = m_pBlocks[m_vecUncompressedBlockCache[ct].uBlockIndex].m_uTimestamp;
leastRecentlyUsedBlockIndex = ct; leastRecentlyUsedBlockIndex = ct;
} }
} }
uUncompressedBlockIndex = leastRecentlyUsedBlockIndex; uUncompressedBlockIndex = leastRecentlyUsedBlockIndex;
m_vecUncompressedBlockCache[leastRecentlyUsedBlockIndex].block->compress(); m_pBlocks[m_vecUncompressedBlockCache[leastRecentlyUsedBlockIndex].uBlockIndex].compress();
m_vecUncompressedBlockCache[leastRecentlyUsedBlockIndex].block->m_tUncompressedData = 0; m_pBlocks[m_vecUncompressedBlockCache[leastRecentlyUsedBlockIndex].uBlockIndex].m_tUncompressedData = 0;
m_uCompressions++; m_uCompressions++;
m_vecUncompressedBlockCache[leastRecentlyUsedBlockIndex].block = block; m_vecUncompressedBlockCache[leastRecentlyUsedBlockIndex].uBlockIndex = uBlockIndex;
} }
else else
{ {
UncompressedBlock uncompressedBlock; UncompressedBlock uncompressedBlock;
uncompressedBlock.block = block; //uncompressedBlock.block = block;
uncompressedBlock.uBlockIndex = uBlockIndex;
uncompressedBlock.data = new VoxelType[m_uBlockSideLength * m_uBlockSideLength * m_uBlockSideLength]; uncompressedBlock.data = new VoxelType[m_uBlockSideLength * m_uBlockSideLength * m_uBlockSideLength];
m_vecUncompressedBlockCache.push_back(uncompressedBlock); m_vecUncompressedBlockCache.push_back(uncompressedBlock);
uUncompressedBlockIndex = m_vecUncompressedBlockCache.size() - 1; uUncompressedBlockIndex = m_vecUncompressedBlockCache.size() - 1;

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

@ -155,14 +155,16 @@ namespace PolyVox
uZBlock * mVolume->m_uWidthInBlocks * mVolume->m_uHeightInBlocks; uZBlock * mVolume->m_uWidthInBlocks * mVolume->m_uHeightInBlocks;
const Block<VoxelType>& currentBlock = mVolume->m_pBlocks[uBlockIndexInVolume]; const Block<VoxelType>& currentBlock = mVolume->m_pBlocks[uBlockIndexInVolume];
Block<VoxelType>* pUncompressedCurrentBlock = mVolume->getUncompressedBlock(const_cast<Block<VoxelType>*>(&currentBlock)); Block<VoxelType>* pUncompressedCurrentBlock = mVolume->getUncompressedBlock(uXBlock, uYBlock, uZBlock);
mCurrentVoxel = pUncompressedCurrentBlock->m_tUncompressedData + uVoxelIndexInBlock; mCurrentVoxel = pUncompressedCurrentBlock->m_tUncompressedData + uVoxelIndexInBlock;
} }
else else
{ {
Block<VoxelType>* pUncompressedBorderBlock = mVolume->getUncompressedBlock(&(mVolume->m_pBorderBlock)); /*Block<VoxelType>* pUncompressedBorderBlock = mVolume->getUncompressedBlock(&(mVolume->m_pBorderBlock));
mCurrentVoxel = pUncompressedBorderBlock->m_tUncompressedData + uVoxelIndexInBlock; mCurrentVoxel = pUncompressedBorderBlock->m_tUncompressedData + uVoxelIndexInBlock;*/
mCurrentVoxel = mVolume->m_pUncompressedBorderData + uVoxelIndexInBlock;
} }
} }