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

Refactoring work... Argh, this is hard!

Browse Source
This commit is contained in:
David Williams 2007-08-19 20:28:33 +00:00
parent 47bb4b016d
commit adfdb3062f
8 changed files with 129 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/PolyVoxSceneManager.h
View File

@ -82,7 +82,7 @@ namespace Ogre
void generateLevelVolume(void);
std::map<uchar, SurfacePatch> generateMeshDataForRegion(uint regionX, uint regionY, uint regionZ) const;
void mergeVertices6(std::vector< std::vector<SurfaceVertex> >& vertexData, std::vector< std::vector<SurfaceTriangle> >& indexData) const;
//void mergeVertices6(std::vector< std::vector<SurfaceVertex> >& vertexData, std::vector< std::vector<SurfaceTriangle> >& indexData) const;
bool verticesArePlanar3(uint uCurrentVertex, std::set<uint> setConnectedVertices, std::vector<SurfaceVertex>& vertexData) const;
void doRegionGrowing(uint xStart, uint yStart, uint zStart, uchar value);

14
include/SurfacePatch.h
View File

@ -1,6 +1,7 @@
#ifndef __SurfacePatch_H__
#define __SurfacePatch_H__
#include <list>
#include <vector>
#include "SurfaceVertex.h"
@ -16,12 +17,17 @@ namespace Ogre
void addTriangle(const SurfaceVertex& v0,const SurfaceVertex& v1,const SurfaceVertex& v2);
const std::vector<SurfaceVertex>& getVertexArray();
const std::vector<SurfaceTriangle>& getTriangleArray();
/*const std::vector<SurfaceVertex> getVertexArray();
const std::vector<SurfaceTriangle> getTriangleArray();*/
void getVertexAndIndexData(std::vector<SurfaceVertex>& vertexData, std::vector<uint>& indexData);
private:
std::vector<SurfaceVertex> m_vecVertices;
std::vector<SurfaceTriangle> m_vecTriangles;
std::list<SurfaceVertex> m_listVertices;
std::list<SurfaceTriangle> m_listTriangles;
std::vector<SurfaceVertex> m_vecVertexData;
std::vector<uint> m_vecIndexData;
};
}

2
include/SurfacePatchRenderable.h
View File

@ -15,7 +15,7 @@ namespace Ogre
SurfacePatchRenderable(const String& material = "BaseWhiteNoLighting");
~SurfacePatchRenderable(void);
void setGeometry(std::vector<SurfaceVertex> verticesToSet, std::vector<SurfaceTriangle> indicesToSet);
void setGeometry(std::vector<SurfaceVertex> verticesToSet, std::vector<uint> indicesToSet);
Real getSquaredViewDepth(const Camera *cam) const;
Real getBoundingRadius(void) const;

14
include/SurfaceTriangle.h
View File

@ -24,6 +24,8 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "OgreVector3.h"
#include "SurfaceVertex.h"
namespace Ogre
{
class SurfaceTriangle
@ -31,18 +33,18 @@ namespace Ogre
public:
//FIXME - maybe these should be short?
ulong v0;
/*ulong v0;
ulong v1;
ulong v2;
ulong v2;*/
std::list<SurfaceVertex>::iterator v0;
std::list<SurfaceVertex>::iterator v1;
std::list<SurfaceVertex>::iterator v2;
SurfaceTriangle()
:v0(0)
,v1(0)
,v2(0)
{
}
SurfaceTriangle(uint v0ToSet, uint v1ToSet, uint v2ToSet)
SurfaceTriangle(std::list<SurfaceVertex>::iterator v0ToSet, std::list<SurfaceVertex>::iterator v1ToSet, std::list<SurfaceVertex>::iterator v2ToSet)
:v0(v0ToSet)
,v1(v1ToSet)
,v2(v2ToSet)

14
include/SurfaceVertex.h
View File

@ -33,6 +33,10 @@ namespace Ogre
Vector3 normal;
float alpha;
SurfaceVertex()
{
}
SurfaceVertex(Vector3 positionToSet)
:position(positionToSet)
{
@ -50,21 +54,21 @@ namespace Ogre
return ((position - rhs).length() < 0.01);
}
/*bool operator < (const Vertex& rhs) const
bool operator < (const SurfaceVertex& rhs) const
{
if(z < rhs.z)
if(position.z < rhs.position.z)
{
return true;
}
else
{
if(y < rhs.y)
if(position.y < rhs.position.y)
{
return true;
}
else
{
if(x < rhs.x)
if(position.x < rhs.position.x)
{
return true;
}
@ -74,7 +78,7 @@ namespace Ogre
}
}
}
}*/
}
};
}

