baseobject.h

Go to the documentation of this file.

#pragma once
 
#include <osg/Array>
#include <osg/ShapeDrawable>
#include <osg/Switch>
 
#include <osg/PositionAttitudeTransform>
#include <osg/Geode>
 
#include <a_utils/a_utils.h>
#include <memory>
 
namespace adtf
{
 
namespace disptb
{
 
namespace mixinlib
{
 
namespace endor
{

class cBaseObject : public osg::Switch
{
protected:
    tUInt32 m_nId;
 
    // object
    osg::ref_ptr<osg::PositionAttitudeTransform> m_pTransform;
    osg::ref_ptr<osg::ShapeDrawable> m_pDrawable;
    osg::ref_ptr<osg::Box> m_pBox;
 
    // history
    osg::ref_ptr<osg::Geometry> m_pHistoryGeom;
    osg::ref_ptr<osg::DrawArrays> m_pHistoryArray;
 
    // motion vector
    osg::ref_ptr<osg::Geometry> m_pMotionGeom;
    osg::ref_ptr<osg::DrawArrays> m_pMotionArray;
 
    // payload data
    osg::Vec3d m_vPos;
 
    // position history
    osg::ref_ptr<osg::Vec3Array> m_pPositionHistory;
    tUInt32 m_nHistorySize;
 
    // motion vector data
    osg::ref_ptr<osg::Vec3Array> m_pMotionVector;
 
    // color array for both history an motion vector
    osg::ref_ptr<osg::Vec4Array> m_pColorArray;

    osg::ref_ptr<osg::Switch> m_pSelectionSwitch;
    osg::ref_ptr<osg::Geode> m_pSelectionGeode;
    osg::ref_ptr<osg::ShapeDrawable> m_pSelectionDrawable;
    osg::ref_ptr<osg::Box> m_pSelectionBox;
 
    // state data
    tBool m_bHistory;
    tBool m_bMotionVector;
    tBool m_bSelected;
    tBool m_bUpdated;
 
public:
    cBaseObject(tUInt32 nId):
        m_nId(nId),
        m_nHistorySize(0),
        m_bHistory(tTrue),
        m_bMotionVector(tTrue),
        m_bSelected(tFalse),
        m_bUpdated(tFalse)
    {
        m_pPositionHistory = new osg::Vec3Array;
        m_pMotionVector = new osg::Vec3Array;
        m_pMotionVector->resize(2);
        m_pColorArray = new osg::Vec4Array;
        m_pColorArray->resize(1);
        m_pColorArray->at(0).x() = -1.0; // to make sure that the next SetColor will initialize the state
 
        // this will move and rotate the shape
        m_pTransform = new osg::PositionAttitudeTransform;
        addChild(m_pTransform.get());
 
        // now we create a osg::Geode and create our box
        osg::Geode* pGeode = new osg::Geode;
        m_pTransform->addChild(pGeode);
        m_pDrawable = new osg::ShapeDrawable;
        pGeode->addDrawable(m_pDrawable);
        m_pBox = new osg::Box();
        m_pDrawable->setShape(m_pBox.get());
        m_pDrawable->getOrCreateStateSet()->setMode(GL_CULL_FACE, osg::StateAttribute::ON);
 
        // prepare selection bounding box
        m_pSelectionSwitch = new osg::Switch;
        m_pSelectionGeode = new osg::Geode;
        m_pSelectionDrawable = new osg::ShapeDrawable;
        m_pSelectionDrawable->setColor(osg::Vec4(0.0f, 1.0f, 0.0f, 0.4f));
        m_pSelectionBox = new osg::Box;
        m_pSelectionDrawable->setShape(m_pSelectionBox);
 
        m_pSelectionGeode->addDrawable(m_pSelectionDrawable);
        m_pSelectionGeode->getOrCreateStateSet()->setMode(GL_BLEND, osg::StateAttribute::ON);
        m_pSelectionGeode->getOrCreateStateSet()->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
 
        m_pSelectionSwitch->addChild(m_pSelectionGeode);
        m_pSelectionSwitch->setAllChildrenOff();
 
        m_pTransform->addChild(m_pSelectionSwitch);
 
        // this will be the history trail
        m_pHistoryArray = new osg::DrawArrays(osg::PrimitiveSet::LINE_STRIP);
        m_pHistoryGeom = new osg::Geometry;
        m_pHistoryGeom->getOrCreateStateSet()->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
        m_pHistoryGeom->getOrCreateStateSet()->setMode(GL_BLEND, osg::StateAttribute::OFF);
        osg::Geode* pHistoryGeode = new osg::Geode;
 
        m_pHistoryGeom->addPrimitiveSet(m_pHistoryArray.get());
        m_pHistoryGeom->setVertexArray(m_pPositionHistory.get());
        m_pHistoryGeom->setColorArray(m_pColorArray.get(), osg::Array::BIND_OVERALL);
        // it changes almost every frame and is only one line so we do not need to use display lists.
        m_pHistoryGeom->setUseDisplayList(tFalse);
        pHistoryGeode->addDrawable(m_pHistoryGeom.get());
 
        addChild(pHistoryGeode);
 
        // this will be the motion vector
        m_pMotionArray = new osg::DrawArrays(osg::PrimitiveSet::LINE_STRIP);
        m_pMotionGeom = new osg::Geometry;
        m_pMotionGeom->getOrCreateStateSet()->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
        m_pMotionGeom->getOrCreateStateSet()->setMode(GL_BLEND, osg::StateAttribute::OFF);
        osg::Geode* pMotionGeode = new osg::Geode;
 
        m_pMotionGeom->addPrimitiveSet(m_pMotionArray.get());
        m_pMotionGeom->setVertexArray(m_pMotionVector.get());
        m_pMotionArray->setCount(2);
        m_pMotionGeom->setColorArray(m_pColorArray.get(), osg::Array::BIND_OVERALL);
        // it changes almost every frame and is only one line so we do not need to use display lists.
        m_pMotionGeom->setUseDisplayList(tFalse);
        pMotionGeode->addDrawable(m_pMotionGeom.get());
 
        addChild(pMotionGeode);
 
        SetColor(1.0, 1.0, 1.0, 1.0);
    }

