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

Replaced constants with functions for type traits.

Browse Source
This commit is contained in:
unknown 2012-02-06 17:51:37 +01:00
parent 1ab1d9bed3
commit c483b44a41
18 changed files with 125 additions and 292 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/Basic/main.cpp
View File

@ -54,7 +54,7 @@ void createSphereInVolume(SimpleVolume<MaterialDensityPair44>& volData, float fR
if(fDistToCenter <= fRadius)
{
//Our new density value
uint8_t uDensity = VoxelTypeTraits<MaterialDensityPair44>::MaxDensity;
uint8_t uDensity = VoxelTypeTraits<MaterialDensityPair44>::maxDensity();
//Get the old voxel
MaterialDensityPair44 voxel = volData.getVoxelAt(x,y,z);

6
examples/OpenGL/Shapes.cpp
View File

@ -48,7 +48,7 @@ void createSphereInVolume(LargeVolume<MaterialDensityPair44>& volData, float fRa
//then we make it solid, otherwise we make it empty space.
if(fDistToCenter <= fRadius)
{
volData.setVoxelAt(x,y,z, MaterialDensityPair44(uValue, uValue > 0 ? VoxelTypeTraits<MaterialDensityPair44>::MaxDensity : VoxelTypeTraits<MaterialDensityPair44>::MinDensity));
volData.setVoxelAt(x,y,z, MaterialDensityPair44(uValue, uValue > 0 ? VoxelTypeTraits<MaterialDensityPair44>::maxDensity() : VoxelTypeTraits<MaterialDensityPair44>::minDensity()));
}
}
}
@ -57,8 +57,8 @@ void createSphereInVolume(LargeVolume<MaterialDensityPair44>& volData, float fRa
void createCubeInVolume(LargeVolume<MaterialDensityPair44>& volData, Vector3DInt32 lowerCorner, Vector3DInt32 upperCorner, uint8_t uValue)
{
int maxDen = VoxelTypeTraits<MaterialDensityPair44>::MaxDensity;
int minDen = VoxelTypeTraits<MaterialDensityPair44>::MinDensity;
int maxDen = VoxelTypeTraits<MaterialDensityPair44>::maxDensity();
int minDen = VoxelTypeTraits<MaterialDensityPair44>::minDensity();
//This three-level for loop iterates over every voxel between the specified corners
for (int z = lowerCorner.getZ(); z <= upperCorner.getZ(); z++)
{

6
examples/OpenGL/main.cpp
View File

@ -97,9 +97,9 @@ int main(int argc, char *argv[])
createCubeInVolume(volData, Vector3DInt32(midPos+1, minPos, midPos+1), Vector3DInt32(maxPos, midPos-1, maxPos), 0);
createCubeInVolume(volData, Vector3DInt32(minPos, midPos+1, midPos+1), Vector3DInt32(midPos-1, maxPos, maxPos), 0);
createCubeInVolume(volData, Vector3DInt32(1, midPos-10, midPos-10), Vector3DInt32(maxPos-1, midPos+10, midPos+10), VoxelTypeTraits<MaterialDensityPair44>::MaxDensity);
createCubeInVolume(volData, Vector3DInt32(midPos-10, 1, midPos-10), Vector3DInt32(midPos+10, maxPos-1, midPos+10), VoxelTypeTraits<MaterialDensityPair44>::MaxDensity);
createCubeInVolume(volData, Vector3DInt32(midPos-10, midPos-10 ,1), Vector3DInt32(midPos+10, midPos+10, maxPos-1), VoxelTypeTraits<MaterialDensityPair44>::MaxDensity);
createCubeInVolume(volData, Vector3DInt32(1, midPos-10, midPos-10), Vector3DInt32(maxPos-1, midPos+10, midPos+10), VoxelTypeTraits<MaterialDensityPair44>::maxDensity());
createCubeInVolume(volData, Vector3DInt32(midPos-10, 1, midPos-10), Vector3DInt32(midPos+10, maxPos-1, midPos+10), VoxelTypeTraits<MaterialDensityPair44>::maxDensity());
createCubeInVolume(volData, Vector3DInt32(midPos-10, midPos-10 ,1), Vector3DInt32(midPos+10, midPos+10, maxPos-1), VoxelTypeTraits<MaterialDensityPair44>::maxDensity());
//Smooth part of the volume
RawVolume<MaterialDensityPair44> tempVolume(PolyVox::Region(0,0,0,128, 128, 128));

22
examples/Paging/main.cpp
View File

@ -50,7 +50,7 @@ void createPerlinVolumeSlow(LargeVolume<MaterialDensityPair44>& volData)
perlinVal += 1.0f;
perlinVal *= 0.5f;
perlinVal *= VoxelTypeTraits<MaterialDensityPair44>::MaxDensity;
perlinVal *= VoxelTypeTraits<MaterialDensityPair44>::maxDensity();
MaterialDensityPair44 voxel;
@ -60,12 +60,12 @@ void createPerlinVolumeSlow(LargeVolume<MaterialDensityPair44>& volData)
/*if(perlinVal < 0.0f)
{
voxel.setMaterial(245);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::MaxDensity);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::maxDensity());
}
else
{
voxel.setMaterial(0);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::MinDensity);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::minDensity());
}*/
volData.setVoxelAt(x, y, z, voxel);
@ -105,12 +105,12 @@ void createPerlinVolumeSlow(LargeVolume<MaterialDensityPair44>& volData)
if(perlinVal < 0.0f)
{
voxel.setMaterial(245);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::MaxDensity);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::maxDensity());
}
else
{
voxel.setMaterial(0);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::MinDensity);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::minDensity());
}
volData.setVoxelAt(x, y, z, voxel);
@ -143,12 +143,12 @@ void createPerlinTerrain(LargeVolume<MaterialDensityPair44>& volData)
if(z < perlinVal)
{
voxel.setMaterial(245);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::MaxDensity);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::maxDensity());
}
else
{
voxel.setMaterial(0);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::MinDensity);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::minDensity());
}
volData.setVoxelAt(x, y, z, voxel);
@ -181,7 +181,7 @@ void createSphereInVolume(LargeVolume<MaterialDensityPair44>& volData, Vector3DF
if(fDistToCenter <= fRadius)
{
//Our new density value
uint8_t uDensity = VoxelTypeTraits<MaterialDensityPair44>::MaxDensity;
uint8_t uDensity = VoxelTypeTraits<MaterialDensityPair44>::maxDensity();
//Get the old voxel
MaterialDensityPair44 voxel = volData.getVoxelAt(x,y,z);
@ -219,17 +219,17 @@ void load(const ConstVolumeProxy<MaterialDensityPair44>& volume, const PolyVox::
if((x-xpos)*(x-xpos) + (z-zpos)*(z-zpos) < 200) {
// tunnel
voxel.setMaterial(0);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::MinDensity);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::minDensity());
} else {
// solid
voxel.setMaterial(245);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::MaxDensity);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::maxDensity());
}
}
else
{
voxel.setMaterial(0);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::MinDensity);
voxel.setDensity(VoxelTypeTraits<MaterialDensityPair44>::minDensity());
}
volume.setVoxelAt(x, y, z, voxel);

