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

Removed SurfacePatch::getVertexAndIndexData and replaced it with passing a SurfacePatch to a SurfacePatchRenderable.

Browse Source
This commit is contained in:
David Williams
2007-09-29 01:10:01 +00:00
parent 2a6e758e4b
commit d0386f8853
6 changed files with 157 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
include/SurfacePatch.h
View File

@ -26,15 +26,9 @@ namespace Ogre
SurfaceVertexIterator getVerticesEnd(void); SurfaceVertexIterator getVerticesEnd(void);
//Users of the class might want these for debugging or info purposes. //Users of the class might want these for debugging or info purposes.
uint getNoOfEdges(void); uint getNoOfEdges(void) const;
uint getNoOfTriangles(void); uint getNoOfTriangles(void) const;
uint getNoOfVertices(void); uint getNoOfVertices(void) const;
void getVertexAndIndexData(std::vector<SurfaceVertex>& vertexData, std::vector<uint>& indexData);
bool canRemoveVertexFrom(SurfaceVertexIterator vertexIter, std::list<SurfaceVertexIterator> listConnectedIter, bool isEdge); bool canRemoveVertexFrom(SurfaceVertexIterator vertexIter, std::list<SurfaceVertexIterator> listConnectedIter, bool isEdge);
std::list<SurfaceVertexIterator> findConnectedVertices(SurfaceVertexIterator vertexIter, bool& isEdge); std::list<SurfaceVertexIterator> findConnectedVertices(SurfaceVertexIterator vertexIter, bool& isEdge);

6
include/SurfacePatchRenderable.h
View File

