OgreProgressiveMesh.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
// The underlying algorithms in this class are based heavily on:
/*
 *  Progressive Mesh type Polygon Reduction Algorithm
 *  by Stan Melax (c) 1998
 */

#ifndef __ProgressiveMesh_H_
#define __ProgressiveMesh_H_

#include "OgrePrerequisites.h"
#include "OgreVector3.h"
#include "OgreHardwareVertexBuffer.h"
#include "OgreHardwareIndexBuffer.h"
#include "OgreRenderOperation.h"

namespace Ogre {

    class _OgreExport ProgressiveMesh
    {
    public:

        enum VertexReductionQuota
        {
            VRQ_CONSTANT,
            VRQ_PROPORTIONAL
        };

        typedef std::vector<IndexData*> LODFaceList;

        ProgressiveMesh(const VertexData* vertexData, const IndexData* indexData);
        virtual ~ProgressiveMesh();

        virtual void addExtraVertexPositionBuffer(const VertexData* vertexData);

        virtual void build(ushort numLevels, LODFaceList* outList, 
            VertexReductionQuota quota = VRQ_PROPORTIONAL, Real reductionValue = 0.5f );

    protected:
        const VertexData *mpVertexData;
        const IndexData *mpIndexData;

        size_t mCurrNumIndexes;
        size_t mNumCommonVertices;

        // Internal classes
        class PMTriangle;
        class PMVertex;

        public: // VC6 hack

        class _OgrePrivate PMFaceVertex {
        public:
            size_t realIndex;
            PMVertex* commonVertex;
        };

        protected:

        class _OgrePrivate PMTriangle {
        public:
            PMTriangle();
            void setDetails(size_t index, PMFaceVertex *v0, PMFaceVertex *v1, PMFaceVertex *v2);
            void computeNormal(void);
            void replaceVertex(PMFaceVertex *vold, PMFaceVertex *vnew);
            bool hasCommonVertex(PMVertex *v) const;
            bool hasFaceVertex(PMFaceVertex *v) const;
            PMFaceVertex* getFaceVertexFromCommon(PMVertex* commonVert);
            void notifyRemoved(void);

            PMFaceVertex* vertex[3]; // the 3 points that make this tri
            Vector3   normal;    // unit vector othogonal to this face
            bool      removed;   // true if this tri is now removed
            size_t index;
        };

        class _OgrePrivate PMVertex {
        public:
            PMVertex();
            void setDetails(const Vector3& v, size_t index);
            void removeIfNonNeighbor(PMVertex *n);
            bool isBorder(void);
            bool isManifoldEdgeWith(PMVertex* v); // is edge this->src a manifold edge?
            void notifyRemoved(void);

            Vector3  position;  // location of point in euclidean space
            size_t index;       // place of vertex in original list
            typedef std::set<PMVertex *> NeighborList;
            typedef std::set<PMVertex *> DuplicateList;
            NeighborList neighbor; // adjacent vertices
            typedef std::set<PMTriangle *> FaceList;
            FaceList face;     // adjacent triangles

            Real collapseCost;  // cached cost of collapsing edge
            PMVertex * collapseTo; // candidate vertex for collapse
            bool      removed;   // true if this vert is now removed
            bool      toBeRemoved; // denug

            bool seam;  

        };

        typedef std::vector<PMTriangle> TriangleList;
        typedef std::vector<PMFaceVertex> FaceVertexList;
        typedef std::vector<PMVertex> CommonVertexList;
        typedef std::vector<Real> WorstCostList;

        struct PMWorkingData
        {
            TriangleList mTriList; 
            FaceVertexList mFaceVertList; // The vertex details referenced by the triangles
            CommonVertexList mVertList; // The master list of common vertices
        };

        typedef std::vector<PMWorkingData> WorkingDataList;
        WorkingDataList mWorkingData;

        WorstCostList mWorstCosts;

        void addWorkingData(const VertexData* vertexData, const IndexData* indexData);

        void initialiseEdgeCollapseCosts(void);
        Real computeEdgeCollapseCost(PMVertex *src, PMVertex *dest);
        Real computeEdgeCostAtVertexForBuffer(WorkingDataList::iterator idata, size_t vertIndex);
        void computeEdgeCostAtVertex(size_t vertIndex);
        void computeAllCosts(void);
        size_t getNextCollapser(void);
        void bakeNewLOD(IndexData* pData);

        void collapse(PMVertex *collapser);

        void dumpContents(const String& log);









    };



}

#endif 

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:47 2006