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

I accidentally merged the 'cubiquity-version' feature back into develop. It seems I can't simply reverse this commit (at least through SourceTree ) because it was a merge, so I'm having to simply revert the contents of the commit (i.e. the files). Bit of a mess!

Browse Source
This commit is contained in:
David Williams 2014-05-11 20:34:41 +02:00
parent 1bff5c207c
commit a34c106382
8 changed files with 115 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -82,7 +82,7 @@ namespace PolyVox
struct IndexAndMaterial
{
int32_t iIndex;
typename VolumeType::VoxelType uMaterial;
int32_t uMaterial; //Should actually use the material type here, but this is ok for now.
};
enum FaceNames
@ -113,16 +113,16 @@ namespace PolyVox
// This is a bit ugly - it seems that the C++03 syntax is different from the C++11 syntax? See this thread: http://stackoverflow.com/questions/6076015/typename-outside-of-template
// Long term we should probably come back to this and if the #ifdef is still needed then maybe it should check for C++11 mode instead of MSVC?
#if defined(_MSC_VER)
CubicSurfaceExtractor(VolumeType* volData, Region region, SurfaceMesh<PositionMaterial<typename VolumeType::VoxelType> >* result, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = VolumeType::VoxelType(), bool bMergeQuads = true, IsQuadNeeded isQuadNeeded = IsQuadNeeded());
CubicSurfaceExtractor(VolumeType* volData, Region region, SurfaceMesh<PositionMaterial>* result, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = VolumeType::VoxelType(), bool bMergeQuads = true, IsQuadNeeded isQuadNeeded = IsQuadNeeded());
#else
CubicSurfaceExtractor(VolumeType* volData, Region region, SurfaceMesh<PositionMaterial<typename VolumeType::VoxelType> >* result, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = typename VolumeType::VoxelType(), bool bMergeQuads = true, IsQuadNeeded isQuadNeeded = IsQuadNeeded());
CubicSurfaceExtractor(VolumeType* volData, Region region, SurfaceMesh<PositionMaterial>* result, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = typename VolumeType::VoxelType(), bool bMergeQuads = true, IsQuadNeeded isQuadNeeded = IsQuadNeeded());
#endif
void execute();
private:
int32_t addVertex(uint32_t uX, uint32_t uY, uint32_t uZ, typename VolumeType::VoxelType uMaterial, Array<3, IndexAndMaterial>& existingVertices);
int32_t addVertex(uint32_t uX, uint32_t uY, uint32_t uZ, uint32_t uMaterial, Array<3, IndexAndMaterial>& existingVertices);
bool performQuadMerging(std::list<Quad>& quads);
bool mergeQuads(Quad& q1, Quad& q2);
@ -135,7 +135,7 @@ namespace PolyVox
Region m_regSizeInVoxels;
//The surface patch we are currently filling.
SurfaceMesh<PositionMaterial<typename VolumeType::VoxelType> >* m_meshCurrent;
SurfaceMesh<PositionMaterial>* m_meshCurrent;
//Used to avoid creating duplicate vertices.
Array<3, IndexAndMaterial> m_previousSliceVertices;

12
library/PolyVoxCore/include/PolyVoxCore/CubicSurfaceExtractor.inl
View File

