eng_class.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).
 *****************************************************************************/

// REMINDER: Must lock Engine methods.

#ifndef ENG_CLASS_HH
#define ENG_CLASS_HH 1

namespace eng {

class Engine : public Threadable
{


// Related classes such as Eye can obtain Engine's lock.
#if COMPILE_THREADS
#define ENGINE_AUTO_LOCK() THREAD_CODE( AutoLock<SlowLock> lock( &Engine::mLock ); )
#else
#define ENGINE_AUTO_LOCK()
#endif

//------------------------------------------------------------------------------
// Initialization and destruction:
//------------------------------------------------------------------------------

// Methods:
public:                     Engine( void );
public:                     ~Engine();
public:  void               Init( int argc, char** argv, const string& programName );
public:  void               Start( void );
public:  bool               IfReady( void ) { return mReady; }
public:  void               SpawnZombie( SharedPtr<Object> obj );

private: void               InitPreCmdarg( void );
private: void               InitCmdarg( int argc, char** argv );
private: void               InitPostCmdarg( void );
private: void               SelfCheck( void );
private: CLASS_METHOD void  AtExit( void );
private: void               KillZombies( void );

// Data:
private: bool           mReady;

//------------------------------------------------------------------------------
// Events:
//------------------------------------------------------------------------------

// Data:
public:  Events         mEvents;

//------------------------------------------------------------------------------
// Drawing:
//------------------------------------------------------------------------------

// Methods:
private: void           Draw( void );
public:  bool           IfDrawing( void ) { return mDrawing; }
public:  enum eDrawMode { eDrawMode_NORMAL, eDrawMode_FAST };
public:  void           SetDrawMode( const eDrawMode drawMode ) { ENGINE_AUTO_LOCK(); mDrawMode = drawMode; }
public:  eDrawMode      GetDrawMode( void ) { return mDrawMode; }
public:  bool           IfDrawModeFast( void ) { return mDrawMode == eDrawMode_FAST; }
public:  uint           GetFPS( void );
#if DEBUG
// SetPolygonMode() affects VisitorDraw (not GFX).
public:  GFX::ePolygonMode GetPolygonMode( void );
public:  void              SetPolygonMode( const GFX::ePolygonMode polygonMode );
// For debugging normal vectors.
public:  void              SetDrawNormalVectors( bool f, fp scale );
public:  bool              IfDrawNormalVectors( void ) { return mDrawNormalVectors; }
#endif

// Data:
private: bool              mDrawing;        
private: eDrawMode         mDrawMode;       
#if DEBUG
private: bool              mDrawNormalVectors;
#endif

//------------------------------------------------------------------------------
// View/Eye:
//------------------------------------------------------------------------------

// View methods:
public:  void           SetView( SharedPtr<View> view );
public:  shptr<View>    GetView( void )  
                        {
                        ENGINE_AUTO_LOCK();
                            return mCurrentView;
                        }
public:  SharedPtr<View>    GetMainView( void )
                        {
                        ENGINE_AUTO_LOCK();
                        ASSERT( not mViews.empty() );
                            return mViews.begin()->second;
                        }
public:  void           AddView( SharedPtr<View> view, int viewNum );
public:  void           WindowReshape( WidthHeight<int> wh );

public: 
    // Alternate name: IfInsideViewFrustum()
    bool IfVisibleWorldBoxVolume( const BoxVolume& worldBoxVolume )
    {
    ENGINE_AUTO_LOCK();
        // Transform box's midpoint from World Space to Eye Space.
        // BoxVolume::GetPosition() returns center/midpoint.
        const EyeVertex ev = GetEyeMatrix()->TranslateRotate<EyeVertex,Vector3>( worldBoxVolume.GetPosition() );
        return GFX::IfVisibleSphere( ev, worldBoxVolume.GetRadius() );
    }

// Eye methods:
public:  SharedPtr<const Matrix>    GetEyeMatrix( void )
                                {
                                ENGINE_AUTO_LOCK();
                                    return GetView()->mEye.GetMatrix();
                                }
public:  void                   SetEyeMatrix( const Matrix& matrix )
                                {
                                ENGINE_AUTO_LOCK();
                                    GetView()->mEye.SetMatrix( matrix );
                                }
public:  WorldVertex            GetEyePosition( void )
                                {
                                ENGINE_AUTO_LOCK();
                                    return GetView()->mEye.GetPosition();
                                }
public:  void                   SetEyePosition( const WorldVertex& pos )
                                {
                                ENGINE_AUTO_LOCK();
                                    GetView()->mEye.SetPosition( pos );
                                }

struct DrawStats
{
    void Reset( void )
    {
    ENGINE_AUTO_LOCK();
        mObjectCntDrawn = mObjectCntCulledBSP = mObjectCntCulledGraph = 0;
    }

