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

More work on multidimensional Array class.

Browse Source
This commit is contained in:
David Williams 2010-03-28 23:18:50 +00:00
parent 834b747171
commit 3e1c07550b
3 changed files with 223 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

209
library/PolyVoxCore/include/Array.h
View File

@ -39,12 +39,58 @@ namespace PolyVox
class Array class Array
{ {
public: public:
Array<noOfDims, ElementType>()
:m_pElements(0)
,m_pDimensions(0)
,m_pOffsets(0)
,m_uNoOfElements(0)
{
}
Array<noOfDims, ElementType>(const uint32_t (&pDimensions)[noOfDims]) Array<noOfDims, ElementType>(const uint32_t (&pDimensions)[noOfDims])
:m_pElements(0) :m_pElements(0)
,m_pDimensions(0) ,m_pDimensions(0)
,m_pOffsets(0) ,m_pOffsets(0)
,m_uNoOfElements(0) ,m_uNoOfElements(0)
{ {
resize(pDimensions);
}
~Array<noOfDims, ElementType>()
{
deallocate();
}
SubArray<noOfDims-1, ElementType> operator[](uint32_t uIndex)
{
assert(uIndex<m_pDimensions[0]);
return
SubArray<noOfDims-1, ElementType>(&m_pElements[uIndex*m_pOffsets[0]],
m_pDimensions+1, m_pOffsets+1);
}
const SubArray<noOfDims-1, ElementType> operator[](uint32_t uIndex) const
{
assert(uIndex<m_pDimensions[0]);
return
SubArray<noOfDims-1, ElementType>(&m_pElements[uIndex*m_pOffsets[0]],
m_pDimensions+1, m_pOffsets+1);
}
uint32_t getNoOfElements(void) const
{
return m_uNoOfElements;
}
ElementType* getRawData(void) const
{
return m_pElements;
}
void resize(const uint32_t (&pDimensions)[noOfDims])
{
deallocate();
m_pDimensions = new uint32_t[noOfDims]; m_pDimensions = new uint32_t[noOfDims];
m_pOffsets = new uint32_t[noOfDims]; m_pOffsets = new uint32_t[noOfDims];
@ -64,42 +110,59 @@ namespace PolyVox
} }
// Allocate new elements, let exception propagate // Allocate new elements, let exception propagate
m_pElements = new ElementType[m_uNoOfElements]; m_pElements = new ElementType[m_uNoOfElements];
}
~Array<noOfDims, ElementType>()
{
delete[] m_pDimensions;
delete[] m_pOffsets;
delete[] m_pElements;
} }
SubArray<noOfDims-1, ElementType> operator [](uint32_t uIndex) void swap(Array<noOfDims, ElementType>& rhs)
{ {
assert(uIndex<m_pDimensions[0]); //Implement this function without temporary 'Array'
return //objects, as the destructors will free the memory...
SubArray<noOfDims-1, ElementType>(&m_pElements[uIndex*m_pOffsets[0]], uint32_t* m_pTempDimensions = m_pDimensions;
m_pDimensions+1, m_pOffsets+1); uint32_t* m_pTempOffsets = m_pOffsets;
} uint32_t m_uTempNoOfElements = m_uNoOfElements;
ElementType* m_pTempElements = m_pElements;
const SubArray<noOfDims-1, ElementType> operator [](uint32_t uIndex) const m_pDimensions = rhs.m_pDimensions;
{ m_pOffsets = rhs.m_pOffsets;
assert(uIndex<m_pDimensions[0]); m_uNoOfElements = rhs.m_uNoOfElements;
return m_pElements = rhs.m_pElements;
SubArray<noOfDims-1, ElementType>(&m_pElements[uIndex*m_pOffsets[0]],
m_pDimensions+1, m_pOffsets+1);
}
ElementType* getRawData(void) rhs.m_pDimensions = m_pTempDimensions;
{ rhs.m_pOffsets = m_pTempOffsets;
return m_pElements; rhs.m_uNoOfElements = m_uTempNoOfElements;
} rhs.m_pElements = m_pTempElements;
uint32_t getNoOfElements(void)
{
return m_uNoOfElements;
} }
private: private:
Array<noOfDims, ElementType>(const Array<noOfDims, ElementType>& rhs)
:m_pElements(0)
,m_pDimensions(0)
,m_pOffsets(0)
,m_uNoOfElements(0)
{
//Not implemented
assert(false);
}
Array<noOfDims, ElementType>& Array<noOfDims, ElementType>::operator=(const Array<noOfDims, ElementType>& rhs)
{
//Not implemented
assert(false);
return *this;
}
void deallocate(void)
{
delete[] m_pDimensions;
m_pDimensions = 0;
delete[] m_pOffsets;
m_pOffsets = 0;
delete[] m_pElements;
m_pElements = 0;
m_uNoOfElements = 0;
}
uint32_t * m_pDimensions; uint32_t * m_pDimensions;
uint32_t * m_pOffsets; uint32_t * m_pOffsets;
uint32_t m_uNoOfElements; uint32_t m_uNoOfElements;
@ -110,40 +173,96 @@ namespace PolyVox
class Array<1, ElementType> class Array<1, ElementType>
{ {
public: public:
Array<1, ElementType>()
: m_pElements(0)
,m_pDimensions(0)
{
}
Array<1, ElementType>(const uint32_t (&pDimensions)[1]) Array<1, ElementType>(const uint32_t (&pDimensions)[1])
: m_pElements(0) : m_pElements(0)
,m_pDimensions(0) ,m_pDimensions(0)
{ {
resize(pDimensions);
}
~Array<1, ElementType>()
{
deallocate();
}
ElementType& operator[] (uint32_t uIndex)
{
assert(uIndex<m_pDimensions[0]);
return m_pElements[uIndex];
}
const ElementType& operator[] (uint32_t uIndex) const
{
assert(uIndex<m_pDimensions[0]);
return m_pElements[uIndex];
}
uint32_t getNoOfElements(void) const
{
return m_pDimensions[0];
}
ElementType* getRawData(void) const
{
return m_pElements;
}
void resize(const uint32_t (&pDimensions)[1])
{
deallocate();
m_pDimensions = new uint32_t[1]; m_pDimensions = new uint32_t[1];
m_pDimensions[0] = pDimensions[0]; m_pDimensions[0] = pDimensions[0];
// Allocate new elements, let exception propagate // Allocate new elements, let exception propagate
m_pElements = new ElementType[m_pDimensions[0]]; m_pElements = new ElementType[m_pDimensions[0]];
}
ElementType & operator [] (uint32_t uIndex)
{
assert(uIndex<m_pDimensions[0]);
return m_pElements[uIndex];
} }
const ElementType & operator [] (uint32_t uIndex) const void swap(Array<1, ElementType>& rhs)
{ {
assert(uIndex<m_pDimensions[0]); //Implement this function without temporary 'Array'
return m_pElements[uIndex]; //objects, as the destructors will free the memory...
} uint32_t* m_pTempDimensions = m_pDimensions;
ElementType* m_pTempElements = m_pElements;
ElementType* getRawData(void) m_pDimensions = rhs.m_pDimensions;
{ m_pElements = rhs.m_pElements;
return m_pElements;
}
uint32_t getNoOfElements(void) rhs.m_pDimensions = m_pTempDimensions;
{ rhs.m_pElements = m_pTempElements;
return m_pDimensions[0];
} }
private: private:
Array<1, ElementType>(const Array<1, ElementType>& rhs)
: m_pElements(0)
,m_pDimensions(0)
{
//Not implemented
assert(false);
}
Array<1, ElementType>& Array<1, ElementType>::operator=(const Array<1, ElementType>& rhs)
{
//Not implemented
assert(false);
return *this;
}
void deallocate(void)
{
delete[] m_pDimensions;
m_pDimensions = 0;
delete[] m_pElements;
m_pElements = 0;
}
uint32_t * m_pDimensions; uint32_t * m_pDimensions;
ElementType * m_pElements; ElementType * m_pElements;
}; };