4
examples/SmoothLOD/main.cpp
View File

@ -55,8 +55,8 @@ void createSphereInVolume(SimpleVolume<Density8>& volData, float fRadius)
if(fDistToCenter <= fRadius)
{
//Our new density value
//uint8_t uDensity = Density8::getMaxDensity();
uint8_t uDensity = VoxelTypeTraits<Density8>::MaxDensity;
//uint8_t uDensity = Density8::getmaxDensity()();
uint8_t uDensity = VoxelTypeTraits<Density8>::maxDensity();
//Get the old voxel
Density8 voxel = volData.getVoxelAt(x,y,z);

4
library/PolyVoxCore/CMakeLists.txt
View File

@ -6,16 +6,12 @@ PROJECT(PolyVoxCore)
SET(CORE_SRC_FILES
source/ArraySizes.cpp
source/AStarPathfinder.cpp
source/Density.cpp
source/GradientEstimators.cpp
source/Log.cpp
source/Material.cpp
source/MaterialDensityPair.cpp
source/MeshDecimator.cpp
source/Region.cpp
source/SimpleInterface.cpp
source/VertexTypes.cpp
source/Voxel.cpp
source/VoxelFilters.cpp
)

6
library/PolyVoxCore/include/PolyVoxCore/AStarPathfinder.inl
View File

@ -37,18 +37,18 @@ namespace PolyVox
return false;
}
if(VoxelTypeTraits<VoxelType>::HasDensity)
if(VoxelTypeTraits<VoxelType>::hasDensity())
{
//and if their density is above the threshold.
VoxelType voxel = volData->getVoxelAt(v3dPos);
VoxelType::DensityType tThreshold = (VoxelTypeTraits<VoxelType>::MinDensity + VoxelTypeTraits<VoxelType>::MaxDensity) / 2;
VoxelType::DensityType tThreshold = (VoxelTypeTraits<VoxelType>::minDensity() + VoxelTypeTraits<VoxelType>::maxDensity()) / 2;
if(voxel.getDensity() >= tThreshold)
{
return false;
}
}
if(VoxelTypeTraits<VoxelType>::HasMaterial)
if(VoxelTypeTraits<VoxelType>::hasMaterial())
{
//and if their material is not zero.
VoxelType voxel = volData->getVoxelAt(v3dPos);

62
library/PolyVoxCore/include/PolyVoxCore/Density.h
View File

@ -31,6 +31,9 @@ freely, subject to the following restrictions:
#include <cassert>
#include <limits>
#undef min
#undef max
namespace PolyVox
{
///This class represents a voxel storing only a density.
@ -45,8 +48,11 @@ namespace PolyVox
///
/// \sa Material, MaterialDensityPair
////////////////////////////////////////////////////////////////////////////////
// int32_t template parameter is a dummy, required as the compiler expects to be able to declare an
// instance of VoxelType::MaterialType without knowing that VoxelType doesn't actually have a material.
template <typename Type>
class Density : public Voxel<Type, uint8_t>
class Density : public Voxel<Type, int32_t>
{
public:
//We expose DensityType and MaterialType in this way so that, when code is
@ -54,7 +60,7 @@ namespace PolyVox
//using code such as 'VoxelType::DensityType value = voxel.getDensity()'
//or 'VoxelType::MaterialType value = voxel.getMaterial()'.
typedef Type DensityType;
typedef uint8_t MaterialType; //Shouldn't define this one...
typedef int32_t MaterialType; //Shouldn't define this one...
Density() : m_uDensity(0) {}
Density(DensityType uDensity) : m_uDensity(uDensity) {}
@ -75,8 +81,8 @@ namespace PolyVox
void setDensity(DensityType uDensity) { m_uDensity = uDensity; }
//void setMaterial(MaterialType /*uMaterial*/) { assert(false); } //Cannot set material on voxel of type Density
//static DensityType getMaxDensity() throw() { return (std::numeric_limits<DensityType>::max)(); }
//static DensityType getMinDensity() throw() { return (std::numeric_limits<DensityType>::min)(); }
//static DensityType getmaxDensity()() throw() { return (std::numeric_limits<DensityType>::max)(); }
//static DensityType getminDensity()() throw() { return (std::numeric_limits<DensityType>::min)(); }
static DensityType getThreshold() throw() { return (std::numeric_limits<DensityType>::max)() / 2; }
private:
@ -103,60 +109,60 @@ namespace PolyVox
class VoxelTypeTraits< DensityI8 >
{
public:
const static bool HasDensity;
const static bool HasMaterial;
const static DensityI8::DensityType MinDensity;
const static DensityI8::DensityType MaxDensity;
static bool hasDensity() { return true; }
static bool hasMaterial() { return false; }
static DensityI8::DensityType minDensity() { return -std::numeric_limits<DensityI8::DensityType>::max(); }
static DensityI8::DensityType maxDensity() { return std::numeric_limits<DensityI8::DensityType>::max(); }
};
template<>
class VoxelTypeTraits< DensityU8 >
{
public:
const static bool HasDensity;
const static bool HasMaterial;
const static DensityU8::DensityType MinDensity;
const static DensityU8::DensityType MaxDensity;
static bool hasDensity() { return true; }
static bool hasMaterial() { return false; }
static DensityU8::DensityType minDensity() { return std::numeric_limits<DensityU8::DensityType>::min(); }
static DensityU8::DensityType maxDensity() { return std::numeric_limits<DensityU8::DensityType>::max(); }
};
template<>
class VoxelTypeTraits< DensityI16 >
{
public:
const static bool HasDensity;
const static bool HasMaterial;
const static DensityI16::DensityType MinDensity;
const static DensityI16::DensityType MaxDensity;
static bool hasDensity() { return true; }
static bool hasMaterial() { return false; }
static DensityI16::DensityType minDensity() { return -std::numeric_limits<DensityI16::DensityType>::max(); }
static DensityI16::DensityType maxDensity() { return std::numeric_limits<DensityI16::DensityType>::max(); }
};
template<>
class VoxelTypeTraits< DensityU16 >
{
public:
const static bool HasDensity;
const static bool HasMaterial;
const static DensityU16::DensityType MinDensity;
const static DensityU16::DensityType MaxDensity;
static bool hasDensity() { return true; }
static bool hasMaterial() { return false; }
static DensityU16::DensityType minDensity() { return std::numeric_limits<DensityU16::DensityType>::min(); }
static DensityU16::DensityType maxDensity() { return std::numeric_limits<DensityU16::DensityType>::max(); }
};
template<>
class VoxelTypeTraits< DensityFloat >
{
public:
const static bool HasDensity;
const static bool HasMaterial;
const static DensityFloat::DensityType MinDensity;
const static DensityFloat::DensityType MaxDensity;
static bool hasDensity() { return true; }
static bool hasMaterial() { return false; }
static DensityFloat::DensityType minDensity() { return -std::numeric_limits<DensityFloat::DensityType>::max(); }
static DensityFloat::DensityType maxDensity() { return std::numeric_limits<DensityFloat::DensityType>::max(); }
};
template<>
class VoxelTypeTraits< DensityDouble >
{
public:
const static bool HasDensity;
const static bool HasMaterial;
const static DensityDouble::DensityType MinDensity;
const static DensityDouble::DensityType MaxDensity;
static bool hasDensity() { return true; }
static bool hasMaterial() { return false; }
static DensityDouble::DensityType minDensity() { return -std::numeric_limits<DensityDouble::DensityType>::max(); }
static DensityDouble::DensityType maxDensity() { return std::numeric_limits<DensityDouble::DensityType>::max(); }
};
}

39
library/PolyVoxCore/include/PolyVoxCore/Material.h
View File

@ -45,15 +45,18 @@ namespace PolyVox
///
/// \sa Density, MaterialDensityPair
////////////////////////////////////////////////////////////////////////////////
// int32_t template parameter is a dummy, required as the compiler expects to be able to declare an
// instance of VoxelType::DensityType without knowing that VoxelType doesn't actually have a density.
template <typename Type>
class Material : public Voxel<uint8_t, Type>
class Material : public Voxel<int32_t, Type>
{
public:
//We expose DensityType and MaterialType in this way so that, when code is
//templatised on voxel type, it can determine the underlying storage type
//using code such as 'VoxelType::DensityType value = voxel.getDensity()'
//or 'VoxelType::MaterialType value = voxel.getMaterial()'.
typedef uint8_t DensityType; //Shouldn't define this one...
typedef int32_t DensityType;
typedef Type MaterialType;
Material() : m_uMaterial(0) {}
@ -74,12 +77,12 @@ namespace PolyVox
//We don't actually have a density, so make one up based on the material.
if(m_uMaterial == 0)
{
//return getMinDensity();
//return getminDensity()();
return 0;
}
else
{
//return getMaxDensity();
//return getmaxDensity()();
return 2;
}
}
@ -89,8 +92,8 @@ namespace PolyVox
void setDensity(DensityType /*uDensity*/) { assert(false); } //Cannot set density on voxel of type Material
void setMaterial(MaterialType uMaterial) { m_uMaterial = uMaterial; }
//static DensityType getMaxDensity() throw() { return 2; }
//static DensityType getMinDensity() throw() { return 0; }
//static DensityType getmaxDensity()() throw() { return 2; }
//static DensityType getminDensity()() throw() { return 0; }
static DensityType getThreshold() throw() { return 1; }
private:
@ -111,30 +114,30 @@ namespace PolyVox
class VoxelTypeTraits< MaterialU8 >
{
public:
const static bool HasDensity;
const static bool HasMaterial;
const static MaterialU8::DensityType MinDensity;
const static MaterialU8::DensityType MaxDensity;
static bool hasDensity() { return false; }
static bool hasMaterial() { return true; }
static int minDensity() { assert(false); return 0; }
static int maxDensity() { assert(false); return 0; }
};
template<>
class VoxelTypeTraits< MaterialU16 >
{
public:
const static bool HasDensity;
const static bool HasMaterial;
const static MaterialU16::DensityType MinDensity;
const static MaterialU16::DensityType MaxDensity;
static bool hasDensity() { return false; }
static bool hasMaterial() { return true; }
static int minDensity() { assert(false); return 0; }
static int maxDensity() { assert(false); return 0; }
};
template<>
class VoxelTypeTraits< MaterialU32 >
{
public:
const static bool HasDensity;
const static bool HasMaterial;
const static MaterialU32::DensityType MinDensity;
const static MaterialU32::DensityType MaxDensity;
static bool hasDensity() { return false; }
static bool hasMaterial() { return true; }
static int minDensity() { assert(false); return 0; }
static int maxDensity() { assert(false); return 0; }
};
}

20
library/PolyVoxCore/include/PolyVoxCore/MaterialDensityPair.h
View File

@ -74,8 +74,8 @@ namespace PolyVox
void setDensity(DensityType uDensity) { m_uDensity = uDensity; }
void setMaterial(MaterialType uMaterial) { m_uMaterial = uMaterial; }
//static DensityType getMaxDensity() throw() { return (0x01 << NoOfDensityBits) - 1; }
//static DensityType getMinDensity() throw() { return 0; }
//static DensityType getmaxDensity()() throw() { return (0x01 << NoOfDensityBits) - 1; }
//static DensityType getminDensity()() throw() { return 0; }
static DensityType getThreshold() throw() {return 0x01 << (NoOfDensityBits - 1);}
private:
@ -90,20 +90,20 @@ namespace PolyVox
class VoxelTypeTraits< MaterialDensityPair44 >
{
public:
const static bool HasDensity;
const static bool HasMaterial;
const static MaterialDensityPair44::DensityType MinDensity;
const static MaterialDensityPair44::DensityType MaxDensity;
static bool hasDensity() { return true; }
static bool hasMaterial() { return true; }
static MaterialDensityPair44::DensityType minDensity() { return 0; }
static MaterialDensityPair44::DensityType maxDensity() { return 15; }
};
template<>
class VoxelTypeTraits< MaterialDensityPair88 >
{
public:
const static bool HasDensity;
const static bool HasMaterial;
const static MaterialDensityPair88::DensityType MinDensity;
const static MaterialDensityPair88::DensityType MaxDensity;
static bool hasDensity() { return true; }
static bool hasMaterial() { return true; }
static MaterialDensityPair88::DensityType minDensity() { return 0; }
static MaterialDensityPair88::DensityType maxDensity() { return 255; }
};
}

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

