diff --git a/CMakeLists.txt b/CMakeLists.txt index aab5ff42..36411cfa 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -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 diff --git a/include/SurfaceEdge.h b/include/SurfaceEdge.h index e69de29b..b695b751 100644 --- a/include/SurfaceEdge.h +++ b/include/SurfaceEdge.h @@ -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::iterator SurfaceVertexIterator; + class SurfaceTriangle; + typedef std::list::iterator SurfaceTriangleIterator; + class SurfaceEdge; + typedef std::list::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 diff --git a/include/SurfacePatch.h b/include/SurfacePatch.h index 4f13cf1e..e4c590e5 100644 --- a/include/SurfacePatch.h +++ b/include/SurfacePatch.h @@ -19,9 +19,11 @@ namespace Ogre }; class SurfaceVertex; - typedef std::set::iterator SurfaceVertexIterator; + typedef std::list::iterator SurfaceVertexIterator; class SurfaceTriangle; - typedef std::set::iterator SurfaceTriangleIterator; + typedef std::list::iterator SurfaceTriangleIterator; + class SurfaceEdge; + typedef std::list::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 m_setVertices; - std::set m_setTriangles; + std::list m_listVertices; + std::list m_listTriangles; + std::list m_listEdges; //std::vector m_vecVertexData; //std::vector m_vecIndexData; diff --git a/include/SurfaceTriangle.h b/include/SurfaceTriangle.h index b925d12d..2c29ab08 100644 --- a/include/SurfaceTriangle.h +++ b/include/SurfaceTriangle.h @@ -25,25 +25,21 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. namespace Ogre { class SurfaceVertex; - typedef std::set::iterator SurfaceVertexIterator; + typedef std::list::iterator SurfaceVertexIterator; class SurfaceTriangle; - typedef std::set::iterator SurfaceTriangleIterator; + typedef std::list::iterator SurfaceTriangleIterator; + class SurfaceEdge; + typedef std::list::iterator SurfaceEdgeIterator; class SurfaceTriangle { public: - SurfaceVertexIterator v0; - SurfaceVertexIterator v1; - SurfaceVertexIterator v2; + SurfaceEdgeIterator edge; SurfaceTriangle(); - - SurfaceTriangle(SurfaceVertexIterator v0ToSet, SurfaceVertexIterator v1ToSet, SurfaceVertexIterator v2ToSet); }; - typedef std::set::iterator SurfaceTriangleIterator; - bool operator == (const SurfaceTriangle& lhs, const SurfaceTriangle& rhs); bool operator < (const SurfaceTriangle& lhs, const SurfaceTriangle& rhs); diff --git a/include/SurfaceVertex.h b/include/SurfaceVertex.h index 83c5d4bc..00bab496 100644 --- a/include/SurfaceVertex.h +++ b/include/SurfaceVertex.h @@ -28,9 +28,11 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. namespace Ogre { class SurfaceVertex; - typedef std::set::iterator SurfaceVertexIterator; + typedef std::list::iterator SurfaceVertexIterator; class SurfaceTriangle; - typedef std::set::iterator SurfaceTriangleIterator; + typedef std::list::iterator SurfaceTriangleIterator; + class SurfaceEdge; + typedef std::list::iterator SurfaceEdgeIterator; class SurfaceVertex { @@ -38,9 +40,9 @@ namespace Ogre UIntVector3 position; Vector3 normal; float alpha; + uchar flags; - std::list listTrianglesUsingThisVertex; - std::list listConnectedVertices; + SurfaceEdgeIterator edge; SurfaceVertex(); diff --git a/source/PolyVoxSceneManager.cpp b/source/PolyVoxSceneManager.cpp index b6dce681..80eeb2a1 100644 --- a/source/PolyVoxSceneManager.cpp +++ b/source/PolyVoxSceneManager.cpp @@ -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"); diff --git a/source/SurfaceEdge.cpp b/source/SurfaceEdge.cpp new file mode 100644 index 00000000..ebe0a467 --- /dev/null +++ b/source/SurfaceEdge.cpp @@ -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)); + } +} diff --git a/source/SurfacePatch.cpp b/source/SurfacePatch.cpp index 9fd191be..b9676172 100644 --- a/source/SurfacePatch.cpp +++ b/source/SurfacePatch.cpp @@ -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; - 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::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::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& vertexData, std::vector& 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::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::iterator triangleIterIter = currentVertex.listTrianglesUsingThisVertex.begin(); triangleIterIter != currentVertex.listTrianglesUsingThisVertex.end(); ++triangleIterIter) + { + SurfaceVertex connectedVertex = (*(*triangleIterIter)->v0); + } + + + //Change triangles to use new vertex + for(SurfaceTriangleIterator iterTriangles = m_setTriangles.begin(); iterTriangles != m_setTriangles.end(); ++iterTriangles) + { + if(*(iterTriangles->v0) == currentVertex) + iterTriangles->v0 = vertexToMergeWithIter; + if(*(iterTriangles->v1) == currentVertex) + iterTriangles->v1 = vertexToMergeWithIter; + if(*(iterTriangles->v2) == currentVertex) + iterTriangles->v2 = vertexToMergeWithIter; } - if(true/*verticesArePlanar(vertexIter)*/) + //Remove the vertex from other connected vertex lists + /*for(std::list::iterator connectedVertexIter = currentVertex.listConnectedVertices.begin(); connectedVertexIter != currentVertex.listConnectedVertices.end(); ++connectedVertexIter) { - //Find a vertex to merge with - std::list::iterator vertexToMergeWith = vertexIter->listConnectedVertices.begin(); - - //Change triangles to use new vertex - for(SurfaceTriangleIterator iterTriangles = m_setTriangles.begin(); iterTriangles != m_setTriangles.end(); ++iterTriangles) + for(std::list::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::iterator connectedVertex = vertexIter->listConnectedVertices.begin(); connectedVertex != vertexIter->listConnectedVertices.end(); ++connectedVertex) - { - for(std::list::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 + } diff --git a/source/SurfaceTriangle.cpp b/source/SurfaceTriangle.cpp index 7d29b955..6128f24c 100644 --- a/source/SurfaceTriangle.cpp +++ b/source/SurfaceTriangle.cpp @@ -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) diff --git a/source/SurfaceVertex.cpp b/source/SurfaceVertex.cpp index 1ecd2bc0..b1867c8c 100644 --- a/source/SurfaceVertex.cpp +++ b/source/SurfaceVertex.cpp @@ -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); - }*/ } diff --git a/source/VolumeSerializer.cpp b/source/VolumeSerializer.cpp index 893f13dc..0a2d82a5 100644 --- a/source/VolumeSerializer.cpp +++ b/source/VolumeSerializer.cpp @@ -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);*/ } }