eng_world.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) 2004 JIM E. BROOKS
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 *****************************************************************************/

#ifndef ENG_WORLD_HH
#define ENG_WORLD_HH 1

namespace eng {

class Object;
#define QuadrantPtr SafePtr<World::Quadrant>

// Symbolic names for world axises (N/A to matrix axises).
// World axises vs. eye matrix axises:
// In terms of depth, Z defines depth in both world and eye space.
// But in terms of altitude (up/down), Y is up/down in eye space
// while Z is up/down in world space.
enum { AXIS_LAT = AXIS_X, LAT = AXIS_LAT,    // latitude
       AXIS_LON = AXIS_Y, LON = AXIS_LON,    // longitude
       AXIS_ALT = AXIS_Z, ALT = AXIS_ALT };  // altitude
#define AXIS_LAT_ x
#define AXIS_LON_ y
#define AXIS_ALT_ z
#define LAT_ AXIS_LAT_
#define LON_ AXIS_LON_
#define ALT_ AXIS_ALT_

// Macro for constructing a Vector3 independent of definition of axises.
// (For future, this may help to facilitate changing order of axises.)
// WorldVertex pos( LAT_LON_ALT( lat, lon, alt ) );
#define LAT_LON_ALT( LAT, LON, ALT )  (LAT), (LON), (ALT)

class World : public Threadable
{

protected:
class Quadrant;
class Locus;
friend class Locus;
friend class Quadrant;
friend void ThreadQuadrantPopulate( long quadrant );

// Macro also used by friend classes.
#define WORLD_AUTO_LOCK() THREAD_CODE( AutoLock<SlowLock> lock( &gWorld.mLock ); )
#define LOCUS_AUTO_LOCK() THREAD_CODE( AutoLock<SlowLock> lock( &mLock ); )
#define ASSERT_WORLD() 

public:
    FN_MAIN_THREAD virtual void Make( void ) = 0;
    FN_REENTRANT virtual bool   IfMade( void ) = 0;  
    FN_REENTRANT eAttached      Attach( SharedPtr<Object> object );
    FN_REENTRANT eAttached      Detach( SharedPtr<Object> object );
    FN_REENTRANT WorldVertex    CorrectPosition( const WorldVertex& pos );
    FN_MAIN_THREAD void         Draw( void );
    FN_REENTRANT void           EyePositionChanged( void );  // Locus might need updating
    FN_REENTRANT uint           GetObjectCnt( void );
    FN_REENTRANT const BoxVolume& GetBoxVolume( void ) { ASSERT(IfMade()); return mBoxVolume; }
    FN_REENTRANT fp             GetLatWidth( void ) { ASSERT(IfMade()); return mBoxVolume.mMax.LAT_ - mBoxVolume.mMin.LAT_; }
    FN_REENTRANT fp             GetLonWidth( void ) { ASSERT(IfMade()); return mBoxVolume.mMax.LON_ - mBoxVolume.mMin.LON_; }
    FN_REENTRANT fp             GetAltWidth( void ) { ASSERT(IfMade()); return mBoxVolume.mMax.ALT_ - mBoxVolume.mMin.ALT_; }
    FN_REENTRANT WorldVertex    GetCenter( void );

    // Locus:
    FN_REENTRANT fp             GetLocusEdge( uint dim );
    FN_LOCKED uint              GetLocusObjectCnt( void );

    // Quadrant (limited exposure):
    FN_REENTRANT fp             GetQuadrantEdge( void ) { ASSERT(IfMade()); return mQuadrantEdge; }
    FN_REENTRANT uint           GetQuadrantDim( uint dim ) { ASSERT(IfMade()); return mQuadrantDim[dim]; }

#if DEBUG
    void                Check( void );
#endif

protected:
    typedef uint Qidx;  
    enum eSim { eSim_FLIGHT, eSim_SPACE };
    enum eOutsidePolicy { eOutsidePolicy_CLAMP, eOutsidePolicy_WRAP };

protected:
                                World( void ) { }  // Make() substitutes for ctor
    virtual                     ~World() { }
    void                        Make( const eSim sim, const Int3& quadrantDim, const fp quadrantEdge, const Int3& locusDim );
    FN_LOCKED virtual void      Populate( QuadrantPtr quadrant ) = 0;  // part of Template Method
    FN_LOCKED QuadrantPtr       GetQuadrant( const Int3& triplet );
    FN_REENTRANT QuadrantPtr    GetQuadrant( const WorldVertex& pos );
    FN_REENTRANT Qidx           GetQuadrantIdx( const Int3& triplet );
    FN_REENTRANT Qidx           GetQuadrantIdx( const WorldVertex& pos );
    FN_REENTRANT Int3           GetQuadrantTriplet( const WorldVertex& pos );
    FN_REENTRANT Int3           WrapQuadrantTriplet( const Int3& triplet );
    FN_MAIN_THREAD void         DeleteQuadrant( QuadrantPtr quadrant );
    FN_REENTRANT WorldVertex    CorrectPositionClamp( const WorldVertex& pos );
    FN_REENTRANT WorldVertex    CorrectPositionWrap( const WorldVertex& pos );

// Quadrant:
protected:
    class Quadrant : public Threadable
    {
    
