OgreEdgeListBuilder.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.
-----------------------------------------------------------------------------
*/
#ifndef __EdgeListBuilder_H__
#define __EdgeListBuilder_H__

#include "OgrePrerequisites.h"
#include "OgreVector4.h"
#include "OgreHardwareVertexBuffer.h"
#include "OgreRenderOperation.h"

namespace Ogre {


    class _OgreExport EdgeData
    {
    public:
        struct Triangle {
            size_t indexSet; 
            size_t vertexSet;
            size_t vertIndex[3];
            size_t sharedVertIndex[3]; 
                                        // duplicates eliminated (this buffer is not exposed)
            Vector4 normal;   // unit vector othogonal to this face, plus distance from origin
            bool lightFacing; // Working vector used when calculating the silhouette
        };
        struct Edge {
            size_t triIndex[2];
            size_t vertIndex[2];
            size_t sharedVertIndex[2];
            bool degenerate;
        };

        typedef std::vector<Triangle> TriangleList;
        typedef std::vector<Edge> EdgeList;

        struct EdgeGroup
        {
            size_t vertexSet;
            const VertexData* vertexData;
            EdgeList edges;

        };

        typedef std::vector<EdgeGroup> EdgeGroupList;
        TriangleList triangles;
        EdgeGroupList edgeGroups;
        // manifold? NB This value is not stored in the  binary Mesh format yet so
        // cannot be relied upon unless this has been calculated interactively.
        //bool isClosed; // manifold?


        void updateTriangleLightFacing(const Vector4& lightPos);
        void updateFaceNormals(size_t vertexSet, HardwareVertexBufferSharedPtr positionBuffer);



        // Debugging method
        void log(Log* log);
        
    };

    class _OgreExport EdgeListBuilder 
    {
    public:

        EdgeListBuilder();
        virtual ~EdgeListBuilder();
        void addVertexData(const VertexData* vertexData);
        void addIndexData(const IndexData* indexData, size_t vertexSet = 0, 
            RenderOperation::OperationType opType = RenderOperation::OT_TRIANGLE_LIST);

        EdgeData* build(void);

        void log(Log* l);
    protected:

        struct CommonVertex {
            Vector3  position;  // location of point in euclidean space
            size_t index;       // place of vertex in common vertex list
            size_t vertexSet;   // The vertex set this came from
            size_t indexSet;    // The index set this was referenced (first) from
            size_t originalIndex; // place of vertex in original vertex set
        };
        struct Geometry {
            size_t vertexSet;           // The vertex data set this geometry data refers to
            size_t indexSet;            // The index data set this geometry data refers to
            const IndexData* indexData; // The index information which describes the triangles.
            RenderOperation::OperationType opType;  // The operation type used to render this geometry
        };
        struct geometryLess {
            bool operator()(const Geometry& a, const Geometry& b) const
            {
                if (a.vertexSet < b.vertexSet) return true;
                if (a.vertexSet > b.vertexSet) return false;
                return a.indexSet < b.indexSet;
            }
        };
        struct vectorLess {
            bool operator()(const Vector3& a, const Vector3& b) const
            {
                if (a.x < b.x) return true;
                if (a.x > b.x) return false;
                if (a.y < b.y) return true;
                if (a.y > b.y) return false;
                return a.z < b.z;
            }
        };

        typedef std::vector<const VertexData*> VertexDataList;
        typedef std::vector<Geometry> GeometryList;
        typedef std::vector<CommonVertex> CommonVertexList;

        GeometryList mGeometryList;
        VertexDataList mVertexDataList;
        CommonVertexList mVertices;
        EdgeData* mEdgeData;
        typedef std::map<Vector3, size_t, vectorLess> CommonVertexMap;
        CommonVertexMap mCommonVertexMap;
        typedef std::multimap< std::pair<size_t, size_t>, std::pair<size_t, size_t> > EdgeMap;
        EdgeMap mEdgeMap;

        void buildTrianglesEdges(const Geometry &geometry);

        size_t findOrCreateCommonVertex(const Vector3& vec, size_t vertexSet, 
            size_t indexSet, size_t originalIndex);
        void connectOrCreateEdge(size_t vertexSet, size_t triangleIndex, size_t vertIndex0, size_t vertIndex1, 
            size_t sharedVertIndex0, size_t sharedVertIndex1);
    };

}
#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Feb 12 12:59:44 2006