@ -4,6 +4,7 @@
#include "Ogre.h" #include "Ogre.h"
#include <vector> #include <vector>
#include "SurfacePatch.h"
#include "SurfaceTriangle.h" #include "SurfaceTriangle.h"
#include "SurfaceVertex.h" #include "SurfaceVertex.h"
@ -12,10 +13,11 @@ namespace Ogre
class SurfacePatchRenderable : public SimpleRenderable class SurfacePatchRenderable : public SimpleRenderable
{ {
public: public:
SurfacePatchRenderable(const String& material = "BaseWhiteNoLighting"); SurfacePatchRenderable(SurfacePatch& patchToRender, const String& material = "BaseWhiteNoLighting");
~SurfacePatchRenderable(void); ~SurfacePatchRenderable(void);
void setGeometry(std::vector<SurfaceVertex> verticesToSet, std::vector<uint> indicesToSet); void updateWithNewSurfacePatch(SurfacePatch& patchToRender);
void setGeometry(SurfacePatch& patchToRender);
Real getSquaredViewDepth(const Camera *cam) const; Real getSquaredViewDepth(const Camera *cam) const;
Real getBoundingRadius(void) const; Real getBoundingRadius(void) const;

3
include/SurfaceTypes.h
View File

@ -5,10 +5,13 @@ namespace Ogre
{ {
class SurfaceVertex; class SurfaceVertex;
typedef std::set<SurfaceVertex>::iterator SurfaceVertexIterator; typedef std::set<SurfaceVertex>::iterator SurfaceVertexIterator;
typedef std::set<SurfaceVertex>::const_iterator SurfaceVertexConstIterator;
class SurfaceTriangle; class SurfaceTriangle;
typedef std::set<SurfaceTriangle>::iterator SurfaceTriangleIterator; typedef std::set<SurfaceTriangle>::iterator SurfaceTriangleIterator;
typedef std::set<SurfaceTriangle>::const_iterator SurfaceTriangleConstIterator;
class SurfaceEdge; class SurfaceEdge;
typedef std::set<SurfaceEdge>::iterator SurfaceEdgeIterator; typedef std::set<SurfaceEdge>::iterator SurfaceEdgeIterator;
typedef std::set<SurfaceEdge>::const_iterator SurfaceEdgeConstIterator;
} }
#endif #endif

11
source/PolyVoxSceneManager.cpp
View File

@ -279,18 +279,18 @@ namespace Ogre
//for(uint meshCt = 1; meshCt < 256; ++meshCt) //for(uint meshCt = 1; meshCt < 256; ++meshCt)
for(std::map<uchar, SurfacePatch>::iterator iterSurfacePatch = mapSurfacePatch.begin(); iterSurfacePatch != mapSurfacePatch.end(); ++iterSurfacePatch) for(std::map<uchar, SurfacePatch>::iterator iterSurfacePatch = mapSurfacePatch.begin(); iterSurfacePatch != mapSurfacePatch.end(); ++iterSurfacePatch)
{ {
std::vector<SurfaceVertex> vertexData; /*std::vector<SurfaceVertex> vertexData;
std::vector<uint> indexData; std::vector<uint> indexData;
iterSurfacePatch->second.getVertexAndIndexData(vertexData, indexData); iterSurfacePatch->second.getVertexAndIndexData(vertexData, indexData);
triangleCounter += iterSurfacePatch->second.getNoOfTriangles(); triangleCounter += iterSurfacePatch->second.getNoOfTriangles();*/
std::map<uchar,SurfacePatchRenderable*>::iterator iterSurface = m_mapSurfaces[regionX][regionY][regionZ].find(iterSurfacePatch->first); std::map<uchar,SurfacePatchRenderable*>::iterator iterSurface = m_mapSurfaces[regionX][regionY][regionZ].find(iterSurfacePatch->first);
if(iterSurface == m_mapSurfaces[regionX][regionY][regionZ].end()) if(iterSurface == m_mapSurfaces[regionX][regionY][regionZ].end())
{ {
//We have to create the surface //We have to create the surface
SurfacePatchRenderable* surface = new SurfacePatchRenderable(materialMap->getMaterialAtIndex(iterSurfacePatch->first)); SurfacePatchRenderable* surface = new SurfacePatchRenderable(iterSurfacePatch->second,materialMap->getMaterialAtIndex(iterSurfacePatch->first));
//surface->setGeometry(vertexData[meshCt],indexData[meshCt]); //surface->setGeometry(vertexData[meshCt],indexData[meshCt]);
surface->setGeometry(vertexData, indexData); //surface->setGeometry(vertexData, indexData);
m_mapSurfaces[regionX][regionY][regionZ].insert(std::make_pair(iterSurfacePatch->first,surface)); m_mapSurfaces[regionX][regionY][regionZ].insert(std::make_pair(iterSurfacePatch->first,surface));
@ -300,7 +300,8 @@ namespace Ogre
{ {
//We just update the existing surface //We just update the existing surface
//iterSurface->second->setGeometry(vertexData[meshCt],indexData[meshCt]); //iterSurface->second->setGeometry(vertexData[meshCt],indexData[meshCt]);
iterSurface->second->setGeometry(vertexData, indexData); //iterSurface->second->setGeometry(vertexData, indexData);
iterSurface->second->updateWithNewSurfacePatch(iterSurfacePatch->second);
sceneNode->attachObject(iterSurface->second); sceneNode->attachObject(iterSurface->second);
} }
} }

48
source/SurfacePatch.cpp
View File

@ -53,17 +53,17 @@ namespace Ogre
return m_listVertices.end(); return m_listVertices.end();
} }
uint SurfacePatch::getNoOfEdges(void) uint SurfacePatch::getNoOfEdges(void) const
{ {
return m_listEdges.size(); return m_listEdges.size();
} }
uint SurfacePatch::getNoOfTriangles(void) uint SurfacePatch::getNoOfTriangles(void) const
{ {
return m_listTriangles.size(); return m_listTriangles.size();
} }
uint SurfacePatch::getNoOfVertices(void) uint SurfacePatch::getNoOfVertices(void) const
{ {
return m_listVertices.size(); return m_listVertices.size();
} }
@ -132,48 +132,6 @@ namespace Ogre
return edgeIter; return edgeIter;
} }
void SurfacePatch::getVertexAndIndexData(std::vector<SurfaceVertex>& vertexData, std::vector<uint>& indexData)
{
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->getPosition().x) + "," + StringConverter::toString(vertexIter->getPosition().y) + "," + StringConverter::toString(vertexIter->getPosition().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->getEdge();
//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->getTarget()));
//LogManager::getSingleton().logMessage("");
//LogManager::getSingleton().logMessage(" " + StringConverter::toString(iterVertex->getPosition().x) + "," + StringConverter::toString(iterVertex->getPosition().y) + "," + StringConverter::toString(iterVertex->getPosition().z));
indexData.push_back(iterVertex - vertexData.begin());
edgeIter = edgeIter->getNextHalfEdge();
iterVertex = find(vertexData.begin(), vertexData.end(), *(edgeIter->getTarget()));
//LogManager::getSingleton().logMessage(" " + StringConverter::toString(iterVertex->getPosition().x) + "," + StringConverter::toString(iterVertex->getPosition().y) + "," + StringConverter::toString(iterVertex->getPosition().z));
indexData.push_back(iterVertex - vertexData.begin());
edgeIter = edgeIter->getNextHalfEdge();
iterVertex = find(vertexData.begin(), vertexData.end(), *(edgeIter->getTarget()));
//LogManager::getSingleton().logMessage(" " + StringConverter::toString(iterVertex->getPosition().x) + "," + StringConverter::toString(iterVertex->getPosition().y) + "," + StringConverter::toString(iterVertex->getPosition().z));
indexData.push_back(iterVertex - vertexData.begin());
//LogManager::getSingleton().logMessage("End Triangle");
}
}
bool SurfacePatch::canRemoveVertexFrom(SurfaceVertexIterator vertexIter, std::list<SurfaceVertexIterator> listConnectedIter, bool isEdge) bool SurfacePatch::canRemoveVertexFrom(SurfaceVertexIterator vertexIter, std::list<SurfaceVertexIterator> listConnectedIter, bool isEdge)
{ {
bool allXMatch = true; bool allXMatch = true;

234
source/SurfacePatchRenderable.cpp
View File

@ -1,159 +1,197 @@
#include "SurfacePatchRenderable.h" #include "SurfacePatchRenderable.h"
#include "SurfaceEdge.h"
#include "OgreVertexIndexData.h" #include "OgreVertexIndexData.h"
namespace Ogre namespace Ogre
{ {
SurfacePatchRenderable::SurfacePatchRenderable(const String& material) SurfacePatchRenderable::SurfacePatchRenderable(SurfacePatch& patchToRender, const String& material)
{ {
mRenderOp.vertexData = new VertexData(); mRenderOp.vertexData = new VertexData();
mRenderOp.indexData = new IndexData(); mRenderOp.indexData = new IndexData();
this->setMaterial(material); this->setMaterial(material);
setGeometry(patchToRender);
} }
SurfacePatchRenderable::~SurfacePatchRenderable(void) SurfacePatchRenderable::~SurfacePatchRenderable(void)
{ {
delete mRenderOp.vertexData; delete mRenderOp.vertexData;
delete mRenderOp.indexData; delete mRenderOp.indexData;
} }
void SurfacePatchRenderable::setGeometry(std::vector<SurfaceVertex> verticesToSet, std::vector<uint> indicesToSet) void SurfacePatchRenderable::updateWithNewSurfacePatch(SurfacePatch& patchToRender)
{
setGeometry(patchToRender);
}
void SurfacePatchRenderable::setGeometry(SurfacePatch& patchToRender)
{ {
//LogManager::getSingleton().logMessage("In setGeometry()"); //LogManager::getSingleton().logMessage("In setGeometry()");
// Initialization stuff //Initialization stuff
mRenderOp.vertexData->vertexCount = verticesToSet.size(); mRenderOp.vertexData->vertexCount = patchToRender.getNoOfVertices();
mRenderOp.vertexData->vertexStart = 0; mRenderOp.vertexData->vertexStart = 0;
mRenderOp.operationType = RenderOperation::OT_TRIANGLE_LIST; // OT_LINE_LIST, OT_LINE_STRIP mRenderOp.operationType = RenderOperation::OT_TRIANGLE_LIST; // OT_LINE_LIST, OT_LINE_STRIP
mRenderOp.useIndexes = true; mRenderOp.useIndexes = true;
mRenderOp.indexData->indexStart = 0; mRenderOp.indexData->indexStart = 0;
mRenderOp.indexData->indexCount = indicesToSet.size(); mRenderOp.indexData->indexCount = patchToRender.getNoOfTriangles() * 3;
//LogManager::getSingleton().logMessage("Finished initialisaing stuff"); //LogManager::getSingleton().logMessage("Finished initialisaing stuff");
VertexDeclaration *decl = mRenderOp.vertexData->vertexDeclaration; VertexDeclaration *decl = mRenderOp.vertexData->vertexDeclaration;
VertexBufferBinding *bind = mRenderOp.vertexData->vertexBufferBinding; VertexBufferBinding *bind = mRenderOp.vertexData->vertexBufferBinding;
//FIXME - this should be moved to constructor? //FIXME - this should be moved to constructor?
//LogManager::getSingleton().logMessage("Creating Vertex Declaration"); //LogManager::getSingleton().logMessage("Creating Vertex Declaration");
decl->removeAllElements(); decl->removeAllElements();
decl->addElement(0, 0, VET_FLOAT3, VES_POSITION); decl->addElement(0, 0, VET_FLOAT3, VES_POSITION);
decl->addElement(0, 3 * sizeof(float), VET_FLOAT3, VES_NORMAL); decl->addElement(0, 3 * sizeof(float), VET_FLOAT3, VES_NORMAL);
decl->addElement(0, 6 * sizeof(float), VET_FLOAT1, VES_TEXTURE_COORDINATES); decl->addElement(0, 6 * sizeof(float), VET_FLOAT1, VES_TEXTURE_COORDINATES);
//LogManager::getSingleton().logMessage("Creating Vertex Buffer"); //LogManager::getSingleton().logMessage("Creating Vertex Buffer");
HardwareVertexBufferSharedPtr vbuf = HardwareVertexBufferSharedPtr vbuf =
HardwareBufferManager::getSingleton().createVertexBuffer( HardwareBufferManager::getSingleton().createVertexBuffer(
decl->getVertexSize(0), decl->getVertexSize(0),
mRenderOp.vertexData->vertexCount, mRenderOp.vertexData->vertexCount,
HardwareBuffer::HBU_STATIC_WRITE_ONLY); HardwareBuffer::HBU_STATIC_WRITE_ONLY);
bind->setBinding(0, vbuf); bind->setBinding(0, vbuf);
//LogManager::getSingleton().logMessage("Creating Index Buffer"); //LogManager::getSingleton().logMessage("Creating Index Buffer");
HardwareIndexBufferSharedPtr ibuf = HardwareIndexBufferSharedPtr ibuf =
HardwareBufferManager::getSingleton().createIndexBuffer( HardwareBufferManager::getSingleton().createIndexBuffer(
HardwareIndexBuffer::IT_16BIT, // type of index HardwareIndexBuffer::IT_16BIT, // type of index
mRenderOp.indexData->indexCount, // number of indexes mRenderOp.indexData->indexCount, // number of indexes
HardwareBuffer::HBU_STATIC_WRITE_ONLY, // usage HardwareBuffer::HBU_STATIC_WRITE_ONLY, // usage
false); // no shadow buffer false); // no shadow buffer
mRenderOp.indexData->indexBuffer = ibuf; mRenderOp.indexData->indexBuffer = ibuf;
// Drawing stuff
//int size = verticesToSet.size();
Vector3 vaabMin;
Vector3 vaabMax;
vaabMin.x = patchToRender.getVerticesBegin()->getPosition().x/2.0f;
vaabMin.y = patchToRender.getVerticesBegin()->getPosition().y/2.0f;
vaabMin.z = patchToRender.getVerticesBegin()->getPosition().z/2.0f;
vaabMax.x = patchToRender.getVerticesBegin()->getPosition().x/2.0f;
vaabMax.y = patchToRender.getVerticesBegin()->getPosition().y/2.0f;
vaabMax.z = patchToRender.getVerticesBegin()->getPosition().z/2.0f;
// Drawing stuff //LogManager::getSingleton().logMessage("Setting Vertex Data of size " + StringConverter::toString(size));
int size = verticesToSet.size();
Vector3 vaabMin;
Vector3 vaabMax;
vaabMin.x = verticesToSet[0].getPosition().x/2.0f;
vaabMin.y = verticesToSet[0].getPosition().y/2.0f;
vaabMin.z = verticesToSet[0].getPosition().z/2.0f;
vaabMax.x = verticesToSet[0].getPosition().x/2.0f;
vaabMax.y = verticesToSet[0].getPosition().y/2.0f;
vaabMax.z = verticesToSet[0].getPosition().z/2.0f;
//LogManager::getSingleton().logMessage("Setting Vertex Data of size " + StringConverter::toString(size)); Real *prPos = static_cast<Real*>(vbuf->lock(HardwareBuffer::HBL_DISCARD));
Real *prPos = static_cast<Real*>(vbuf->lock(HardwareBuffer::HBL_DISCARD)); //for(int i = 0; i < size; i++)
for(SurfaceVertexConstIterator vertexIter = patchToRender.getVerticesBegin(); vertexIter != patchToRender.getVerticesEnd(); ++vertexIter)
{
*prPos++ = vertexIter->getPosition().x/2.0f;
*prPos++ = vertexIter->getPosition().y/2.0f;
*prPos++ = vertexIter->getPosition().z/2.0f;
for(int i = 0; i < size; i++) *prPos++ = vertexIter->getNormal().x;
{ *prPos++ = vertexIter->getNormal().y;
*prPos++ = verticesToSet[i].getPosition().x/2.0f; *prPos++ = vertexIter->getNormal().z;
*prPos++ = verticesToSet[i].getPosition().y/2.0f;
*prPos++ = verticesToSet[i].getPosition().z/2.0f;
*prPos++ = verticesToSet[i].getNormal().x; *prPos++ = vertexIter->getAlpha();
*prPos++ = verticesToSet[i].getNormal().y;
*prPos++ = verticesToSet[i].getNormal().z;
*prPos++ = verticesToSet[i].getAlpha(); if(vertexIter->getPosition().x < vaabMin.x)
vaabMin.x = vertexIter->getPosition().x;
if(vertexIter->getPosition().y < vaabMin.y)
vaabMin.y = vertexIter->getPosition().y;
if(vertexIter->getPosition().z < vaabMin.z)
vaabMin.z = vertexIter->getPosition().z;
if(verticesToSet[i].getPosition().x < vaabMin.x) if(vertexIter->getPosition().x > vaabMax.x)
vaabMin.x = verticesToSet[i].getPosition().x; vaabMax.x = vertexIter->getPosition().x;
if(verticesToSet[i].getPosition().y < vaabMin.y) if(vertexIter->getPosition().y > vaabMax.y)
vaabMin.y = verticesToSet[i].getPosition().y; vaabMax.y = vertexIter->getPosition().y;
if(verticesToSet[i].getPosition().z < vaabMin.z) if(vertexIter->getPosition().z > vaabMax.z)
vaabMin.z = verticesToSet[i].getPosition().z; vaabMax.z = vertexIter->getPosition().z;
}
if(verticesToSet[i].getPosition().x > vaabMax.x) vbuf->unlock();
vaabMax.x = verticesToSet[i].getPosition().x;
if(verticesToSet[i].getPosition().y > vaabMax.y)
vaabMax.y = verticesToSet[i].getPosition().y;
if(verticesToSet[i].getPosition().z > vaabMax.z)
vaabMax.z = verticesToSet[i].getPosition().z;
}
vbuf->unlock(); vaabMin /= 2.0f;
vaabMax /= 2.0f;
vaabMin /= 2.0f; mBox.setExtents(vaabMin, vaabMax);
vaabMax /= 2.0f;
mBox.setExtents(vaabMin, vaabMax); /*std::vector<SurfaceVertex> verticesToSet;
std::vector<uint> indicesToSet;
patchToRender.getVertexAndIndexData(verticesToSet, indicesToSet);*/
unsigned short* pIdx = static_cast<unsigned short*>(ibuf->lock(HardwareBuffer::HBL_DISCARD)); unsigned short* pIdx = static_cast<unsigned short*>(ibuf->lock(HardwareBuffer::HBL_DISCARD));
for(int i = 0; i < indicesToSet.size(); i++) /*for(int i = 0; i < indicesToSet.size(); i++)
{ {
*pIdx = indicesToSet[i]; *pIdx = indicesToSet[i];
pIdx++; LogManager::getSingleton().logMessage("Correct pIdx = " + StringConverter::toString(*pIdx));
/**pIdx = indicesToSet[i].v1; pIdx++;
pIdx++; }*/
*pIdx = indicesToSet[i].v2;
pIdx++;*/ std::vector<SurfaceVertex> vertexData;
} vertexData.resize(patchToRender.getNoOfVertices());
ibuf->unlock(); std::copy(patchToRender.getVerticesBegin(), patchToRender.getVerticesEnd(), vertexData.begin());
for(SurfaceTriangleConstIterator iterTriangles = patchToRender.getTrianglesBegin(); iterTriangles != patchToRender.getTrianglesEnd(); ++iterTriangles)
{
std::vector<SurfaceVertex>::iterator iterVertex;
SurfaceEdgeIterator edgeIter;
edgeIter = iterTriangles->getEdge();
iterVertex = find(vertexData.begin(), vertexData.end(), *(edgeIter->getTarget()));
*pIdx = (iterVertex - vertexData.begin());
//LogManager::getSingleton().logMessage("Wrong pIdx = " + StringConverter::toString(*pIdx));
pIdx++;
edgeIter = edgeIter->getNextHalfEdge();
iterVertex = find(vertexData.begin(), vertexData.end(), *(edgeIter->getTarget()));
*pIdx = (iterVertex - vertexData.begin());
//LogManager::getSingleton().logMessage("Wrong pIdx = " + StringConverter::toString(*pIdx));
pIdx++;
edgeIter = edgeIter->getNextHalfEdge();
iterVertex = find(vertexData.begin(), vertexData.end(), *(edgeIter->getTarget()));
*pIdx = (iterVertex - vertexData.begin());
//LogManager::getSingleton().logMessage("Wrong pIdx = " + StringConverter::toString(*pIdx));
pIdx++;
}
ibuf->unlock();
} }
Real SurfacePatchRenderable::getSquaredViewDepth(const Camera *cam) const Real SurfacePatchRenderable::getSquaredViewDepth(const Camera *cam) const
{ {
Vector3 vMin, vMax, vMid, vDist; Vector3 vMin, vMax, vMid, vDist;
vMin = mBox.getMinimum(); vMin = mBox.getMinimum();
vMax = mBox.getMaximum(); vMax = mBox.getMaximum();
vMid = ((vMin - vMax) * 0.5) + vMin; vMid = ((vMin - vMax) * 0.5) + vMin;
vDist = cam->getDerivedPosition() - vMid; vDist = cam->getDerivedPosition() - vMid;
return vDist.squaredLength(); return vDist.squaredLength();
} }
Real SurfacePatchRenderable::getBoundingRadius(void) const Real SurfacePatchRenderable::getBoundingRadius(void) const
{ {
return Math::Sqrt((std::max)(mBox.getMaximum().squaredLength(), mBox.getMinimum().squaredLength())); return Math::Sqrt((std::max)(mBox.getMaximum().squaredLength(), mBox.getMinimum().squaredLength()));
//return mRadius; //return mRadius;
} }
/* /*
void Line3D::getWorldTransforms(Matrix4 *xform) const void Line3D::getWorldTransforms(Matrix4 *xform) const
{ {
// return identity matrix to prevent parent transforms // return identity matrix to prevent parent transforms
*xform = Matrix4::IDENTITY; *xform = Matrix4::IDENTITY;
} }
*/ */
const Quaternion &SurfacePatchRenderable::getWorldOrientation(void) const const Quaternion &SurfacePatchRenderable::getWorldOrientation(void) const
{ {
return Quaternion::IDENTITY; return Quaternion::IDENTITY;
} }
const Vector3 &SurfacePatchRenderable::getWorldPosition(void) const const Vector3 &SurfacePatchRenderable::getWorldPosition(void) const
{ {
return Vector3::ZERO; return Vector3::ZERO;
} }
} }