genericobject.h

/*--License:
        Lilith 3D Engine
        Copyright Lee Thomason (Grinning Lizard Software) 2002-2007
        www.grinninglizard.com/lilith

        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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

        The full text of the license can be found in license.txt
*/

#ifndef LILITH_OBJECT_INCLUDED
#define LILITH_OBJECT_INCLUDED

#include <string>
#include <list>

#include "../grinliz/glvector.h"

namespace lilith3d
{
class TerrainMesh;
class Mesh;
struct PathSurfaceInstance;
class BuildingMesh;
class WalkingMob;

enum
{
        TEST_TERRAIN    = 0x01,
        TEST_PSI                = 0x02,                 
        TEST_MESH               = 0x04,                 // test for mesh (that are not trees)
        TEST_TREE               = 0x08,                 // test for trees
        TEST_ALL = TEST_TERRAIN | TEST_PSI | TEST_MESH | TEST_TREE
};

class LilithObject
{
  public:
        LilithObject();
        LilithObject( TerrainMesh* tmesh, const grinliz::Vector3F& intersect, float distance );
        LilithObject( Mesh* mesh, const grinliz::Vector3F& intersect, float distance );
        LilithObject( PathSurfaceInstance* psi, const grinliz::Vector3F& intersect, float distance );

        grinliz::Vector3F Intersection() const  { return intersect; }
        float X() const { return intersect.x; }
        float Y() const { return intersect.y; }
        float Z() const { return intersect.z; }

        const std::string& Description() const  { return desc; }
        
        TerrainMesh* ToTerrain() const                          { return tmesh; }
        Mesh* ToMesh() const                                            { return mesh; }
        PathSurfaceInstance* ToPSI() const      { return psi; }

        float Distance() const                                          { return distance; }

        friend bool operator<( const LilithObject& lhs, const LilithObject& rhs )       { return lhs.distance < rhs.distance; }

  private:
        void Clear();

        float distance;
        grinliz::Vector3F intersect;

        TerrainMesh* tmesh;
        Mesh* mesh;
        PathSurfaceInstance* psi;
        std::string desc;
};

class LilithObjectFar : public std::unary_function< LilithObject, bool> 
{
  public:
        const float d;
        LilithObjectFar( float _d )     : d( _d ) {}
        bool operator()(const LilithObject& a) const { return a.Distance() >= d; }

private:
        void operator=(const LilithObjectFar& );        // private and undefined
};

typedef std::list< LilithObject > LilithObjectList;
typedef LilithObjectList::iterator LilithObjectListIterator;

struct PSIMobRing
{
        PSIMobRing() {
                next = this; 
                prev = this;
                psi = 0; 
                mob = 0; 
        }
        ~PSIMobRing() { 
                Unlink(); 
                #if defined( _MSC_VER ) && defined( DEBUG )
                GLASSERT( _CrtCheckMemory() );
                #endif
        }

        PathSurfaceInstance* psi;
        WalkingMob* mob;

        PSIMobRing* Next() { return next; }

        bool IsLinked() {
                if ( next == this ) {
                        GLASSERT( prev == this );
                        return false;
                }
                return true;
        }
        /*
        void Validate() {
                #ifdef DEBUG
                int count = 0;
                for( PSIMobRing* node = this->next; node != this; node=node->next ) {
                        GLASSERT( psi || mob );
                        GLASSERT( !(psi && mob) );
                        ++count;
                }
                for( PSIMobRing* node = this->prev; node != this; node=node->prev ) {
                        GLASSERT( psi || mob );
                        GLASSERT( !(psi && mob) );
                        --count;
                }
                GLASSERT( count == 0 );
                #endif
        }
        */

        void Unlink() {
                /*
                #ifdef DEBUG
                Validate();
                GLASSERT( !(this->psi && this->mob ) );
                GLOUTPUT(( "unlink %x : ", this ));
                PSIMobRing* start = next;
                #endif
                */
                
                next->prev = prev;
                prev->next = next;
                next = prev = this;

                /*
                #ifdef DEBUG
                PSIMobRing* node = start; 
                do {
                        GLOUTPUT(( "%x ", node ));
                        node = node->next;
                } while ( node != start );
                GLOUTPUT(( "\n" ));
                #endif
                */
        }

        void Link( PSIMobRing* addMe )
        {
                GLASSERT( !addMe->psi && addMe->mob );
                GLASSERT( this->psi && !this->mob );

                addMe->next = next;
                addMe->prev = this;

                next->prev = addMe;
                next = addMe;
                /*
                #ifdef DEBUG
                GLOUTPUT(( "link %x add=%x : %x ", this, addMe, this ));
                for( PSIMobRing* node = this->next; node != this; node=node->next ) {
                        GLOUTPUT(( "%x ", node ));
                }
                GLOUTPUT(( "\n" ));

                this->Validate();
                addMe->Validate();
                #endif
                */
        }

        static PathSurfaceInstance* FindPSI( PSIMobRing* ring )
        {
                //ring->Validate();
                GLASSERT( !(ring->psi && ring->mob ) );
                if ( ring->psi )
                        return ring->psi;

                for( PSIMobRing* node = ring->next; node != ring; node=node->next )
                {
                        GLASSERT( !(node->psi && node->mob ) );
                        if ( node->psi )
                                return node->psi;
                }
                return 0;
        }

private:
        PSIMobRing* next;
        PSIMobRing* prev;
};

};      // namespace lilith3d
#endif

---