@ -36,7 +36,7 @@ namespace PolyVox
class SurfaceExtractor
{
public:
SurfaceExtractor(VolumeType<VoxelType>* volData, Region region, SurfaceMesh<PositionMaterialNormal>* result, typename VoxelType::DensityType tThreshold = (VoxelTypeTraits<VoxelType>::MinDensity + VoxelTypeTraits<VoxelType>::MaxDensity) / 2);
SurfaceExtractor(VolumeType<VoxelType>* volData, Region region, SurfaceMesh<PositionMaterialNormal>* result, typename VoxelType::DensityType tThreshold = (VoxelTypeTraits<VoxelType>::minDensity() + VoxelTypeTraits<VoxelType>::maxDensity()) / 2);
void execute();

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

@ -433,7 +433,7 @@ namespace PolyVox
const VoxelType v100 = m_sampVolume.getVoxel();
const Vector3DFloat n100 = computeCentralDifferenceGradient(m_sampVolume);
//float fInterp = static_cast<float>(v100.getDensity() - VoxelType::getMinDensity()) / static_cast<float>(VoxelType::getMaxDensity() - VoxelType::getMinDensity());
//float fInterp = static_cast<float>(v100.getDensity() - VoxelType::getminDensity()()) / static_cast<float>(VoxelType::getmaxDensity()() - VoxelType::getminDensity()());
float fInterp = static_cast<float>(m_tThreshold - v000.getDensity()) / static_cast<float>(v100.getDensity() - v000.getDensity());
//fInterp = 0.5f;
@ -447,7 +447,7 @@ namespace PolyVox
//material IDs does not make sense). We take the largest, so that if we are working on a material-only
//volume we get the one which is non-zero. Both materials can be non-zero if our volume has a density component.
uint32_t uMaterial = 0;
if(VoxelTypeTraits<VoxelType>::HasMaterial)
if(VoxelTypeTraits<VoxelType>::hasMaterial())
{
uMaterial = (std::max)(v000.getMaterial(), v100.getMaterial());
}
@ -477,7 +477,7 @@ namespace PolyVox
//material IDs does not make sense). We take the largest, so that if we are working on a material-only
//volume we get the one which is non-zero. Both materials can be non-zero if our volume has a density component.
uint32_t uMaterial = 0;
if(VoxelTypeTraits<VoxelType>::HasMaterial)
if(VoxelTypeTraits<VoxelType>::hasMaterial())
{
uMaterial = (std::max)(v000.getMaterial(), v010.getMaterial());
}
@ -507,7 +507,7 @@ namespace PolyVox
//material IDs does not make sense). We take the largest, so that if we are working on a material-only
//volume we get the one which is non-zero. Both materials can be non-zero if our volume has a density component.
uint32_t uMaterial = 0;
if(VoxelTypeTraits<VoxelType>::HasMaterial)
if(VoxelTypeTraits<VoxelType>::hasMaterial())
{
uMaterial = (std::max)(v000.getMaterial(), v001.getMaterial());
}

15
library/PolyVoxCore/include/PolyVoxCore/Voxel.h
View File

@ -56,7 +56,7 @@ namespace PolyVox
// Various properties of the voxel types can be expressed via types traits, similar to the way std::numeric_limits is implemented.
// This has some advantages compared to storing the properties directly in the voxel class. For example, by using traits it is possible
// to also apply these properties to primative types which might be desirable (the Volume classes do accept primative types as template
// parameters). Also, properties such as MinDensity and MaxDensity would be difficult to represent though class members because they
// parameters). Also, properties such as minDensity() and maxDensity() would be difficult to represent though class members because they
// depend ont the type (float has a very different range from int8_t for example).
//
// The properties are currently exposed as constants because we need access to them at compile time. Ideally we would like to make them
@ -68,10 +68,15 @@ namespace PolyVox
class VoxelTypeTraits
{
public:
const static bool HasDensity;
const static bool HasMaterial;
const static typename Type::DensityType MinDensity;
const static typename Type::DensityType MaxDensity;
static bool hasDensity() { return false; }
static bool hasMaterial() { return false; }
// These default implementations return an int32_t rather than void so that the result can be
// assigned to a variable for all voxel types (even those without density coponents). Calls
// to these functions should be protected by calls to hasDensity(), but the compiler still
// needs to ensure the assignment is compilable even if hasDensity() returns false.
static int32_t minDensity() { assert(false); return 0; }
static int32_t maxDensity() { assert(false); return 0; }
};
}

