H3DWindowNode.h

Go to the documentation of this file.

//    Copyright 2004-2019, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    H3D API is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//
#ifndef __H3DWINDOWNODE_H__
#define __H3DWINDOWNODE_H__
 
#include <H3D/X3DViewpointNode.h>
#include <H3D/MFNode.h>
#include <H3D/SFInt32.h>
#include <H3D/SFVec2f.h>
#include <H3D/DefaultAppearance.h>
#include <H3D/NavigationInfo.h>
#include <H3D/FrameBufferTextureGenerator.h>
 
class OculusRiftHandler;
 
namespace H3D {
  class H3DNavigation;
 
 
  class H3DAPI_API H3DWindowNode : public Node {
  public:
 
    typedef TypedSFNode< X3DViewpointNode > SFViewpoint;
    typedef TypedSFNode< NavigationInfo > SFNavigationInfo;
 
    class WindowSizeChanged : public TypedField< SFBool, Types<SFInt32, SFInt32> > {
    public:
      WindowSizeChanged():TypedField< SFBool, Types<SFInt32, SFInt32> >(){
        prev_set = false;
        width_prev = 0;
        height_prev = 0;
      }
      virtual void update();
      H3DInt32 width_prev;
      H3DInt32 height_prev;
      bool prev_set;
    };
 
    class H3DAPI_API RenderMode: public SFString {
    public:
      H3D_VALUE_EXCEPTION( string, InvalidRenderMode );
      typedef enum {
        MONO,
        QUAD_BUFFERED_STEREO, 
        HORIZONTAL_SPLIT,
        VERTICAL_SPLIT,
        HORIZONTAL_INTERLACED,  
        VERTICAL_INTERLACED,  
        CHECKER_INTERLACED,
        VERTICAL_INTERLACED_GREEN_SHIFT,  
        RED_BLUE_STEREO,
        RED_GREEN_STEREO,
        RED_CYAN_STEREO,
 
        VERTICAL_SPLIT_KEEP_RATIO,
    
        HORIZONTAL_SPLIT_KEEP_RATIO,
 
        HDMI_FRAME_PACKED_720P,
 
        HDMI_FRAME_PACKED_1080P,
 
        NVIDIA_3DVISION,
 
        VERTICAL_SPLIT_KEEP_ASPECT_ONE_PASS,
 
        OCULUS_RIFT
 
      } Mode;
 
 
      inline bool isStereoMode() { 
        upToDate();
        return value != "MONO";
      }
 
      inline bool isSinglePass() {
        upToDate();
        return value == "MONO"||
               value == "VERTICAL_SPLIT_KEEP_ASPECT_ONE_PASS";
      }
 
      RenderMode::Mode getRenderMode();
 
      void updateRebuildStencilMaskFlag() {
        upToDate();
        if( "VERTICAL_INTERLACED" == value||
            "HORIZONTAL_INTERLACED" == value||
            "CHECKER_INTERLACED" == value ||
            "VERTICAL_INTERLACED_GREEN_SHIFT" == value ) {
          H3DWindowNode *window = static_cast<H3DWindowNode*>(getOwner());
          window->rebuild_stencil_mask = true;
        }
      }
    };
 
    H3DWindowNode( Inst< SFInt32     > _width      = 0,
                   Inst< SFInt32     > _height     = 0,
                   Inst< SFBool      > _fullscreen = 0,
                   Inst< SFBool      > _mirrored   = 0,
                   Inst< RenderMode  > _renderMode = 0,
                   Inst< SFViewpoint > _viewpoint  = 0,
                   Inst< SFInt32     > _posX       = 0,
                   Inst< SFInt32     > _posY       = 0,
                   Inst< SFBool      > _manualCursorControl = 0,
                   Inst< SFString    > _cursorType = 0,
                   Inst< SFNavigationInfo > _navigationInfo = 0,
                   Inst< SFBool      > _useFullscreenAntiAliasing = 0,
                   Inst< SFVec2f     > _clipDistances = 0,
                   Inst< SFBool      > _singlePassStereo = 0,
                   Inst< SFString    > _pointingDeviceRefreshMode = 0,
                   Inst< SFBool      > _resetViewPoint = 0,
                   Inst< SFInt32     > _numSamples = 0);
 
