mixin.h

Go to the documentation of this file.

#pragma once
 
#include "mixin_types.h"
#include "coordinate_systems_intf.h"
#include "scene_graph_intf.h"
#include "viewer_intf.h"
#include "font.h"
 
#include <adtf_filtersdk.h>
#include <a_utils.h>
#include <adtf_base.h>
#include <adtf_ucom3.h>
#include <adtf_streaming3.h>
#include <osg/Switch>
 
#include <vector>
 
// Undefine macro from "windows.h" for this file, which would cause name clash.
#ifdef GetObject
    #undef GetObject
#endif
 
#ifdef GetCurrentTime
    #undef GetCurrentTime
#endif
 
namespace osgText
{
class Font;
}
namespace osg
{
class Node;
}
namespace osg
{
class Group;
}
 
namespace adtf
{
 
namespace disptb
{
 
namespace mixinlib
{
 
namespace endor
{

class IChildCoordinateSystem
{
protected:
    ~IChildCoordinateSystem() = default;
 
public:
    virtual osg::Group* GetRoot() = 0;

    virtual tVoid SetPosition(const osg::Vec3d& oPos) = 0;

    virtual tVoid SetAttitude(const osg::Quat& oQuat) = 0;

    virtual tVoid SetScale(const osg::Vec3d& oScale) = 0;

    virtual tVoid SetPivotPoint(const osg::Vec3d& oPivot) = 0;
};
 
namespace detail
{
 
class cChildCoordinateSystem : public IChildCoordinateSystem
{
public:
    cChildCoordinateSystem(const tChar* strName,
                           filter::interface_client<ISceneGraph> pSceneGraph,
                           INodeHandler* pHandler):
        m_strName(strName), m_pSceneGraph(pSceneGraph), m_pRoot(new osg::Group), m_pPickHandler(pHandler)
    {
    }
 
    osg::Group* GetRoot() override
    {
        return m_pRoot;
    }
 
    tVoid SetPosition(const osg::Vec3d& oPos) override
    {
        m_oPos = oPos;
 
        if (m_pCoordinateSystem)
        {
            m_pCoordinateSystem->SetPosition(oPos);
        }
    }
    tVoid SetAttitude(const osg::Quat& oQuat) override
    {
        m_oAttitude = oQuat;
 
        if (m_pCoordinateSystem)
        {
            m_pCoordinateSystem->SetAttitude(oQuat);
        }
    }
    tVoid SetScale(const osg::Vec3d& oScale) override
    {
        m_oScale = oScale;
 
        if (m_pCoordinateSystem)
        {
            m_pCoordinateSystem->SetScale(oScale);
        }
    }
    tVoid SetPivotPoint(const osg::Vec3d& oPivot) override
    {
        m_oPivotPoint = oPivot;
 
        if (m_pCoordinateSystem)
        {
            m_pCoordinateSystem->SetPivotPoint(oPivot);
        }
    }
 
    ucom::object_ptr<ICoordinateSystem> GetCoordinateSystem()
    {
        Create();
        return m_pCoordinateSystem;
    }
 
    tVoid Create()
    {
        if (!m_pCoordinateSystem)
        {
            ucom::object_ptr<ICoordinateSystem> pParent;
            THROW_IF_FAILED(m_pSceneGraph->GetObject(pParent));
            THROW_IF_FAILED(pParent->CreateChild(m_strName.c_str(), m_pCoordinateSystem));
            m_pCoordinateSystem->SetPosition(m_oPos);
            m_pCoordinateSystem->SetAttitude(m_oAttitude);
            m_pCoordinateSystem->SetScale(m_oScale);
            m_pCoordinateSystem->SetPivotPoint(m_oPivotPoint);
            m_pCoordinateSystem->AddNode(m_pRoot, m_pPickHandler);
        }
    }
 
public:
    std::string m_strName;
    filter::interface_client<ISceneGraph> m_pSceneGraph;
    osg::ref_ptr<osg::Group> m_pRoot;
    ucom::object_ptr<ICoordinateSystem> m_pCoordinateSystem;
    INodeHandler* m_pPickHandler;
 
    osg::Vec3d m_oPos;
    osg::Quat m_oAttitude;
    osg::Vec3d m_oScale = {1.0, 1.0, 1.0};
    osg::Vec3d m_oPivotPoint;
};
 
class cSceneGraphProxy : public ucom::object<ISceneGraph>
{
public:
    cSceneGraphProxy(const tChar* strName, filter::interface_client<ISceneGraph> pSceneGraph, INodeHandler* pHandler):
        m_pSceneGraph(pSceneGraph), m_oChildCoordinateSystem(strName, pSceneGraph, pHandler)
    {
    }
 
    tResult GetObject(ucom::ant::iobject_ptr<ucom::ant::IObject>& pObject, const tChar* strObjectName = "")
    {
        std::string strNameHelper = strObjectName ? strObjectName : "";
 
        if (strNameHelper.empty() ||
            strNameHelper == adtf::disptb::mixinlib::endor::tSceneGraphObjectNames::CoordinateSystem)
        {
            if (IS_OK(pObject.Reset(m_oChildCoordinateSystem.GetCoordinateSystem())))
            {
                RETURN_NOERROR;
            }
        }
 
        return m_pSceneGraph->GetObject(pObject, strObjectName);
    }
 