59
library/PolyVoxCore/source/Density.cpp
View File

@ -1,59 +0,0 @@
/*******************************************************************************
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.
*******************************************************************************/
#include "PolyVoxCore/Density.h"
#include <cfloat> //Can't use <limits> as we need compile time constants.
namespace PolyVox
{
const bool VoxelTypeTraits< DensityI8 >::HasDensity = true;
const bool VoxelTypeTraits< DensityI8 >::HasMaterial = false;
const DensityI8::DensityType VoxelTypeTraits< DensityI8 >::MinDensity = -127;
const DensityI8::DensityType VoxelTypeTraits< DensityI8 >::MaxDensity = 127;
const bool VoxelTypeTraits< DensityU8 >::HasDensity = true;
const bool VoxelTypeTraits< DensityU8 >::HasMaterial = false;
const DensityU8::DensityType VoxelTypeTraits< DensityU8 >::MinDensity = 0;
const DensityU8::DensityType VoxelTypeTraits< DensityU8 >::MaxDensity = 255;
const bool VoxelTypeTraits< DensityI16 >::HasDensity = true;
const bool VoxelTypeTraits< DensityI16 >::HasMaterial = false;
const DensityI16::DensityType VoxelTypeTraits< DensityI16 >::MinDensity = -32767;
const DensityI16::DensityType VoxelTypeTraits< DensityI16 >::MaxDensity = 32767;
const bool VoxelTypeTraits< DensityU16 >::HasDensity = true;
const bool VoxelTypeTraits< DensityU16 >::HasMaterial = false;
const DensityU16::DensityType VoxelTypeTraits< DensityU16 >::MinDensity = 0;
const DensityU16::DensityType VoxelTypeTraits< DensityU16 >::MaxDensity = 65535;
const bool VoxelTypeTraits< DensityFloat >::HasDensity = true;
const bool VoxelTypeTraits< DensityFloat >::HasMaterial = false;
const DensityFloat::DensityType VoxelTypeTraits< DensityFloat >::MinDensity = -FLT_MAX;
const DensityFloat::DensityType VoxelTypeTraits< DensityFloat >::MaxDensity = FLT_MAX;
const bool VoxelTypeTraits< DensityDouble >::HasDensity = true;
const bool VoxelTypeTraits< DensityDouble >::HasMaterial = false;
const DensityDouble::DensityType VoxelTypeTraits< DensityDouble >::MinDensity = -DBL_MAX;
const DensityDouble::DensityType VoxelTypeTraits< DensityDouble >::MaxDensity = DBL_MAX;
}

