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 //Convienient access to the vertices and indices
const auto& vecIndices = surfaceMesh.getIndices(); const auto& vecIndices = surfaceMesh.getIndices();

4
examples/Basic/OpenGLWidget.h
View File

@ -24,7 +24,7 @@ distribution.
#ifndef __BasicExample_OpenGLWidget_H__ #ifndef __BasicExample_OpenGLWidget_H__
#define __BasicExample_OpenGLWidget_H__ #define __BasicExample_OpenGLWidget_H__
#include "PolyVoxCore/SurfaceMesh.h" #include "PolyVoxCore/Mesh.h"
#include "glew/glew.h" #include "glew/glew.h"
@ -50,7 +50,7 @@ public:
void mousePressEvent(QMouseEvent* event); void mousePressEvent(QMouseEvent* event);
// Convert a SurfaceMesh to OpenGL index/vertex buffers // 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. // The viewable region can be adjusted so that this example framework can be use for different volume sizes.
void setViewableRegion(PolyVox::Region viewableRegion); 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/CubicSurfaceExtractor.h"
#include "PolyVoxCore/MarchingCubesSurfaceExtractor.h" #include "PolyVoxCore/MarchingCubesSurfaceExtractor.h"
#include "PolyVoxCore/SurfaceMesh.h" #include "PolyVoxCore/Mesh.h"
#include "PolyVoxCore/SimpleVolume.h" #include "PolyVoxCore/SimpleVolume.h"
#include <QApplication> #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))); //auto mesh2 = extractCubicMesh(&volData, PolyVox::Region(Vector3DInt32(32, 32, 32), Vector3DInt32(63, 63, 63)));
//Pass the surface to the OpenGL window //Pass the surface to the OpenGL window
openGLWidget.setSurfaceMeshToRender(mesh); openGLWidget.setMeshToRender(mesh);
openGLWidget.setViewableRegion(volData.getEnclosingRegion()); openGLWidget.setViewableRegion(volData.getEnclosingRegion());
//openGLWidget.setSurfaceMeshToRender(mesh2); //openGLWidget.setMeshToRender(mesh2);
//Run the message pump. //Run the message pump.
return app.exec(); return app.exec();

4
examples/OpenGL/OpenGLImmediateModeSupport.cpp
View File

