SceneOSG.h

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

#ifndef VTOSG_SCENEH
#define VTOSG_SCENEH

#include <osgViewer/Viewer>
#include <osgViewer/Renderer>
#include <osg/Timer>

#include "../core/Engine.h"

#include "VisualImpactCalculatorOSG.h"

#if OLD_OSG_SHADOWS
class CStructureShadowsOSG;
#endif


class vtWindow
{
public:
    vtWindow();

    void SetBgColor(const RGBf &color) { m_BgColor = color; }
    RGBf GetBgColor() { return m_BgColor; }

    void SetSize(int w, int h);
    IPoint2 GetSize() { return m_Size; }

protected:
    RGBf m_BgColor;
    IPoint2 m_Size;
};

class vtScene
{
public:
    vtScene();
    ~vtScene();

    void SetRoot(vtGroup *pRoot);

    void SetGlobalWireframe(bool bWire);
    bool GetGlobalWireframe();

    bool Init(int argc, char** argv, bool bStereo = false, int iStereoMode = 0);
    void SetGraphicsContext(osg::GraphicsContext* pGraphicsContext);
    osg::GraphicsContext* GetGraphicsContext();

    void Shutdown();

    void TimerRunning(bool bRun);
    void UpdateBegin();
    void UpdateEngines();
    void UpdateWindow(vtWindow *window);
    void PostDrawEngines();

    // backward compatibility
    void DoUpdate();

    float GetFrameRate()
    {
        return 1.0 / m_fLastFrameTime;
    }

    float GetTime()
    {
        return _timer.delta_s(_initialTick,_frameTick);
    }
    float GetFrameTime()
    {
        return m_fLastFrameTime;
    }

    // View methods
    bool CameraRay(const IPoint2 &win, FPoint3 &pos, FPoint3 &dir, vtWindow *pWindow = NULL);
    void WorldToScreen(const FPoint3 &point, IPoint2 &result);

    void SetRootEngine(vtEngine *ptr) { m_pRootEngine = ptr; }

    vtEngine *GetRootEngine() { return m_pRootEngine; }

    void SetPostDrawEngine(vtEngine *ptr) { m_pRootEnginePostDraw = ptr; }

    vtEngine *GetPostDrawEngine() { return m_pRootEnginePostDraw; }

    void AddEngine(vtEngine *ptr);

    void TargetRemoved(osg::Referenced *tar);

    void SetCamera(vtCamera *cam) { m_pCamera = cam; }
    vtCamera *GetCamera() { return m_pCamera; }

    void OnMouse(vtMouseEvent &event, vtWindow *pWindow = NULL);
    void OnKey(int key, int flags, vtWindow *pWindow = NULL);
    void SetKeyStates(bool *piKeyState) { m_piKeyState = piKeyState; }
    bool GetKeyState(int key);

    void SetWindowSize(int w, int h, vtWindow *pWindow = NULL);
    IPoint2 GetWindowSize(vtWindow *pWindow = NULL);

    bool GetWindowSizeFromOSG();

    vtGroup *GetRoot() { return m_pRoot; }
    osg::StateSet *GetRootState() { return m_StateRoot->getOrCreateStateSet(); }

    // Windows
    void AddWindow(vtWindow *pWindow) {
        m_Windows.Append(pWindow);
    }
    vtWindow *GetWindow(uint i) {
        if (m_Windows.GetSize() > i)
            return m_Windows[i];
        else
            return NULL;
    }

#if OLD_OSG_SHADOWS
    // Experimental:
    // Object-terrain shadow casting, only for OSG
    void SetShadowedNode(vtTransform *pLight, osg::Node *pShadowerNode,
        osg::Node *pShadowed, int iRez, float fDarkness, int iTextureUnit,
        const FSphere &ShadowSphere);
    void UnsetShadowedNode(vtTransform *pTransform);
    void UpdateShadowLightDirection(vtTransform *pLight);
    void SetShadowDarkness(float fDarkness);
    void SetShadowSphere(const FSphere &ShadowSphere, bool bForceRedraw);
    void ShadowVisibleNode(osg::Node *node, bool bVis);
    bool IsShadowVisibleNode(osg::Node *node);
    void ComputeShadows();
#endif

    void SetHUD(vtHUD *hud) { m_pHUD = hud; }
    vtHUD *GetHUD() { return m_pHUD; }

    // For backward compatibility
    void SetBgColor(const RGBf &color) {
        if (GetWindow(0))
            GetWindow(0)->SetBgColor(color);
    }

    bool IsStereo() const;;
    void SetStereoSeparation(float fSep);
    float GetStereoSeparation() const;
    void SetStereoFusionDistance(float fDist);
    float GetStereoFusionDistance();

    void ComputeViewMatrix(FMatrix4 &mat);

    // OSG access
    osgViewer::Viewer *getViewer() { return m_pOsgViewer.get(); }

#if VISUAL_IMPACT_CALCULATOR
    // Visual Impact Calculation
    virtual CVisualImpactCalculatorOSG& GetVisualImpactCalculator() { return m_VisualImpactCalculator; }
#endif

protected:
    void DoEngines(vtEngine *eng);

    vtArray<vtWindow*> m_Windows;
    vtCamera    *m_pCamera;
    vtGroup     *m_pRoot;
    vtEnginePtr m_pRootEngine;
    vtEngine    *m_pRootEnginePostDraw;
    bool        *m_piKeyState;
    vtHUD       *m_pHUD;

    vtCameraPtr  m_pDefaultCamera;
    vtWindow    *m_pDefaultWindow;

    osg::ref_ptr<osgViewer::Viewer> m_pOsgViewer;
    osg::ref_ptr<osg::GraphicsContext>  m_pGraphicsContext;

    osg::ref_ptr<osg::Group>    m_StateRoot;

    osg::Timer   _timer;
    osg::Timer_t _initialTick;
    osg::Timer_t _lastFrameTick;
    osg::Timer_t _lastRunningTick;
    osg::Timer_t _frameTick;
    double  m_fAccumulatedFrameTime, m_fLastFrameTime;

    bool    m_bWinInfo;
    bool    m_bInitialized;
    bool    m_bWireframe;
#if OLD_OSG_SHADOWS
    osg::ref_ptr<CStructureShadowsOSG> m_pStructureShadowsOSG;
#endif
#if VISUAL_IMPACT_CALCULATOR
    CVisualImpactCalculatorOSG m_VisualImpactCalculator;
#endif
};

// global
vtScene *vtGetScene();
float vtGetTime();
float vtGetFrameTime();
int vtGetMaxTextureSize();
    // Group sg

#endif  // VTOSG_SCENEH