Engine.h

//
// Engine.h
//
// Copyright (c) 2001-2011 Virtual Terrain Project
// Free for all uses, see license.txt for details.
//

#ifndef VTENGINEH
#define VTENGINEH

#include "vtdata/vtString.h"
#include "Event.h"

class vtWindow;


class vtEnabledBase
{
public:
    vtEnabledBase() { m_bEnabled = true; }

    virtual void SetEnabled(bool bOn) { m_bEnabled = bOn; }
    bool GetEnabled() { return m_bEnabled; }

protected:
    bool m_bEnabled;
};

typedef osg::ref_ptr<class vtEngine> vtEnginePtr;

class vtEngine : public vtEnabledBase, public osg::Referenced
{
public:
    vtEngine();

    osg::Referenced *GetTarget(uint which = 0);
    void AddTarget(osg::Referenced *ptr) { m_Targets.Append(ptr); }
    void SetTarget(osg::Referenced *ptr) { m_Targets.SetAt(0, ptr); }
    void RemoveTarget(osg::Referenced *ptr);

    uint NumTargets() { return m_Targets.GetSize(); }

    void setName(const char *str) { m_strName = str; }
    const char *getName() { return m_strName; }

    virtual void OnMouse(vtMouseEvent &event);

    virtual void OnKey(int key, int flags);

    virtual void OnWindowSize(int width, int height);

    virtual void Eval();

    // an engine may be associate with a window
    void SetWindow(vtWindow *pWin) { m_pWindow = pWin; }
    vtWindow *GetWindow() { return m_pWindow; }

    // Engine tree methods
    void AddChild(vtEngine *pEngine) { m_Children.push_back(pEngine); }
    void RemoveChild(vtEngine *pEngine);
    vtEngine *GetChild(uint i) { return m_Children[i].get(); }
    uint NumChildren() { return m_Children.size(); }

    void AddChildrenToList(vtArray<vtEngine*> &list, bool bEnabledOnly);

protected:
    vtArray<osg::Referenced*> m_Targets;
    std::vector<vtEnginePtr> m_Children;
    vtString         m_strName;
    vtWindow        *m_pWindow;

protected:
    ~vtEngine() {}
};


class vtEngineArray : public vtArray<vtEngine*>
{
public:
    vtEngineArray(vtEngine *pTop, bool bEnabledOnly = true)
    {
        if (pTop)
            pTop->AddChildrenToList(*this, bEnabledOnly);
    }
};


class vtLastMouse : public vtEngine
{
public:
    vtLastMouse();

    void OnMouse(vtMouseEvent &event);

    void GetNormalizedMouseCoords(float &mx, float &my);

    int m_buttons;

    IPoint2 m_pos;

    int m_flags;

protected:
    virtual ~vtLastMouse() {}
};

class vtSimpleBillboardEngine : public vtEngine
{
public:
    vtSimpleBillboardEngine(float fAngleOffset = 0.0f);
    virtual ~vtSimpleBillboardEngine() {}

    void SetPitch(bool bFlag) { m_bPitch = bFlag; }

    void Eval();

    bool m_bPitch;
    float m_fAngleOffset;
};
    // Group eng

#endif  // VTENGINEH