    ~H3DWindowNode();
 
    virtual void swapBuffers() = 0;
 
    virtual void initWindow() = 0;
 
    virtual void deinitWindow();
 
    virtual void initWindowHandler() = 0;
 
    virtual void setFullscreen( bool fullscreen ) = 0;
 
    virtual void makeWindowActive() = 0;
 
    virtual void initialize();
 
    static void fboCallback( FrameBufferTextureGenerator *g, int i, void *args );
 
    virtual void render( X3DChildNode *child_to_render );
 
    virtual void reshape( int w, int h );
 
    virtual void display();
 
    virtual void onKeyDown( int key, bool special );
 
    virtual void onKeyUp( int key, bool special );
 
    virtual void onMouseButtonAction( int button, int state );
 
    virtual void onMouseMotionAction( int x, int y );
 
    virtual void onMouseWheelAction( int direction );
 
    static bool calculateFarAndNearPlane( H3DFloat &far,
                                   H3DFloat &near,
                                   X3DChildNode *child,
                                   X3DViewpointNode *vp,
                                   bool include_stylus );
 
    H3DUniquePtr< SFInt32 >  posX;
 
    H3DUniquePtr< SFInt32 >  posY;
 
    H3DUniquePtr< SFInt32 >  width;
 
    H3DUniquePtr< SFInt32 >  height;
 
    H3DUniquePtr< SFBool >  fullscreen;
 
    H3DUniquePtr< SFBool >  mirrored;
 
    H3DUniquePtr< RenderMode >  renderMode;
 
    H3DUniquePtr< SFViewpoint > viewpoint;
 
    H3DUniquePtr< SFBool > manualCursorControl;
 
    H3DUniquePtr< SFString >  cursorType;
 
    H3DUniquePtr< SFNavigationInfo > navigationInfo;
 
    H3DUniquePtr< SFVec2f > clipDistances;
 
    H3DUniquePtr< SFBool > useFullscreenAntiAliasing;
 
    H3DUniquePtr< SFInt32 > viewportWidth;
 
    H3DUniquePtr< SFInt32 > projectionWidth;
    //int projection_width;
 
    H3DUniquePtr< SFInt32 > viewportHeight;
 
    H3DUniquePtr< SFInt32 > projectionHeight;
    
    H3DUniquePtr< SFBool > singlePassStereo;
 
    H3DUniquePtr< SFString > pointingDeviceRefreshMode;
 
    H3DUniquePtr< SFBool > resetViewPoint;
 
    H3DUniquePtr< SFInt32 > numSamples;
 
#ifdef HAVE_LIBOVR
    OculusRiftHandler *oculus;
#endif
 
    static set< H3DWindowNode* > windows;
 
    inline static bool getMultiPassTransparency() {
      return multi_pass_transparency;
    }
 
    inline X3DViewpointNode::EyeMode getEyeMode() {
      return eye_mode;
    }
 
    virtual void shareRenderingContext( H3DWindowNode *w );
 
#ifdef H3D_WINDOWS
    HGLRC getRenderingContext() {
      return rendering_context;
    }
 
    operator HWND() { return hWnd; }
#endif // H3D_WINDOWS
 
    static H3DNodeDatabase database;
 
    // Variables containing default values for navigation.
    string default_nav;
    vector< H3DFloat > default_avatar;
    H3DFloat default_speed;
    bool default_collision;
    vector< string > default_transition_type;
    H3DTime default_transition_time;
 
    // the size of the frame buffer portion in use normally will match the 
    // viewport width and height for the FBTG node. However when it is 
    // in single pass render stereo mode, they are no longer the same. 
    // These value will be used for FBTG node to creat framebuffer object.
    H3DInt32 fbo_current_width ;
    H3DInt32 fbo_current_height;
 