    virtual ~cBaseObject()
    {
    }

    tUInt32 GetId()
    {
        return m_nId;
    }

    tResult Update()
    {
        m_bUpdated = tTrue;
        RETURN_NOERROR;
    }

    tBool IsUpdated()
    {
        return m_bUpdated;
    }

    tResult Reset()
    {
        m_bUpdated = tFalse;
        RETURN_NOERROR;
    }

    virtual tResult SetHistory(tBool bEnabled, tUInt32 nCount = 0)
    {
        if (!bEnabled && m_bHistory)
        {
            // if it hase been enabled clear the data.
            m_pPositionHistory->clear();
        }
 
        m_bHistory = bEnabled;
        m_nHistorySize = nCount;
 
        // enable/disable the history node
        setValue(1, m_bHistory);
 
        RETURN_NOERROR;
    }

    virtual tResult SetMotionVector(tBool bEnabled)
    {
        m_bMotionVector = bEnabled;
        setValue(2, m_bMotionVector);
        RETURN_NOERROR;
    }

    virtual tResult SetPosition(tFloat64 fPosX, tFloat64 fPosY, tFloat64 fPosZ)
    {
        // store the position vector
        m_vPos.x() = fPosX;
        m_vPos.y() = fPosY;
        m_vPos.z() = fPosZ;
 
        m_pTransform->setPosition(m_vPos);
 
        // update the history data
        if (m_bHistory)
        {
            m_pPositionHistory->push_back(m_vPos);
            if (m_nHistorySize && m_pPositionHistory->size() > m_nHistorySize)
            {
                // this is expensive!!!
                m_pPositionHistory->erase(m_pPositionHistory->begin());
            }
 
            // update the amount of history data
            m_pHistoryArray->setCount(m_pPositionHistory->size());
            // make sure the the display list and the bounding sphere is recomputed during rendering.
            m_pPositionHistory->dirty();
            m_pHistoryGeom->dirtyBound();
        }
 
        RETURN_NOERROR;
    }

