Canvas.h

#ifndef CANVAS
#define CANVAS

#include "Settings.h"
#include "ShaderedEntity2D.h"
#include "Stroke.h"
#include "Polygon.h"
#include "LineSegment.h"
#include "Photo.h"
#include "ToolGlobal.h"
#include "SelectedGroup.h"
#include "ProtectedGroup.h"
#include "libSGControls/ProgramStroke.h"
#include "libSGControls/ProgramPolygon.h"
#include "libSGControls/ProgramLineSegment.h"

#include <osg/ref_ptr>
#include <osg/Geode>
#include <osg/Group>
#include <osg/BoundingBox>
#include <osg/Geometry>
#include <osg/MatrixTransform>
#include <osg/Switch>
#include <osgDB/ObjectWrapper>
#include <osg/AutoTransform>

namespace entity {
class Canvas : public osg::ProtectedGroup {
public:
    Canvas();

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    Canvas(const Canvas& cnv, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY);
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:
    virtual void initializeTools();

    virtual void initializeSG();

    virtual void initializeStateMachine();

    virtual void initializeMasks();

    osg::Matrix getMatrixInverse() const;

    osg::Matrix getMatrix() const;

    osg::Vec3f getCenter3D() const;

    ProgramStroke* getProgramStroke() const;
    ProgramPolygon* getProgramPolygon() const;
    ProgramLineSegment* getProgramLineSegment() const;

#ifndef DOXYGEN_SHOULD_SKIP_THIS
public:
    META_Node(entity, Canvas)

    /* setters and getters for serialization only! */
    void setMatrixRotation(const osg::Matrix& R);
    const osg::Matrix& getMatrixRotation() const;

    void setMatrixTranslation(const osg::Matrix& T);
    const osg::Matrix& getMatrixTranslation() const;

    void setTransform(osg::MatrixTransform* t);
    const osg::MatrixTransform* getTransform() const;
    osg::MatrixTransform* getTransform();

    void setSwitch(osg::Switch* sw);
    const osg::Switch* getSwitch() const;

    void setGroupData(osg::Group* group);
    const osg::Group* getGroupData() const;

    void setGeodeStrokes(osg::Geode* geode);
    const osg::Geode* getGeodeStrokes() const;

    void setGeodePhotos(osg::Geode* geode);
    const osg::Geode* getGeodePhotos() const;

    void setGeodePolygons(osg::Geode* geode);
    const osg::Geode* getGeodePolygons() const;

    void setGeodeLineSegments(osg::Geode* geode);
    const osg::Geode* getGeodeLineSegments() const;

    void setCenter(const osg::Vec3f& center);
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

    const osg::Vec3f& getCenter() const;

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    void setNormal(const osg::Vec3f& normal);
    const osg::Vec3f& getNormal() const;

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

    void setColor(const osg::Vec4f& color, const osg::Vec4f& colorIntersection = cher::CANVAS_CLR_PREVIOUS);
    const osg::Vec4f& getColor() const;

protected:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    void setVisibilityFrame(bool vis);
    bool getVisibilityFrame() const;
#endif // DOXYGEN_SHOULD_SKIP_THIS
public:
    void setVisibilityFrameInternal(bool vis);

    bool getVisibilityFrameInternal() const;

    bool getVisibilityAll() const;

    void setVisibilityAll(bool vis);

protected:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    bool getVisibilityData() const;
    void setVisibilityData(bool vis);
#endif // DOXYGEN_SHOULD_SKIP_THIS

public:
    osg::Vec3f getGlobalAxisU() const;

    osg::Vec3f getGlobalAxisV() const;

    const osg::Geometry* getGeometryPickable() const;

    void translate(const osg::Matrix& mt);

    void rotate(const osg::Matrix& mr, const osg::Vec3f& c3d_new);

    void unselectAll();

    void unselectEntities();

    void selectAllEntities();

    void setStrokeCurrent(entity::Stroke* stroke);

    void setStrokeCurrent(bool current);

    entity::Stroke* getStrokeCurrent() const;

    void setPolygonCurrent(entity::Polygon* poly);

    void setPolygonCurrent(bool current);

    entity::Polygon* getPolygonCurrent() const;

    void setEntityCurrent(entity::ShaderedEntity2D* entity);
    void setEntityCurrent(bool current);

    template <typename EntityType>
    // imlementation is in header so that to avoid template definition
    EntityType* getEntityCurrent() const{
        return dynamic_cast<EntityType*>(m_entityCurrent.get());
    }

