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

Renamed SurfaceMesh to just Mesh

Browse Source
This commit is contained in:
David Williams 2014-05-23 15:17:07 +02:00
parent da8f294847
commit 4aae00e4a8
27 changed files with 679 additions and 679 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/Basic/OpenGLWidget.cpp
View File

@ -15,7 +15,7 @@ OpenGLWidget::OpenGLWidget(QWidget *parent)
{
}
void OpenGLWidget::setSurfaceMeshToRender(const PolyVox::SurfaceMesh<CubicVertex<uint8_t> >& surfaceMesh)
void OpenGLWidget::setMeshToRender(const PolyVox::Mesh<CubicVertex<uint8_t> >& surfaceMesh)
{
//Convienient access to the vertices and indices
const auto& vecIndices = surfaceMesh.getIndices();

4
examples/Basic/OpenGLWidget.h
View File

@ -24,7 +24,7 @@ distribution.
#ifndef __BasicExample_OpenGLWidget_H__
#define __BasicExample_OpenGLWidget_H__
#include "PolyVoxCore/SurfaceMesh.h"
#include "PolyVoxCore/Mesh.h"
#include "glew/glew.h"
@ -50,7 +50,7 @@ public:
void mousePressEvent(QMouseEvent* event);
// Convert a SurfaceMesh to OpenGL index/vertex buffers
void setSurfaceMeshToRender(const PolyVox::SurfaceMesh<PolyVox::CubicVertex<uint8_t> >& surfaceMesh);
void setMeshToRender(const PolyVox::Mesh<PolyVox::CubicVertex<uint8_t> >& surfaceMesh);
// The viewable region can be adjusted so that this example framework can be use for different volume sizes.
void setViewableRegion(PolyVox::Region viewableRegion);

6
examples/Basic/main.cpp
View File

@ -25,7 +25,7 @@ freely, subject to the following restrictions:
#include "PolyVoxCore/CubicSurfaceExtractor.h"
#include "PolyVoxCore/MarchingCubesSurfaceExtractor.h"
#include "PolyVoxCore/SurfaceMesh.h"
#include "PolyVoxCore/Mesh.h"
#include "PolyVoxCore/SimpleVolume.h"
#include <QApplication>
@ -85,9 +85,9 @@ int main(int argc, char *argv[])
//auto mesh2 = extractCubicMesh(&volData, PolyVox::Region(Vector3DInt32(32, 32, 32), Vector3DInt32(63, 63, 63)));
//Pass the surface to the OpenGL window
openGLWidget.setSurfaceMeshToRender(mesh);
openGLWidget.setMeshToRender(mesh);
openGLWidget.setViewableRegion(volData.getEnclosingRegion());
//openGLWidget.setSurfaceMeshToRender(mesh2);
//openGLWidget.setMeshToRender(mesh2);
//Run the message pump.
return app.exec();

4
examples/OpenGL/OpenGLImmediateModeSupport.cpp
View File

@ -24,12 +24,12 @@ freely, subject to the following restrictions:
#include "OpenGLImmediateModeSupport.h"
#include "OpenGLSupport.h"
#include "PolyVoxCore/SurfaceMesh.h"
#include "PolyVoxCore/Mesh.h"
using namespace PolyVox;
using namespace std;
void renderRegionImmediateMode(PolyVox::SurfaceMesh<MarchingCubesVertex<MaterialDensityPair44> >& mesh, unsigned int uLodLevel)
void renderRegionImmediateMode(PolyVox::Mesh<MarchingCubesVertex<MaterialDensityPair44> >& mesh, unsigned int uLodLevel)
{
const vector<MarchingCubesVertex<MaterialDensityPair44> >& vecVertices = mesh.getVertices();
const vector<uint32_t>& vecIndices = mesh.getIndices();

2
examples/OpenGL/OpenGLImmediateModeSupport.h
View File

@ -29,6 +29,6 @@ freely, subject to the following restrictions:
#include "glew/glew.h"
void renderRegionImmediateMode(PolyVox::SurfaceMesh<PolyVox::MarchingCubesVertex<PolyVox::MaterialDensityPair44> >& mesh, unsigned int uLodLevel);
void renderRegionImmediateMode(PolyVox::Mesh<PolyVox::MarchingCubesVertex<PolyVox::MaterialDensityPair44> >& mesh, unsigned int uLodLevel);
#endif //__OpenGLExample_OpenGLImmediateModeSupport_H__

20
examples/OpenGL/OpenGLVertexBufferObjectSupport.cpp
View File

@ -25,15 +25,15 @@ freely, subject to the following restrictions:
#include "OpenGLVertexBufferObjectSupport.h"
#include "PolyVoxCore/MaterialDensityPair.h"
#include "PolyVoxCore/SurfaceMesh.h"
#include "PolyVoxCore/Mesh.h"
using namespace PolyVox;
using namespace std;
OpenGLSurfaceMesh BuildOpenGLSurfaceMesh(const SurfaceMesh<MarchingCubesVertex<MaterialDensityPair44> >& mesh)
OpenGLMesh BuildOpenGLMesh(const Mesh<MarchingCubesVertex<MaterialDensityPair44> >& mesh)
{
//Represents our filled in OpenGL vertex and index buffer objects.
OpenGLSurfaceMesh result;
OpenGLMesh result;
//The source
result.sourceMesh = &mesh;
@ -102,23 +102,23 @@ OpenGLSurfaceMesh BuildOpenGLSurfaceMesh(const SurfaceMesh<MarchingCubesVertex<M
return result;
}
void renderRegionVertexBufferObject(const OpenGLSurfaceMesh& openGLSurfaceMesh, unsigned int uLodLevel)
void renderRegionVertexBufferObject(const OpenGLMesh& openGLMesh, unsigned int uLodLevel)
{
int beginIndex = openGLSurfaceMesh.sourceMesh->m_vecLodRecords[uLodLevel].beginIndex;
int endIndex = openGLSurfaceMesh.sourceMesh->m_vecLodRecords[uLodLevel].endIndex;
glBindBuffer(GL_ARRAY_BUFFER, openGLSurfaceMesh.vertexBuffer);
int beginIndex = openGLMesh.sourceMesh->m_vecLodRecords[uLodLevel].beginIndex;
int endIndex = openGLMesh.sourceMesh->m_vecLodRecords[uLodLevel].endIndex;
glBindBuffer(GL_ARRAY_BUFFER, openGLMesh.vertexBuffer);
glVertexPointer(3, GL_FLOAT, 36, 0);
glNormalPointer(GL_FLOAT, 36, (GLvoid*)12);
glColorPointer(3, GL_FLOAT, 36, (GLvoid*)24);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, openGLSurfaceMesh.indexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, openGLMesh.indexBuffer);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
//glDrawElements(GL_TRIANGLES, openGLSurfaceMesh.noOfIndices, GL_UNSIGNED_INT, 0);
glDrawRangeElements(GL_TRIANGLES, beginIndex, endIndex-1, endIndex - beginIndex,/* openGLSurfaceMesh.noOfIndices,*/ GL_UNSIGNED_INT, 0);
//glDrawElements(GL_TRIANGLES, openGLMesh.noOfIndices, GL_UNSIGNED_INT, 0);
glDrawRangeElements(GL_TRIANGLES, beginIndex, endIndex-1, endIndex - beginIndex,/* openGLMesh.noOfIndices,*/ GL_UNSIGNED_INT, 0);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);

8
examples/OpenGL/OpenGLVertexBufferObjectSupport.h
View File

@ -28,15 +28,15 @@ freely, subject to the following restrictions:
#include "glew/glew.h"
struct OpenGLSurfaceMesh
struct OpenGLMesh
{
GLulong noOfIndices;
GLuint indexBuffer;
GLuint vertexBuffer;
const PolyVox::SurfaceMesh<PolyVox::MarchingCubesVertex<PolyVox::MaterialDensityPair44> >* sourceMesh;
const PolyVox::Mesh<PolyVox::MarchingCubesVertex<PolyVox::MaterialDensityPair44> >* sourceMesh;
};
OpenGLSurfaceMesh BuildOpenGLSurfaceMesh(const PolyVox::SurfaceMesh<PolyVox::MarchingCubesVertex<PolyVox::MaterialDensityPair44> >& mesh);
void renderRegionVertexBufferObject(const OpenGLSurfaceMesh& openGLSurfaceMesh, unsigned int uLodLevel);
OpenGLMesh BuildOpenGLMesh(const PolyVox::Mesh<PolyVox::MarchingCubesVertex<PolyVox::MaterialDensityPair44> >& mesh);
void renderRegionVertexBufferObject(const OpenGLMesh& openGLMesh, unsigned int uLodLevel);
#endif //__OpenGLExample_OpenGLVertexBufferObjectSupport_H__

18
examples/OpenGL/OpenGLWidget.cpp
View File

@ -50,8 +50,8 @@ OpenGLWidget::OpenGLWidget(QWidget *parent)
void OpenGLWidget::setVolume(PolyVox::LargeVolume<MaterialDensityPair44>* volData)
{
//First we free anything from the previous volume (if there was one).
m_mapOpenGLSurfaceMeshes.clear();
m_mapSurfaceMeshes.clear();
m_mapOpenGLMeshes.clear();
m_mapMeshes.clear();
m_volData = volData;
//If we have any volume data then generate the new surface patches.
@ -87,7 +87,7 @@ void OpenGLWidget::setVolume(PolyVox::LargeVolume<MaterialDensityPair44>* volDat
//Extract the surface for this region
//extractSurface(m_volData, 0, PolyVox::Region(regLowerCorner, regUpperCorner), meshCurrent);
std::shared_ptr< SurfaceMesh<MarchingCubesVertex<MaterialDensityPair44> > > mesh(new SurfaceMesh<MarchingCubesVertex<MaterialDensityPair44> >);
std::shared_ptr< Mesh<MarchingCubesVertex<MaterialDensityPair44> > > mesh(new Mesh<MarchingCubesVertex<MaterialDensityPair44> >);
MarchingCubesSurfaceExtractor< LargeVolume<MaterialDensityPair44> > surfaceExtractor(volData, PolyVox::Region(regLowerCorner, regUpperCorner), mesh.get());
surfaceExtractor.execute();
@ -105,12 +105,12 @@ void OpenGLWidget::setVolume(PolyVox::LargeVolume<MaterialDensityPair44>* volDat
Vector3DUint8 v3dRegPos(uRegionX,uRegionY,uRegionZ);
if(m_bUseOpenGLVertexBufferObjects)
{
OpenGLSurfaceMesh openGLSurfaceMesh = BuildOpenGLSurfaceMesh(*(mesh.get()));
m_mapOpenGLSurfaceMeshes.insert(make_pair(v3dRegPos, openGLSurfaceMesh));
OpenGLMesh openGLMesh = BuildOpenGLMesh(*(mesh.get()));
m_mapOpenGLMeshes.insert(make_pair(v3dRegPos, openGLMesh));
}
//else
//{
m_mapSurfaceMeshes.insert(make_pair(v3dRegPos, mesh));
m_mapMeshes.insert(make_pair(v3dRegPos, mesh));
//}
//delete meshCurrent;
}
@ -191,13 +191,13 @@ void OpenGLWidget::paintGL()
for(uint16_t uRegionX = 0; uRegionX < m_uVolumeWidthInRegions; ++uRegionX)
{
Vector3DUint8 v3dRegPos(uRegionX,uRegionY,uRegionZ);
if(m_mapSurfaceMeshes.find(v3dRegPos) != m_mapSurfaceMeshes.end())
if(m_mapMeshes.find(v3dRegPos) != m_mapMeshes.end())
{
std::shared_ptr< SurfaceMesh<MarchingCubesVertex<MaterialDensityPair44> > > meshCurrent = m_mapSurfaceMeshes[v3dRegPos];
std::shared_ptr< Mesh<MarchingCubesVertex<MaterialDensityPair44> > > meshCurrent = m_mapMeshes[v3dRegPos];
unsigned int uLodLevel = 0; //meshCurrent->m_vecLodRecords.size() - 1;
if(m_bUseOpenGLVertexBufferObjects)
{
renderRegionVertexBufferObject(m_mapOpenGLSurfaceMeshes[v3dRegPos], uLodLevel);
renderRegionVertexBufferObject(m_mapOpenGLMeshes[v3dRegPos], uLodLevel);
}
else
{

6
examples/OpenGL/OpenGLWidget.h
View File

@ -30,7 +30,7 @@ freely, subject to the following restrictions:
#include <QTimer>
#include "PolyVoxCore/LargeVolume.h"
#include "PolyVoxCore/SurfaceMesh.h"
#include "PolyVoxCore/Mesh.h"
#include "PolyVoxCore/Impl/Utility.h"
#include "OpenGLImmediateModeSupport.h"
@ -87,8 +87,8 @@ class OpenGLWidget : public QGLWidget
PolyVox::LargeVolume<PolyVox::MaterialDensityPair44>* m_volData;
//Rather than storing one big mesh, the volume is broken into regions and a mesh is stored for each region
std::map<PolyVox::Vector3DUint8, OpenGLSurfaceMesh, Vector3DUint8Compare> m_mapOpenGLSurfaceMeshes;
std::map<PolyVox::Vector3DUint8, std::shared_ptr<PolyVox::SurfaceMesh<PolyVox::MarchingCubesVertex<PolyVox::MaterialDensityPair44> > >, Vector3DUint8Compare> m_mapSurfaceMeshes;
std::map<PolyVox::Vector3DUint8, OpenGLMesh, Vector3DUint8Compare> m_mapOpenGLMeshes;
std::map<PolyVox::Vector3DUint8, std::shared_ptr<PolyVox::Mesh<PolyVox::MarchingCubesVertex<PolyVox::MaterialDensityPair44> > >, Vector3DUint8Compare> m_mapMeshes;
unsigned int m_uRegionSideLength;
unsigned int m_uVolumeWidthInRegions;

2
examples/OpenGL/main.cpp
View File

@ -27,7 +27,7 @@ freely, subject to the following restrictions:
#include "PolyVoxCore/LowPassFilter.h"
#include "PolyVoxCore/RawVolume.h"
#include "PolyVoxCore/RLEBlockCompressor.h"
#include "PolyVoxCore/SurfaceMesh.h"
#include "PolyVoxCore/Mesh.h"
#include "PolyVoxCore/Impl/Utility.h"
#include "OpenGLImmediateModeSupport.h"

2
examples/Paging/OpenGLWidget.cpp
View File

@ -15,7 +15,7 @@ OpenGLWidget::OpenGLWidget(QWidget *parent)
{
}
void OpenGLWidget::setSurfaceMeshToRender(const PolyVox::SurfaceMesh<CubicVertex<MaterialDensityPair44> >& surfaceMesh)
void OpenGLWidget::setMeshToRender(const PolyVox::Mesh<CubicVertex<MaterialDensityPair44> >& surfaceMesh)
{
if((surfaceMesh.getNoOfIndices() == 0) || (surfaceMesh.getNoOfVertices() == 0))
{

4
examples/Paging/OpenGLWidget.h
View File

@ -25,7 +25,7 @@ distribution.
#define __BasicExample_OpenGLWidget_H__
#include "PolyVoxCore/MaterialDensityPair.h"
#include "PolyVoxCore/SurfaceMesh.h"
#include "PolyVoxCore/Mesh.h"
#include "glew/glew.h"
@ -42,7 +42,7 @@ public:
void mousePressEvent(QMouseEvent* event);
//Convert a SrfaceMesh to OpenGL index/vertex buffers
void setSurfaceMeshToRender(const PolyVox::SurfaceMesh<PolyVox::CubicVertex<PolyVox::MaterialDensityPair44> >& surfaceMesh);
void setMeshToRender(const PolyVox::Mesh<PolyVox::CubicVertex<PolyVox::MaterialDensityPair44> >& surfaceMesh);
protected:
//Qt OpenGL functions

4
examples/Paging/main.cpp
View File

@ -29,7 +29,7 @@ freely, subject to the following restrictions:
#include "PolyVoxCore/MarchingCubesSurfaceExtractor.h"
#include "PolyVoxCore/Pager.h"
#include "PolyVoxCore/RLEBlockCompressor.h"
#include "PolyVoxCore/SurfaceMesh.h"
#include "PolyVoxCore/Mesh.h"
#include "PolyVoxCore/LargeVolume.h"
#include <QApplication>
@ -190,7 +190,7 @@ int main(int argc, char *argv[])
std::cout << "#vertices: " << mesh.getNoOfVertices() << std::endl;
//Pass the surface to the OpenGL window
openGLWidget.setSurfaceMeshToRender(mesh);
openGLWidget.setMeshToRender(mesh);
//Run the message pump.
return app.exec();

4
examples/SmoothLOD/OpenGLWidget.cpp
View File

@ -21,7 +21,7 @@ OpenGLWidget::OpenGLWidget(QWidget *parent)
{
}
void OpenGLWidget::setSurfaceMeshToRender(const PolyVox::SurfaceMesh<MarchingCubesVertex<uint8_t> >& surfaceMesh)
void OpenGLWidget::setMeshToRender(const PolyVox::Mesh<MarchingCubesVertex<uint8_t> >& surfaceMesh)
{
//Convienient access to the vertices and indices
const vector<uint32_t>& vecIndices = surfaceMesh.getIndices();
@ -43,7 +43,7 @@ void OpenGLWidget::setSurfaceMeshToRender(const PolyVox::SurfaceMesh<MarchingCub
m_uEndIndex = vecIndices.size();
}
void OpenGLWidget::setSurfaceMeshToRenderLowLOD(const PolyVox::SurfaceMesh<MarchingCubesVertex<uint8_t> >& surfaceMesh)
void OpenGLWidget::setMeshToRenderLowLOD(const PolyVox::Mesh<MarchingCubesVertex<uint8_t> >& surfaceMesh)
{
//Convienient access to the vertices and indices
const vector<uint32_t>& vecIndices = surfaceMesh.getIndices();

6
examples/SmoothLOD/OpenGLWidget.h
View File

@ -24,7 +24,7 @@ distribution.
#ifndef __BasicExample_OpenGLWidget_H__
#define __BasicExample_OpenGLWidget_H__
#include "PolyVoxCore/SurfaceMesh.h"
#include "PolyVoxCore/Mesh.h"
#include "glew/glew.h"
@ -41,8 +41,8 @@ public:
void mousePressEvent(QMouseEvent* event);
//Convert a SrfaceMesh to OpenGL index/vertex buffers
void setSurfaceMeshToRender(const PolyVox::SurfaceMesh<PolyVox::MarchingCubesVertex <uint8_t> >& surfaceMesh);
void setSurfaceMeshToRenderLowLOD(const PolyVox::SurfaceMesh<PolyVox::MarchingCubesVertex<uint8_t> >& surfaceMesh);
void setMeshToRender(const PolyVox::Mesh<PolyVox::MarchingCubesVertex <uint8_t> >& surfaceMesh);
void setMeshToRenderLowLOD(const PolyVox::Mesh<PolyVox::MarchingCubesVertex<uint8_t> >& surfaceMesh);
protected:
//Qt OpenGL functions

6
examples/SmoothLOD/main.cpp
View File

@ -25,7 +25,7 @@ freely, subject to the following restrictions:
#include "PolyVoxCore/Density.h"
#include "PolyVoxCore/MarchingCubesSurfaceExtractor.h"
#include "PolyVoxCore/SurfaceMesh.h"
#include "PolyVoxCore/Mesh.h"
#include "PolyVoxCore/RawVolume.h"
#include "PolyVoxCore/SimpleVolume.h"
#include "PolyVoxCore/VolumeResampler.h"
@ -98,8 +98,8 @@ int main(int argc, char *argv[])
meshHighLOD.translateVertices(Vector3DFloat(30, 0, 0));
//Pass the surface to the OpenGL window
openGLWidget.setSurfaceMeshToRender(meshHighLOD);
openGLWidget.setSurfaceMeshToRenderLowLOD(meshLowLOD);
openGLWidget.setMeshToRender(meshHighLOD);
openGLWidget.setMeshToRenderLowLOD(meshLowLOD);
//Run the message pump.
return app.exec();

4
library/PolyVoxCore/CMakeLists.txt
View File

@ -84,8 +84,8 @@ SET(CORE_INC_FILES
include/PolyVoxCore/SimpleVolume.inl
include/PolyVoxCore/SimpleVolumeBlock.inl
include/PolyVoxCore/SimpleVolumeSampler.inl
include/PolyVoxCore/SurfaceMesh.h
include/PolyVoxCore/SurfaceMesh.inl
include/PolyVoxCore/Mesh.h
include/PolyVoxCore/Mesh.inl
include/PolyVoxCore/UncompressedBlock.h
include/PolyVoxCore/UncompressedBlock.inl
include/PolyVoxCore/Vector.h

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

@ -31,7 +31,7 @@ freely, subject to the following restrictions:
#include "PolyVoxCore/Array.h"
#include "PolyVoxCore/BaseVolume.h" //For wrap modes... should move these?
#include "PolyVoxCore/DefaultIsQuadNeeded.h"
#include "PolyVoxCore/SurfaceMesh.h"
#include "PolyVoxCore/Mesh.h"
namespace PolyVox
{
@ -113,9 +113,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)
CubicSurfaceExtractor(VolumeType* volData, Region region, SurfaceMesh<CubicVertex<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, Mesh<CubicVertex<typename VolumeType::VoxelType> >* result, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = VolumeType::VoxelType(), bool bMergeQuads = true, IsQuadNeeded isQuadNeeded = IsQuadNeeded());
#else
CubicSurfaceExtractor(VolumeType* volData, Region region, SurfaceMesh<CubicVertex<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, Mesh<CubicVertex<typename VolumeType::VoxelType> >* result, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = typename VolumeType::VoxelType(), bool bMergeQuads = true, IsQuadNeeded isQuadNeeded = IsQuadNeeded());
#endif
@ -135,7 +135,7 @@ namespace PolyVox
Region m_regSizeInVoxels;
//The surface patch we are currently filling.
SurfaceMesh<CubicVertex<typename VolumeType::VoxelType> >* m_meshCurrent;
Mesh<CubicVertex<typename VolumeType::VoxelType> >* m_meshCurrent;
//Used to avoid creating duplicate vertices.
Array<3, IndexAndMaterial> m_previousSliceVertices;
@ -159,9 +159,9 @@ namespace PolyVox
};
template<typename VolumeType, typename IsQuadNeeded>
SurfaceMesh<CubicVertex<typename VolumeType::VoxelType> > extractCubicMesh(VolumeType* volData, Region region, WrapMode eWrapMode, typename VolumeType::VoxelType tBorderValue, bool bMergeQuads, IsQuadNeeded isQuadNeeded)
Mesh<CubicVertex<typename VolumeType::VoxelType> > extractCubicMesh(VolumeType* volData, Region region, WrapMode eWrapMode, typename VolumeType::VoxelType tBorderValue, bool bMergeQuads, IsQuadNeeded isQuadNeeded)
{
SurfaceMesh<CubicVertex<typename VolumeType::VoxelType> > result;
Mesh<CubicVertex<typename VolumeType::VoxelType> > result;
CubicSurfaceExtractor<VolumeType, IsQuadNeeded> extractor(volData, region, &result, eWrapMode, tBorderValue, bMergeQuads, isQuadNeeded);
extractor.execute();
return result;
@ -171,9 +171,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)
SurfaceMesh<CubicVertex<typename VolumeType::VoxelType> > extractCubicMesh(VolumeType* volData, Region region, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = VolumeType::VoxelType(), bool bMergeQuads = true)
Mesh<CubicVertex<typename VolumeType::VoxelType> > extractCubicMesh(VolumeType* volData, Region region, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = VolumeType::VoxelType(), bool bMergeQuads = true)
#else
SurfaceMesh<CubicVertex<typename VolumeType::VoxelType> > extractCubicMesh(VolumeType* volData, Region region, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = typename VolumeType::VoxelType(), bool bMergeQuads = true)
Mesh<CubicVertex<typename VolumeType::VoxelType> > extractCubicMesh(VolumeType* volData, Region region, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = typename VolumeType::VoxelType(), bool bMergeQuads = true)
#endif
{
DefaultIsQuadNeeded<typename VolumeType::VoxelType> isQuadNeeded;

2
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<CubicVertex<typename VolumeType::VoxelType> >* result, WrapMode eWrapMode, typename VolumeType::VoxelType tBorderValue, bool bMergeQuads, IsQuadNeeded isQuadNeeded)
CubicSurfaceExtractor<VolumeType, IsQuadNeeded>::CubicSurfaceExtractor(VolumeType* volData, Region region, Mesh<CubicVertex<typename VolumeType::VoxelType> >* result, WrapMode eWrapMode, typename VolumeType::VoxelType tBorderValue, bool bMergeQuads, IsQuadNeeded isQuadNeeded)
:m_volData(volData)
,m_regSizeInVoxels(region)
,m_meshCurrent(result)

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

@ -55,7 +55,7 @@ namespace PolyVox
template<typename VolumeType>
Vector3DFloat computeSmoothSobelGradient(typename VolumeType::Sampler& volIter);
//POLYVOX_API void computeNormalsForVertices(VolumeType<uint8_t>* volumeData, SurfaceMesh<PositionMaterialNormal>& mesh, NormalGenerationMethod normalGenerationMethod);
//POLYVOX_API void computeNormalsForVertices(VolumeType<uint8_t>* volumeData, Mesh<PositionMaterialNormal>& mesh, NormalGenerationMethod normalGenerationMethod);
//POLYVOX_API Vector3DFloat computeNormal(VolumeType<uint8_t>* volumeData, const Vector3DFloat& v3dPos, NormalGenerationMethod normalGenerationMethod);
}

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

@ -29,7 +29,7 @@ freely, subject to the following restrictions:
#include "PolyVoxCore/Array.h"
#include "PolyVoxCore/BaseVolume.h" //For wrap modes... should move these?
#include "PolyVoxCore/SurfaceMesh.h"
#include "PolyVoxCore/Mesh.h"
#include "PolyVoxCore/DefaultMarchingCubesController.h"
namespace PolyVox
@ -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<MarchingCubesVertex<typename VolumeType::VoxelType> >* result, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = VolumeType::VoxelType(), Controller controller = Controller());
MarchingCubesSurfaceExtractor(VolumeType* volData, Region region, Mesh<MarchingCubesVertex<typename VolumeType::VoxelType> >* result, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = VolumeType::VoxelType(), Controller controller = Controller());
#else
MarchingCubesSurfaceExtractor(VolumeType* volData, Region region, SurfaceMesh<MarchingCubesVertex<typename VolumeType::VoxelType> >* result, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = typename VolumeType::VoxelType(), Controller controller = Controller());
MarchingCubesSurfaceExtractor(VolumeType* volData, Region region, Mesh<MarchingCubesVertex<typename VolumeType::VoxelType> >* 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<MarchingCubesVertex<typename VolumeType::VoxelType> >* m_meshCurrent;
Mesh<MarchingCubesVertex<typename VolumeType::VoxelType> >* m_meshCurrent;
//Information about the region we are currently processing
Region m_regSizeInVoxels;
@ -212,9 +212,9 @@ namespace PolyVox
};
template< typename VolumeType, typename Controller>
SurfaceMesh<MarchingCubesVertex<typename VolumeType::VoxelType> > extractMarchingCubesMesh(VolumeType* volData, Region region, WrapMode eWrapMode, typename VolumeType::VoxelType tBorderValue, Controller controller)
Mesh<MarchingCubesVertex<typename VolumeType::VoxelType> > extractMarchingCubesMesh(VolumeType* volData, Region region, WrapMode eWrapMode, typename VolumeType::VoxelType tBorderValue, Controller controller)
{
SurfaceMesh<MarchingCubesVertex<typename VolumeType::VoxelType> > result;
Mesh<MarchingCubesVertex<typename VolumeType::VoxelType> > result;
MarchingCubesSurfaceExtractor<VolumeType, Controller> extractor(volData, region, &result, eWrapMode, tBorderValue, controller);
extractor.execute();
return result;
@ -224,9 +224,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)
SurfaceMesh<MarchingCubesVertex<typename VolumeType::VoxelType> > extractMarchingCubesMesh(VolumeType* volData, Region region, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = VolumeType::VoxelType())
Mesh<MarchingCubesVertex<typename VolumeType::VoxelType> > extractMarchingCubesMesh(VolumeType* volData, Region region, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = VolumeType::VoxelType())
#else
SurfaceMesh<MarchingCubesVertex<typename VolumeType::VoxelType> > extractMarchingCubesMesh(VolumeType* volData, Region region, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = typename VolumeType::VoxelType())
Mesh<MarchingCubesVertex<typename VolumeType::VoxelType> > extractMarchingCubesMesh(VolumeType* volData, Region region, WrapMode eWrapMode = WrapModes::Border, typename VolumeType::VoxelType tBorderValue = typename VolumeType::VoxelType())
#endif
{
DefaultMarchingCubesController<typename VolumeType::VoxelType> controller;

2
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<MarchingCubesVertex<typename VolumeType::VoxelType> >* result, WrapMode eWrapMode, typename VolumeType::VoxelType tBorderValue, Controller controller)
MarchingCubesSurfaceExtractor<VolumeType, Controller>::MarchingCubesSurfaceExtractor(VolumeType* volData, Region region, Mesh<MarchingCubesVertex<typename VolumeType::VoxelType> >* result, WrapMode eWrapMode, typename VolumeType::VoxelType tBorderValue, Controller controller)
:m_volData(volData)
,m_sampVolume(volData)
,m_meshCurrent(result)

18
library/PolyVoxCore/include/PolyVoxCore/SurfaceMesh.h → library/PolyVoxCore/include/PolyVoxCore/Mesh.h
View File

@ -21,8 +21,8 @@ freely, subject to the following restrictions:
distribution.
*******************************************************************************/
#ifndef __PolyVox_SurfaceMesh_H__
#define __PolyVox_SurfaceMesh_H__
#ifndef __PolyVox_Mesh_H__
#define __PolyVox_Mesh_H__
#include "Impl/TypeDef.h"
@ -46,11 +46,11 @@ namespace PolyVox
};
template <typename VertexType>
class SurfaceMesh
class Mesh
{
public:
SurfaceMesh();
~SurfaceMesh();
Mesh();
~Mesh();
const std::vector<uint32_t>& getIndices(void) const;
uint32_t getNoOfIndices(void) const;
@ -75,7 +75,7 @@ namespace PolyVox
//RATE THE STD::SET CAUSES PROBLEMS WITH SWIG. IF YOU UNCOMMENT ANY OF THESE FUNCTIONS, PLEASE POST ON
//THE FORUM SO WE CAN KNOW THE FUNCTIONALITY IS STILL NEEDED IN SOME FORM.
//void sumNearbyNormals(bool bNormaliseResult = true);
//std::shared_ptr< SurfaceMesh<VertexType> > extractSubset(std::set<uint8_t> setMaterials);
//std::shared_ptr< Mesh<VertexType> > extractSubset(std::set<uint8_t> setMaterials);
//void generateAveragedFaceNormals(bool bNormalise, bool bIncludeEdgeVertices = false);
int noOfDegenerateTris(void);
@ -96,9 +96,9 @@ namespace PolyVox
};
template <typename VertexType>
std::shared_ptr< SurfaceMesh<VertexType> > extractSubset(SurfaceMesh<VertexType>& inputMesh, std::set<uint8_t> setMaterials);
std::shared_ptr< Mesh<VertexType> > extractSubset(Mesh<VertexType>& inputMesh, std::set<uint8_t> setMaterials);
}
#include "PolyVoxCore/SurfaceMesh.inl"
#include "PolyVoxCore/Mesh.inl"
#endif /* __SurfaceMesh_H__ */
#endif /* __Mesh_H__ */

50
library/PolyVoxCore/include/PolyVoxCore/SurfaceMesh.inl → library/PolyVoxCore/include/PolyVoxCore/Mesh.inl
View File

@ -24,30 +24,30 @@ freely, subject to the following restrictions:
namespace PolyVox
{
template <typename VertexType>
SurfaceMesh<VertexType>::SurfaceMesh()
Mesh<VertexType>::Mesh()
{
m_iTimeStamp = -1;
}
template <typename VertexType>
SurfaceMesh<VertexType>::~SurfaceMesh()
Mesh<VertexType>::~Mesh()
{
}
template <typename VertexType>
const std::vector<uint32_t>& SurfaceMesh<VertexType>::getIndices(void) const
const std::vector<uint32_t>& Mesh<VertexType>::getIndices(void) const
{
return m_vecTriangleIndices;
}
template <typename VertexType>
uint32_t SurfaceMesh<VertexType>::getNoOfIndices(void) const
uint32_t Mesh<VertexType>::getNoOfIndices(void) const
{
return m_vecTriangleIndices.size();
}
template <typename VertexType>
uint32_t SurfaceMesh<VertexType>::getNoOfNonUniformTrianges(void) const
uint32_t Mesh<VertexType>::getNoOfNonUniformTrianges(void) const
{
uint32_t result = 0;
for(uint32_t i = 0; i < m_vecTriangleIndices.size() - 2; i += 3)
@ -65,7 +65,7 @@ namespace PolyVox
}
template <typename VertexType>
uint32_t SurfaceMesh<VertexType>::getNoOfUniformTrianges(void) const
uint32_t Mesh<VertexType>::getNoOfUniformTrianges(void) const
{
uint32_t result = 0;
for(uint32_t i = 0; i < m_vecTriangleIndices.size() - 2; i += 3)
@ -80,25 +80,25 @@ namespace PolyVox
}
template <typename VertexType>
uint32_t SurfaceMesh<VertexType>::getNoOfVertices(void) const
uint32_t Mesh<VertexType>::getNoOfVertices(void) const
{
return m_vecVertices.size();
}
template <typename VertexType>
std::vector<VertexType>& SurfaceMesh<VertexType>::getRawVertexData(void)
std::vector<VertexType>& Mesh<VertexType>::getRawVertexData(void)
{
return m_vecVertices;
}
template <typename VertexType>
const std::vector<VertexType>& SurfaceMesh<VertexType>::getVertices(void) const
const std::vector<VertexType>& Mesh<VertexType>::getVertices(void) const
{
return m_vecVertices;
}
template <typename VertexType>
void SurfaceMesh<VertexType>::addTriangle(uint32_t index0, uint32_t index1, uint32_t index2)
void Mesh<VertexType>::addTriangle(uint32_t index0, uint32_t index1, uint32_t index2)
{
//Make sure the specified indices correspond to valid vertices.
POLYVOX_ASSERT(index0 < m_vecVertices.size(), "Index points at an invalid vertex.");
@ -111,7 +111,7 @@ namespace PolyVox
}
template <typename VertexType>
void SurfaceMesh<VertexType>::addTriangleCubic(uint32_t index0, uint32_t index1, uint32_t index2)
void Mesh<VertexType>::addTriangleCubic(uint32_t index0, uint32_t index1, uint32_t index2)
{
//Make sure the specified indices correspond to valid vertices.
POLYVOX_ASSERT(index0 < m_vecVertices.size(), "Index points at an invalid vertex.");
@ -124,14 +124,14 @@ namespace PolyVox
}
template <typename VertexType>
uint32_t SurfaceMesh<VertexType>::addVertex(const VertexType& vertex)
uint32_t Mesh<VertexType>::addVertex(const VertexType& vertex)
{
m_vecVertices.push_back(vertex);
return m_vecVertices.size() - 1;
}
template <typename VertexType>
void SurfaceMesh<VertexType>::clear(void)
void Mesh<VertexType>::clear(void)
{
m_vecVertices.clear();
m_vecTriangleIndices.clear();
@ -139,7 +139,7 @@ namespace PolyVox
}
template <typename VertexType>
bool SurfaceMesh<VertexType>::isEmpty(void) const
bool Mesh<VertexType>::isEmpty(void) const
{
return (getNoOfVertices() == 0) || (getNoOfIndices() == 0);
}
@ -153,7 +153,7 @@ namespace PolyVox
/// Note: This function can cause lighting discontinuities accross region boundaries.
////////////////////////////////////////////////////////////////////////////////
/*template <typename VertexType>
void SurfaceMesh<VertexType>::sumNearbyNormals(bool bNormaliseResult)
void Mesh<VertexType>::sumNearbyNormals(bool bNormaliseResult)
{
if(m_vecVertices.size() == 0) //FIXME - I don't think we should need this test, but I have seen crashes otherwise...
{
@ -195,7 +195,7 @@ namespace PolyVox
}*/
/*template <typename VertexType>
void SurfaceMesh<VertexType>::generateAveragedFaceNormals(bool bNormalise, bool bIncludeEdgeVertices)
void Mesh<VertexType>::generateAveragedFaceNormals(bool bNormalise, bool bIncludeEdgeVertices)
{
Vector3DFloat offset = static_cast<Vector3DFloat>(m_Region.getLowerCorner());
@ -245,9 +245,9 @@ namespace PolyVox
}*/
/*template <typename VertexType>
std::shared_ptr< SurfaceMesh<VertexType> > SurfaceMesh<VertexType>::extractSubset(std::set<uint8_t> setMaterials)
std::shared_ptr< Mesh<VertexType> > Mesh<VertexType>::extractSubset(std::set<uint8_t> setMaterials)
{
std::shared_ptr< SurfaceMesh<VertexType> > result(new SurfaceMesh<VertexType>);
std::shared_ptr< Mesh<VertexType> > result(new Mesh<VertexType>);
if(m_vecVertices.size() == 0) //FIXME - I don't think we should need this test, but I have seen crashes otherwise...
{
@ -311,7 +311,7 @@ namespace PolyVox
}*/
template <typename VertexType>
int SurfaceMesh<VertexType>::noOfDegenerateTris(void)
int Mesh<VertexType>::noOfDegenerateTris(void)
{
int count = 0;
for(uint32_t triCt = 0; triCt < m_vecTriangleIndices.size();)
@ -332,7 +332,7 @@ namespace PolyVox
}
template <typename VertexType>
void SurfaceMesh<VertexType>::removeDegenerateTris(void)
void Mesh<VertexType>::removeDegenerateTris(void)
{
int noOfNonDegenerate = 0;
int targetCt = 0;
@ -362,7 +362,7 @@ namespace PolyVox
}
template <typename VertexType>
void SurfaceMesh<VertexType>::removeUnusedVertices(void)
void Mesh<VertexType>::removeUnusedVertices(void)
{
std::vector<bool> isVertexUsed(m_vecVertices.size());
std::fill(isVertexUsed.begin(), isVertexUsed.end(), false);
@ -395,9 +395,9 @@ namespace PolyVox
//Currently a free function - think where this needs to go.
template <typename VertexType>
std::shared_ptr< SurfaceMesh<VertexType> > extractSubset(SurfaceMesh<VertexType>& inputMesh, std::set<uint8_t> setMaterials)
std::shared_ptr< Mesh<VertexType> > extractSubset(Mesh<VertexType>& inputMesh, std::set<uint8_t> setMaterials)
{
std::shared_ptr< SurfaceMesh<VertexType> > result(new SurfaceMesh<VertexType>);
std::shared_ptr< Mesh<VertexType> > result(new Mesh<VertexType>);
result->m_Region = inputMesh.m_Region;
@ -463,7 +463,7 @@ namespace PolyVox
}
template <typename VertexType>
void SurfaceMesh<VertexType>::scaleVertices(float amount)
void Mesh<VertexType>::scaleVertices(float amount)
{
for(uint32_t ct = 0; ct < m_vecVertices.size(); ct++)
{
@ -475,7 +475,7 @@ namespace PolyVox
}
template <typename VertexType>
void SurfaceMesh<VertexType>::translateVertices(const Vector3DFloat& amount)
void Mesh<VertexType>::translateVertices(const Vector3DFloat& amount)
{
for(uint32_t ct = 0; ct < m_vecVertices.size(); ct++)
{

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

@ -160,9 +160,9 @@ namespace PolyVox
template<typename VolumeType, typename Controller> class MarchingCubesSurfaceExtractor;
////////////////////////////////////////////////////////////////////////////////
// SurfaceMesh
// Mesh
////////////////////////////////////////////////////////////////////////////////
template <typename VertexType> class SurfaceMesh;
template <typename VertexType> class Mesh;
////////////////////////////////////////////////////////////////////////////////
// Vector

2
tests/TestCubicSurfaceExtractor.cpp
View File

@ -130,7 +130,7 @@ void TestCubicSurfaceExtractor::testExecute()
const static uint32_t uIndexToCheck = 2000;
const static uint32_t uExpectedIndex = 1334;
SurfaceMesh<CubicVertex> mesh;*/
Mesh<CubicVertex> mesh;*/
/*testForType<int8_t>(mesh);
QCOMPARE(mesh.getNoOfVertices(), uExpectedVertices);

6
tests/TestSurfaceExtractor.cpp
View File

@ -102,7 +102,7 @@ void writeMaterialValueToVoxel(int valueToWrite, MaterialDensityPair88& voxel)
// Runs the surface extractor for a given type.
template <typename VoxelType>
SurfaceMesh<MarchingCubesVertex<VoxelType> > testForType(void) //I think we could avoid specifying this return type by using auto/decltype?
Mesh<MarchingCubesVertex<VoxelType> > testForType(void) //I think we could avoid specifying this return type by using auto/decltype?
{
const int32_t uVolumeSideLength = 32;
@ -133,7 +133,7 @@ SurfaceMesh<MarchingCubesVertex<VoxelType> > testForType(void) //I think we coul
return result;
}
void testCustomController(SurfaceMesh<MarchingCubesVertex<float> >& result)
void testCustomController(Mesh<MarchingCubesVertex<float> >& result)
{
const int32_t uVolumeSideLength = 32;
@ -165,7 +165,7 @@ void TestSurfaceExtractor::testExecute()
const static float fExpectedMaterial = 42.0f;
const static float fNoMaterial = 1.0f;
SurfaceMesh<MarchingCubesVertex<int8_t> > mesh;
Mesh<MarchingCubesVertex<int8_t> > mesh;
//Run the test for various voxel types.
QBENCHMARK {
mesh = testForType<int8_t>();