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 = 0, y = 0, z = 0;
            Vec3d() {}
            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 = Color(128, 128, 220);
        CameraManipulatorType cameraManipulatorType = CAM_AUTO;
        double fieldOfViewAngle = 30;  // 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