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

Refactoring work... working on meshes

Browse Source
This commit is contained in:
David Williams 2007-09-01 10:53:15 +00:00
parent ca0805bd2f
commit 94df0acd48
5 changed files with 250 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
include/PolyVoxSceneManager.h
View File

@ -35,13 +35,6 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
namespace Ogre
{
enum NormalGenerationMethod
{
SIMPLE,
CENTRAL_DIFFERENCE,
SOBEL
};
/// Factory for default scene manager
class VOXEL_SCENE_MANAGER_API PolyVoxSceneManagerFactory : public SceneManagerFactory
{

16
include/SurfacePatch.h
View File

@ -7,8 +7,18 @@
#include "SurfaceVertex.h"
#include "SurfaceTriangle.h"
#include "VolumeIterator.h"
namespace Ogre
{
enum NormalGenerationMethod
{
SIMPLE,
CENTRAL_DIFFERENCE,
SOBEL
};
class SurfacePatch
{
public:
@ -22,12 +32,14 @@ namespace Ogre
void getVertexAndIndexData(std::vector<SurfaceVertex>& vertexData, std::vector<uint>& indexData);
void computeNormalsFromVolume(uint regionX, uint regionY, uint regionZ, VolumeIterator volIter);
private:
std::set<SurfaceVertex> m_setVertices;
std::list<SurfaceTriangle> m_listTriangles;
std::vector<SurfaceVertex> m_vecVertexData;
std::vector<uint> m_vecIndexData;
//std::vector<SurfaceVertex> m_vecVertexData;
//std::vector<uint> m_vecIndexData;
uint m_uTrianglesAdded;
uint m_uVerticesAdded;

133
include/VolumeIterator.h Normal file
View File

@ -0,0 +1,133 @@
/******************************************************************************
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 __VolumeIterator_H__
#define __VolumeIterator_H__
#include "OgrePrerequisites.h"
#include "OgreSharedPtr.h"
#include "Typedef.h"
namespace Ogre
{
class Volume;
class VOXEL_SCENE_MANAGER_API VolumeIterator
{
public:
VolumeIterator(Volume& volume);
~VolumeIterator();
void setVoxel(uchar value);
uchar getVoxel(void);
uchar getVoxelAt(const uint xPosition, const uint yPosition, const uint zPosition) const;
void setVoxelAt(const uint xPosition, const uint yPosition, const uint zPosition, const uchar value);
float getAveragedVoxelAt(const uint xPosition, const uint yPosition, const uint zPosition, uint size) const;
//FIXME - this shouldn't return float vector
Vector3 getCentralDifferenceGradient(void) const;
Vector3 getAveragedCentralDifferenceGradient(void) const;
Vector3 getSobelGradient(void) const;
uint getPosX(void);
uint getPosY(void);
uint getPosZ(void);
void setPosition(uint xPos, uint yPos, uint zPos);
void setValidRegion(uint xFirst, uint yFirst, uint zFirst, uint xLast, uint yLast, uint zLast);
void moveForwardInRegion(void);
bool isValidForRegion(void);
uchar peekVoxel1nx1ny1nz(void) const;
uchar peekVoxel1nx1ny0pz(void) const;
uchar peekVoxel1nx1ny1pz(void) const;
uchar peekVoxel1nx0py1nz(void) const;
uchar peekVoxel1nx0py0pz(void) const;
uchar peekVoxel1nx0py1pz(void) const;
uchar peekVoxel1nx1py1nz(void) const;
uchar peekVoxel1nx1py0pz(void) const;
uchar peekVoxel1nx1py1pz(void) const;
uchar peekVoxel0px1ny1nz(void) const;
uchar peekVoxel0px1ny0pz(void) const;
uchar peekVoxel0px1ny1pz(void) const;
uchar peekVoxel0px0py1nz(void) const;
uchar peekVoxel0px0py0pz(void) const;
uchar peekVoxel0px0py1pz(void) const;
uchar peekVoxel0px1py1nz(void) const;
uchar peekVoxel0px1py0pz(void) const;
uchar peekVoxel0px1py1pz(void) const;
uchar peekVoxel1px1ny1nz(void) const;
uchar peekVoxel1px1ny0pz(void) const;
uchar peekVoxel1px1ny1pz(void) const;
uchar peekVoxel1px0py1nz(void) const;
uchar peekVoxel1px0py0pz(void) const;
uchar peekVoxel1px0py1pz(void) const;
uchar peekVoxel1px1py1nz(void) const;
uchar peekVoxel1px1py0pz(void) const;
uchar peekVoxel1px1py1pz(void) const;
private:
//The current volume
Volume& mVolume;
//The current position in the volume
uint mXPosInVolume;
uint mYPosInVolume;
uint mZPosInVolume;
//The position of the current block
uint mXBlock;
uint mYBlock;
uint mZBlock;
//The offset into the current block
uint mXPosInBlock;
uint mYPosInBlock;
uint mZPosInBlock;
//Other current position information
uchar* mCurrentVoxel;
//SharedPtr<Block> mCurrentBlock;
ulong mBlockIndexInVolume;
ulong mVoxelIndexInBlock;
uint mXRegionFirst;
uint mYRegionFirst;
uint mZRegionFirst;
uint mXRegionLast;
uint mYRegionLast;
uint mZRegionLast;
uint mXRegionFirstBlock;
uint mYRegionFirstBlock;
uint mZRegionFirstBlock;
uint mXRegionLastBlock;
uint mYRegionLastBlock;
uint mZRegionLastBlock;
bool mIsValidForRegion;
};
}
#endif

10
source/PolyVoxSceneManager.cpp
View File

@ -772,21 +772,24 @@ namespace Ogre
surfaceVertex0.alpha = 1.0;
else
surfaceVertex0.alpha = 0.0;
surfaceVertex0.normal = Vector3(1.0,1.0,1.0);
//surfaceVertex0.normal = Vector3(1.0,1.0,1.0);
surfaceVertex0.normal = Vector3(0.0,0.0,0.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);
//surfaceVertex1.normal = Vector3(1.0,1.0,1.0);
surfaceVertex1.normal = Vector3(0.0,0.0,0.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);
//surfaceVertex2.normal = Vector3(1.0,1.0,1.0);
surfaceVertex2.normal = Vector3(0.0,0.0,0.0);
result[material].addTriangle(surfaceVertex0, surfaceVertex1, surfaceVertex2);
@ -1002,6 +1005,7 @@ namespace Ogre
for(std::map<uchar, SurfacePatch>::iterator iterPatch = result.begin(); iterPatch != result.end(); ++iterPatch)
{
iterPatch->second.computeNormalsFromVolume(regionX,regionY,regionZ,volIter);
iterPatch->second.endDefinition();
}

232
source/SurfacePatch.cpp
View File

@ -18,7 +18,7 @@ namespace Ogre
vertexIndices = 0;
beginDefinition(); //FIXME - we shouldn't really be calling this from the constructor.
//beginDefinition(); //FIXME - we shouldn't really be calling this from the constructor.
}
SurfacePatch::~SurfacePatch()
@ -27,8 +27,6 @@ namespace Ogre
void SurfacePatch::beginDefinition(void)
{
vertexIndices = new long int [(OGRE_REGION_SIDE_LENGTH*2+1)*(OGRE_REGION_SIDE_LENGTH*2+1)*(OGRE_REGION_SIDE_LENGTH*2+1)];
memset(vertexIndices,0xFF,sizeof(long int)*(OGRE_REGION_SIDE_LENGTH*2+1)*(OGRE_REGION_SIDE_LENGTH*2+1)*(OGRE_REGION_SIDE_LENGTH*2+1)); //0xFF is -1 as two's complement - this may not be portable...
}
void SurfacePatch::endDefinition(void)
@ -37,85 +35,113 @@ namespace Ogre
//LogManager::getSingleton().logMessage("No of triangles present = " + StringConverter::toString(m_listTriangles.size()));
//LogManager::getSingleton().logMessage("No of vertices added = " + StringConverter::toString(m_uVerticesAdded));
//LogManager::getSingleton().logMessage("No of vertices present = " + StringConverter::toString(m_setVertices.size()));
delete vertexIndices;
vertexIndices = 0;
}
void SurfacePatch::addTriangle(const SurfaceVertex& v0,const SurfaceVertex& v1,const SurfaceVertex& v2)
{
m_uTrianglesAdded++;
m_uVerticesAdded += 3;
/*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);*/
/*long int index;
//If a vertex has not yet been added, it's index is -1
index = vertexIndices[(v0.position.x*(OGRE_REGION_SIDE_LENGTH*2+1)*(OGRE_REGION_SIDE_LENGTH*2+1)) + (v0.position.y*(OGRE_REGION_SIDE_LENGTH*2+1)) + (v0.position.z)];
if((index == -1))
{
//Add the vertex
m_vecVertexData.push_back(v0);
vertexIndices[(v0.position.x*(OGRE_REGION_SIDE_LENGTH*2+1)*(OGRE_REGION_SIDE_LENGTH*2+1)) + (v0.position.y*(OGRE_REGION_SIDE_LENGTH*2+1)) + (v0.position.z)] = m_vecVertexData.size()-1;
m_vecIndexData.push_back(m_vecVertexData.size()-1);
}
else
{
//Just reuse the existing vertex
m_vecIndexData.push_back(index);
}
//If a vertex has not yet been added, it's index is -1
index = vertexIndices[(v1.position.x*(OGRE_REGION_SIDE_LENGTH*2+1)*(OGRE_REGION_SIDE_LENGTH*2+1)) + (v1.position.y*(OGRE_REGION_SIDE_LENGTH*2+1)) + (v1.position.z)];
if((index == -1))
{
//Add the vertex
m_vecVertexData.push_back(v1);
vertexIndices[(v1.position.x*(OGRE_REGION_SIDE_LENGTH*2+1)*(OGRE_REGION_SIDE_LENGTH*2+1)) + (v1.position.y*(OGRE_REGION_SIDE_LENGTH*2+1)) + (v1.position.z)] = m_vecVertexData.size()-1;
m_vecIndexData.push_back(m_vecVertexData.size()-1);
}
else
{
//Just reuse the existing vertex
m_vecIndexData.push_back(index);
}
//If a vertex has not yet been added, it's index is -1
index = vertexIndices[(v2.position.x*(OGRE_REGION_SIDE_LENGTH*2+1)*(OGRE_REGION_SIDE_LENGTH*2+1)) + (v2.position.y*(OGRE_REGION_SIDE_LENGTH*2+1)) + (v2.position.z)];
if((index == -1))
{
//Add the vertex
m_vecVertexData.push_back(v2);
vertexIndices[(v2.position.x*(OGRE_REGION_SIDE_LENGTH*2+1)*(OGRE_REGION_SIDE_LENGTH*2+1)) + (v2.position.y*(OGRE_REGION_SIDE_LENGTH*2+1)) + (v2.position.z)] = m_vecVertexData.size()-1;
m_vecIndexData.push_back(m_vecVertexData.size()-1);
}
else
{
//Just reuse the existing vertex
m_vecIndexData.push_back(index);
}*/
m_uVerticesAdded += 3;
SurfaceTriangle triangle;
triangle.v0 = m_setVertices.insert(v0).first;
triangle.v1 = m_setVertices.insert(v1).first;
triangle.v2 = m_setVertices.insert(v2).first;
/*triangle.v0 = std::find(m_setVertices.begin(), m_setVertices.end(), v0);
triangle.v1 = std::find(m_setVertices.begin(), m_setVertices.end(), v1);
triangle.v2 = std::find(m_setVertices.begin(), m_setVertices.end(), v2); */
triangle.v2 = m_setVertices.insert(v2).first;
m_listTriangles.push_back(triangle);
/*triangle.v0->listTrianglesUsingThisVertex.push_back(m_listTriangles.end());
triangle.v0->listTrianglesUsingThisVertex.push_back(m_listTriangles.end());
triangle.v1->listTrianglesUsingThisVertex.push_back(m_listTriangles.end());
triangle.v2->listTrianglesUsingThisVertex.push_back(m_listTriangles.end());*/
triangle.v2->listTrianglesUsingThisVertex.push_back(m_listTriangles.end());
}
void SurfacePatch::computeNormalsFromVolume(uint regionX, uint regionY, uint regionZ, VolumeIterator volIter)
{
//LogManager::getSingleton().logMessage("In SurfacePatch::computeNormalsFromVolume");
for(std::set<SurfaceVertex>::iterator vertexIter = m_setVertices.begin(); vertexIter != m_setVertices.end(); ++vertexIter)
{
//LogManager::getSingleton().logMessage("In Loop");
const float posX = vertexIter->position.x/2.0f + static_cast<float>(regionX * OGRE_REGION_SIDE_LENGTH);
const float posY = vertexIter->position.y/2.0f + static_cast<float>(regionY * OGRE_REGION_SIDE_LENGTH);
const float posZ = vertexIter->position.z/2.0f + static_cast<float>(regionZ * OGRE_REGION_SIDE_LENGTH);
const uint floorX = static_cast<uint>(vertexIter->position.x/2.0f) + regionX * OGRE_REGION_SIDE_LENGTH;
const uint floorY = static_cast<uint>(vertexIter->position.y/2.0f) + regionY * OGRE_REGION_SIDE_LENGTH;
const uint floorZ = static_cast<uint>(vertexIter->position.z/2.0f) + regionZ * OGRE_REGION_SIDE_LENGTH;
NormalGenerationMethod normalGenerationMethod = CENTRAL_DIFFERENCE;
switch(normalGenerationMethod)
{
case SIMPLE:
{
volIter.setPosition(static_cast<uint>(posX),static_cast<uint>(posY),static_cast<uint>(posZ));
const uchar uFloor = volIter.getVoxel() > 0 ? 1 : 0;
if((posX - floorX) > 0.25) //The result should be 0.0 or 0.5
{
uchar uCeil = volIter.peekVoxel1px0py0pz() > 0 ? 1 : 0;
vertexIter->normal = Vector3(uFloor - uCeil,0.0,0.0);
}
else if((posY - floorY) > 0.25) //The result should be 0.0 or 0.5
{
uchar uCeil = volIter.peekVoxel0px1py0pz() > 0 ? 1 : 0;
vertexIter->normal = Vector3(0.0,uFloor - uCeil,0.0);
}
else if((posZ - floorZ) > 0.25) //The result should be 0.0 or 0.5
{
uchar uCeil = volIter.peekVoxel0px0py1pz() > 0 ? 1 : 0;
vertexIter->normal = Vector3(0.0, 0.0,uFloor - uCeil);
}
vertexIter->normal.normalise();
break;
}
case CENTRAL_DIFFERENCE:
{
volIter.setPosition(static_cast<uint>(posX),static_cast<uint>(posY),static_cast<uint>(posZ));
const Vector3 gradFloor = volIter.getCentralDifferenceGradient();
if((posX - floorX) > 0.25) //The result should be 0.0 or 0.5
{
volIter.setPosition(static_cast<uint>(posX+1.0),static_cast<uint>(posY),static_cast<uint>(posZ));
}
if((posY - floorY) > 0.25) //The result should be 0.0 or 0.5
{
volIter.setPosition(static_cast<uint>(posX),static_cast<uint>(posY+1.0),static_cast<uint>(posZ));
}
if((posZ - floorZ) > 0.25) //The result should be 0.0 or 0.5
{
volIter.setPosition(static_cast<uint>(posX),static_cast<uint>(posY),static_cast<uint>(posZ+1.0));
}
const Vector3 gradCeil = volIter.getCentralDifferenceGradient();
vertexIter->normal = gradFloor + gradCeil;
vertexIter->normal *= -1;
vertexIter->normal.normalise();
break;
}
case SOBEL:
{
volIter.setPosition(static_cast<uint>(posX),static_cast<uint>(posY),static_cast<uint>(posZ));
const Vector3 gradFloor = volIter.getSobelGradient();
if((posX - floorX) > 0.25) //The result should be 0.0 or 0.5
{
volIter.setPosition(static_cast<uint>(posX+1.0),static_cast<uint>(posY),static_cast<uint>(posZ));
}
if((posY - floorY) > 0.25) //The result should be 0.0 or 0.5
{
volIter.setPosition(static_cast<uint>(posX),static_cast<uint>(posY+1.0),static_cast<uint>(posZ));
}
if((posZ - floorZ) > 0.25) //The result should be 0.0 or 0.5
{
volIter.setPosition(static_cast<uint>(posX),static_cast<uint>(posY),static_cast<uint>(posZ+1.0));
}
const Vector3 gradCeil = volIter.getSobelGradient();
vertexIter->normal = gradFloor + gradCeil;
vertexIter->normal *= -1;
vertexIter->normal.normalise();
break;
}
}
}
}
void SurfacePatch::getVertexAndIndexData(std::vector<SurfaceVertex>& vertexData, std::vector<uint>& indexData)
@ -123,87 +149,21 @@ namespace Ogre
vertexData.clear();
indexData.clear();
/*vertexData = m_vecVertexData;
indexData = m_vecIndexData;*/
//return;
vertexData.resize(m_setVertices.size());
std::copy(m_setVertices.begin(), m_setVertices.end(), vertexData.begin());
//sort(vertexData.begin(),vertexData.end());
//reverse(vertexData.begin(),vertexData.end());
//LogManager::getSingleton().logMessage("No of triangles = " + StringConverter::toString(m_listTriangles.size()));
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); */
std::vector<SurfaceVertex>::iterator iterVertex;
/*std::set<SurfaceVertex>::iterator iterVertex = m_setVertices.find((*(iterTriangles->v0)));
indexData.push_back(iterVertex - m_setVertices.begin());
iterVertex = m_setVertices.find((*(iterTriangles->v1)));
indexData.push_back(iterVertex - m_setVertices.begin());
iterVertex = m_setVertices.find((*(iterTriangles->v2)));
indexData.push_back(iterVertex - m_setVertices.begin());*/
/*for(uint ct = 0; ct < vertexData.size(); ++ct)
{
if(vertexData[ct] == (*(iterTriangles->v0)))
{
indexData.push_back(ct);
break;
}
}*/
std::vector<SurfaceVertex>::iterator iterVertex = lower_bound(vertexData.begin(), vertexData.end(),(*(iterTriangles->v0)));
if(iterVertex == vertexData.end())
{
LogManager::getSingleton().logMessage("Vertex 0 Not Found");
}
iterVertex = lower_bound(vertexData.begin(), vertexData.end(),(*(iterTriangles->v0)));
indexData.push_back(iterVertex - vertexData.begin());
iterVertex = lower_bound(vertexData.begin(), vertexData.end(),(*(iterTriangles->v1)));
if(iterVertex == vertexData.end())
{
LogManager::getSingleton().logMessage("Vertex 1 Not Found");
}
indexData.push_back(iterVertex - vertexData.begin());
iterVertex = lower_bound(vertexData.begin(), vertexData.end(),(*(iterTriangles->v2)));
if(iterVertex == vertexData.end())
{
LogManager::getSingleton().logMessage("Vertex 2 Not Found");
}
indexData.push_back(iterVertex - vertexData.begin());
/*for(uint ct = 0; ct < vertexData.size(); ++ct)
{
if(vertexData[ct] == (*(iterTriangles->v1)))
{
indexData.push_back(ct);
break;
}
}
for(uint ct = 0; ct < vertexData.size(); ++ct)
{
if(vertexData[ct] == (*(iterTriangles->v2)))
{
indexData.push_back(ct);
break;
}
}*/
indexData.push_back(iterVertex - vertexData.begin());
}
//LogManager::getSingleton().logMessage("Out of Loop");
/*vertexData = m_vecVertexData;
indexData = m_vecIndexData;*/
}
}