@ -36,7 +36,7 @@ namespace PolyVox
const uint32_t CubicSurfaceExtractor<VolumeType, IsQuadNeeded>::MaxVerticesPerPosition = 8;
template<typename VolumeType, typename IsQuadNeeded>
CubicSurfaceExtractor<VolumeType, IsQuadNeeded>::CubicSurfaceExtractor(VolumeType* volData, Region region, SurfaceMesh<PositionMaterial<typename VolumeType::VoxelType> >* result, WrapMode eWrapMode, typename VolumeType::VoxelType tBorderValue, bool bMergeQuads, IsQuadNeeded isQuadNeeded)
CubicSurfaceExtractor<VolumeType, IsQuadNeeded>::CubicSurfaceExtractor(VolumeType* volData, Region region, SurfaceMesh<PositionMaterial>* result, WrapMode eWrapMode, typename VolumeType::VoxelType tBorderValue, bool bMergeQuads, IsQuadNeeded isQuadNeeded)
:m_volData(volData)
,m_regSizeInVoxels(region)
,m_meshCurrent(result)
@ -88,7 +88,7 @@ namespace PolyVox
{
uint32_t regX = x - m_regSizeInVoxels.getLowerX();
typename VolumeType::VoxelType material; //Filled in by callback
uint32_t material; //Filled in by callback
typename VolumeType::VoxelType currentVoxel = volumeSampler.getVoxel();
typename VolumeType::VoxelType negXVoxel = volumeSampler.peekVoxel1nx0py0pz();
typename VolumeType::VoxelType negYVoxel = volumeSampler.peekVoxel0px1ny0pz();
@ -205,7 +205,7 @@ namespace PolyVox
}
template<typename VolumeType, typename IsQuadNeeded>
int32_t CubicSurfaceExtractor<VolumeType, IsQuadNeeded>::addVertex(uint32_t uX, uint32_t uY, uint32_t uZ, typename VolumeType::VoxelType uMaterialIn, Array<3, IndexAndMaterial>& existingVertices)
int32_t CubicSurfaceExtractor<VolumeType, IsQuadNeeded>::addVertex(uint32_t uX, uint32_t uY, uint32_t uZ, uint32_t uMaterialIn, Array<3, IndexAndMaterial>& existingVertices)
{
for(uint32_t ct = 0; ct < MaxVerticesPerPosition; ct++)
{
@ -214,14 +214,14 @@ namespace PolyVox
if(rEntry.iIndex == -1)
{
//No vertices matched and we've now hit an empty space. Fill it by creating a vertex. The 0.5f offset is because vertices set between voxels in order to build cubes around them.
rEntry.iIndex = m_meshCurrent->addVertex(PositionMaterial<typename VolumeType::VoxelType> (Vector3DFloat(static_cast<float>(uX) - 0.5f, static_cast<float>(uY) - 0.5f, static_cast<float>(uZ) - 0.5f), uMaterialIn));
rEntry.iIndex = m_meshCurrent->addVertex(PositionMaterial(Vector3DFloat(static_cast<float>(uX) - 0.5f, static_cast<float>(uY) - 0.5f, static_cast<float>(uZ) - 0.5f), uMaterialIn));
rEntry.uMaterial = uMaterialIn;
return rEntry.iIndex;
}
//If we have an existing vertex and the material matches then we can return it.
if(rEntry.uMaterial == uMaterialIn)
if(rEntry.uMaterial == static_cast<int32_t>(uMaterialIn))
{
return rEntry.iIndex;
}
@ -268,7 +268,7 @@ namespace PolyVox
{
//All four vertices of a given quad have the same material,
//so just check that the first pair of vertices match.
if(m_meshCurrent->getVertices()[q1.vertices[0]].getMaterial() == m_meshCurrent->getVertices()[q2.vertices[0]].getMaterial())
if(std::abs(m_meshCurrent->getVertices()[q1.vertices[0]].getMaterial() - m_meshCurrent->getVertices()[q2.vertices[0]].getMaterial()) < 0.001)
{
//Now check whether quad 2 is adjacent to quad one by comparing vertices.
//Adjacent quads must share two vertices, and the second quad could be to the

6
library/PolyVoxCore/include/PolyVoxCore/MarchingCubesSurfaceExtractor.h
View File

@ -41,9 +41,9 @@ namespace PolyVox
// This is a bit ugly - it seems that the C++03 syntax is different from the C++11 syntax? See this thread: http://stackoverflow.com/questions/6076015/typename-outside-of-template
// Long term we should probably come back to this and if the #ifdef is still needed then maybe it should check for C++11 mode instead of MSVC?
#if defined(_MSC_VER)
MarchingCubesSurfaceExtractor(VolumeType* volData, Region region, SurfaceMesh<PositionMaterialNormal<typename Controller::MaterialType> >* result, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = VolumeType::VoxelType(), Controller controller = Controller());
MarchingCubesSurfaceExtractor(VolumeType* volData, Region region, SurfaceMesh<PositionMaterialNormal>* result, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = VolumeType::VoxelType(), Controller controller = Controller());
#else
MarchingCubesSurfaceExtractor(VolumeType* volData, Region region, SurfaceMesh<PositionMaterialNormal<typename Controller::MaterialType> >* result, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = typename VolumeType::VoxelType(), Controller controller = Controller());
MarchingCubesSurfaceExtractor(VolumeType* volData, Region region, SurfaceMesh<PositionMaterialNormal>* result, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = typename VolumeType::VoxelType(), Controller controller = Controller());
#endif
void execute();
@ -193,7 +193,7 @@ namespace PolyVox
uint32_t m_uNoOfOccupiedCells;
//The surface patch we are currently filling.
SurfaceMesh<PositionMaterialNormal<typename Controller::MaterialType> >* m_meshCurrent;
SurfaceMesh<PositionMaterialNormal>* m_meshCurrent;
//Information about the region we are currently processing
Region m_regSizeInVoxels;

10
library/PolyVoxCore/include/PolyVoxCore/MarchingCubesSurfaceExtractor.inl
View File

@ -26,7 +26,7 @@ freely, subject to the following restrictions:
namespace PolyVox
{
template<typename VolumeType, typename Controller>
MarchingCubesSurfaceExtractor<VolumeType, Controller>::MarchingCubesSurfaceExtractor(VolumeType* volData, Region region, SurfaceMesh<PositionMaterialNormal<typename Controller::MaterialType> >* result, WrapMode eWrapMode, typename VolumeType::VoxelType tBorderValue, Controller controller)
MarchingCubesSurfaceExtractor<VolumeType, Controller>::MarchingCubesSurfaceExtractor(VolumeType* volData, Region region, SurfaceMesh<PositionMaterialNormal>* result, WrapMode eWrapMode, typename VolumeType::VoxelType tBorderValue, Controller controller)
:m_volData(volData)
,m_sampVolume(volData)
,m_meshCurrent(result)
@ -459,7 +459,7 @@ namespace PolyVox
// Allow the controller to decide how the material should be derived from the voxels.
const typename Controller::MaterialType uMaterial = m_controller.blendMaterials(v000, v100, fInterp);
const PositionMaterialNormal<typename Controller::MaterialType> surfaceVertex(v3dPosition, v3dNormal, uMaterial);
const PositionMaterialNormal surfaceVertex(v3dPosition, v3dNormal, static_cast<float>(uMaterial));
const uint32_t uLastVertexIndex = m_meshCurrent->addVertex(surfaceVertex);
m_pCurrentVertexIndicesX[iXVolSpace - m_regSizeInVoxels.getLowerX()][iYVolSpace - m_regSizeInVoxels.getLowerY()] = uLastVertexIndex;
@ -488,8 +488,8 @@ namespace PolyVox
// Allow the controller to decide how the material should be derived from the voxels.
const typename Controller::MaterialType uMaterial = m_controller.blendMaterials(v000, v010, fInterp);
PositionMaterialNormal<typename Controller::MaterialType> surfaceVertex(v3dPosition, v3dNormal, uMaterial);
uint32_t uLastVertexIndex = m_meshCurrent->addVertex(surfaceVertex);
const PositionMaterialNormal surfaceVertex(v3dPosition, v3dNormal, static_cast<float>(uMaterial));
const uint32_t uLastVertexIndex = m_meshCurrent->addVertex(surfaceVertex);
m_pCurrentVertexIndicesY[iXVolSpace - m_regSizeInVoxels.getLowerX()][iYVolSpace - m_regSizeInVoxels.getLowerY()] = uLastVertexIndex;
m_sampVolume.moveNegativeY();
@ -516,7 +516,7 @@ namespace PolyVox
// Allow the controller to decide how the material should be derived from the voxels.
const typename Controller::MaterialType uMaterial = m_controller.blendMaterials(v000, v001, fInterp);
const PositionMaterialNormal<typename Controller::MaterialType> surfaceVertex(v3dPosition, v3dNormal, uMaterial);
const PositionMaterialNormal surfaceVertex(v3dPosition, v3dNormal, static_cast<float>(uMaterial));
const uint32_t uLastVertexIndex = m_meshCurrent->addVertex(surfaceVertex);
m_pCurrentVertexIndicesZ[iXVolSpace - m_regSizeInVoxels.getLowerX()][iYVolSpace - m_regSizeInVoxels.getLowerY()] = uLastVertexIndex;

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

@ -132,12 +132,12 @@ namespace PolyVox
////////////////////////////////////////////////////////////////////////////////
// PositionMaterial
////////////////////////////////////////////////////////////////////////////////
template<typename MaterialType> class PositionMaterial;
class PositionMaterial;
////////////////////////////////////////////////////////////////////////////////
// PositionMaterialNormal
////////////////////////////////////////////////////////////////////////////////
template<typename MaterialType> class PositionMaterialNormal;
class PositionMaterialNormal;
////////////////////////////////////////////////////////////////////////////////
// RawVolume

2
library/PolyVoxCore/include/PolyVoxCore/UncompressedBlock.inl
View File

@ -21,8 +21,6 @@ freely, subject to the following restrictions:
distribution.
*******************************************************************************/
#include "PolyVoxCore/Impl/Utility.h"
namespace PolyVox
{
template <typename VoxelType>

92
library/PolyVoxCore/include/PolyVoxCore/VertexTypes.h
View File

@ -36,107 +36,49 @@ namespace PolyVox
#ifdef SWIG
class PositionMaterial
#else
template<typename MaterialType>
class POLYVOX_API PositionMaterial
#endif
{
public:
PositionMaterial()
{
}
PositionMaterial();
PositionMaterial(Vector3DFloat positionToSet, float materialToSet);
PositionMaterial(Vector3DFloat positionToSet, MaterialType materialToSet)
:position(positionToSet)
,material(materialToSet)
{
}
float getMaterial(void) const;
const Vector3DFloat& getPosition(void) const;
MaterialType getMaterial(void) const
{
return material;
}
const Vector3DFloat& getPosition(void) const
{
return position;
}
void setMaterial(MaterialType materialToSet)
{
material = materialToSet;
}
void setPosition(const Vector3DFloat& positionToSet)
{
position = positionToSet;
}
void setMaterial(float materialToSet);
void setPosition(const Vector3DFloat& positionToSet);
public:
//Nicely fits into four floats.
Vector3DFloat position;
MaterialType material;
float material;
};
#ifdef SWIG
class PositionMaterialNormal
#else
template<typename MaterialType>
class POLYVOX_API PositionMaterialNormal
#endif
{
public:
PositionMaterialNormal()
{
}
PositionMaterialNormal();
PositionMaterialNormal(Vector3DFloat positionToSet, float materialToSet);
PositionMaterialNormal(Vector3DFloat positionToSet, Vector3DFloat normalToSet, float materialToSet);
PositionMaterialNormal(Vector3DFloat positionToSet, MaterialType materialToSet)
:position(positionToSet)
,material(materialToSet)
{
}
float getMaterial(void) const;
const Vector3DFloat& getNormal(void) const;
const Vector3DFloat& getPosition(void) const;
PositionMaterialNormal(Vector3DFloat positionToSet, Vector3DFloat normalToSet, MaterialType materialToSet)
:position(positionToSet)
,normal(normalToSet)
,material(materialToSet)
{
}
MaterialType getMaterial(void) const
{
return material;
}
const Vector3DFloat& getNormal(void) const
{
return normal;
}
const Vector3DFloat& getPosition(void) const
{
return position;
}
void setMaterial(MaterialType materialToSet)
{
material = materialToSet;
}
void setNormal(const Vector3DFloat& normalToSet)
{
normal = normalToSet;
}
void setPosition(const Vector3DFloat& positionToSet)
{
position = positionToSet;
}
void setMaterial(float materialToSet);
void setNormal(const Vector3DFloat& normalToSet);
void setPosition(const Vector3DFloat& positionToSet);
public:
//Nicely fits into seven floats, meaning we
//can squeeze in one more for material blending.
Vector3DFloat position;
Vector3DFloat normal;
MaterialType material; //FIXME: This shouldn't be float on CPU?
float material; //FIXME: This shouldn't be float on CPU?
};
}

77
library/PolyVoxCore/source/VertexTypes.cpp
View File

@ -25,9 +25,86 @@ freely, subject to the following restrictions:
namespace PolyVox
{
PositionMaterialNormal::PositionMaterialNormal()
{
}
PositionMaterialNormal::PositionMaterialNormal(Vector3DFloat positionToSet, float materialToSet)
:position(positionToSet)
,material(materialToSet)
{
}
PositionMaterialNormal::PositionMaterialNormal(Vector3DFloat positionToSet, Vector3DFloat normalToSet, float materialToSet)
:position(positionToSet)
,normal(normalToSet)
,material(materialToSet)
{
}
float PositionMaterialNormal::getMaterial(void) const
{
return material;
}
const Vector3DFloat& PositionMaterialNormal::getNormal(void) const
{
return normal;
}
const Vector3DFloat& PositionMaterialNormal::getPosition(void) const
{
return position;
}
void PositionMaterialNormal::setMaterial(float materialToSet)
{
material = materialToSet;
}
void PositionMaterialNormal::setNormal(const Vector3DFloat& normalToSet)
{
normal = normalToSet;
}
void PositionMaterialNormal::setPosition(const Vector3DFloat& positionToSet)
{
position = positionToSet;
}
////////////////////////////////////////////////////////////////////////////////
// PositionMaterial
////////////////////////////////////////////////////////////////////////////////
PositionMaterial::PositionMaterial()
{
}
PositionMaterial::PositionMaterial(Vector3DFloat positionToSet, float materialToSet)
:position(positionToSet)
,material(materialToSet)
{
}
float PositionMaterial::getMaterial(void) const
{
return material;
}
const Vector3DFloat& PositionMaterial::getPosition(void) const
{
return position;
}
void PositionMaterial::setMaterial(float materialToSet)
{
material = materialToSet;
}
void PositionMaterial::setPosition(const Vector3DFloat& positionToSet)
{
position = positionToSet;
}
}