44
library/PolyVoxCore/source/Material.cpp
View File

@ -1,44 +0,0 @@
/*******************************************************************************
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.
*******************************************************************************/
#include "PolyVoxCore/Material.h"
#include <cfloat> //Can't use <limits> as we need compile time constants.
namespace PolyVox
{
const bool VoxelTypeTraits< MaterialU8 >::HasDensity = false;
const bool VoxelTypeTraits< MaterialU8 >::HasMaterial = true;
const MaterialU8::DensityType VoxelTypeTraits< MaterialU8 >::MinDensity = 0;
const MaterialU8::DensityType VoxelTypeTraits< MaterialU8 >::MaxDensity = 0;
const bool VoxelTypeTraits< MaterialU16 >::HasDensity = false;
const bool VoxelTypeTraits< MaterialU16 >::HasMaterial = true;
const MaterialU16::DensityType VoxelTypeTraits< MaterialU16 >::MinDensity = 0;
const MaterialU16::DensityType VoxelTypeTraits< MaterialU16 >::MaxDensity = 0;
const bool VoxelTypeTraits< MaterialU32 >::HasDensity = false;
const bool VoxelTypeTraits< MaterialU32 >::HasMaterial = true;
const MaterialU32::DensityType VoxelTypeTraits< MaterialU32 >::MinDensity = 0;
const MaterialU32::DensityType VoxelTypeTraits< MaterialU32 >::MaxDensity = 0;
}

