cosgcanvas.h

//==========================================================================
//   COSGCANVAS.H  -  header for
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 1992-2017 Andras Varga
  Copyright (C) 2006-2017 OpenSim Ltd.

  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/

#ifndef __OMNETPP_COSGCANVAS_H
#define __OMNETPP_COSGCANVAS_H

#include "cownedobject.h"
#include "ccanvas.h"

// don't include OSG headers
namespace osg { class Node;  }

namespace omnetpp {

class SIM_API cOsgCanvas : public cOwnedObject
{
    public:
        enum ViewerStyle {
            STYLE_GENERIC, 
            STYLE_EARTH    
        };

        typedef cFigure::Color Color;

        enum CameraManipulatorType {
            CAM_AUTO,      
            CAM_TERRAIN,   
            CAM_OVERVIEW,  
            CAM_TRACKBALL, 
            CAM_EARTH      
        };

        // this is only needed to simplify the Viewpoint hint
        struct SIM_API Vec3d {
            double x, y, z;
            Vec3d() : x(0), y(0), z(0) {}
            Vec3d(double x, double y, double z): x(x), y(y), z(z) {}
            std::string str();
        };

        struct SIM_API Viewpoint {
            Vec3d eye;    
            Vec3d center; 
            Vec3d up;     
            bool valid;   


            Viewpoint() : valid(false) {}
            Viewpoint(const Vec3d& eye, const Vec3d& center, const Vec3d& up): eye(eye), center(center), up(up), valid(true) {}
        };

        struct SIM_API EarthViewpoint {
            double longitude = 0, latitude = 0, altitude = 0; 
            double heading = 0, pitch = 0, range = 0;         
            bool valid = false;                               


            EarthViewpoint() {}
            EarthViewpoint(double longitude, double latitude, double altitude, double heading, double pitch, double range)
                : longitude(longitude), latitude(latitude), altitude(altitude), heading(heading), pitch(pitch), range(range), valid(true) {}
        };

    protected:
        osg::Node *scene;  // reference counted

        ViewerStyle viewerStyle;

        // OSG viewer hints
        Color clearColor;
        CameraManipulatorType cameraManipulatorType;
        double fieldOfViewAngle;  // a.k.a. fovy, see OpenGL gluPerspective
        double zNear; // see OpenGL gluPerspective
        double zFar;  // see OpenGL gluPerspective

        Viewpoint *genericViewpoint; // never nullptr
        EarthViewpoint *earthViewpoint; // never nullptr

    private:
        void copy(const cOsgCanvas& other);

    public:
        cOsgCanvas(const char *name=nullptr, ViewerStyle viewerStyle=STYLE_GENERIC, osg::Node *scene=nullptr);
        cOsgCanvas(const cOsgCanvas& other) : cOwnedObject(other) {copy(other);}
        virtual ~cOsgCanvas();
        cOsgCanvas& operator=(const cOsgCanvas& other);

        virtual cOsgCanvas *dup() const override {return new cOsgCanvas(*this);}
        virtual std::string str() const override;

        virtual void setScene(osg::Node *scene);

        virtual osg::Node *getScene() const {return scene;}

        void setViewerStyle(ViewerStyle viewerStyle) {this->viewerStyle = viewerStyle;}

        ViewerStyle getViewerStyle() const {return viewerStyle;}

        void setClearColor(Color clearColor) {this->clearColor = clearColor;}

        const Color& getClearColor() const {return clearColor;}

        void setCameraManipulatorType(CameraManipulatorType manipulator) {this->cameraManipulatorType = manipulator;}

        CameraManipulatorType getCameraManipulatorType() const {return cameraManipulatorType;}

        void setFieldOfViewAngle(double fieldOfViewAngle) {this->fieldOfViewAngle = fieldOfViewAngle;}

        double getFieldOfViewAngle() const {return fieldOfViewAngle;}

        void setZNear(double zNear) {this->zNear = zNear;}

        void setZFar(double zFar) {this->zFar = zFar;}

        void setZLimits(double zNear, double zFar) {this->zNear = zNear; this->zFar = zFar;}

        void clearZLimits();

        bool hasZLimits() const;

        double getZNear() const {return zNear;}

        double getZFar() const {return zFar;}

        void setGenericViewpoint(const Viewpoint& viewpoint);

        const Viewpoint& getGenericViewpoint() const {return *genericViewpoint;}

        void setEarthViewpoint(const EarthViewpoint& earthViewpoint);

        const EarthViewpoint& getEarthViewpoint() const {return *earthViewpoint;}
};

} // namespace omnetpp

#endif