    cChildCoordinateSystem* GetCoordinateSystem()
    {
        return &m_oChildCoordinateSystem;
    }
 
private:
    filter::interface_client<ISceneGraph> m_pSceneGraph;
    cChildCoordinateSystem m_oChildCoordinateSystem;
};
 
} // namespace detail

class cMixin :
    public ucom::catwo::object<filter::cFilter, INodeHandler, IMenuEventSink>,
    public ucom::ant::enable_object_ptr_from_this<cMixin>
{
public:
    cMixin()
    {
        m_pSceneGraph = CreateInterfaceClient<ISceneGraph>("scene_graph");
        SetDescription("scene_graph", "ISceneGraph interface for use with Openscenegraph 3.5.6");
    }

    ~cMixin() override
    {
    }

    IChildCoordinateSystem* CreateCoordinateSystem(const tChar* strName)
    {
        auto pSceneGraph = ucom::make_object_ptr<detail::cSceneGraphProxy>(strName, m_pSceneGraph, this);
        CreateInterfaceServer<ISceneGraph>(strName, ucom::ucom_object_ptr_cast<ISceneGraph>(pSceneGraph));
        m_oCoordinateSystemSceneGraphProxys.push_back(pSceneGraph);
        return pSceneGraph->GetCoordinateSystem();
    }

    osg::Group* GetRoot()
    {
        if (!m_pRootNode)
        {
            osg::ref_ptr<osg::Switch> pRootNode = new osg::Switch;
            ucom::object_ptr<ICoordinateSystem> pCoordinateSystem;
            THROW_IF_FAILED(GetSceneGraph().GetObject(pCoordinateSystem));
            THROW_IF_FAILED(pCoordinateSystem->AddNode(pRootNode, this));
            m_pRootNode = pRootNode;
        }
 
        return m_pRootNode;
    }

    ISceneGraph& GetSceneGraph()
    {
        return m_pSceneGraph.Get();
    }

    osgText::Font* GetFont()
    {
        return m_pFont;
    }

    tResult HandleMenuEvent(const tChar* /*strMenuText*/, tVoid* /*pvEventData*/) override
    {
        RETURN_NOERROR;
    }

    virtual tResult OnPick(tInt32 /*nPosX*/, tInt32 /*nPosY*/, tUInt32 /*nFlags*/, const tNodePath& /*sNodePath*/)
    {
        RETURN_NOERROR;
    }

    virtual tResult AddMenuItemForPick(chewbacca::IMenu& /*oMenu*/, const tNodePath& /*sNodePath*/)
    {
        RETURN_NOERROR;
    }

    virtual tResult AddGlobalMenuItem(chewbacca::IMenu& /*oMenu*/)
    {
        RETURN_NOERROR;
    }

    std::vector<const osg::Node*> GetLastMenuPath()
    {
        return m_oLastPick;
    }

    tResult Init(tInitStage eStage) override
    {
        RETURN_IF_FAILED(cFilter::Init(eStage));
 
        if (eStage == tInitStage::StageGraphReady)
        {
            RETURN_IF_FAILED(GetSceneGraph().GetObject(m_pViewer));
            m_pViewer->MakeCurrent();
            CreateCoordinateSystems();
            RETURN_IF_FAILED(InitScene());
        }
 
        RETURN_NOERROR;
    }
 
    tResult Shutdown(tInitStage eStage) override
    {
        if (eStage == tInitStage::StageGraphReady)
        {
            ClearScene();
        }
        return cFilter::Shutdown(eStage);
    }
 
    tResult GetName(base::ant::IString&& strName) const override
    {
        return cFilter::GetName(std::move(strName));
    }
 
    tResult
        OnPick(tInt32 nPosX, tInt32 nPosY, tUInt32 nFlags, const tNodePath& sNodePath, chewbacca::IMenu& oMenu) override
    {
        if (sNodePath.nCount == 0)
        {
            RETURN_IF_FAILED(AddGlobalMenuItem(oMenu));
        }
        else
        {
            if (nFlags & INodeHandler::CM_RIGHT_MB)
            {
                m_oLastPick.clear();
                m_oLastPick.insert(m_oLastPick.end(), sNodePath.ppNodePath, sNodePath.ppNodePath + sNodePath.nCount);
                RETURN_IF_FAILED(AddMenuItemForPick(oMenu, sNodePath));
            }
            else
            {
                RETURN_IF_FAILED(OnPick(nPosX, nPosY, nFlags, sNodePath));
            }
        }
        RETURN_NOERROR;
    }
 
    tResult Process(base::flash::tNanoSeconds tmTrigger, streaming::ant::IRunner* pRunner) override
    {
        m_pViewer->Lock();
        auto oResult = cFilter::Process(tmTrigger, pRunner);
        m_pViewer->Unlock();
        return oResult;
    }
 
    tResult ProcessInput(base::flash::tNanoSeconds tmTrigger, streaming::flash::ISampleReader* pReader) override
    {
        m_pViewer->Lock();
        auto oResult = cFilter::ProcessInput(tmTrigger, pReader);
        m_pViewer->Unlock();
        return oResult;
    }
 
protected:
    virtual tResult InitScene()
    {
        RETURN_NOERROR;
    }

    virtual tVoid ClearScene()
    {
    }
 
protected:
    tVoid CreateCoordinateSystems()
    {
        for (auto& pProxy : m_oCoordinateSystemSceneGraphProxys)
        {
            pProxy->GetCoordinateSystem()->Create();
        }
    }
 
    osg::ref_ptr<osg::Switch> m_pRootNode;
    filter::interface_client<ISceneGraph> m_pSceneGraph;
    std::vector<ucom::object_ptr<detail::cSceneGraphProxy>> m_oCoordinateSystemSceneGraphProxys;
    osg::ref_ptr<osgText::Font> m_pFont = new cInstanceFont;
    ucom::object_ptr<IViewer> m_pViewer;
    std::vector<const osg::Node*> m_oLastPick;
};
 
} // namespace endor
 
using endor::cMixin;
using endor::IChildCoordinateSystem;
 
} // namespace mixinlib
 
} // namespace disptb
 
} // namespace adtf