37
library/PolyVoxCore/source/MaterialDensityPair.cpp
View File

@ -1,37 +0,0 @@
/*******************************************************************************
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.
*******************************************************************************/
#include "PolyVoxCore/MaterialDensityPair.h"
namespace PolyVox
{
const bool VoxelTypeTraits< MaterialDensityPair44 >::HasDensity = true;
const bool VoxelTypeTraits< MaterialDensityPair44 >::HasMaterial = true;
const MaterialDensityPair44::DensityType VoxelTypeTraits< MaterialDensityPair44 >::MinDensity = 0;
const MaterialDensityPair44::DensityType VoxelTypeTraits< MaterialDensityPair44 >::MaxDensity = 15;
const bool VoxelTypeTraits< MaterialDensityPair88 >::HasDensity = true;
const bool VoxelTypeTraits< MaterialDensityPair88 >::HasMaterial = true;
const MaterialDensityPair88::DensityType VoxelTypeTraits< MaterialDensityPair88 >::MinDensity = 0;
const MaterialDensityPair88::DensityType VoxelTypeTraits< MaterialDensityPair88 >::MaxDensity = 255;
}

37
library/PolyVoxCore/source/Voxel.cpp
View File

@ -1,37 +0,0 @@
/*******************************************************************************
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.
*******************************************************************************/
#include "PolyVoxCore/Voxel.h"
namespace PolyVox
{
template<typename Type>
const bool VoxelTypeTraits<Type>::HasDensity = false;
template<typename Type>
const bool VoxelTypeTraits<Type>::HasMaterial = false;
template<typename Type>
const typename Type::DensityType VoxelTypeTraits< Type >::MinDensity = 0;
template<typename Type>
const typename Type::DensityType VoxelTypeTraits< Type >::MaxDensity = 0;
}