    void addEntitySelected(entity::Entity2D* entity);

    void removeEntitySelected(entity::Entity2D* entity);

    const std::vector<Entity2D *> &getEntitiesSelected() const;

    int getEntitiesSelectedSize() const;

    bool isEntitiesSelected() const;

    osg::Vec3f getEntitiesSelectedCenter3D() const;

    osg::Vec3f getEntitiesSelectedCenter2D() const;

    osg::Vec3f getCenter2D() const;

    osg::Vec3f getBoundingBoxCenter3D() const;

    osg::Vec3f getBoundingBoxCenter2D() const;

    osg::BoundingBox getBoundingBox() const;


    void moveEntities(std::vector<Entity2D *> &entities, double du, double dv);

    void moveEntitiesSelected(double du, double dv);

    void scaleEntities(std::vector<Entity2D *> &entities, double sx, double sy, osg::Vec3f center);

    void scaleEntitiesSelected(double sx, double sy);

    void rotateEntities(std::vector<entity::Entity2D*> entities, double theta, osg::Vec3f center);

    void rotateEntitiesSelected(double theta);

    void updateFrame(entity::Canvas *against = 0);

    const osg::Vec3Array* getFrameVertices() const;

    bool detachFrame();

    bool attachFrame();

    osg::Group* attachMeshGroup();

    bool disattachMeshGroup(osg::Group* group);

    bool addToMeshGroup(osg::Group* group, osg::Node* mesh);

    void setModeEdit(bool on);

    void setFrameEditable(bool on);

    bool getModeEdit() const;

    osg::Plane getPlane() const;

    entity::Canvas* clone() const;

    entity::Canvas* separate();

    const entity::FrameTool* getToolFrame() const;

    unsigned int getNumEntities() const;

    unsigned int getNumPhotos() const;

    unsigned int getNumStrokes() const;

    unsigned int getNumPolygons() const;

    unsigned int getNumLineSegments() const;

    entity::Photo* getPhoto(int row) const;

    entity::Stroke* getStroke(int i) const;

    entity::Polygon* getPolygon(int i) const;

    entity::LineSegment* getLineSegment(int i) const;

    entity::Entity2D* getEntity(unsigned int i) const;

    bool addEntity(entity::Entity2D* entity);

    bool removeEntity(entity::Entity2D* entity);

    bool containsEntity(entity::Entity2D* entity) const;

protected:
    void updateTransforms();
    void resetTransforms();
    void setVertices(const osg::Vec3f& center, float szX, float szY, float szCr, float szAx);
    void setVerticesDefault(const osg::Vec3f& center);
    void setIntersection(entity::Canvas* against = 0);

public:
    void initializeProgramStroke();
    void initializeProgramPolygon();
    void initializeProgramLineSegment();

private:
    osg::Matrix                 m_mR; /* part of m_transform */
    osg::Matrix                 m_mT; /* part of m_transform */
    osg::ref_ptr<osg::MatrixTransform> m_transform; /* matrix transform in 3D space */
    osg::ref_ptr<osg::Switch>   m_switch; /* inisible or not, the whole canvas content */
    osg::ref_ptr<osg::Group>    m_groupData; /* keeps user canvas 2d entities such as strokes and photos */
    osg::ref_ptr<osg::Geode>    m_geodeStrokes; // contains all the strokes as children
    osg::ref_ptr<osg::Geode>    m_geodePhotos; // contains all the photos as children
    osg::ref_ptr<osg::Geode>    m_geodePolygons; // contains all the polygons as children
    osg::ref_ptr<osg::Geode>    m_geodeLineSegments; 
    osg::ref_ptr<ProgramStroke> m_programStroke; 
    osg::ref_ptr<ProgramPolygon> m_programPolygon; 
    osg::ref_ptr<ProgramLineSegment> m_programLineSegment;
    /* construction geodes */
    osg::ref_ptr<entity::FrameTool> m_toolFrame;

    osg::observer_ptr<entity::Stroke> m_strokeCurrent; /* for stroke drawing */
    osg::observer_ptr<entity::Polygon> m_polygonCurrent; /* for polygon drawing, see UserScene::addPolygon */
    osg::observer_ptr<entity::ShaderedEntity2D> m_entityCurrent; 
    entity::SelectedGroup m_selectedGroup;
    osg::Vec3f m_center; /* 3D global - virtual plane parameter */
    osg::Vec3f m_normal; /* 3D global - virtual plane parameter*/

    bool m_edit;

};
}

#endif // CANVAS