    friend void ThreadQuadrantPopulate( long quadrant );
    public:
        enum eState { EMPTY, SHRUNK, POPULATING, POPULATED };
                    Quadrant( const Int3& triplet, const fp edge, const uint seed );
                    ~Quadrant();
        FN_LOCKED void          Populate( void );
        FN_LOCKED uint          Shrink( void );
        FN_LOCKED eAttached     Attach( SharedPtr<Object> object );
        FN_LOCKED eAttached     Detach( SharedPtr<Object> object );
        FN_REENTRANT void       Draw( void );
        FN_LOCKED const BoxVolume& GetBoxVolume( void );
        FN_LOCKED WorldVertex   GetCenter( void );
        FN_LOCKED Int3          GetTriplet( void );
        FN_REENTRANT eState     GetState( void );
        FN_LOCKED void          SetState( eState state );
        FN_LOCKED uint          GetSeed( void );
        FN_REENTRANT uint       GetObjectCnt( void );  // NOTE: shrunk Objects are counted

    private:
        BoxVolume   ComputeBoxVolume( const Int3& triplet, const fp edge );
        class ShrinkEachObjectFunctor : public BSP::ForEachObjectFunctor
        {
        public:
            ShrinkEachObjectFunctor( void ) : mObjectCnt(0) { }
            void operator()( SharedPtr<Object> object );
            uint mObjectCnt;  // count of objects that were shrunk
        };

    public:
        SlowLock        mLock;          
    private:
        Int3            mTriplet;       
        eState          mState;         
        uint            mSeed;          
        BSP             mBSP;           
        int             mObjectCnt;     
        CLASS_VAR fp    msEdge;         
    public:
        
    };

// Locus:
protected:
    class Locus
    {
    
    public:
        typedef World::Qidx Qidx;
        typedef vector<QuadrantPtr> PopulateQueue;
                                Locus( void );  // Init() is actual ctor
                                ~Locus();
        FN_MAIN_THREAD void     Init( const Int3& dim );
        FN_MAIN_THREAD void     Update( void );
        FN_MAIN_THREAD void     Draw( void );
        FN_LOCKED uint          GetObjectCnt( void );

    private:
        FN_MAIN_THREAD void     Move( QuadrantPtr centerQuadrant );
        FN_MAIN_THREAD uint     MakeQuadrant( const Int3 t, vector<PopulateQueue*>& populateQueues, uint populateQueueIdx );
        FN_MAIN_THREAD void     DestroyZombieQuadrants( void );
        FN_MAIN_THREAD bool     ShrinkQuadrant( QuadrantPtr quadrant );
#if DEBUG
        FN_LOCKED QuadrantPtr   GetCenterQuadrant( void );
        FN_LOCKED World::Qidx   GetQuadrantIdx( const Int3& triplet );
#endif

    private:
        class LocusIdleFunctor : public Event<>::ListenerFunctor
        {
        public:
            LocusIdleFunctor( Locus& locus ) : mLocus(locus) { }
            void operator()( Void nothing );
            Locus& mLocus;
        };
        friend class LocusIdleFunctor;

    private:
        typedef vector<Qidx> QuadrantContainer;  // flat idx to World::mQuadrants[]
        typedef QuadrantContainer::iterator QuadrantIterator;

        SlowLock            mLock;
        QuadrantContainer   mQuadrants;
        Int3                mDim;                   // locus <= world
        Int3                mDimHalf;               // pre-computed by constructor
        Int3                mCenterTriplet;         // pre-computed by constructor, center's triplet is constant
        Int3                mPrevQuadrantTriplet;   // singular, N/A if mPrevQuadrants empty
        QuadrantContainer   mPrevQuadrants;         // plural
        set<Qidx>           mZombieQuadrants;       // flat idx to World::mQuadrants[]
    };

private:
    struct QuadrantSeed
    {
        QuadrantSeed( Quadrant* q, uint seed ) : mQuadrant(q), mSeed(seed) { }
        Quadrant*   mQuadrant;
        uint        mSeed;
    };

// World data:
protected:
    SlowLock                mLock;
    eSim                    mSim;               
    eOutsidePolicy          mOutsidePolicy;     
    BoxVolume               mBoxVolume;         
    fp                      mQuadrantEdge;      
    Int3                    mQuadrantDim;       
    Int3                    mLocusDim;          
    vector<QuadrantSeed>    mQuadrants;         
    Locus                   mLocus;             
    fp                      mMargin;            
};

} // namespace eng

#endif // ENG_WORLD_HH

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:10 2007