44
tests/TestVoxels.cpp
View File

@ -38,43 +38,43 @@ void TestVoxels::testVoxelTypeLimits()
// It's worth testing these as they are not all explictily defined (e.g. Density8 is just a
// typedef of DensityI8), and in the future we might define then with bitwise magic or something.
QCOMPARE(VoxelTypeTraits<Density8>::MinDensity, Density8::DensityType(0));
QCOMPARE(VoxelTypeTraits<Density8>::MaxDensity, Density8::DensityType(255));
QCOMPARE(VoxelTypeTraits<Density8>::minDensity(), Density8::DensityType(0));
QCOMPARE(VoxelTypeTraits<Density8>::maxDensity(), Density8::DensityType(255));
QCOMPARE(VoxelTypeTraits<DensityI8>::MinDensity, DensityI8::DensityType(-127));
QCOMPARE(VoxelTypeTraits<DensityI8>::MaxDensity, DensityI8::DensityType(127));
QCOMPARE(VoxelTypeTraits<DensityI8>::minDensity(), DensityI8::DensityType(-127));
QCOMPARE(VoxelTypeTraits<DensityI8>::maxDensity(), DensityI8::DensityType(127));
QCOMPARE(VoxelTypeTraits<DensityU8>::MinDensity, DensityU8::DensityType(0));
QCOMPARE(VoxelTypeTraits<DensityU8>::MaxDensity, DensityU8::DensityType(255));
QCOMPARE(VoxelTypeTraits<DensityU8>::minDensity(), DensityU8::DensityType(0));
QCOMPARE(VoxelTypeTraits<DensityU8>::maxDensity(), DensityU8::DensityType(255));
QCOMPARE(VoxelTypeTraits<Density16>::MinDensity, Density16::DensityType(0));
QCOMPARE(VoxelTypeTraits<Density16>::MaxDensity, Density16::DensityType(65535));
QCOMPARE(VoxelTypeTraits<Density16>::minDensity(), Density16::DensityType(0));
QCOMPARE(VoxelTypeTraits<Density16>::maxDensity(), Density16::DensityType(65535));
QCOMPARE(VoxelTypeTraits<DensityI16>::MinDensity, DensityI16::DensityType(-32767));
QCOMPARE(VoxelTypeTraits<DensityI16>::MaxDensity, DensityI16::DensityType(32767));
QCOMPARE(VoxelTypeTraits<DensityI16>::minDensity(), DensityI16::DensityType(-32767));
QCOMPARE(VoxelTypeTraits<DensityI16>::maxDensity(), DensityI16::DensityType(32767));
QCOMPARE(VoxelTypeTraits<DensityU16>::MinDensity, DensityU16::DensityType(0));
QCOMPARE(VoxelTypeTraits<DensityU16>::MaxDensity, DensityU16::DensityType(65535));
QCOMPARE(VoxelTypeTraits<DensityU16>::minDensity(), DensityU16::DensityType(0));
QCOMPARE(VoxelTypeTraits<DensityU16>::maxDensity(), DensityU16::DensityType(65535));
QCOMPARE(VoxelTypeTraits<DensityFloat>::MinDensity, FLT_MIN);
QCOMPARE(VoxelTypeTraits<DensityFloat>::MaxDensity, FLT_MAX);
QCOMPARE(VoxelTypeTraits<DensityFloat>::minDensity(), FLT_MIN);
QCOMPARE(VoxelTypeTraits<DensityFloat>::maxDensity(), FLT_MAX);
QCOMPARE(VoxelTypeTraits<DensityDouble>::MinDensity, DBL_MIN);
QCOMPARE(VoxelTypeTraits<DensityDouble>::MaxDensity, DBL_MAX);
QCOMPARE(VoxelTypeTraits<DensityDouble>::minDensity(), DBL_MIN);
QCOMPARE(VoxelTypeTraits<DensityDouble>::maxDensity(), DBL_MAX);
/*fValue = VoxelTypeTraits<DensityFloat>::MinDensity;
/*fValue = VoxelTypeTraits<DensityFloat>::minDensity();
QCOMPARE(fValue, -FLT_MAX);
fValue = VoxelTypeTraits<DensityFloat>::MaxDensity;
fValue = VoxelTypeTraits<DensityFloat>::maxDensity();
QCOMPARE(fValue, FLT_MAX);*/
/*iValue = VoxelTypeTraits<Material8>::MinDensity;
/*iValue = VoxelTypeTraits<Material8>::minDensity();
QCOMPARE(iValue, 0);
iValue = VoxelTypeTraits<Material8>::MaxDensity;
iValue = VoxelTypeTraits<Material8>::maxDensity();
QCOMPARE(iValue, 0);*/
/*iValue = VoxelTypeTraits<MaterialDensityPair44>::MinDensity;
/*iValue = VoxelTypeTraits<MaterialDensityPair44>::minDensity();
QCOMPARE(iValue, 0);
iValue = VoxelTypeTraits<MaterialDensityPair44>::MaxDensity;
iValue = VoxelTypeTraits<MaterialDensityPair44>::maxDensity();
QCOMPARE(iValue, 15);*/
}