59
source/PolyVoxSceneManager.cpp
View File

@ -354,17 +354,17 @@ namespace Ogre
//for(uint meshCt = 1; meshCt < 256; ++meshCt)
for(std::map<uchar, SurfacePatch>::iterator iterSurfacePatch = mapSurfacePatch.begin(); iterSurfacePatch != mapSurfacePatch.end(); ++iterSurfacePatch)
{
/*if(indexData[meshCt].size() == 0)
{
continue;
}*/
std::vector<SurfaceVertex> vertexData;
std::vector<uint> indexData;
iterSurfacePatch->second.getVertexAndIndexData(vertexData, indexData);
std::map<uchar,SurfacePatchRenderable*>::iterator iterSurface = m_mapSurfaces[regionX][regionY][regionZ].find(iterSurfacePatch->first);
if(iterSurface == m_mapSurfaces[regionX][regionY][regionZ].end())
{
//We have to create the surface
SurfacePatchRenderable* surface = new SurfacePatchRenderable(materialMap->getMaterialAtIndex(iterSurfacePatch->first));
//surface->setGeometry(vertexData[meshCt],indexData[meshCt]);
surface->setGeometry(iterSurfacePatch->second.getVertexArray(),iterSurfacePatch->second.getTriangleArray());
surface->setGeometry(vertexData, indexData);
m_mapSurfaces[regionX][regionY][regionZ].insert(std::make_pair(iterSurfacePatch->first,surface));
@ -374,7 +374,7 @@ namespace Ogre
{
//We just update the existing surface
//iterSurface->second->setGeometry(vertexData[meshCt],indexData[meshCt]);
iterSurface->second->setGeometry(iterSurfacePatch->second.getVertexArray(),iterSurfacePatch->second.getTriangleArray());
iterSurface->second->setGeometry(vertexData, indexData);
sceneNode->attachObject(iterSurface->second);
}
}
@ -560,6 +560,8 @@ namespace Ogre
vertexData.resize(256);
indexData.resize(256);
std::map<uchar, SurfacePatch> result;
//Used later to check if vertex has already been added
long int vertexIndices[OGRE_REGION_SIDE_LENGTH*2+1][OGRE_REGION_SIDE_LENGTH*2+1][OGRE_REGION_SIDE_LENGTH*2+1][10];
//uchar materialAtPosition[OGRE_REGION_SIDE_LENGTH*2+1][OGRE_REGION_SIDE_LENGTH*2+1][OGRE_REGION_SIDE_LENGTH*2+1]; //FIXME - do we really need this? Can't we just get it from the volume...
@ -754,19 +756,42 @@ namespace Ogre
//vertexScaled values are always integers and so can be used as indices.
//FIXME - these integer values can just be obtained by using floor()?
long int index;
/*long int index;
unsigned int vertexScaledX;
unsigned int vertexScaledY;
unsigned int vertexScaledZ;
unsigned int vertexScaledZ;*/
SurfaceTriangle triangle; //Triangle to be created...
//SurfaceTriangle triangle; //Triangle to be created...
for(std::set<uchar>::iterator materialsIter = materials.begin(); materialsIter != materials.end(); ++materialsIter)
{
uchar material = *materialsIter;
SurfaceVertex surfaceVertex0(vertex0);
if(material0 == material)
surfaceVertex0.alpha = 1.0;
else
surfaceVertex0.alpha = 0.0;
surfaceVertex0.normal = Vector3(1.0,1.0,1.0);
SurfaceVertex surfaceVertex1(vertex1);
if(material1 == material)
surfaceVertex1.alpha = 1.0;
else
surfaceVertex1.alpha = 0.0;
surfaceVertex1.normal = Vector3(1.0,1.0,1.0);
SurfaceVertex surfaceVertex2(vertex2);
if(material2 == material)
surfaceVertex2.alpha = 1.0;
else
surfaceVertex2.alpha = 0.0;
surfaceVertex2.normal = Vector3(1.0,1.0,1.0);
result[material].addTriangle(surfaceVertex0, surfaceVertex1, surfaceVertex2);
//Get scaled values for vertex 0
vertexScaledX = static_cast<unsigned int>((vertex0.x * 2.0) + 0.5);
/*vertexScaledX = static_cast<unsigned int>((vertex0.x * 2.0) + 0.5);
vertexScaledY = static_cast<unsigned int>((vertex0.y * 2.0) + 0.5);
vertexScaledZ = static_cast<unsigned int>((vertex0.z * 2.0) + 0.5);
vertexScaledX %= OGRE_REGION_SIDE_LENGTH*2+1;
@ -847,7 +872,7 @@ namespace Ogre
}
//Add the triangle
indexData[material].push_back(triangle);
indexData[material].push_back(triangle);*/
}
}
}
@ -859,7 +884,7 @@ namespace Ogre
//Compute normals
//////////////////////////////////////////////////////////////////////////
for(uint materialCt = 0; materialCt < 256; materialCt++)
/*for(uint materialCt = 0; materialCt < 256; materialCt++)
{
for(uint vertexCt = 0; vertexCt < vertexData[materialCt].size(); ++vertexCt)
{
@ -943,7 +968,7 @@ namespace Ogre
}
}
}
}
}*/
//////////////////////////////////////////////////////////////////////////
//Decimate mesh
@ -953,7 +978,7 @@ namespace Ogre
//mergeVertices6(vertexData, indexData);
//Ogre::LogManager::getSingleton().logMessage("After merge: vertices = " + Ogre::StringConverter::toString(vertexData[4].size()) + ", triangles = " + Ogre::StringConverter::toString(indexData[4].size()/3));
std::map<uchar, SurfacePatch> result;
/*std::map<uchar, SurfacePatch> result;
for(uint materialCt = 1; materialCt < 256; materialCt++)
{
if(indexData[materialCt].size() == 0)
@ -973,11 +998,13 @@ namespace Ogre
}
result.insert(std::make_pair(materialCt, surfacePatch));
}
}*/
return result;
}
#ifdef BLAH
void PolyVoxSceneManager::mergeVertices6(std::vector< std::vector<SurfaceVertex> >& vertexData, std::vector< std::vector<SurfaceTriangle> >& indexData) const
{
for(uint material = 1; material < 256; ++material)
@ -1092,6 +1119,8 @@ namespace Ogre
}
}
#endif
bool PolyVoxSceneManager::verticesArePlanar3(uint uCurrentVertex, std::set<uint> setConnectedVertices, std::vector<SurfaceVertex>& vertexData) const
{
//FIXME - specially handle the case where they are all the same.

61
source/SurfacePatch.cpp
View File

@ -1,5 +1,7 @@
#include "SurfacePatch.h"
#include <algorithm>
namespace Ogre
{
SurfacePatch::SurfacePatch()
@ -14,23 +16,60 @@ namespace Ogre
{
SurfaceTriangle triangle;
m_vecVertices.push_back(v0);
triangle.v0 = m_vecVertices.size()-1;
m_vecVertices.push_back(v1);
triangle.v1 = m_vecVertices.size()-1;
m_vecVertices.push_back(v2);
triangle.v2 = m_vecVertices.size()-1;
m_listVertices.push_back(v0);
triangle.v0 = m_listVertices.end();
triangle.v0--;
m_vecTriangles.push_back(triangle);
m_listVertices.push_back(v1);
triangle.v1 = m_listVertices.end();
triangle.v1--;
m_listVertices.push_back(v2);
triangle.v2 = m_listVertices.end();
triangle.v2--;
m_listTriangles.push_back(triangle);
/*m_vecVertexData.push_back(v0);
m_vecIndexData.push_back(m_vecVertexData.size()-1);
m_vecVertexData.push_back(v1);
m_vecIndexData.push_back(m_vecVertexData.size()-1);
m_vecVertexData.push_back(v2);
m_vecIndexData.push_back(m_vecVertexData.size()-1);*/
}
const std::vector<SurfaceVertex>& SurfacePatch::getVertexArray()
/*const std::vector<SurfaceVertex> SurfacePatch::getVertexArray()
{
return m_vecVertices;
std::vector<SurfaceVertex> vertexArray;
vertexArray.resize(m_listVertices.size());
std::copy(m_listVertices.begin(), m_listVertices.end(), vertexArray.begin());
return vertexArray;
}
const std::vector<SurfaceTriangle>& SurfacePatch::getTriangleArray()
const std::vector<SurfaceTriangle> SurfacePatch::getTriangleArray()
{
return m_vecTriangles;
std::vector<SurfaceTriangle> triangleArray;
triangleArray.resize(m_listTriangles.size());
std::copy(m_listTriangles.begin(), m_listTriangles.end(), triangleArray.begin());
return triangleArray;
}*/
void SurfacePatch::getVertexAndIndexData(std::vector<SurfaceVertex>& vertexData, std::vector<uint>& indexData)
{
vertexData.clear();
indexData.clear();
for(std::list<SurfaceTriangle>::iterator iterTriangles = m_listTriangles.begin(); iterTriangles != m_listTriangles.end(); ++iterTriangles)
{
vertexData.push_back(*(iterTriangles->v0));
indexData.push_back(vertexData.size()-1);
vertexData.push_back(*(iterTriangles->v1));
indexData.push_back(vertexData.size()-1);
vertexData.push_back(*(iterTriangles->v2));
indexData.push_back(vertexData.size()-1);
}
/*vertexData = m_vecVertexData;
indexData = m_vecIndexData;*/
}
}

12
source/SurfacePatchRenderable.cpp
View File

@ -18,7 +18,7 @@ namespace Ogre
delete mRenderOp.indexData;
}
void SurfacePatchRenderable::setGeometry(std::vector<SurfaceVertex> verticesToSet, std::vector<SurfaceTriangle> indicesToSet)
void SurfacePatchRenderable::setGeometry(std::vector<SurfaceVertex> verticesToSet, std::vector<uint> indicesToSet)
{
//LogManager::getSingleton().logMessage("In setGeometry()");
@ -28,7 +28,7 @@ namespace Ogre
mRenderOp.operationType = RenderOperation::OT_TRIANGLE_LIST; // OT_LINE_LIST, OT_LINE_STRIP
mRenderOp.useIndexes = true;
mRenderOp.indexData->indexStart = 0;
mRenderOp.indexData->indexCount = indicesToSet.size()*3;
mRenderOp.indexData->indexCount = indicesToSet.size();
//LogManager::getSingleton().logMessage("Finished initialisaing stuff");
@ -55,7 +55,7 @@ namespace Ogre
HardwareIndexBufferSharedPtr ibuf =
HardwareBufferManager::getSingleton().createIndexBuffer(
HardwareIndexBuffer::IT_16BIT, // type of index
mRenderOp.indexData->indexCount * 3, // number of indexes
mRenderOp.indexData->indexCount, // number of indexes
HardwareBuffer::HBU_STATIC_WRITE_ONLY, // usage
false); // no shadow buffer
@ -105,12 +105,12 @@ namespace Ogre
unsigned short* pIdx = static_cast<unsigned short*>(ibuf->lock(HardwareBuffer::HBL_DISCARD));
for(int i = 0; i < indicesToSet.size(); i++)
{
*pIdx = indicesToSet[i].v0;
*pIdx = indicesToSet[i];
pIdx++;
*pIdx = indicesToSet[i].v1;
/**pIdx = indicesToSet[i].v1;
pIdx++;
*pIdx = indicesToSet[i].v2;
pIdx++;
pIdx++;*/
}
ibuf->unlock();
}