    osg::Vec3d GetPosition()
    {
        return m_pTransform->getPosition();
    }

    virtual tResult SetRotation(tFloat64 fRotX, tFloat64 fRotY, tFloat64 fRotZ)
    {
        m_pTransform->setAttitude(
            osg::Quat(fRotX, osg::Vec3(1, 0, 0), fRotY, osg::Vec3(0, 1, 0), fRotZ, osg::Vec3(0, 0, 1)));
        RETURN_NOERROR;
    }

    osg::Vec3d GetRotation()
    {
        return m_pTransform->getAttitude().asVec3();
    }

    virtual tResult SetSize(tFloat64 fSizeX, tFloat64 fSizeY, tFloat64 fSizeZ)
    {
        // update the size of the object
        auto oNewDimensions = osg::Vec3d(fSizeX / 2.0, fSizeY / 2.0, fSizeZ / 2.0);
        if (oNewDimensions != m_pBox->getHalfLengths())
        {
            m_pBox->setHalfLengths(oNewDimensions);
            m_pDrawable->build();
            m_pDrawable->dirtyGLObjects();
            m_pDrawable->dirtyBound();
 
            // update selection bounding sphere if neccessary
            if (m_bSelected)
            {
                RETURN_IF_FAILED(UpdateSelection());
            }
        }
        RETURN_NOERROR;
    }

    osg::Vec3d GetSize()
    {
        return m_pBox->getHalfLengths() * 2;
    }

    virtual tResult SetColor(tFloat64 fRed, tFloat64 fGreen, tFloat64 fBlue, tFloat64 fAlpha)
    {
        // store the color
        osg::Vec4 oColor(fRed, fGreen, fBlue, fAlpha);
        if (m_pColorArray->at(0) != oColor)
        {
            m_pDrawable->setColor(oColor);
            m_pColorArray->at(0) = oColor;
 
            if (fAlpha < 1.0)
            {
                m_pDrawable->getOrCreateStateSet()->setMode(GL_BLEND, osg::StateAttribute::ON);
                m_pDrawable->getOrCreateStateSet()->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
            }
            else
            {
                m_pDrawable->getOrCreateStateSet()->setMode(GL_BLEND, osg::StateAttribute::OFF);
                m_pDrawable->getOrCreateStateSet()->setRenderingHint(osg::StateSet::DEFAULT_BIN);
            }
 
            // make sure the display list is updated
            m_pDrawable->dirtyDisplayList();
        }
        RETURN_NOERROR;
    }

    virtual tResult SetMotion(tFloat64 fMotionX, tFloat64 fMotionY, tFloat64 fMotionZ)
    {
        // calculate its end vertices
        m_pMotionVector->at(0) = m_vPos;
        m_pMotionVector->at(1) = osg::Vec3(fMotionX, fMotionY, fMotionZ) + m_vPos;
        m_pMotionVector->dirty();
        // make sure that the bounding sphere is recomputed during rendering.
        m_pMotionGeom->dirtyBound();
        RETURN_NOERROR;
    }

    osg::Vec3d GetMotion()
    {
        return m_pMotionVector->at(1) - m_vPos;
    }

    virtual tResult SetSelected(tBool bSelected)
    {
        if (bSelected && !m_bSelected)
        {
            RETURN_IF_FAILED(UpdateSelection());
        }
 
        // enable/disable the sphere
        m_pSelectionSwitch->setValue(0, bSelected);
        m_bSelected = bSelected;
 
        RETURN_NOERROR;
    }

    virtual tBool IsSelected()
    {
        return m_bSelected;
    }
 
protected:
    virtual tResult UpdateSelection()
    {
        // update the size of the selection box
        osg::Vec3 vSize = m_pBox->getHalfLengths();
        vSize += osg::Vec3(0.1f, 0.1f, 0.1f);
        m_pSelectionBox->setHalfLengths(vSize);
        m_pSelectionDrawable->dirtyDisplayList();
 
        RETURN_NOERROR;
    }
};
 
} // namespace endor

using endor::cBaseObject;
 
} // namespace mixinlib
 
} // namespace disptb
 
} // namespace adtf