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

Switched to Half-Edge based data structure for meshes.

Browse Source
This commit is contained in:
David Williams 2007-09-05 21:40:32 +00:00
parent 9bf977b704
commit 2c69a373a1
11 changed files with 329 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -8,6 +8,7 @@ SET(SRC_FILES
source/MaterialMapManager.cpp
source/MaterialMapSerializer.cpp
source/PolyVoxSceneManager.cpp
source/SurfaceEdge.cpp
source/SurfacePatch.cpp
source/SurfacePatchRenderable.cpp
source/SurfaceTriangle.cpp

53
include/SurfaceEdge.h
View File

@ -0,0 +1,53 @@
/******************************************************************************
This file is part of a voxel plugin for OGRE
Copyright (C) 2006 David Williams
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
******************************************************************************/
#ifndef __SurfaceEdge_H__
#define __SurfaceEdge_H__
#include "OgrePrerequisites.h"
namespace Ogre
{
class SurfaceVertex;
typedef std::list<SurfaceVertex>::iterator SurfaceVertexIterator;
class SurfaceTriangle;
typedef std::list<SurfaceTriangle>::iterator SurfaceTriangleIterator;
class SurfaceEdge;
typedef std::list<SurfaceEdge>::iterator SurfaceEdgeIterator;
class SurfaceEdge
{
public:
SurfaceVertexIterator target;
SurfaceTriangleIterator triangle;
SurfaceEdgeIterator nextHalfEdge;
SurfaceEdgeIterator otherHalfEdge;
SurfaceEdge();
};
bool operator == (const SurfaceEdge& lhs, const SurfaceEdge& rhs);
bool operator < (const SurfaceEdge& lhs, const SurfaceEdge& rhs);
}
#endif

13
include/SurfacePatch.h
View File

@ -19,9 +19,11 @@ namespace Ogre
};
class SurfaceVertex;
typedef std::set<SurfaceVertex>::iterator SurfaceVertexIterator;
typedef std::list<SurfaceVertex>::iterator SurfaceVertexIterator;
class SurfaceTriangle;
typedef std::set<SurfaceTriangle>::iterator SurfaceTriangleIterator;
typedef std::list<SurfaceTriangle>::iterator SurfaceTriangleIterator;
class SurfaceEdge;
typedef std::list<SurfaceEdge>::iterator SurfaceEdgeIterator;
class SurfacePatch
{
@ -38,15 +40,16 @@ namespace Ogre
void computeNormalsFromVolume(VolumeIterator volIter);
void decimate(void);
//void decimate(void);
//bool verticesArePlanar(SurfaceVertexIterator iterCurrentVertex);
UIntVector3 m_v3dOffset;
private:
std::set<SurfaceVertex> m_setVertices;
std::set<SurfaceTriangle> m_setTriangles;
std::list<SurfaceVertex> m_listVertices;
std::list<SurfaceTriangle> m_listTriangles;
std::list<SurfaceEdge> m_listEdges;
//std::vector<SurfaceVertex> m_vecVertexData;
//std::vector<uint> m_vecIndexData;

14
include/SurfaceTriangle.h
View File

@ -25,25 +25,21 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
namespace Ogre
{
class SurfaceVertex;
typedef std::set<SurfaceVertex>::iterator SurfaceVertexIterator;
typedef std::list<SurfaceVertex>::iterator SurfaceVertexIterator;
class SurfaceTriangle;
typedef std::set<SurfaceTriangle>::iterator SurfaceTriangleIterator;
typedef std::list<SurfaceTriangle>::iterator SurfaceTriangleIterator;
class SurfaceEdge;
typedef std::list<SurfaceEdge>::iterator SurfaceEdgeIterator;
class SurfaceTriangle
{
public:
SurfaceVertexIterator v0;
SurfaceVertexIterator v1;
SurfaceVertexIterator v2;
SurfaceEdgeIterator edge;
SurfaceTriangle();
SurfaceTriangle(SurfaceVertexIterator v0ToSet, SurfaceVertexIterator v1ToSet, SurfaceVertexIterator v2ToSet);
};
typedef std::set<SurfaceTriangle>::iterator SurfaceTriangleIterator;
bool operator == (const SurfaceTriangle& lhs, const SurfaceTriangle& rhs);
bool operator < (const SurfaceTriangle& lhs, const SurfaceTriangle& rhs);

10
include/SurfaceVertex.h
View File

@ -28,9 +28,11 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
namespace Ogre
{
class SurfaceVertex;
typedef std::set<SurfaceVertex>::iterator SurfaceVertexIterator;
typedef std::list<SurfaceVertex>::iterator SurfaceVertexIterator;
class SurfaceTriangle;
typedef std::set<SurfaceTriangle>::iterator SurfaceTriangleIterator;
typedef std::list<SurfaceTriangle>::iterator SurfaceTriangleIterator;
class SurfaceEdge;
typedef std::list<SurfaceEdge>::iterator SurfaceEdgeIterator;
class SurfaceVertex
{
@ -38,9 +40,9 @@ namespace Ogre
UIntVector3 position;
Vector3 normal;
float alpha;
uchar flags;
std::list<SurfaceTriangleIterator> listTrianglesUsingThisVertex;
std::list<SurfaceVertexIterator> listConnectedVertices;
SurfaceEdgeIterator edge;
SurfaceVertex();

7
source/PolyVoxSceneManager.cpp
View File

@ -20,6 +20,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "MarchingCubesTables.h"
#include "MaterialMapManager.h"
#include "SurfaceVertex.h"
#include "SurfaceEdge.h"
#include "PolyVoxSceneManager.h"
#include "VolumeIterator.h"
#include "VolumeManager.h"
@ -323,10 +324,10 @@ namespace Ogre
for(uint regionZ = 0; regionZ < OGRE_VOLUME_SIDE_LENGTH_IN_REGIONS; ++regionZ)
{
//LogManager::getSingleton().logMessage("regionZ = " + StringConverter::toString(regionZ));
for(uint regionY = OGRE_VOLUME_SIDE_LENGTH_IN_REGIONS/2; regionY < OGRE_VOLUME_SIDE_LENGTH_IN_REGIONS/2+1; ++regionY)
for(uint regionY = 0; regionY < OGRE_VOLUME_SIDE_LENGTH_IN_REGIONS; ++regionY)
{
//LogManager::getSingleton().logMessage("regionY = " + StringConverter::toString(regionY));
for(uint regionX = OGRE_VOLUME_SIDE_LENGTH_IN_REGIONS/2; regionX < OGRE_VOLUME_SIDE_LENGTH_IN_REGIONS/2+1; ++regionX)
for(uint regionX = 0; regionX < OGRE_VOLUME_SIDE_LENGTH_IN_REGIONS; ++regionX)
{
//LogManager::getSingleton().logMessage("regionX = " + StringConverter::toString(regionX));
if(surfaceUpToDate[regionX][regionY][regionZ] == false)
@ -1008,7 +1009,7 @@ namespace Ogre
iterPatch->second.m_v3dOffset = offset;
iterPatch->second.computeNormalsFromVolume(volIter);
iterPatch->second.endDefinition();
iterPatch->second.decimate();
//iterPatch->second.decimate();
}
//LogManager::getSingleton().logMessage("Finished Generating Mesh Data");

32
source/SurfaceEdge.cpp Normal file
View File

@ -0,0 +1,32 @@
#include "SurfaceEdge.h"
#include "SurfaceTriangle.h"
#include "SurfaceVertex.h"
namespace Ogre
{
SurfaceEdge::SurfaceEdge()
{
}
bool operator == (const SurfaceEdge& lhs, const SurfaceEdge& rhs)
{
return
(
(lhs.target == rhs.target) &&
(lhs.triangle == rhs.triangle)
);
}
bool operator < (const SurfaceEdge& lhs, const SurfaceEdge& rhs)
{
if(lhs.target == rhs.target)
{
if(lhs.triangle == rhs.triangle)
{
return false;
}
return (*(lhs.triangle) < *(rhs.triangle));
}
return (*(lhs.target) < *(rhs.target));
}
}

225
source/SurfacePatch.cpp
View File

@ -3,6 +3,7 @@
#include "SurfaceVertex.h"
#include "SurfaceTriangle.h"
#include "SurfaceEdge.h"
#include "OgreLogManager.h"
#include "OgreStringConverter.h"
@ -13,8 +14,9 @@ namespace Ogre
{
SurfacePatch::SurfacePatch()
{
m_setVertices.clear();
m_setTriangles.clear();
m_listVertices.clear();
m_listTriangles.clear();
m_listEdges.clear();
m_uTrianglesAdded = 0;
m_uVerticesAdded = 0;
@ -42,27 +44,88 @@ namespace Ogre
void SurfacePatch::addTriangle(const SurfaceVertex& v0,const SurfaceVertex& v1,const SurfaceVertex& v2)
{
//if(m_uTrianglesAdded > 1) return;
//LogManager::getSingleton().logMessage("Adding Triangle " + StringConverter::toString(m_uTrianglesAdded));
m_uTrianglesAdded++;
m_uVerticesAdded += 3;
SurfaceVertexIterator v0Iter = find(m_listVertices.begin(), m_listVertices.end(), v0);
if(v0Iter == m_listVertices.end())
{
//LogManager::getSingleton().logMessage("Adding Vertex " + StringConverter::toString(v0.position.x) + "," + StringConverter::toString(v0.position.y) + "," + StringConverter::toString(v0.position.z));
m_listVertices.push_back(v0);
v0Iter = m_listVertices.end();
v0Iter--;
}
//else
//LogManager::getSingleton().logMessage("Already Exists " + StringConverter::toString(v0.position.x) + "," + StringConverter::toString(v0.position.y) + "," + StringConverter::toString(v0.position.z));
SurfaceVertexIterator v1Iter = find(m_listVertices.begin(), m_listVertices.end(), v1);
if(v1Iter == m_listVertices.end())
{
//LogManager::getSingleton().logMessage("Adding Vertex " + StringConverter::toString(v1.position.x) + "," + StringConverter::toString(v1.position.y) + "," + StringConverter::toString(v1.position.z));
m_listVertices.push_back(v1);
v1Iter = m_listVertices.end();
v1Iter--;
}
//else
//LogManager::getSingleton().logMessage("Already Exists " + StringConverter::toString(v1.position.x) + "," + StringConverter::toString(v1.position.y) + "," + StringConverter::toString(v1.position.z));
SurfaceVertexIterator v2Iter = find(m_listVertices.begin(), m_listVertices.end(), v2);
if(v2Iter == m_listVertices.end())
{
//LogManager::getSingleton().logMessage("Adding Vertex " + StringConverter::toString(v2.position.x) + "," + StringConverter::toString(v2.position.y) + "," + StringConverter::toString(v2.position.z));
m_listVertices.push_back(v2);
v2Iter = m_listVertices.end();
v2Iter--;
}
//else
//LogManager::getSingleton().logMessage("Already Exists " + StringConverter::toString(v2.position.x) + "," + StringConverter::toString(v2.position.y) + "," + StringConverter::toString(v2.position.z));
//LogManager::getSingleton().logMessage("Creating Edges");
SurfaceEdge v0v1;
v0v1.target = v1Iter;
SurfaceEdge v1v2;
v1v2.target = v2Iter;
SurfaceEdge v2v0;
v2v0.target = v0Iter;
m_listEdges.push_back(v0v1);
SurfaceEdgeIterator v0v1Iter = m_listEdges.end();
v0v1Iter--;
m_listEdges.push_back(v1v2);
SurfaceEdgeIterator v1v2Iter = m_listEdges.end();
v1v2Iter--;
m_listEdges.push_back(v2v0);
SurfaceEdgeIterator v2v0Iter = m_listEdges.end();
v2v0Iter--;
v0Iter->edge = v0v1Iter;
v1Iter->edge = v1v2Iter;
v2Iter->edge = v2v0Iter;
v0v1Iter->nextHalfEdge = v1v2Iter;
v1v2Iter->nextHalfEdge = v2v0Iter;
v2v0Iter->nextHalfEdge = v0v1Iter;
SurfaceTriangle triangle;
triangle.v0 = m_setVertices.insert(v0).first;
triangle.v1 = m_setVertices.insert(v1).first;
triangle.v2 = m_setVertices.insert(v2).first;
triangle.edge = v0v1Iter;
SurfaceTriangleIterator iterTriangle = m_setTriangles.insert(triangle).first;
m_listTriangles.push_back(triangle);
SurfaceTriangleIterator iterTriangle = m_listTriangles.end();
iterTriangle--;
triangle.v0->listTrianglesUsingThisVertex.push_back(iterTriangle);
triangle.v1->listTrianglesUsingThisVertex.push_back(iterTriangle);
triangle.v2->listTrianglesUsingThisVertex.push_back(iterTriangle);
v0v1Iter->triangle = iterTriangle;
v1v2Iter->triangle = iterTriangle;
v2v0Iter->triangle = iterTriangle;
}
void SurfacePatch::computeNormalsFromVolume(VolumeIterator volIter)
{
//LogManager::getSingleton().logMessage("In SurfacePatch::computeNormalsFromVolume");
for(SurfaceVertexIterator vertexIter = m_setVertices.begin(); vertexIter != m_setVertices.end(); ++vertexIter)
for(SurfaceVertexIterator vertexIter = m_listVertices.begin(); vertexIter != m_listVertices.end(); ++vertexIter)
{
//LogManager::getSingleton().logMessage("In Loop");
const float posX = (vertexIter->position.x + m_v3dOffset.x) / 2.0f;
@ -152,6 +215,47 @@ namespace Ogre
vertexData.clear();
indexData.clear();
vertexData.resize(m_listVertices.size());
std::copy(m_listVertices.begin(), m_listVertices.end(), vertexData.begin());
/*LogManager::getSingleton().logMessage("----------Vertex Data----------");
for(std::vector<SurfaceVertex>::iterator vertexIter = vertexData.begin(); vertexIter != vertexData.end(); ++vertexIter)
{
LogManager::getSingleton().logMessage(StringConverter::toString(vertexIter->position.x) + "," + StringConverter::toString(vertexIter->position.y) + "," + StringConverter::toString(vertexIter->position.z));
}
LogManager::getSingleton().logMessage("----------End Vertex Data----------");*/
for(SurfaceTriangleIterator iterTriangles = m_listTriangles.begin(); iterTriangles != m_listTriangles.end(); ++iterTriangles)
{
//LogManager::getSingleton().logMessage("Begin Triangle:");
std::vector<SurfaceVertex>::iterator iterVertex;
SurfaceEdgeIterator edgeIter;
edgeIter = iterTriangles->edge;
//LogManager::getSingleton().logMessage("Edge Target " + StringConverter::toString(edgeIter->target->position.x) + "," + StringConverter::toString(edgeIter->target->position.y) + "," + StringConverter::toString(edgeIter->target->position.z));
iterVertex = find(vertexData.begin(), vertexData.end(), *(edgeIter->target));
LogManager::getSingleton().logMessage(" " + StringConverter::toString(iterVertex->position.x) + "," + StringConverter::toString(iterVertex->position.y) + "," + StringConverter::toString(iterVertex->position.z));
indexData.push_back(iterVertex - vertexData.begin());
edgeIter = edgeIter->nextHalfEdge;
iterVertex = find(vertexData.begin(), vertexData.end(), *(edgeIter->target));
//LogManager::getSingleton().logMessage(" " + StringConverter::toString(iterVertex->position.x) + "," + StringConverter::toString(iterVertex->position.y) + "," + StringConverter::toString(iterVertex->position.z));
indexData.push_back(iterVertex - vertexData.begin());
edgeIter = edgeIter->nextHalfEdge;
iterVertex = find(vertexData.begin(), vertexData.end(), *(edgeIter->target));
//LogManager::getSingleton().logMessage(" " + StringConverter::toString(iterVertex->position.x) + "," + StringConverter::toString(iterVertex->position.y) + "," + StringConverter::toString(iterVertex->position.z));
indexData.push_back(iterVertex - vertexData.begin());
//LogManager::getSingleton().logMessage("End Triangle");
}
}
/*void SurfacePatch::getVertexAndIndexData(std::vector<SurfaceVertex>& vertexData, std::vector<uint>& indexData)
{
vertexData.clear();
indexData.clear();
vertexData.resize(m_setVertices.size());
std::copy(m_setVertices.begin(), m_setVertices.end(), vertexData.begin());
@ -168,7 +272,9 @@ namespace Ogre
iterVertex = lower_bound(vertexData.begin(), vertexData.end(),(*(iterTriangles->v2)));
indexData.push_back(iterVertex - vertexData.begin());
}
}
}*/
#ifdef BLAH
void SurfacePatch::decimate(void)
{
@ -176,7 +282,7 @@ namespace Ogre
LogManager::getSingleton().logMessage("Triangles before decimation = " + StringConverter::toString(m_setTriangles.size()));
//Build the lists of connected vertices
for(SurfaceVertexIterator vertexIter = m_setVertices.begin(); vertexIter != m_setVertices.end(); ++vertexIter)
/*for(SurfaceVertexIterator vertexIter = m_setVertices.begin(); vertexIter != m_setVertices.end(); ++vertexIter)
{
vertexIter->listConnectedVertices.clear();
@ -199,49 +305,80 @@ namespace Ogre
//Remove self from own connected vertex list
vertexIter->listConnectedVertices.remove(vertexIter);
}
}*/
//do the vertex merging
for(SurfaceVertexIterator vertexIter = m_setVertices.begin(); vertexIter != m_setVertices.end(); ++vertexIter)
//for(SurfaceVertexIterator vertexIter = m_setVertices.begin(); vertexIter != m_setVertices.end(); ++vertexIter)
for(uint ct = 0; ct < 500; ++ct)
{
//LogManager::getSingleton().logMessage("Vertex Pos = " + StringConverter::toString(vertexIter->position.x) + "," + StringConverter::toString(vertexIter->position.y) + "," + StringConverter::toString(vertexIter->position.z) + " No of connected vertices = " + StringConverter::toString(vertexIter->listConnectedVertices.size()));
/*if(vertexIter->alpha < 0.9)
continue;*/
if(vertexIter->listConnectedVertices.size() != 6)
SurfaceVertexIterator currentVertexIter;
for(currentVertexIter = m_setVertices.begin(); currentVertexIter != m_setVertices.end(); ++currentVertexIter)
{
//LogManager::getSingleton().logMessage("Skipping edge/corner vertex");
continue;
//LogManager::getSingleton().logMessage("Vertex Pos = " + StringConverter::toString(vertexIter->position.x) + "," + StringConverter::toString(vertexIter->position.y) + "," + StringConverter::toString(vertexIter->position.z) + " No of connected vertices = " + StringConverter::toString(vertexIter->listConnectedVertices.size()));
/*if(vertexIter->listConnectedVertices.size() == 6)
break;*/
if(currentVertexIter->flags == 0)
break;
if(currentVertexIter->flags == 0x01)
break;
if(currentVertexIter->flags == 0x02)
break;
if(currentVertexIter->flags == 0x04)
break;
if(currentVertexIter->flags == 0x08)
break;
}
if(currentVertexIter == m_setVertices.end())
break;
SurfaceVertex& currentVertex = *currentVertexIter;
//Find a vertex to merge with
/*std::list<SurfaceVertexIterator>::iterator firstConnectedVertexIter = currentVertex.listConnectedVertices.begin();
SurfaceVertex& vertexToMergeWith = (*(*firstConnectedVertexIter));
SurfaceVertexIterator vertexToMergeWithIter = m_setVertices.find(vertexToMergeWith);*/
SurfaceVertexIterator vertexToMergeWithIter = (*(currentVertex.listTrianglesUsingThisVertex.begin()))->v0;
SurfaceVertex vertexToMergeWith = *vertexToMergeWithIter;
if(currentVertex == vertexToMergeWith)
{
vertexToMergeWithIter = (*(currentVertex.listTrianglesUsingThisVertex.begin()))->v1;
vertexToMergeWith = *vertexToMergeWithIter;
}
for(std::list<SurfaceTriangleIterator>::iterator triangleIterIter = currentVertex.listTrianglesUsingThisVertex.begin(); triangleIterIter != currentVertex.listTrianglesUsingThisVertex.end(); ++triangleIterIter)
{
SurfaceVertex connectedVertex = (*(*triangleIterIter)->v0);
}
if(true/*verticesArePlanar(vertexIter)*/)
//Change triangles to use new vertex
for(SurfaceTriangleIterator iterTriangles = m_setTriangles.begin(); iterTriangles != m_setTriangles.end(); ++iterTriangles)
{
//Find a vertex to merge with
std::list<SurfaceVertexIterator>::iterator vertexToMergeWith = vertexIter->listConnectedVertices.begin();
if(*(iterTriangles->v0) == currentVertex)
iterTriangles->v0 = vertexToMergeWithIter;
if(*(iterTriangles->v1) == currentVertex)
iterTriangles->v1 = vertexToMergeWithIter;
if(*(iterTriangles->v2) == currentVertex)
iterTriangles->v2 = vertexToMergeWithIter;
}
//Change triangles to use new vertex
for(SurfaceTriangleIterator iterTriangles = m_setTriangles.begin(); iterTriangles != m_setTriangles.end(); ++iterTriangles)
//Remove the vertex from other connected vertex lists
/*for(std::list<SurfaceVertexIterator>::iterator connectedVertexIter = currentVertex.listConnectedVertices.begin(); connectedVertexIter != currentVertex.listConnectedVertices.end(); ++connectedVertexIter)
{
for(std::list<SurfaceVertexIterator>::iterator secondLevelConnectedIter = (*connectedVertexIter)->listConnectedVertices.begin(); secondLevelConnectedIter != (*connectedVertexIter)->listConnectedVertices.end(); ++secondLevelConnectedIter)
{
if(iterTriangles->v0 == vertexIter)
iterTriangles->v0 = *vertexToMergeWith;
if(iterTriangles->v1 == vertexIter)
iterTriangles->v1 = *vertexToMergeWith;
if(iterTriangles->v2 == vertexIter)
iterTriangles->v2 = *vertexToMergeWith;
}
//Change connected vertices to use new vertex
for(std::list<SurfaceVertexIterator>::iterator connectedVertex = vertexIter->listConnectedVertices.begin(); connectedVertex != vertexIter->listConnectedVertices.end(); ++connectedVertex)
{
for(std::list<SurfaceVertexIterator>::iterator secondLevelConnected = (*connectedVertex)->listConnectedVertices.begin(); secondLevelConnected != (*connectedVertex)->listConnectedVertices.end(); ++secondLevelConnected)
if((*(*secondLevelConnectedIter)) == currentVertex)
{
if((*secondLevelConnected) == vertexIter)
(*secondLevelConnected) = *vertexToMergeWith;
(*connectedVertexIter)->listConnectedVertices.remove(secondLevelConnected);
break;
}
}
}*/
//Now remove the vertex as nothing should point to it.
//m_setVertices.erase(vertexIter);
}
//Now remove the vertex as nothing should point to it.
m_setVertices.erase(currentVertexIter);
}
}
@ -283,4 +420,6 @@ namespace Ogre
return allXMatch || allYMatch || allZMatch;
}*/
#endif
}

20
source/SurfaceTriangle.cpp
View File

@ -1,5 +1,6 @@
#include "SurfaceTriangle.h"
#include "SurfaceVertex.h"
#include "SurfaceEdge.h"
namespace Ogre
{
@ -7,26 +8,21 @@ namespace Ogre
{
}
SurfaceTriangle::SurfaceTriangle(SurfaceVertexIterator v0ToSet, SurfaceVertexIterator v1ToSet, SurfaceVertexIterator v2ToSet)
:v0(v0ToSet)
,v1(v1ToSet)
,v2(v2ToSet)
{
}
bool operator == (const SurfaceTriangle& lhs, const SurfaceTriangle& rhs)
{
return
/*return
(
(lhs.v0 == rhs.v0) &&
(lhs.v1 == rhs.v1) &&
(lhs.v2 == rhs.v2)
);
);*/
return lhs.edge == rhs.edge;
}
bool operator < (const SurfaceTriangle& lhs, const SurfaceTriangle& rhs)
{
if(lhs.v0 == rhs.v0)
/*if(lhs.v0 == rhs.v0)
{
if(lhs.v1 == rhs.v1)
{
@ -38,7 +34,9 @@ namespace Ogre
}
return (*(lhs.v1) < *(rhs.v1));
}
return (*(lhs.v0) < *(rhs.v0));
return (*(lhs.v0) < *(rhs.v0));*/
return (*lhs.edge < *rhs.edge);
}
/*bool operator < (const SurfaceTriangleIterator& lhs, const SurfaceTriangleIterator& rhs)

31
source/SurfaceVertex.cpp
View File

@ -1,5 +1,7 @@
#include "Constants.h"
#include "SurfaceVertex.h"
#include "SurfaceTriangle.h"
#include "SurfaceEdge.h"
namespace Ogre
{
@ -10,12 +12,30 @@ namespace Ogre
SurfaceVertex::SurfaceVertex(UIntVector3 positionToSet)
:position(positionToSet)
{
flags = 0;
if(position.x == 0)
flags |= 0x01;
if(position.x == 32)
flags |= 0x02;
if(position.y == 0)
flags |= 0x04;
if(position.y == 32)
flags |= 0x08;
}
SurfaceVertex::SurfaceVertex(UIntVector3 positionToSet, Vector3 normalToSet)
:position(positionToSet)
,normal(normalToSet)
{
flags = 0;
if(position.x == 0)
flags |= 0x01;
if(position.x == 32)
flags |= 0x02;
if(position.y == 0)
flags |= 0x04;
if(position.y == 32)
flags |= 0x08;
}
bool operator==(const SurfaceVertex& lhs, const SurfaceVertex& rhs)
@ -48,7 +68,7 @@ namespace Ogre
unsigned long lhsOffset = (lhs.position.x*(OGRE_REGION_SIDE_LENGTH*2+1)*(OGRE_REGION_SIDE_LENGTH*2+1)) + (lhs.position.y*(OGRE_REGION_SIDE_LENGTH*2+1)) + (lhs.position.z);
unsigned long rhsOffset = (rhs.position.x*(OGRE_REGION_SIDE_LENGTH*2+1)*(OGRE_REGION_SIDE_LENGTH*2+1)) + (rhs.position.y*(OGRE_REGION_SIDE_LENGTH*2+1)) + (rhs.position.z);
return (lhsOffset == rhsOffset) && (abs(lhs.alpha - rhs.alpha) <= 0.01);
return (lhsOffset == rhsOffset) /*&& (abs(lhs.alpha - rhs.alpha) <= 0.01)*/;
}
bool operator < (const SurfaceVertex& lhs, const SurfaceVertex& rhs)
@ -97,15 +117,10 @@ namespace Ogre
return lhsOffset < rhsOffset;
if(lhsOffset == rhsOffset)
/*if(lhsOffset == rhsOffset)
{
return (lhs.alpha < rhs.alpha);
}
return (lhsOffset < rhsOffset);
return (lhsOffset < rhsOffset)*/;
}
/*bool operator < (const SurfaceVertexIterator& lhs, const SurfaceVertexIterator& rhs)
{
return (*lhs) < (*rhs);
}*/
}

10
source/VolumeSerializer.cpp
View File

@ -59,15 +59,15 @@ namespace Ogre
LogManager::getSingleton().logMessage("Value is " + StringConverter::toString(int(value)));
}*/
volIter.setVoxelAt(x,y,z,value);
if(z < 24)
/*if(z < 24)
{
//if(x % 32 < 16)
if(x % 32 < 16)
volIter.setVoxelAt(x,y,z,4);
/*else
volIter.setVoxelAt(x,y,z,5);*/
else
volIter.setVoxelAt(x,y,z,5);
}
else
volIter.setVoxelAt(x,y,z,0);
volIter.setVoxelAt(x,y,z,0);*/
}
}