    uint GetObjectCntCulled( void )
    {
    ENGINE_AUTO_LOCK();
        return mObjectCntCulledBSP + mObjectCntCulledGraph;  // total
    }

    uint    mObjectCntDrawn;        
    uint    mObjectCntCulledBSP;    
    uint    mObjectCntCulledGraph;  
};

// Data:
private: typedef multimap<int,shptr<View> > Views;  // View,viewNum
private: Views          mViews;
private: SharedPtr<View>    mCurrentView;
public:  DrawStats      mDrawStats;

//------------------------------------------------------------------------------
// Collision-detection:
//------------------------------------------------------------------------------

// Methods:
public:  void           EnableCollisionDetection( bool f )
                        {
                        ENGINE_AUTO_LOCK();
                            mCollisionDetection = f;
                        }
public:  bool           IfCollisionDetection( void )
                        {
                        ENGINE_AUTO_LOCK();
                            return mCollisionDetection;
                        }

// Data:
private: bool       mCollisionDetection;  

//------------------------------------------------------------------------------
// Textures:
//------------------------------------------------------------------------------

// During loading textures from Targa files, an event is broadcast to let a module pre-filter a texture.
// A listening module may respond by calling Engine::SetTextureFilterFunc().

private: typedef map<string,SharedPtr<Texture> > TextureMap;

// Methods:
public:  void                   LoadTextureFromFile( const string& filename, const string& pathname );
private: void                   InitTextures( void );
private: void                   InitTexturesTgaFiles( const string& dirName );
public:  void                   SetTextureDirs( const vector<string>& textureDirs ) { mTextureDirs = textureDirs; }
public:  SharedPtr<Texture>         GetTexture( const string& textureName )
                                {
                                ENGINE_AUTO_LOCK();
                                ASSERT( not textureName.empty() );
                                    return GetTexture( textureName.c_str() );
                                }
public:  SharedPtr<Texture>         GetTexture( const char* textureName );
public:  TargaFilterFuncType    GetTextureFilterFunc( void ) { return mTextureFilterFunc; }
public:  void                   SetTextureFilterFunc( TargaFilterFuncType filterFunc )
                                {
                                ENGINE_AUTO_LOCK();
                                    mTextureFilterFunc = filterFunc;
                                }
private: void                   ReadTextureConf( const string& dirName );

private:
    class TextureConfReader : public ConfReader
    {
    public:
        void ProcessField( string& field, ifstream& config );
    };

// Data:
private: TextureMap             mTextureMap;
private: vector<string>         mTextureDirs;     
private: TargaFilterFuncType    mTextureFilterFunc;

//------------------------------------------------------------------------------
// User-selected LOD:
//------------------------------------------------------------------------------

public: UserLod     mUserLod;

//------------------------------------------------------------------------------
// Listeners:
//------------------------------------------------------------------------------

private:
    // Timer-tick handler.
    struct ListenerTick : public Event<gfx::Events::TickInfo>::ListenerFunctor
    {
        void operator()( gfx::Events::TickInfo tickInfo );
    };
    friend class ListenerTick;

    // Redisplay (repaint) handler.
    struct ListenerDisplay : public Event<>::ListenerFunctor
    {
        void operator()( Void nothing );  // just "void" is wrong
    };
    friend class ListenerDisplay;

    // Window reshape event.
    struct ListenerWindow : public Event< WidthHeight<int> >::ListenerFunctor
    {
        void operator()( WidthHeight<int> wh );
    };

//------------------------------------------------------------------------------
// Debug, stats:
//------------------------------------------------------------------------------

public:  void           PrintException( const Exception& exception, const string& functionName );
#if DEBUG
public:  string         GetCurrentObjectName( void ) { return mCurrentObjectName; }
public:  void           SetCurrentObjectName( const string& name ) { mCurrentObjectName = name; }
private: string         mCurrentObjectName;  
friend ostream& operator<<( ostream& strm, const EngineStats& o );
#endif // DEBUG

#if STATS
public:  EngineStats        mStats;
#endif

//------------------------------------------------------------------------------
// Other data members:
//------------------------------------------------------------------------------

#if COMPILE_THREADS
public:  CLASS_VAR SlowLock mLock;                  
#endif
private: typedef vector< shptr<Object> > Zombies;   
private: Zombies            mZombies;

}; // class Engine

} // namespace eng

#endif // ENG_CLASS_HH

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