82
library/PolyVoxCore/include/PolyVoxImpl/SubArray.inl
View File

@ -27,50 +27,50 @@ namespace PolyVox
{ {
template <uint32_t noOfDims, typename ElementType> template <uint32_t noOfDims, typename ElementType>
SubArray<noOfDims-1, ElementType> SubArray<noOfDims, ElementType>::operator[](uint32_t uIndex) SubArray<noOfDims-1, ElementType> SubArray<noOfDims, ElementType>::operator[](uint32_t uIndex)
{ {
assert(uIndex<m_pDimensions[0]); assert(uIndex<m_pDimensions[0]);
return return
SubArray<noOfDims-1, ElementType>(&m_pElements[uIndex*m_pOffsets[0]], SubArray<noOfDims-1, ElementType>(&m_pElements[uIndex*m_pOffsets[0]],
m_pDimensions+1, m_pOffsets+1); m_pDimensions+1, m_pOffsets+1);
} }
template <uint32_t noOfDims, typename ElementType> template <uint32_t noOfDims, typename ElementType>
const SubArray<noOfDims-1, ElementType> SubArray<noOfDims, ElementType>::operator[](uint32_t uIndex) const const SubArray<noOfDims-1, ElementType> SubArray<noOfDims, ElementType>::operator[](uint32_t uIndex) const
{ {
assert(uIndex<m_pDimensions[0]); assert(uIndex<m_pDimensions[0]);
return return
SubArray<noOfDims-1, ElementType>(&m_pElements[uIndex*m_pOffsets[0]], SubArray<noOfDims-1, ElementType>(&m_pElements[uIndex*m_pOffsets[0]],
m_pDimensions+1, m_pOffsets+1); m_pDimensions+1, m_pOffsets+1);
} }
template <uint32_t noOfDims, typename ElementType> template <uint32_t noOfDims, typename ElementType>
SubArray<noOfDims, ElementType>::SubArray<noOfDims, ElementType>(ElementType * pElements, uint32_t * pDimensions, uint32_t * pOffsets) SubArray<noOfDims, ElementType>::SubArray<noOfDims, ElementType>(ElementType * pElements, uint32_t * pDimensions, uint32_t * pOffsets)
:m_pElements(pElements) :m_pElements(pElements)
,m_pDimensions(pDimensions) ,m_pDimensions(pDimensions)
,m_pOffsets(pOffsets) ,m_pOffsets(pOffsets)
,m_uNoOfElements(0) ,m_uNoOfElements(0)
{ {
} }
template <typename ElementType> template <typename ElementType>
ElementType& SubArray<1, ElementType>::operator[] (uint32_t uIndex) ElementType& SubArray<1, ElementType>::operator[] (uint32_t uIndex)
{ {
assert(uIndex<m_pDimensions[0]); assert(uIndex<m_pDimensions[0]);
return m_pElements[uIndex]; return m_pElements[uIndex];
} }
template <typename ElementType> template <typename ElementType>
const ElementType& SubArray<1, ElementType>::operator[] (uint32_t uIndex) const const ElementType& SubArray<1, ElementType>::operator[] (uint32_t uIndex) const
{ {
assert(uIndex<m_pDimensions[0]); assert(uIndex<m_pDimensions[0]);
return m_pElements[uIndex]; return m_pElements[uIndex];
} }
template <typename ElementType> template <typename ElementType>
SubArray<1, ElementType>::SubArray<1, ElementType>(ElementType * pElements, uint32_t * pDimensions, uint32_t * /*pOffsets*/) SubArray<1, ElementType>::SubArray<1, ElementType>(ElementType * pElements, uint32_t * pDimensions, uint32_t * /*pOffsets*/)
:m_pDimensions(pDimensions) :m_pDimensions(pDimensions)
,m_pElements(pElements) ,m_pElements(pElements)
{ {
} }
}//namespace PolyVox }//namespace PolyVox

78
library/PolyVoxCore/source/SurfaceExtractor.cpp
View File

@ -57,53 +57,18 @@ namespace PolyVox
m_uScratchPadWidth = m_uRegionWidth+1; m_uScratchPadWidth = m_uRegionWidth+1;
m_uScratchPadHeight = m_uRegionHeight+1; m_uScratchPadHeight = m_uRegionHeight+1;
uint32_t arraySizes[2]= {m_uScratchPadWidth, m_uScratchPadHeight}; // Array dimensions
//For edge indices //For edge indices
/*m_pPreviousVertexIndicesX = new int32_t[m_uScratchPadWidth * m_uScratchPadHeight]; Array2DInt32 m_pPreviousVertexIndicesX(arraySizes);
m_pPreviousVertexIndicesY = new int32_t[m_uScratchPadWidth * m_uScratchPadHeight]; Array2DInt32 m_pPreviousVertexIndicesY(arraySizes);
m_pPreviousVertexIndicesZ = new int32_t[m_uScratchPadWidth * m_uScratchPadHeight]; Array2DInt32 m_pPreviousVertexIndicesZ(arraySizes);
m_pCurrentVertexIndicesX = new int32_t[m_uScratchPadWidth * m_uScratchPadHeight]; Array2DInt32 m_pCurrentVertexIndicesX(arraySizes);
m_pCurrentVertexIndicesY = new int32_t[m_uScratchPadWidth * m_uScratchPadHeight]; Array2DInt32 m_pCurrentVertexIndicesY(arraySizes);
m_pCurrentVertexIndicesZ = new int32_t[m_uScratchPadWidth * m_uScratchPadHeight];*/ Array2DInt32 m_pCurrentVertexIndicesZ(arraySizes);
//uint32_t Size1 [1]= {m_uScratchPadWidth}; // Array dimensions Array2DUint8 pPreviousBitmask(arraySizes);
uint32_t Size2 [2]= {m_uScratchPadWidth, m_uScratchPadHeight}; // Array dimensions Array2DUint8 pCurrentBitmask(arraySizes);
/*Array2DInt32 m_pPreviousVertexIndicesX(m_uScratchPadWidth, m_uScratchPadHeight);
Array2DInt32 m_pPreviousVertexIndicesY(m_uScratchPadWidth, m_uScratchPadHeight);
Array2DInt32 m_pPreviousVertexIndicesZ(m_uScratchPadWidth, m_uScratchPadHeight);
Array2DInt32 m_pCurrentVertexIndicesX(m_uScratchPadWidth, m_uScratchPadHeight);
Array2DInt32 m_pCurrentVertexIndicesY(m_uScratchPadWidth, m_uScratchPadHeight);
Array2DInt32 m_pCurrentVertexIndicesZ(m_uScratchPadWidth, m_uScratchPadHeight);*/
Array2DInt32 m_pPreviousVertexIndicesX(ArraySizes(m_uScratchPadWidth)(m_uScratchPadHeight));
Array2DInt32 m_pPreviousVertexIndicesY(Size2);
Array2DInt32 m_pPreviousVertexIndicesZ(Size2);
Array2DInt32 m_pCurrentVertexIndicesX(Size2);
Array2DInt32 m_pCurrentVertexIndicesY(Size2);
Array2DInt32 m_pCurrentVertexIndicesZ(Size2);
//Array1DFloat test1d(ArraySizes(10));
//Array2DFloat test2d(ArraySizes(10)(20));
/*m_pPreviousVertexIndicesX.resize(Size2);
m_pPreviousVertexIndicesY.resize(Size2);
m_pPreviousVertexIndicesZ.resize(Size2);
m_pCurrentVertexIndicesX.resize(Size2);
m_pCurrentVertexIndicesY.resize(Size2);
m_pCurrentVertexIndicesZ.resize(Size2);*/
//Cell bitmasks
/*Array2DUint8 pPreviousBitmask(m_uScratchPadWidth, m_uScratchPadHeight);
Array2DUint8 pCurrentBitmask(m_uScratchPadWidth, m_uScratchPadHeight);*/
Array2DUint8 pPreviousBitmask(Size2);
Array2DUint8 pCurrentBitmask(Size2);
/*pPreviousBitmask.resize(Size2);
pCurrentBitmask.resize(Size2);*/
//Create a region corresponding to the first slice //Create a region corresponding to the first slice
m_regSlicePrevious = m_regInputCropped; m_regSlicePrevious = m_regInputCropped;
@ -128,10 +93,10 @@ namespace PolyVox
} }
std::swap(uNoOfNonEmptyCellsForSlice0, uNoOfNonEmptyCellsForSlice1); std::swap(uNoOfNonEmptyCellsForSlice0, uNoOfNonEmptyCellsForSlice1);
std::swap(pPreviousBitmask, pCurrentBitmask); pPreviousBitmask.swap(pCurrentBitmask);
std::swap(m_pPreviousVertexIndicesX, m_pCurrentVertexIndicesX); m_pPreviousVertexIndicesX.swap(m_pCurrentVertexIndicesX);
std::swap(m_pPreviousVertexIndicesY, m_pCurrentVertexIndicesY); m_pPreviousVertexIndicesY.swap(m_pCurrentVertexIndicesY);
std::swap(m_pPreviousVertexIndicesZ, m_pCurrentVertexIndicesZ); m_pPreviousVertexIndicesZ.swap(m_pCurrentVertexIndicesZ);
m_regSlicePrevious = m_regSliceCurrent; m_regSlicePrevious = m_regSliceCurrent;
m_regSliceCurrent.shift(Vector3DInt16(0,0,1)); m_regSliceCurrent.shift(Vector3DInt16(0,0,1));
@ -156,10 +121,10 @@ namespace PolyVox
} }
std::swap(uNoOfNonEmptyCellsForSlice0, uNoOfNonEmptyCellsForSlice1); std::swap(uNoOfNonEmptyCellsForSlice0, uNoOfNonEmptyCellsForSlice1);
std::swap(pPreviousBitmask, pCurrentBitmask); pPreviousBitmask.swap(pCurrentBitmask);
std::swap(m_pPreviousVertexIndicesX, m_pCurrentVertexIndicesX); m_pPreviousVertexIndicesX.swap(m_pCurrentVertexIndicesX);
std::swap(m_pPreviousVertexIndicesY, m_pCurrentVertexIndicesY); m_pPreviousVertexIndicesY.swap(m_pCurrentVertexIndicesY);
std::swap(m_pPreviousVertexIndicesZ, m_pCurrentVertexIndicesZ); m_pPreviousVertexIndicesZ.swap(m_pCurrentVertexIndicesZ);
m_regSlicePrevious = m_regSliceCurrent; m_regSlicePrevious = m_regSliceCurrent;
m_regSliceCurrent.shift(Vector3DInt16(0,0,1)); m_regSliceCurrent.shift(Vector3DInt16(0,0,1));
@ -175,13 +140,6 @@ namespace PolyVox
generateIndicesForSlice(pPreviousBitmask, m_pPreviousVertexIndicesX, m_pPreviousVertexIndicesY, m_pPreviousVertexIndicesZ, m_pCurrentVertexIndicesX, m_pCurrentVertexIndicesY, m_pCurrentVertexIndicesZ); generateIndicesForSlice(pPreviousBitmask, m_pPreviousVertexIndicesX, m_pPreviousVertexIndicesY, m_pPreviousVertexIndicesZ, m_pCurrentVertexIndicesX, m_pCurrentVertexIndicesY, m_pCurrentVertexIndicesZ);
} }
/*delete[] m_pPreviousVertexIndicesX;
delete[] m_pCurrentVertexIndicesX;
delete[] m_pPreviousVertexIndicesY;
delete[] m_pCurrentVertexIndicesY;
delete[] m_pPreviousVertexIndicesZ;
delete[] m_pCurrentVertexIndicesZ; */
m_meshCurrent->m_Region = m_regInputUncropped; m_meshCurrent->m_Region = m_regInputUncropped;
m_meshCurrent->m_vecLodRecords.clear(); m_meshCurrent->m_vecLodRecords.clear();