RenderRectangle.hpp

Go to the documentation of this file.

/***********************************
 Copyright 2018 Ravishankar Mathur
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
 http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 ***********************************/

#ifndef _OF_RENDERRECTANGLE_
#define _OF_RENDERRECTANGLE_

#include <OpenFrames/Export.h>
#include <OpenFrames/DepthPartitioner.hpp>
#include <OpenFrames/FrameManager.hpp>
#include <OpenFrames/OpenVRDevice.hpp>
#include <OpenFrames/SkySphere.hpp>
#include <OpenFrames/View.hpp>
#include <OpenFrames/VRUtils.hpp>
#include <osg/Camera>
#include <osg/Referenced>
#include <osg/ref_ptr>
#include <osgViewer/View>
#include <vector>

namespace OpenFrames
{
  class OF_EXPORT RenderRectangle : public osg::Referenced
  {
  public:
    typedef std::vector<osg::ref_ptr<View> > ViewList;
    
    RenderRectangle(OpenVRDevice *ovrDevice = NULL, VRTextureBuffer *vrTextureBuffer = NULL);
    
    void setFrameManager(FrameManager *fm);
    inline FrameManager* getFrameManager() const { return _frameManager.get(); }
    
    osgViewer::View* getSceneView() const { return _sceneView.get(); }
    
    osg::Group* getHUD() const { return _hudCamera.get(); }
    
    void setGraphicsContext(osg::GraphicsContext *gc);
    
    void setViewport(int x, int y, int w, int h);
    
    void setSelected(bool select);
    bool getSelected();
    
    void setShowBorder(bool show);
    bool getShowBorder() { return (_borderGeode->getNodeMask() != 0x0); }
    
    void setSkySphereTexture(const std::string& fname);
    
    bool setSkySphereStarData(const std::string& catalogName, float minMag, float maxMag, unsigned int maxNumStars = 100000, 
                              float minPixSize = 1.0, float maxPixSize = 10.0, float minDimRatio = 0.5f);
    
    SkySphere* getSkySphere() const { return _skySphere.get(); }
    
    void setBackgroundColor(float r, float g, float b);
    
    void setDepthPartitioningEnabled(bool enable) {}
    
    void addView(View *view);    // Adds view to the end of the view list
    void removeView(View *view); // Removes all instances of view
    void removeAllViews();       // Clears entire view list
    
    void nextView();
    void previousView();
    
    void selectView(View *view);
    void selectView(unsigned int newView);
    
    View* getCurrentView();
    
    void applyCurrentViewProjection();
    
    //void enableVR();
    
  protected:
    virtual ~RenderRectangle();
    void _init();
    
    void selectCurrentView(); // Just make sure current view is selected
    void updateViewProjection(View *view); // Update projection matrix
    
    ViewList _views; // All of the added Views
    osg::ref_ptr<View> _defaultView; // Used if no Views have been added
    unsigned int _currView; // Currently active View
    
    // Contains the ReferenceFrame scene, and any decorations such as
    // a box around this RenderRectangle
    osg::ref_ptr<osgViewer::View> _sceneView;
    
    // Uses multipass rendering on scenes with large depth ranges
    osg::ref_ptr<DepthPartitioner> _depthPartitioner;
    
    osg::ref_ptr<osg::Group> _scene; // Everything to be drawn
    
    // Cameras used to render various parts of the scene
    osg::ref_ptr<osg::Camera> _hudCamera; // Heads-up-display camera
    osg::ref_ptr<osg::Camera> _backCamera; // Background camera
    osg::ref_ptr<osg::Camera> _mirrorCamera; // Camera to mirror scene onto window

    osg::ref_ptr<VRCamera> _backCameraVR; // VR version of background camera
    
    // Render textures used for storing each eye's image in VR
    osg::observer_ptr<VRTextureBuffer> _vrTextureBuffer;
    
    // OpenVR device
    osg::observer_ptr<OpenVRDevice> _ovrDevice;
    bool _useVR;
    
    osg::ref_ptr<osg::Geode> _borderGeode; // The border rectangle
    osg::ref_ptr<SkySphere> _skySphere; // The background sky
    
    // Manager for access to the ReferenceFrame scene
    osg::ref_ptr<FrameManager> _frameManager;
  };
  
}

#endif