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

Moved some stuff to the scrapyard

Browse Source
This commit is contained in:
David Williams 2008-01-16 21:35:43 +00:00
parent 2ec6e8fbda
commit bb67aaceb1
7 changed files with 2 additions and 524 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -2,9 +2,7 @@ PROJECT(PolyVoxSceneManager)
#Projects source files
SET(SRC_FILES
source/AbstractSurfacePatch.cpp
source/Block.cpp
source/HalfEdgeSurfacePatch.cpp
source/IndexedSurfacePatch.cpp
source/MarchingCubesTables.cpp
source/MaterialMap.cpp
@ -23,10 +21,8 @@ SET(SRC_FILES
#Projects headers files
SET(INC_FILES
include/AbstractSurfacePatch.h
include/Block.h
include/Constants.h
include/HalfEdgeSurfacePatch.h
include/IndexedSurfacePatch.h
include/IntegralVector3.h
include/MarchingCubesTables.h

26
include/AbstractSurfacePatch.h
View File

@ -1,26 +0,0 @@
#ifndef __AbstractSurfacePatch_H__
#define __AbstractSurfacePatch_H__
#include "SurfaceTypes.h"
#include "SurfaceVertex.h"
namespace Ogre
{
class AbstractSurfacePatch
{
public:
AbstractSurfacePatch();
virtual ~AbstractSurfacePatch();
SurfaceVertexIterator getVerticesBegin(void);
SurfaceVertexIterator getVerticesEnd(void);
virtual void addTriangle(const SurfaceVertex& v0,const SurfaceVertex& v1,const SurfaceVertex& v2) = 0;
virtual void fillVertexAndIndexData(std::vector<SurfaceVertex>& vecVertices, std::vector<ushort>& vecIndices) = 0;
protected:
std::set<SurfaceVertex> m_listVertices;
};
}
#endif /* __AbstractSurfacePatch_H__ */

54
include/HalfEdgeSurfacePatch.h
View File

@ -1,54 +0,0 @@
#ifndef __HalfEdgeSurfacePatch_H__
#define __HalfEdgeSurfacePatch_H__
#include <set>
#include <list>
#include "AbstractSurfacePatch.h"
#include "IntegralVector3.h"
#include "SurfaceTypes.h"
#include "VolumeIterator.h"
namespace Ogre
{
class HalfEdgeSurfacePatch : public AbstractSurfacePatch
{
public:
HalfEdgeSurfacePatch();
~HalfEdgeSurfacePatch();
//This allow users of the class to iterate over its contents.
SurfaceEdgeIterator getEdgesBegin(void);
SurfaceEdgeIterator getEdgesEnd(void);
SurfaceTriangleIterator getTrianglesBegin(void);
SurfaceTriangleIterator getTrianglesEnd(void);
//Users of the class might want these for debugging or info purposes.
uint getNoOfEdges(void) const;
uint getNoOfTriangles(void) const;
uint getNoOfVertices(void) const;
bool canRemoveVertexFrom(SurfaceVertexIterator vertexIter, std::list<SurfaceVertexIterator> listConnectedIter, bool isEdge);
std::list<SurfaceVertexIterator> findConnectedVertices(SurfaceVertexIterator vertexIter, bool& isEdge);
uint decimate(void);
void triangulate(std::list<SurfaceVertexIterator> listVertices);
bool isPolygonConvex(std::list<SurfaceVertexIterator> listVertices, Vector3 normal);
void addTriangle(const SurfaceVertex& v0,const SurfaceVertex& v1,const SurfaceVertex& v2);
void fillVertexAndIndexData(std::vector<SurfaceVertex>& vecVertices, std::vector<ushort>& vecIndices);
private:
std::set<SurfaceTriangle> m_listTriangles;
std::set<SurfaceEdge> m_listEdges;
SurfaceEdgeIterator findEdge(const SurfaceVertexIterator& source, const SurfaceVertexIterator& target);
SurfaceEdgeIterator findOrAddEdge(const SurfaceVertexIterator& source, const SurfaceVertexIterator& target);
SurfaceVertexIterator findOrAddVertex(const SurfaceVertex& vertex);
};
}
#endif /* __HalfEdgeSurfacePatch_H__ */

22
source/AbstractSurfacePatch.cpp
View File

@ -1,22 +0,0 @@
#include "AbstractSurfacePatch.h"
namespace Ogre
{
AbstractSurfacePatch::AbstractSurfacePatch()
{
}
AbstractSurfacePatch::~AbstractSurfacePatch()
{
}
SurfaceVertexIterator AbstractSurfacePatch::getVerticesBegin(void)
{
return m_listVertices.begin();
}
SurfaceVertexIterator AbstractSurfacePatch::getVerticesEnd(void)
{
return m_listVertices.end();
}
}

414
source/HalfEdgeSurfacePatch.cpp
View File

@ -1,414 +0,0 @@
#include "HalfEdgeSurfacePatch.h"
#include "Constants.h"
#include "SurfaceVertex.h"
#include "SurfaceTriangle.h"
#include "SurfaceEdge.h"
#include "OgreLogManager.h"
#include "OgreStringConverter.h"
#include <algorithm>
namespace Ogre
{
HalfEdgeSurfacePatch::HalfEdgeSurfacePatch()
{
m_listVertices.clear();
m_listTriangles.clear();
m_listEdges.clear();
}
HalfEdgeSurfacePatch::~HalfEdgeSurfacePatch()
{
}
SurfaceEdgeIterator HalfEdgeSurfacePatch::getEdgesBegin(void)
{
return m_listEdges.begin();
}
SurfaceEdgeIterator HalfEdgeSurfacePatch::getEdgesEnd(void)
{
return m_listEdges.end();
}
SurfaceTriangleIterator HalfEdgeSurfacePatch::getTrianglesBegin(void)
{
return m_listTriangles.begin();
}
SurfaceTriangleIterator HalfEdgeSurfacePatch::getTrianglesEnd(void)
{
return m_listTriangles.end();
}
uint HalfEdgeSurfacePatch::getNoOfEdges(void) const
{
return m_listEdges.size();
}
uint HalfEdgeSurfacePatch::getNoOfTriangles(void) const
{
return m_listTriangles.size();
}
uint HalfEdgeSurfacePatch::getNoOfVertices(void) const
{
return m_listVertices.size();
}
void HalfEdgeSurfacePatch::addTriangle(const SurfaceVertex& v0,const SurfaceVertex& v1,const SurfaceVertex& v2)
{
SurfaceVertexIterator v0Iter = findOrAddVertex(v0);
SurfaceVertexIterator v1Iter = findOrAddVertex(v1);
SurfaceVertexIterator v2Iter = findOrAddVertex(v2);
SurfaceEdgeIterator v0v1Iter = findOrAddEdge(v0Iter,v1Iter);
SurfaceEdgeIterator v1v2Iter = findOrAddEdge(v1Iter,v2Iter);
SurfaceEdgeIterator v2v0Iter = findOrAddEdge(v2Iter,v0Iter);
const_cast<SurfaceVertex&>(*v0Iter).setEdge(v0v1Iter);
const_cast<SurfaceVertex&>(*v1Iter).setEdge(v1v2Iter);
const_cast<SurfaceVertex&>(*v2Iter).setEdge(v2v0Iter);
const_cast<SurfaceEdge&>(*v0v1Iter).setNextHalfEdge(v1v2Iter);
const_cast<SurfaceEdge&>(*v1v2Iter).setNextHalfEdge(v2v0Iter);
const_cast<SurfaceEdge&>(*v2v0Iter).setNextHalfEdge(v0v1Iter);
const_cast<SurfaceEdge&>(*v0v1Iter).setPreviousHalfEdge(v2v0Iter);
const_cast<SurfaceEdge&>(*v1v2Iter).setPreviousHalfEdge(v0v1Iter);
const_cast<SurfaceEdge&>(*v2v0Iter).setPreviousHalfEdge(v1v2Iter);
SurfaceTriangle triangle;
triangle.setEdge(v0v1Iter);
SurfaceTriangleIterator iterTriangle = m_listTriangles.insert(triangle).first;
const_cast<SurfaceEdge&>(*v0v1Iter).setTriangle(iterTriangle);
const_cast<SurfaceEdge&>(*v1v2Iter).setTriangle(iterTriangle);
const_cast<SurfaceEdge&>(*v2v0Iter).setTriangle(iterTriangle);
}
SurfaceVertexIterator HalfEdgeSurfacePatch::findOrAddVertex(const SurfaceVertex& vertex)
{
return m_listVertices.insert(vertex).first;
}
SurfaceEdgeIterator HalfEdgeSurfacePatch::findEdge(const SurfaceVertexIterator& source, const SurfaceVertexIterator& target)
{
return m_listEdges.find(SurfaceEdge(target,source));
}
SurfaceEdgeIterator HalfEdgeSurfacePatch::findOrAddEdge(const SurfaceVertexIterator& source, const SurfaceVertexIterator& target)
{
SurfaceEdge edge(target,source);
std::pair<SurfaceEdgeIterator, bool> insertionResult = m_listEdges.insert(edge);
if(insertionResult.second == false)
{
//Edge was already in there, so other edge is too.
return insertionResult.first;
}
SurfaceEdgeIterator edgeIter = insertionResult.first;
SurfaceEdge otherEdge(source, target);
SurfaceEdgeIterator otherEdgeIter = m_listEdges.insert(otherEdge).first;
const_cast<SurfaceEdge&>(*edgeIter).pairWithOtherHalfEdge(otherEdgeIter);
const_cast<SurfaceEdge&>(*otherEdgeIter).pairWithOtherHalfEdge(edgeIter);
return edgeIter;
}
bool HalfEdgeSurfacePatch::canRemoveVertexFrom(SurfaceVertexIterator vertexIter, std::list<SurfaceVertexIterator> listConnectedIter, bool isEdge)
{
bool allXMatch = true;
bool allYMatch = true;
bool allZMatch = true;
bool allAlphaMatch = true;
bool allNormalsMatch = true;
bool twoEdgesMatch = true;
for(std::list<SurfaceVertexIterator>::iterator connectedIter = listConnectedIter.begin(); connectedIter != listConnectedIter.end(); ++connectedIter)
{
if((*connectedIter)->getPosition().x != vertexIter->getPosition().x)
{
allXMatch = false;
}
if((*connectedIter)->getPosition().y != vertexIter->getPosition().y)
{
allYMatch = false;
}
if((*connectedIter)->getPosition().z != vertexIter->getPosition().z)
{
allZMatch = false;
}
if((*connectedIter)->getAlpha() != vertexIter->getAlpha())
{
allAlphaMatch = false;
}
if((*connectedIter)->getNormal().dotProduct(vertexIter->getNormal()) < 0.99)
{
return false;
}
}
if(isEdge)
{
SurfaceVertexIterator firstExtreme = *(listConnectedIter.begin());
SurfaceVertexIterator secondExtreme = *(--listConnectedIter.end());
bool edgeXMatch = (firstExtreme->getPosition().x == vertexIter->getPosition().x) && (secondExtreme->getPosition().x == vertexIter->getPosition().x);
bool edgeYMatch = (firstExtreme->getPosition().y == vertexIter->getPosition().y) && (secondExtreme->getPosition().y == vertexIter->getPosition().y);
bool edgeZMatch = (firstExtreme->getPosition().z == vertexIter->getPosition().z) && (secondExtreme->getPosition().z == vertexIter->getPosition().z);
twoEdgesMatch = ((edgeXMatch&&edgeYMatch) || (edgeXMatch&&edgeZMatch) || (edgeYMatch&&edgeZMatch));
}
return (allXMatch || allYMatch || allZMatch)
&& (allAlphaMatch)
&& (twoEdgesMatch);
}
std::list<SurfaceVertexIterator> HalfEdgeSurfacePatch::findConnectedVertices(SurfaceVertexIterator vertexIter, bool& isEdge)
{
isEdge = false;
std::list<SurfaceVertexIterator> result;
//LogManager::getSingleton().logMessage("findConnectedVertices " + vertexIter->toString());
SurfaceEdgeIterator firstEdge = vertexIter->getEdge();
SurfaceEdgeIterator nextEdge = firstEdge;
SurfaceEdgeIterator previousEdge = firstEdge;
int ct = 0;
do
{
ct++;
//LogManager::getSingleton().logMessage("ct = " + StringConverter::toString(ct));
if(ct > 100)
{
LogManager::getSingleton().logMessage("ct too big!!! Aborting decimation");
exit(1);
}
result.push_back(nextEdge->getTarget());
previousEdge = nextEdge;
nextEdge = nextEdge->getPreviousHalfEdge()->getOtherHalfEdge();
}while((nextEdge != firstEdge) && (nextEdge != previousEdge));
if(nextEdge == previousEdge)
{
//LogManager::getSingleton().logMessage("Is edge");
//In this case vertexIter is on an edge/
isEdge = true;
nextEdge = firstEdge;
previousEdge = firstEdge;
previousEdge = nextEdge;
nextEdge = nextEdge->getOtherHalfEdge()->getNextHalfEdge();
int ct2 = 0;
do
{
ct2++;
//LogManager::getSingleton().logMessage("ct2 = " + StringConverter::toString(ct2));
if(ct2 > 100)
{
LogManager::getSingleton().logMessage("ct2 too big!!! Aborting decimation");
exit(1);
}
result.push_front(nextEdge->getTarget());
previousEdge = nextEdge;
nextEdge = nextEdge->getOtherHalfEdge()->getNextHalfEdge();
}while(nextEdge != previousEdge);
}
//LogManager::getSingleton().logMessage("Done find");
return result;
}
uint HalfEdgeSurfacePatch::decimate(void)
{
uint uNoRemoved = 0;
//LogManager::getSingleton().logMessage("\n\nPerforming decimation");
//LogManager::getSingleton().logMessage("No of triangles at start = " + StringConverter::toString(m_listTriangles.size()));
//LogManager::getSingleton().logMessage("No of edges at start = " + StringConverter::toString(m_listEdges.size()));
//int fixed = 0;
//int movable = 0;
std::vector<SurfaceVertexIterator> listVertexIterators;
//listVertexIterators.resize(m_listVertices.size());
for(SurfaceVertexIterator vertexIter = m_listVertices.begin(); vertexIter != m_listVertices.end(); ++vertexIter)
{
listVertexIterators.push_back(vertexIter);
}
//random_shuffle(listVertexIterators.begin(),listVertexIterators.end());
for(std::vector<SurfaceVertexIterator>::iterator vertexIterIter = listVertexIterators.begin(); vertexIterIter != listVertexIterators.end(); ++vertexIterIter)
//for(SurfaceVertexIterator vertexIter = m_listVertices.begin(); vertexIter != m_listVertices.end(); ++vertexIter)
{
//LogManager::getSingleton().logMessage("Examining vertex " + vertexIter->toString());
SurfaceVertexIterator vertexIter = *vertexIterIter;
bool isEdge;
std::list<SurfaceVertexIterator> listConnectedVertices = findConnectedVertices(vertexIter,isEdge);
listConnectedVertices.remove(vertexIter);
listConnectedVertices.unique();
/*LogManager::getSingleton().logMessage("No of connected vertices = " + StringConverter::toString(listConnectedVertices.size()));
for(std::list<SurfaceVertexIterator>::iterator iter = listConnectedVertices.begin(); iter != listConnectedVertices.end(); ++iter)
{
LogManager::getSingleton().logMessage(" Connected vertex = " + (*iter)->toString());
}*/
if(canRemoveVertexFrom(vertexIter, listConnectedVertices, isEdge) == false)
{
continue;
}
if(isPolygonConvex(listConnectedVertices, vertexIter->getNormal()) == false)
{
continue;
}
//LogManager::getSingleton().logMessage("Vertex can be removed");
//std::list<SurfaceEdgeIterator> edgesToRemove;
for(std::list<SurfaceVertexIterator>::iterator iter = listConnectedVertices.begin(); iter != listConnectedVertices.end(); ++iter)
{
SurfaceEdgeIterator edgeToDelete = findEdge(vertexIter, *iter);
/*if(edgeToDelete == m_listEdges.end())
{
LogManager::getSingleton().logMessage("Error - Failed to find");
}*/
SurfaceEdgeIterator otherEdgeToDelete = edgeToDelete->getOtherHalfEdge();
if(edgeToDelete->getNextHalfEdge() != edgeToDelete->getOtherHalfEdge())
{
m_listTriangles.erase(edgeToDelete->getTriangle());
}
//LogManager::getSingleton().logMessage("Removing edge " + edgeToDelete->toString());
m_listEdges.erase(edgeToDelete);
//LogManager::getSingleton().logMessage("Removing edge " + otherEdgeToDelete->toString());
m_listEdges.erase(otherEdgeToDelete);
//edgesToRemove.push_back(edgeToDelete);
//edgesToRemove.push_back(otherEdgeToDelete);
}
/*LogManager::getSingleton().logMessage("Now removing edges");
for(std::list<SurfaceEdgeIterator>::iterator iter = edgesToRemove.begin(); iter != edgesToRemove.end(); ++iter)
{
m_listEdges.erase(*iter);
}*/
//LogManager::getSingleton().logMessage("Removing vertex " + vertexIter->toString());
m_listVertices.erase(vertexIter);
//Now triangulate...
//LogManager::getSingleton().logMessage("Doing triangulation");
triangulate(listConnectedVertices);
++uNoRemoved;
//break;
}
//LogManager::getSingleton().logMessage("Fixed = " + StringConverter::toString(fixed) + " Movable = " + StringConverter::toString(movable));
//LogManager::getSingleton().logMessage("Done decimation");
//LogManager::getSingleton().logMessage("No of triangles at end = " + StringConverter::toString(m_listTriangles.size()));
/*std::vector<SurfaceVertex> vertexDataTemp;
std::vector<uint> indexDataTemp;
getVertexAndIndexData(vertexDataTemp, indexDataTemp);*/
return uNoRemoved;
}
void HalfEdgeSurfacePatch::triangulate(std::list<SurfaceVertexIterator> listVertices)
{
std::list<SurfaceVertexIterator>::iterator v0IterIter = listVertices.begin();
std::list<SurfaceVertexIterator>::iterator v1IterIter = listVertices.begin();
std::list<SurfaceVertexIterator>::iterator v2IterIter = listVertices.begin();
++v1IterIter;
++v2IterIter;
++v2IterIter;
while(v2IterIter != listVertices.end())
{
SurfaceVertexIterator v0Iter = *v0IterIter;
SurfaceVertexIterator v1Iter = *v1IterIter;
SurfaceVertexIterator v2Iter = *v2IterIter;
addTriangle(*v0Iter, *v1Iter, *v2Iter);
++v1IterIter;
++v2IterIter;
}
}
bool HalfEdgeSurfacePatch::isPolygonConvex(std::list<SurfaceVertexIterator> listVertices, Vector3 normal)
{
std::list<SurfaceVertexIterator>::iterator v0IterIter = listVertices.begin();
std::list<SurfaceVertexIterator>::iterator v1IterIter = listVertices.begin();
std::list<SurfaceVertexIterator>::iterator v2IterIter = listVertices.begin();
++v1IterIter;
++v2IterIter;
++v2IterIter;
while(v2IterIter != listVertices.end())
{
SurfaceVertexIterator v0Iter = *v0IterIter;
SurfaceVertexIterator v1Iter = *v1IterIter;
SurfaceVertexIterator v2Iter = *v2IterIter;
Vector3 v1tov0(v0Iter->getPosition().toOgreVector3() - v1Iter->getPosition().toOgreVector3());
Vector3 v1tov2(v2Iter->getPosition().toOgreVector3() - v1Iter->getPosition().toOgreVector3());
Vector3 cross = (v1tov2).crossProduct(v1tov0);
cross.normalise();
//LogManager::getSingleton().logMessage("Cross = " + StringConverter::toString(cross));
if(cross.dotProduct(normal) < 0.99)
{
return false;
}
++v1IterIter;
++v2IterIter;
}
return true;
}
void HalfEdgeSurfacePatch::fillVertexAndIndexData(std::vector<SurfaceVertex>& vecVertices, std::vector<ushort>& vecIndices)
{
vecVertices.resize(m_listVertices.size());
std::copy(m_listVertices.begin(), m_listVertices.end(), vecVertices.begin());
//vecIndices.resize(m_listTriangles.size() * 3);
for(SurfaceTriangleConstIterator iterTriangles = m_listTriangles.begin(); iterTriangles != m_listTriangles.end(); ++iterTriangles)
{
std::vector<SurfaceVertex>::iterator iterVertex;
SurfaceEdgeIterator edgeIter;
edgeIter = iterTriangles->getEdge();
iterVertex = lower_bound(vecVertices.begin(), vecVertices.end(), *(edgeIter->getTarget()));
vecIndices.push_back(iterVertex - vecVertices.begin());
edgeIter = edgeIter->getNextHalfEdge();
iterVertex = lower_bound(vecVertices.begin(), vecVertices.end(), *(edgeIter->getTarget()));
vecIndices.push_back(iterVertex - vecVertices.begin());
edgeIter = edgeIter->getNextHalfEdge();
iterVertex = lower_bound(vecVertices.begin(), vecVertices.end(), *(edgeIter->getTarget()));
vecIndices.push_back(iterVertex - vecVertices.begin());
}
}
}

5
source/PolyVoxSceneManager.cpp
View File

@ -21,7 +21,6 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "MaterialMapManager.h"
#include "SurfaceVertex.h"
#include "SurfaceEdge.h"
#include "HalfEdgeSurfacePatch.h"
#include "IndexedSurfacePatch.h"
#include "PolyVoxSceneManager.h"
#include "VolumeIterator.h"
@ -183,8 +182,8 @@ namespace Ogre
singleMaterialSurfacePatchRenderable = new SurfacePatchRenderable(singleMaterialPatch,materialMap->getMaterialAtIndex(1));
multiMaterialSurfacePatchRenderable = new SurfacePatchRenderable(multiMaterialPatch,materialMap->getMaterialAtIndex(2));
multiMaterialSurfacePatchRenderable->setRenderQueueGroup(RenderQueueGroupID::RENDER_QUEUE_3);
singleMaterialSurfacePatchRenderable->setRenderQueueGroup(RenderQueueGroupID::RENDER_QUEUE_4);
multiMaterialSurfacePatchRenderable->setRenderQueueGroup(RENDER_QUEUE_3);
singleMaterialSurfacePatchRenderable->setRenderQueueGroup(RENDER_QUEUE_4);
m_singleMaterialSurfaces[regionX][regionY][regionZ] = singleMaterialSurfacePatchRenderable;
sceneNode->attachObject(singleMaterialSurfacePatchRenderable);

1
source/SurfacePatchRenderable.cpp
View File

@ -28,7 +28,6 @@ namespace Ogre
decl->addElement(0, 0, VET_FLOAT3, VES_POSITION);
decl->addElement(0, 3 * sizeof(float), VET_FLOAT3, VES_NORMAL);
decl->addElement(0, 6 * sizeof(float), VET_FLOAT2, VES_TEXTURE_COORDINATES);
//decl->addElement(0, 7 * sizeof(float), VET_FLOAT1, VES_TEXTURE_COORDINATES);
this->setMaterial(material);