Work on Array and ArraySize classes.

library/PolyVoxCore/CMakeLists.txt

@@ -21,6 +21,8 @@ SET(CORE_SRC_FILES
 SET(CORE_INC_FILES
 	include/Array.h
 	include/Array.inl
+	include/Dimensions.h
+	include/Dimensions.inl
 	include/GradientEstimators.inl
 	include/SurfaceMesh.h
 	include/Log.h

library/PolyVoxCore/include/Array.h

@@ -49,19 +49,21 @@ namespace PolyVox
 			m_pOffsets = new uint32_t[noOfDims];
 			
 			// Calculate all the information you need to use the array
-			m_uNoOfElements=1;
-			for (uint32_t i=0; i<noOfDims; i++)
+			m_uNoOfElements = 1;
+			for (uint32_t i = 0; i<noOfDims; i++)
 			{
 				assert(Dimensions[i] != 0);
 
-				m_uNoOfElements*=Dimensions[i]; 
-				m_pDimensions[i]=Dimensions[i];
-				m_pOffsets[i]=1; 
+				m_uNoOfElements *= Dimensions[i]; 
+				m_pDimensions[i] = Dimensions[i];
+				m_pOffsets[i] = 1; 
 				for (int k=noOfDims-1; k>i; k--)
-					m_pOffsets[i]*=Dimensions[k];
+				{
+					m_pOffsets[i] *= Dimensions[k];
+				}
 			} 
 			// Allocate new elements, let exception propagate 
-			m_pElements=new ElementType[m_uNoOfElements];
+			m_pElements = new ElementType[m_uNoOfElements];
 		} 
 
 		Array<noOfDims-1, ElementType> operator [](uint32_t uIndex)
@@ -111,6 +113,17 @@ namespace PolyVox
 		friend class Array<2, ElementType>;
 
 	public:
+		Array<1, ElementType>(const uint32_t (&Dimensions)[1])
+			: m_pElements(0)
+			,m_pDimensions(0)
+		{
+			m_pDimensions = new uint32_t[1];			
+			m_pDimensions[0] = Dimensions[0];
+
+			// Allocate new elements, let exception propagate 
+			m_pElements = new ElementType[m_pDimensions[0]];
+		} 
+
 		ElementType & operator [] (uint32_t uIndex)
 		{
 			assert(uIndex<m_pDimensions[0]);
@@ -201,7 +214,7 @@ namespace PolyVox
 	typedef Array<3,int32_t> Array3DInt32;
 	///A 3D Array of unsigned 32-bit values.
 	typedef Array<3,uint32_t> Array3DUint32;
-}//namespace Thermite
+}//namespace PolyVox
 
 #include "Array.inl"
 

library/PolyVoxCore/include/Dimensions.h

@@ -0,0 +1,92 @@
+#pragma region License
+/*******************************************************************************
+Copyright (c) 2005-2009 David Williams
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+claim that you wrote the original software. If you use this software
+in a product, an acknowledgment in the product documentation would be
+appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not be
+misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution. 	
+*******************************************************************************/
+#pragma endregion
+
+#ifndef __PolyVox_Dimensions_H__
+#define __PolyVox_Dimensions_H__
+
+#pragma region Headers
+#include "PolyVoxImpl/TypeDef.h"
+#include "PolyVoxImpl/CPlusPlusZeroXSupport.h"
+#pragma endregion
+
+namespace PolyVox
+{
+	template <uint32_t N>
+	class ArraySizesImpl
+	{
+		typedef const uint32_t (&UIntArrayN)[N];
+
+		friend class ArraySizes;
+		friend class ArraySizesImpl<N-1>;
+
+	public:
+		ArraySizesImpl<N+1> operator () (uint32_t uSize) 
+		{ 
+			return ArraySizesImpl<N+1>(m_pSizes, uSize);
+		}
+
+		operator UIntArrayN () const
+		{
+			return m_pSizes;
+		}		
+
+	private:
+		ArraySizesImpl(const uint32_t (&pSizes)[N-1], uint32_t uSize)
+		{
+			std::copy(&pSizes[0],&pSizes[N-1],m_pSizes);
+			m_pSizes[N-1]=uSize;
+		}
+
+		uint32_t m_pSizes[N];
+	};
+
+	class ArraySizes
+	{
+		typedef const uint32_t (&UIntArray1)[1];
+
+	public:
+		explicit ArraySizes(uint32_t uSize) 
+		{ 
+			m_pSizes[0]=uSize;
+		}
+
+		ArraySizesImpl<2> operator () (uint32_t uSize) 
+		{ 
+			return ArraySizesImpl<2>(m_pSizes, uSize);
+		}
+
+		operator UIntArray1 () const
+		{
+			return m_pSizes;
+		}
+
+	private:
+		uint32_t m_pSizes[1]; 
+	};
+}//namespace PolyVox
+
+#include "Array.inl"
+
+#endif //__PolyVox_Dimensions_H__

library/PolyVoxCore/include/Vector.h

@@ -152,7 +152,7 @@ namespace PolyVox
 
 
 
-}//namespace Thermite
+}//namespace PolyVox
 
 #include "Vector.inl"
 

library/PolyVoxCore/include/Vector.inl

@@ -582,4 +582,4 @@ namespace PolyVox
 		}
     }
 	#pragma endregion	
-}//namespace Thermite
+}//namespace PolyVox

library/PolyVoxCore/source/SurfaceExtractor.cpp

@@ -24,6 +24,7 @@ freely, subject to the following restrictions:
 #include "SurfaceExtractor.h"
 
 #include "Array.h"
+#include "Dimensions.h"
 #include "SurfaceMesh.h"
 #include "PolyVoxImpl/MarchingCubesTables.h"
 #include "SurfaceVertex.h"
@@ -65,6 +66,7 @@ namespace PolyVox
 		m_pCurrentVertexIndicesY = new int32_t[m_uScratchPadWidth * m_uScratchPadHeight];
 		m_pCurrentVertexIndicesZ = new int32_t[m_uScratchPadWidth * m_uScratchPadHeight];*/
 
+		//uint32_t Size1 [1]= {m_uScratchPadWidth}; // Array dimensions
 		uint32_t Size2 [2]= {m_uScratchPadWidth, m_uScratchPadHeight}; // Array dimensions
 
 		/*Array2DInt32 m_pPreviousVertexIndicesX(m_uScratchPadWidth, m_uScratchPadHeight);
@@ -74,13 +76,16 @@ namespace PolyVox
 		Array2DInt32 m_pCurrentVertexIndicesY(m_uScratchPadWidth, m_uScratchPadHeight);
 		Array2DInt32 m_pCurrentVertexIndicesZ(m_uScratchPadWidth, m_uScratchPadHeight);*/
 
-		Array2DInt32 m_pPreviousVertexIndicesX(Size2);
+		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);