    // the starting point of the frame buffer being used. Mostly of the time
    // it will match the viewport staring point. 
    H3DInt32 fbo_current_x;
    H3DInt32 fbo_current_y;
 
    // viewport_sizes contains a sequence of (x,y,w,h) size values 
    // the first four values are the default viewport which cover the whole
    // window. The second and third four value tuple represent the viewport
    // for stereo mode which requires two viewports
    // the type of viewports_size is float because the place where it is used
    // glViewportArray requires the viewport bounds to be floating point value
    // to allow fractional pixel offsets in viewport transform
    H3DFloat viewports_size[12];
 
    // number of viewport in this window
    // this value is used together with viewports_size to get viewport dimensions
    H3DInt32 nr_viewports;
 
  protected:
    void initWindowWithContext();
#ifdef H3D_WINDOWS
    HGLRC rendering_context;
    HWND hWnd;
    HINSTANCE windowInstance;
 
    // WindowProc calls the Window Procedure stored in wpOrigProc
    // Default is DefWindowProc
    WNDPROC wpOrigProc;
 
    static LRESULT CALLBACK WindowProc(HWND _hWnd, UINT uMsg, 
                                       WPARAM wParam, LPARAM lParam);
    LRESULT Message(HWND _hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
#endif // H3D_WINDOWS
 
    inline static void setMultiPassTransparency( bool b ) {
      multi_pass_transparency = b;
    }
 
    // Render the child node. Will be called after all viewports etc has
    // been set up in order to render the child and everything else that
    // needs to be rendered.
    void renderChild( X3DChildNode *c );
 
    void renderChild( X3DChildNode *child_to_render,
                      bool render_fbo_only );
 
    virtual int setCursorType( const std::string & /*cursor_type*/ ) {
      return -1;
    }
 
    virtual string getCursorForMode( const string &) { return "DEFAULT"; }
 
    friend class Scene; 
 
    AutoRef< FrameBufferTextureGenerator > generator;
 
    static bool multi_pass_transparency;
    X3DChildNode *last_render_child;
    static bool GLEW_init;
    int window_id;
    bool rebuild_stencil_mask;
    unsigned char *stencil_mask;
    unsigned int stencil_mask_height;
    unsigned int stencil_mask_width;
    bool last_loop_mirrored;
 
    AutoRef< X3DViewpointNode > vp_ref;
 
    RenderMode::Mode last_render_mode;
 
    X3DViewpointNode::EyeMode eye_mode;
 
    string current_cursor;
 
    // Stores the current mouse_position as it was when updating MouseSensors.
    // Used as input to updateX3DPointingDeviceSensors.
    H3DInt32 mouse_position[2];
    // Stores the previous mouse position.
    H3DInt32 previous_mouse_position[2];
    // Stores the current left mouse button state.
    vector< bool > left_mouse_button;
    // Stores previous left mouse button state.
    bool previous_left_mouse_button;
 
    // Instance to class handling navigation for this window.
    H3DNavigation * h3d_navigation;
 
    bool window_is_made_active, check_if_stereo_obtained;
 
    H3DUniquePtr<WindowSizeChanged> windowSizeChanged;
 
    
 
    void checkIfStereoObtained();
    // function to calculate the number of viewport for window node which is the 
    // return value. viewports_size will contains a sequence of the viewport size infos
    // for all the viewports. The function will take windows width and height and 
    // give back viewport width and height based on the stereo mode
    void configureViewPortsSize( RenderMode::Mode stereo_mode,
    H3DInt32& viewport_width, H3DInt32& viewport_height, H3DFloat* _viewports_size );
  public:
 
    DEPRECATED("takeScreenshot", )
 
    static string takeScreenShot( const string &url );
 
    static string takeScreenshot( const string &url );
  };
}
 
#endif