@ -24,12 +24,12 @@ freely, subject to the following restrictions:
#include "OpenGLImmediateModeSupport.h" #include "OpenGLImmediateModeSupport.h"
#include "OpenGLSupport.h" #include "OpenGLSupport.h"
#include "PolyVoxCore/SurfaceMesh.h" #include "PolyVoxCore/Mesh.h"
using namespace PolyVox; using namespace PolyVox;
using namespace std; 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<MarchingCubesVertex<MaterialDensityPair44> >& vecVertices = mesh.getVertices();
const vector<uint32_t>& vecIndices = mesh.getIndices(); 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" #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__ #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 "OpenGLVertexBufferObjectSupport.h"
#include "PolyVoxCore/MaterialDensityPair.h" #include "PolyVoxCore/MaterialDensityPair.h"
#include "PolyVoxCore/SurfaceMesh.h" #include "PolyVoxCore/Mesh.h"
using namespace PolyVox; using namespace PolyVox;
using namespace std; 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. //Represents our filled in OpenGL vertex and index buffer objects.
OpenGLSurfaceMesh result; OpenGLMesh result;
//The source //The source
result.sourceMesh = &mesh; result.sourceMesh = &mesh;
@ -102,23 +102,23 @@ OpenGLSurfaceMesh BuildOpenGLSurfaceMesh(const SurfaceMesh<MarchingCubesVertex<M
return result; 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 beginIndex = openGLMesh.sourceMesh->m_vecLodRecords[uLodLevel].beginIndex;
int endIndex = openGLSurfaceMesh.sourceMesh->m_vecLodRecords[uLodLevel].endIndex; int endIndex = openGLMesh.sourceMesh->m_vecLodRecords[uLodLevel].endIndex;
glBindBuffer(GL_ARRAY_BUFFER, openGLSurfaceMesh.vertexBuffer); glBindBuffer(GL_ARRAY_BUFFER, openGLMesh.vertexBuffer);
glVertexPointer(3, GL_FLOAT, 36, 0); glVertexPointer(3, GL_FLOAT, 36, 0);
glNormalPointer(GL_FLOAT, 36, (GLvoid*)12); glNormalPointer(GL_FLOAT, 36, (GLvoid*)12);
glColorPointer(3, GL_FLOAT, 36, (GLvoid*)24); 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_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_COLOR_ARRAY); glEnableClientState(GL_COLOR_ARRAY);
//glDrawElements(GL_TRIANGLES, openGLSurfaceMesh.noOfIndices, GL_UNSIGNED_INT, 0); //glDrawElements(GL_TRIANGLES, openGLMesh.noOfIndices, GL_UNSIGNED_INT, 0);
glDrawRangeElements(GL_TRIANGLES, beginIndex, endIndex-1, endIndex - beginIndex,/* openGLSurfaceMesh.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_COLOR_ARRAY);
glDisableClientState(GL_NORMAL_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" #include "glew/glew.h"
struct OpenGLSurfaceMesh struct OpenGLMesh
{ {
GLulong noOfIndices; GLulong noOfIndices;
GLuint indexBuffer; GLuint indexBuffer;
GLuint vertexBuffer; 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); OpenGLMesh BuildOpenGLMesh(const PolyVox::Mesh<PolyVox::MarchingCubesVertex<PolyVox::MaterialDensityPair44> >& mesh);
void renderRegionVertexBufferObject(const OpenGLSurfaceMesh& openGLSurfaceMesh, unsigned int uLodLevel); void renderRegionVertexBufferObject(const OpenGLMesh& openGLMesh, unsigned int uLodLevel);
#endif //__OpenGLExample_OpenGLVertexBufferObjectSupport_H__ #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) void OpenGLWidget::setVolume(PolyVox::LargeVolume<MaterialDensityPair44>* volData)
{ {
//First we free anything from the previous volume (if there was one). //First we free anything from the previous volume (if there was one).
m_mapOpenGLSurfaceMeshes.clear(); m_mapOpenGLMeshes.clear();
m_mapSurfaceMeshes.clear(); m_mapMeshes.clear();
m_volData = volData; m_volData = volData;
//If we have any volume data then generate the new surface patches. //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 //Extract the surface for this region
//extractSurface(m_volData, 0, PolyVox::Region(regLowerCorner, regUpperCorner), meshCurrent); //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()); MarchingCubesSurfaceExtractor< LargeVolume<MaterialDensityPair44> > surfaceExtractor(volData, PolyVox::Region(regLowerCorner, regUpperCorner), mesh.get());
surfaceExtractor.execute(); surfaceExtractor.execute();
@ -105,12 +105,12 @@ void OpenGLWidget::setVolume(PolyVox::LargeVolume<MaterialDensityPair44>* volDat
Vector3DUint8 v3dRegPos(uRegionX,uRegionY,uRegionZ); Vector3DUint8 v3dRegPos(uRegionX,uRegionY,uRegionZ);
if(m_bUseOpenGLVertexBufferObjects) if(m_bUseOpenGLVertexBufferObjects)
{ {
OpenGLSurfaceMesh openGLSurfaceMesh = BuildOpenGLSurfaceMesh(*(mesh.get())); OpenGLMesh openGLMesh = BuildOpenGLMesh(*(mesh.get()));
m_mapOpenGLSurfaceMeshes.insert(make_pair(v3dRegPos, openGLSurfaceMesh)); m_mapOpenGLMeshes.insert(make_pair(v3dRegPos, openGLMesh));
} }
//else //else
//{ //{
m_mapSurfaceMeshes.insert(make_pair(v3dRegPos, mesh)); m_mapMeshes.insert(make_pair(v3dRegPos, mesh));
//} //}
//delete meshCurrent; //delete meshCurrent;
} }
@ -191,13 +191,13 @@ void OpenGLWidget::paintGL()
for(uint16_t uRegionX = 0; uRegionX < m_uVolumeWidthInRegions; ++uRegionX) for(uint16_t uRegionX = 0; uRegionX < m_uVolumeWidthInRegions; ++uRegionX)
{ {
Vector3DUint8 v3dRegPos(uRegionX,uRegionY,uRegionZ); 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; unsigned int uLodLevel = 0; //meshCurrent->m_vecLodRecords.size() - 1;
if(m_bUseOpenGLVertexBufferObjects) if(m_bUseOpenGLVertexBufferObjects)
{ {
renderRegionVertexBufferObject(m_mapOpenGLSurfaceMeshes[v3dRegPos], uLodLevel); renderRegionVertexBufferObject(m_mapOpenGLMeshes[v3dRegPos], uLodLevel);
} }
else else
{ {

6
examples/OpenGL/OpenGLWidget.h
View File

@ -30,7 +30,7 @@ freely, subject to the following restrictions:
#include <QTimer> #include <QTimer>
#include "PolyVoxCore/LargeVolume.h" #include "PolyVoxCore/LargeVolume.h"
#include "PolyVoxCore/SurfaceMesh.h" #include "PolyVoxCore/Mesh.h"
#include "PolyVoxCore/Impl/Utility.h" #include "PolyVoxCore/Impl/Utility.h"
#include "OpenGLImmediateModeSupport.h" #include "OpenGLImmediateModeSupport.h"
@ -87,8 +87,8 @@ class OpenGLWidget : public QGLWidget
PolyVox::LargeVolume<PolyVox::MaterialDensityPair44>* m_volData; 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 //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, OpenGLMesh, Vector3DUint8Compare> m_mapOpenGLMeshes;
std::map<PolyVox::Vector3DUint8, std::shared_ptr<PolyVox::SurfaceMesh<PolyVox::MarchingCubesVertex<PolyVox::MaterialDensityPair44> > >, Vector3DUint8Compare> m_mapSurfaceMeshes; std::map<PolyVox::Vector3DUint8, std::shared_ptr<PolyVox::Mesh<PolyVox::MarchingCubesVertex<PolyVox::MaterialDensityPair44> > >, Vector3DUint8Compare> m_mapMeshes;
unsigned int m_uRegionSideLength; unsigned int m_uRegionSideLength;
unsigned int m_uVolumeWidthInRegions; 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/LowPassFilter.h"
#include "PolyVoxCore/RawVolume.h" #include "PolyVoxCore/RawVolume.h"
#include "PolyVoxCore/RLEBlockCompressor.h" #include "PolyVoxCore/RLEBlockCompressor.h"
#include "PolyVoxCore/SurfaceMesh.h" #include "PolyVoxCore/Mesh.h"
#include "PolyVoxCore/Impl/Utility.h" #include "PolyVoxCore/Impl/Utility.h"
#include "OpenGLImmediateModeSupport.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)) if((surfaceMesh.getNoOfIndices() == 0) || (surfaceMesh.getNoOfVertices() == 0))
{ {

4
examples/Paging/OpenGLWidget.h
View File

@ -25,7 +25,7 @@ distribution.
#define __BasicExample_OpenGLWidget_H__ #define __BasicExample_OpenGLWidget_H__
#include "PolyVoxCore/MaterialDensityPair.h" #include "PolyVoxCore/MaterialDensityPair.h"
#include "PolyVoxCore/SurfaceMesh.h" #include "PolyVoxCore/Mesh.h"
#include "glew/glew.h" #include "glew/glew.h"
@ -42,7 +42,7 @@ public:
void mousePressEvent(QMouseEvent* event); void mousePressEvent(QMouseEvent* event);
//Convert a SrfaceMesh to OpenGL index/vertex buffers //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: protected:
//Qt OpenGL functions //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/MarchingCubesSurfaceExtractor.h"
#include "PolyVoxCore/Pager.h" #include "PolyVoxCore/Pager.h"
#include "PolyVoxCore/RLEBlockCompressor.h" #include "PolyVoxCore/RLEBlockCompressor.h"
#include "PolyVoxCore/SurfaceMesh.h" #include "PolyVoxCore/Mesh.h"
#include "PolyVoxCore/LargeVolume.h" #include "PolyVoxCore/LargeVolume.h"
#include <QApplication> #include <QApplication>
@ -190,7 +190,7 @@ int main(int argc, char *argv[])
std::cout << "#vertices: " << mesh.getNoOfVertices() << std::endl; std::cout << "#vertices: " << mesh.getNoOfVertices() << std::endl;
//Pass the surface to the OpenGL window //Pass the surface to the OpenGL window
openGLWidget.setSurfaceMeshToRender(mesh); openGLWidget.setMeshToRender(mesh);
//Run the message pump. //Run the message pump.
return app.exec(); 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 //Convienient access to the vertices and indices
const vector<uint32_t>& vecIndices = surfaceMesh.getIndices(); const vector<uint32_t>& vecIndices = surfaceMesh.getIndices();
@ -43,7 +43,7 @@ void OpenGLWidget::setSurfaceMeshToRender(const PolyVox::SurfaceMesh<MarchingCub
m_uEndIndex = vecIndices.size(); 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 //Convienient access to the vertices and indices
const vector<uint32_t>& vecIndices = surfaceMesh.getIndices(); const vector<uint32_t>& vecIndices = surfaceMesh.getIndices();

6
examples/SmoothLOD/OpenGLWidget.h
View File

@ -24,7 +24,7 @@ distribution.
#ifndef __BasicExample_OpenGLWidget_H__ #ifndef __BasicExample_OpenGLWidget_H__
#define __BasicExample_OpenGLWidget_H__ #define __BasicExample_OpenGLWidget_H__
#include "PolyVoxCore/SurfaceMesh.h" #include "PolyVoxCore/Mesh.h"
#include "glew/glew.h" #include "glew/glew.h"
@ -41,8 +41,8 @@ public:
void mousePressEvent(QMouseEvent* event); void mousePressEvent(QMouseEvent* event);
//Convert a SrfaceMesh to OpenGL index/vertex buffers //Convert a SrfaceMesh to OpenGL index/vertex buffers
void setSurfaceMeshToRender(const PolyVox::SurfaceMesh<PolyVox::MarchingCubesVertex <uint8_t> >& surfaceMesh); void setMeshToRender(const PolyVox::Mesh<PolyVox::MarchingCubesVertex <uint8_t> >& surfaceMesh);
void setSurfaceMeshToRenderLowLOD(const PolyVox::SurfaceMesh<PolyVox::MarchingCubesVertex<uint8_t> >& surfaceMesh); void setMeshToRenderLowLOD(const PolyVox::Mesh<PolyVox::MarchingCubesVertex<uint8_t> >& surfaceMesh);
protected: protected:
//Qt OpenGL functions //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/Density.h"
#include "PolyVoxCore/MarchingCubesSurfaceExtractor.h" #include "PolyVoxCore/MarchingCubesSurfaceExtractor.h"
#include "PolyVoxCore/SurfaceMesh.h" #include "PolyVoxCore/Mesh.h"
#include "PolyVoxCore/RawVolume.h" #include "PolyVoxCore/RawVolume.h"
#include "PolyVoxCore/SimpleVolume.h" #include "PolyVoxCore/SimpleVolume.h"
#include "PolyVoxCore/VolumeResampler.h" #include "PolyVoxCore/VolumeResampler.h"
@ -98,8 +98,8 @@ int main(int argc, char *argv[])
meshHighLOD.translateVertices(Vector3DFloat(30, 0, 0)); meshHighLOD.translateVertices(Vector3DFloat(30, 0, 0));
//Pass the surface to the OpenGL window //Pass the surface to the OpenGL window
openGLWidget.setSurfaceMeshToRender(meshHighLOD); openGLWidget.setMeshToRender(meshHighLOD);
openGLWidget.setSurfaceMeshToRenderLowLOD(meshLowLOD); openGLWidget.setMeshToRenderLowLOD(meshLowLOD);
//Run the message pump. //Run the message pump.
return app.exec(); return app.exec();

4
library/PolyVoxCore/CMakeLists.txt
View File

@ -84,8 +84,8 @@ SET(CORE_INC_FILES
include/PolyVoxCore/SimpleVolume.inl include/PolyVoxCore/SimpleVolume.inl
include/PolyVoxCore/SimpleVolumeBlock.inl include/PolyVoxCore/SimpleVolumeBlock.inl
include/PolyVoxCore/SimpleVolumeSampler.inl include/PolyVoxCore/SimpleVolumeSampler.inl
include/PolyVoxCore/SurfaceMesh.h include/PolyVoxCore/Mesh.h
include/PolyVoxCore/SurfaceMesh.inl include/PolyVoxCore/Mesh.inl
include/PolyVoxCore/UncompressedBlock.h include/PolyVoxCore/UncompressedBlock.h
include/PolyVoxCore/UncompressedBlock.inl include/PolyVoxCore/UncompressedBlock.inl
include/PolyVoxCore/Vector.h 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/Array.h"
#include "PolyVoxCore/BaseVolume.h" //For wrap modes... should move these? #include "PolyVoxCore/BaseVolume.h" //For wrap modes... should move these?
#include "PolyVoxCore/DefaultIsQuadNeeded.h" #include "PolyVoxCore/DefaultIsQuadNeeded.h"
#include "PolyVoxCore/SurfaceMesh.h" #include "PolyVoxCore/Mesh.h"
namespace PolyVox 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 // 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? // 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) #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 #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 #endif
@ -135,7 +135,7 @@ namespace PolyVox
Region m_regSizeInVoxels; Region m_regSizeInVoxels;
//The surface patch we are currently filling. //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. //Used to avoid creating duplicate vertices.
Array<3, IndexAndMaterial> m_previousSliceVertices; Array<3, IndexAndMaterial> m_previousSliceVertices;
@ -159,9 +159,9 @@ namespace PolyVox
}; };
template<typename VolumeType, typename IsQuadNeeded> 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); CubicSurfaceExtractor<VolumeType, IsQuadNeeded> extractor(volData, region, &result, eWrapMode, tBorderValue, bMergeQuads, isQuadNeeded);
extractor.execute(); extractor.execute();
return result; 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 // 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? // 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) #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 #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 #endif
{ {
DefaultIsQuadNeeded<typename VolumeType::VoxelType> isQuadNeeded; 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; const uint32_t CubicSurfaceExtractor<VolumeType, IsQuadNeeded>::MaxVerticesPerPosition = 8;
template<typename VolumeType, typename IsQuadNeeded> 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_volData(volData)
,m_regSizeInVoxels(region) ,m_regSizeInVoxels(region)
,m_meshCurrent(result) ,m_meshCurrent(result)

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

@ -55,7 +55,7 @@ namespace PolyVox
template<typename VolumeType> template<typename VolumeType>
Vector3DFloat computeSmoothSobelGradient(typename VolumeType::Sampler& volIter); 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); //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/Array.h"
#include "PolyVoxCore/BaseVolume.h" //For wrap modes... should move these? #include "PolyVoxCore/BaseVolume.h" //For wrap modes... should move these?
#include "PolyVoxCore/SurfaceMesh.h" #include "PolyVoxCore/Mesh.h"
#include "PolyVoxCore/DefaultMarchingCubesController.h" #include "PolyVoxCore/DefaultMarchingCubesController.h"
namespace PolyVox 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 // 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? // 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) #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 #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 #endif
void execute(); void execute();
@ -193,7 +193,7 @@ namespace PolyVox
uint32_t m_uNoOfOccupiedCells; uint32_t m_uNoOfOccupiedCells;
//The surface patch we are currently filling. //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 //Information about the region we are currently processing
Region m_regSizeInVoxels; Region m_regSizeInVoxels;
@ -212,9 +212,9 @@ namespace PolyVox
}; };
template< typename VolumeType, typename Controller> 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); MarchingCubesSurfaceExtractor<VolumeType, Controller> extractor(volData, region, &result, eWrapMode, tBorderValue, controller);
extractor.execute(); extractor.execute();
return result; 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 // 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? // 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) #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 #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 #endif
{ {
DefaultMarchingCubesController<typename VolumeType::VoxelType> controller; 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 namespace PolyVox
{ {
template<typename VolumeType, typename Controller> 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_volData(volData)
,m_sampVolume(volData) ,m_sampVolume(volData)
,m_meshCurrent(result) ,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. distribution.
*******************************************************************************/ *******************************************************************************/
#ifndef __PolyVox_SurfaceMesh_H__ #ifndef __PolyVox_Mesh_H__
#define __PolyVox_SurfaceMesh_H__ #define __PolyVox_Mesh_H__
#include "Impl/TypeDef.h" #include "Impl/TypeDef.h"
@ -46,11 +46,11 @@ namespace PolyVox
}; };
template <typename VertexType> template <typename VertexType>
class SurfaceMesh class Mesh
{ {
public: public:
SurfaceMesh(); Mesh();
~SurfaceMesh(); ~Mesh();
const std::vector<uint32_t>& getIndices(void) const; const std::vector<uint32_t>& getIndices(void) const;
uint32_t getNoOfIndices(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 //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. //THE FORUM SO WE CAN KNOW THE FUNCTIONALITY IS STILL NEEDED IN SOME FORM.
//void sumNearbyNormals(bool bNormaliseResult = true); //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); //void generateAveragedFaceNormals(bool bNormalise, bool bIncludeEdgeVertices = false);
int noOfDegenerateTris(void); int noOfDegenerateTris(void);
@ -96,9 +96,9 @@ namespace PolyVox
}; };
template <typename VertexType> 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 namespace PolyVox
{ {
template <typename VertexType> template <typename VertexType>
SurfaceMesh<VertexType>::SurfaceMesh() Mesh<VertexType>::Mesh()
{ {
m_iTimeStamp = -1; m_iTimeStamp = -1;
} }
template <typename VertexType> template <typename VertexType>
SurfaceMesh<VertexType>::~SurfaceMesh() Mesh<VertexType>::~Mesh()
{ {
} }
template <typename VertexType> 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; return m_vecTriangleIndices;
} }
template <typename VertexType> template <typename VertexType>
uint32_t SurfaceMesh<VertexType>::getNoOfIndices(void) const uint32_t Mesh<VertexType>::getNoOfIndices(void) const
{ {
return m_vecTriangleIndices.size(); return m_vecTriangleIndices.size();
} }
template <typename VertexType> template <typename VertexType>
uint32_t SurfaceMesh<VertexType>::getNoOfNonUniformTrianges(void) const uint32_t Mesh<VertexType>::getNoOfNonUniformTrianges(void) const
{ {
uint32_t result = 0; uint32_t result = 0;
for(uint32_t i = 0; i < m_vecTriangleIndices.size() - 2; i += 3) for(uint32_t i = 0; i < m_vecTriangleIndices.size() - 2; i += 3)
@ -65,7 +65,7 @@ namespace PolyVox
} }
template <typename VertexType> template <typename VertexType>
uint32_t SurfaceMesh<VertexType>::getNoOfUniformTrianges(void) const uint32_t Mesh<VertexType>::getNoOfUniformTrianges(void) const
{ {
uint32_t result = 0; uint32_t result = 0;
for(uint32_t i = 0; i < m_vecTriangleIndices.size() - 2; i += 3) for(uint32_t i = 0; i < m_vecTriangleIndices.size() - 2; i += 3)
@ -80,25 +80,25 @@ namespace PolyVox
} }
template <typename VertexType> template <typename VertexType>
uint32_t SurfaceMesh<VertexType>::getNoOfVertices(void) const uint32_t Mesh<VertexType>::getNoOfVertices(void) const
{ {
return m_vecVertices.size(); return m_vecVertices.size();
} }
template <typename VertexType> template <typename VertexType>
std::vector<VertexType>& SurfaceMesh<VertexType>::getRawVertexData(void) std::vector<VertexType>& Mesh<VertexType>::getRawVertexData(void)
{ {
return m_vecVertices; return m_vecVertices;
} }
template <typename VertexType> template <typename VertexType>
const std::vector<VertexType>& SurfaceMesh<VertexType>::getVertices(void) const const std::vector<VertexType>& Mesh<VertexType>::getVertices(void) const
{ {
return m_vecVertices; return m_vecVertices;
} }
template <typename VertexType> 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. //Make sure the specified indices correspond to valid vertices.
POLYVOX_ASSERT(index0 < m_vecVertices.size(), "Index points at an invalid vertex."); POLYVOX_ASSERT(index0 < m_vecVertices.size(), "Index points at an invalid vertex.");
@ -111,7 +111,7 @@ namespace PolyVox
} }
template <typename VertexType> 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. //Make sure the specified indices correspond to valid vertices.
POLYVOX_ASSERT(index0 < m_vecVertices.size(), "Index points at an invalid vertex."); POLYVOX_ASSERT(index0 < m_vecVertices.size(), "Index points at an invalid vertex.");
@ -124,14 +124,14 @@ namespace PolyVox
} }
template <typename VertexType> template <typename VertexType>
uint32_t SurfaceMesh<VertexType>::addVertex(const VertexType& vertex) uint32_t Mesh<VertexType>::addVertex(const VertexType& vertex)
{ {
m_vecVertices.push_back(vertex); m_vecVertices.push_back(vertex);
return m_vecVertices.size() - 1; return m_vecVertices.size() - 1;
} }
template <typename VertexType> template <typename VertexType>
void SurfaceMesh<VertexType>::clear(void) void Mesh<VertexType>::clear(void)
{ {
m_vecVertices.clear(); m_vecVertices.clear();
m_vecTriangleIndices.clear(); m_vecTriangleIndices.clear();
@ -139,7 +139,7 @@ namespace PolyVox
} }
template <typename VertexType> template <typename VertexType>
bool SurfaceMesh<VertexType>::isEmpty(void) const bool Mesh<VertexType>::isEmpty(void) const
{ {
return (getNoOfVertices() == 0) || (getNoOfIndices() == 0); return (getNoOfVertices() == 0) || (getNoOfIndices() == 0);
} }
@ -153,7 +153,7 @@ namespace PolyVox
/// Note: This function can cause lighting discontinuities accross region boundaries. /// Note: This function can cause lighting discontinuities accross region boundaries.
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/*template <typename VertexType> /*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... 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> /*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()); Vector3DFloat offset = static_cast<Vector3DFloat>(m_Region.getLowerCorner());
@ -245,9 +245,9 @@ namespace PolyVox
}*/ }*/
/*template <typename VertexType> /*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... 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> template <typename VertexType>
int SurfaceMesh<VertexType>::noOfDegenerateTris(void) int Mesh<VertexType>::noOfDegenerateTris(void)
{ {
int count = 0; int count = 0;
for(uint32_t triCt = 0; triCt < m_vecTriangleIndices.size();) for(uint32_t triCt = 0; triCt < m_vecTriangleIndices.size();)
@ -332,7 +332,7 @@ namespace PolyVox
} }
template <typename VertexType> template <typename VertexType>
void SurfaceMesh<VertexType>::removeDegenerateTris(void) void Mesh<VertexType>::removeDegenerateTris(void)
{ {
int noOfNonDegenerate = 0; int noOfNonDegenerate = 0;
int targetCt = 0; int targetCt = 0;
@ -362,7 +362,7 @@ namespace PolyVox
} }
template <typename VertexType> template <typename VertexType>
void SurfaceMesh<VertexType>::removeUnusedVertices(void) void Mesh<VertexType>::removeUnusedVertices(void)
{ {
std::vector<bool> isVertexUsed(m_vecVertices.size()); std::vector<bool> isVertexUsed(m_vecVertices.size());
std::fill(isVertexUsed.begin(), isVertexUsed.end(), false); std::fill(isVertexUsed.begin(), isVertexUsed.end(), false);
@ -395,9 +395,9 @@ namespace PolyVox
//Currently a free function - think where this needs to go. //Currently a free function - think where this needs to go.
template <typename VertexType> 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; result->m_Region = inputMesh.m_Region;
@ -463,7 +463,7 @@ namespace PolyVox
} }
template <typename VertexType> 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++) for(uint32_t ct = 0; ct < m_vecVertices.size(); ct++)
{ {
@ -475,7 +475,7 @@ namespace PolyVox
} }
template <typename VertexType> 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++) 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; template<typename VolumeType, typename Controller> class MarchingCubesSurfaceExtractor;
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// SurfaceMesh // Mesh
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
template <typename VertexType> class SurfaceMesh; template <typename VertexType> class Mesh;
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Vector // Vector

2
tests/TestCubicSurfaceExtractor.cpp
View File

@ -130,7 +130,7 @@ void TestCubicSurfaceExtractor::testExecute()
const static uint32_t uIndexToCheck = 2000; const static uint32_t uIndexToCheck = 2000;
const static uint32_t uExpectedIndex = 1334; const static uint32_t uExpectedIndex = 1334;
SurfaceMesh<CubicVertex> mesh;*/ Mesh<CubicVertex> mesh;*/
/*testForType<int8_t>(mesh); /*testForType<int8_t>(mesh);
QCOMPARE(mesh.getNoOfVertices(), uExpectedVertices); 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. // Runs the surface extractor for a given type.
template <typename VoxelType> 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; const int32_t uVolumeSideLength = 32;
@ -133,7 +133,7 @@ SurfaceMesh<MarchingCubesVertex<VoxelType> > testForType(void) //I think we coul
return result; return result;
} }
void testCustomController(SurfaceMesh<MarchingCubesVertex<float> >& result) void testCustomController(Mesh<MarchingCubesVertex<float> >& result)
{ {
const int32_t uVolumeSideLength = 32; const int32_t uVolumeSideLength = 32;
@ -165,7 +165,7 @@ void TestSurfaceExtractor::testExecute()
const static float fExpectedMaterial = 42.0f; const static float fExpectedMaterial = 42.0f;
const static float fNoMaterial = 1.0f; const static float fNoMaterial = 1.0f;
SurfaceMesh<MarchingCubesVertex<int8_t> > mesh; Mesh<MarchingCubesVertex<int8_t> > mesh;
//Run the test for various voxel types. //Run the test for various voxel types.
QBENCHMARK { QBENCHMARK {
mesh = testForType<int8_t>(); mesh = testForType<int8_t>();