OpenGLCanvasBase.hh

#ifndef __OpenGLCanvasBase_hh__
#define __OpenGLCanvasBase_hh__
#include <wx/wx.h>
/** \author Jan Woetzel 01/2003 - 10/2005 */
#include <bias_config.h>
#ifndef BIAS_HAVE_WXWIDGETS
#  error Please recompile BIAS with USE_WXWIDGETS to use this lib. 
#endif // BIAS_HAVE_WXWIDGETS

#ifndef BIAS_HAVE_OPENGL
#  error Please recompile BIAS with USE_OPENGL to use this file.
#endif // BIAS_HAVE_OPENGL

//#ifndef BIAS_HAVE_GLEW
//#  error Please recompile BIAS with USE_GLEW to use this file.
//#endif // BIAS_HAVE_GLEW


// avoid VS 2005 deprecated warnings
#ifndef _CRT_SECURE_NO_DEPRECATE
#  define _CRT_SECURE_NO_DEPRECATE
#endif

#include <Gui/biasgl.h>
#include <wx/glcanvas.h>
// must be first
#include <Base/Common/W32Compat.hh>
#include <math.h> // avoid M_PI redefinitions in wx/defs.h


// check defines from wx/setup.h implicitly
#if defined(wxUSE_GLCANVAS) && wxUSE_GLCANVAS
// OK, wx compiled in configuration with wxgl lib
#else
#  error wx has not been compiled with wxUSE_GLCANVAS=1. BIASGUi needs a ww with gl support. Please set wx/setup.h: wxUSE_GLCANVAS=1 and recompile WX.
#endif


// STD
#include <vector>
#include <iostream>
#include <iomanip>

// BIAS
#include <Base/Debug/Error.hh>
#include <Base/Debug/DebugSimple.hh>
#include <Base/Math/Vector3.hh>
#include <Base/Math/Vector4.hh>
#include <Base/Image/Image.hh>
#include <Gui/StringConv.hh>

// WX
#include <wx/wx.h>
#include <wx/image.h>


#include <Gui/RenderModeGL.hh>
#ifdef BIAS_HAVE_FONTGL
#  include <Utils/DrawTextGL.hh>
#endif


// true: start with theoretically auto update of time
#ifndef OPENGLCANVASBASE_DEFAULT_animationUpdateEnabled 
#  define OPENGLCANVASBASE_DEFAULT_animationUpdateEnabled true
#endif 

// default fileformat used by screenshot function: 
#ifndef BIAS_SCREENSHOT_DEFAULT_EXTENSION
#  define BIAS_SCREENSHOT_DEFAULT_EXTENSION ".mip"
#endif


#define OpenGLCanvasBase_DEFAULT_FULLSCREEN_STYLE  wxFULLSCREEN_NOMENUBAR|wxFULLSCREEN_NOTOOLBAR|wxFULLSCREEN_NOSTATUSBAR|wxFULLSCREEN_NOBORDER|wxFULLSCREEN_NOCAPTION|wxFULLSCREEN_ALL 


// some exp. beta drivers don't expose their "hidden" capabilities
// bypass extension query and force "on" for all extensions. 
// in general this setting is *NOT* recommended!!! (JW)
//#define USE_EXPERIMENTAL_SETTING_GLEW


namespace BIAS {

  /**  helper to simplify setting up format "red,green,blue,alpha,depth" JW
  to be used as (int*)&attribsRGBAD JW */
  const int attribsRGBAD[] = {  WX_GL_RGBA,
    WX_GL_MIN_RED, 1,
    WX_GL_MIN_GREEN, 1,
    WX_GL_MIN_BLUE, 1,
    WX_GL_MIN_ALPHA, 1,
    WX_GL_STENCIL_SIZE, 0,
    WX_GL_DEPTH_SIZE, 1,
    WX_GL_DOUBLEBUFFER,
    0
  };

    /**  helper to simplify setting up format "red,green,blue,alpha,stencil,depth" JW
  to be used as (int*)&attribsRGBASD JW */
  const int attribsRGBASD[] = {  WX_GL_RGBA,
    WX_GL_MIN_RED, 1,
    WX_GL_MIN_GREEN, 1,
    WX_GL_MIN_BLUE, 1,
    WX_GL_MIN_ALPHA, 1,
    WX_GL_STENCIL_SIZE, 1,
    WX_GL_DEPTH_SIZE, 1,
    WX_GL_DOUBLEBUFFER,
    0
  };


    /** 
    @class OpenGLCanvasBase
    @ingroup g_gui
    @brief base class for OpenGL canvases you could derive from to get base functionality (JW)

    Has minimal dependencies and minimal event interceptions, just functionality. 
    Use a derrived class for automatic event handling. 
    Supports shared GL context. 
    The idea is that you usually just need to derive and reimplement the DisplayCalls() routine.
    This clas is 
    -NOT writing mous epos value to status bar
    -NOT updating periodically.
    See OpenGLCanvas for an extended version. 
    // TODO: page flipping stereo for windows mode (no fullscreen)
    // TODO: handle multiple rendering contexts with different caabilites (e.g 2 differen GPUs) using "GLEW MX"
    // TODO: add application controlled VSYNC enable/disable
    // TODO: add application controlled antialiasing settings
    // TODO: add keys for switching between 3D stereo rendering modes
    // TODO: Rendertexture and Framebufferobject support?
    // TODO: support for shared display lists and vertex buffer objects (VBO,VAR)?

  Use the attriblist like RGBASD for setting the correct pixel formato rliek this:
  \verbatim
   int attriblist[] =  {
      WX_GL_RGBA,
      WX_GL_MIN_RED, 1,
      WX_GL_MIN_GREEN, 1,
      WX_GL_MIN_BLUE, 1,
      WX_GL_MIN_ALPHA, 1,
      WX_GL_STENCIL_SIZE, 1,
      WX_GL_DOUBLEBUFFER,
      0
  };
  \endverbatim

    \mainpage OpenGLCanvasBase and its child classes can be used for OpenGL GUI development. 
    \author     Jan Woetzel */
    class BIASGui_EXPORT OpenGLCanvasBase : public wxGLCanvas 
    {   
    public:
        virtual ~OpenGLCanvasBase(); ///< destructor

        // ctors
        OpenGLCanvasBase(
            wxFrame* parent
            ,wxWindowID id = -1
            ,const wxPoint& pos = wxDefaultPosition
            ,const wxSize& size = wxDefaultSize
            ,long style = 0
            ,const wxString& name = AsciiToWx("OpenGLCanvasBase")
            ,int* attribList = NULL
            ,const wxPalette& palette = wxNullPalette
            );

        /// 
        /// constructor using a shared context 
        OpenGLCanvasBase(
            wxFrame* parent
            ,wxGLContext* sharedContext = NULL
            ,wxWindowID id = -1
            ,const wxPoint& pos = wxDefaultPosition
            ,const wxSize& size = wxDefaultSize
            ,long style=0
            ,const wxString& name=AsciiToWx("OpenGLCanvasBase")
            ,int* attribList = NULL
            ,const wxPalette& palette = wxNullPalette
            );


        /// any constructor should call this function 
        /// to initialize all data members (e.g. pointers to NULL)
        virtual void InitMembers();

        /// init all things that need a context.
        /// sets _InitWithContextDone
        virtual void InitWithContext();

    /// expands parents SwapBUffers by automatic framecount increase
    void SwapBuffers();

        /**
        main display call to be overridden by child classes
        usually displays:
        -InitWithContext (must be done and must eb first because setting up context may take some time while display is not setup correctly!)
        -Clear
        -Camera/virtual view
        -Geometry
        Implements instance 
        @author Jan Woetzel. 
        */
        virtual void Display();

        virtual void DisplayCalls();

        /// display default shade model, polygon mode, 
        virtual void DisplayRenderMode();

        /** pop up keyboard layout help. Must be virtual to let child class add their bindings */
        virtual std::ostream & PrintHelp(std::ostream & os);

        /// useful for quadbuffered stereo, e.g. shutetr glasses 
        void DisplaySelectBuffer();

        /// clears buffers and resets virtual camera to identity 
        virtual void DisplayClear(const GLbitfield & mask=CLEAR_DEFAULT_MASK );

        /// display soem very simple Gl calls to draw something at all
        static void DisplaySampleScene();

        // coordinate cross for orientation
        //static 
    void DisplayCoordCross(const float & size=1.0f, const float & linewidth=1.0f);


        ///
        /// change of size and aspect ratio. 
        virtual void Reshape();

        /// return GL state information 
        virtual void GetInfoGL(std::ostream & os);

        /* onscreen read pixel values JW */
        BIAS::Vector3<float> GetPixelValueRGB(const wxPoint & pos2d);
        BIAS::Vector4<float> GetPixelValueRGBA(const wxPoint & pos2d);

        /* @return Z value at 2d screen position JW */
        float GetPixelValueDepth(const wxPoint & pos2d) const;

        /// activates the current rendereing context if there is one 
        /// and @return true if gl rendering context is available, false if there is none available (yet). 
        bool IsContextAvailable();

        /** computes 3D coordinate from 2D+Z by "unprojection" JW */
        BIAS::Vector3<float> Unproject(const wxPoint & pos2d, double & d);

        //void SetStatusText(const wxString& text, int field = 0);

        unsigned int GetWidth() const;

        unsigned int GetHeight() const;

        /** GetAspectRatio is X/Y */
        float GetAspectRatio() const;

        /** shows FPS to status bar base don frame counter and last call to this function
        Measures and updates only, if two conditions ar eboth met:
        1. at least minUpdateIntervalSec seconds have passed since prvious update 
        2. at least minNewFrames were drawn since a previous update 
        Shouls handle multiplem, shared contextst correctly (jw).
        JW */
        void ShowFPS(const int & framecounter,
            const float & minUpdateIntervalSec,
            const unsigned int & minNewFrames,
            const unsigned int nField);
        /// simple interface for the above
        void ShowFPS();

        /** vertical sync control on or off (VSYNC)  JW*/
        static void SetVSync( const bool & trueForOn );

        /** @return true if vertical sync is enable, 
        false for free running mode JW */
        static bool GetVSync();

        /** try to toggle VSync setting.
        @return true if toggling worked, false if status persisted. */
        static bool ToggleVSync();

        void OnPaint( wxPaintEvent &event );
        void OnSize(wxSizeEvent& event);
        void OnEraseBackground(wxEraseEvent& event);
        virtual void OnChar(wxKeyEvent& event);


        /* make an (onscreen) screenshot JW */
        // TODO: maybe change arg to ImageBase
        void ScreenShot(BIAS::ImageBase & dest, 
      const bool & flipY=true,
      const GLenum & format=GL_RGB,
      const bool &force8Bit=false);

        void ScreenShot(const std::string & filename, 
      const bool & flipY=true,
      const GLenum & format=GL_RGB,
      const bool &force8Bit=false);

        /** JW automatic screenshot to file with filename based on frame, instance etc. JW */
        void ScreenShot();

        unsigned long GetFrameCount() const {return framecount_; };
        void SetFrameCount(const unsigned long & newVal) {framecount_ =newVal; };

        wxFrame* GetOwnerframe();

        void SetOwnerframe(wxFrame* ptr);

        /** let an OpenGL canvas use the status bar of the containing frame and cout as fallback (JW) */
        void SetStatusText(const wxString& text, const int c_field=0 );

        void ShowValue(const wxPoint & pos);

        /* toggles between Fullscreen mode (of the frame).
        This is a hack to make fullscreen work for singel canvas frames. JW */
        void ToggleFullScreen();

    /** helper toggling a bool value in place 
    @return new value JW */
    static bool ToggleIP(bool & value);


    /// sets the internal time param, by default based on realtime wall clock
    virtual void UpdateTime();


#ifdef BIAS_HAVE_STEREOI
        /** interace to NVidias consumer Stereo NVStereo driver API.
        to enable/disbale stereo and control convergence and separation for stereo rendering
        @return 0 on success, negative on error. 
        @author Jan Woetzel */
        static int   StereoI_Init();

        /** query status information on current NVStereo rendering state JW */
        static void StereoI_GetInfo(std::ostream &os=std::cout);

        /** wrappers for StereoI interface */
        static int   StereoI_GetStereoState();
        static int   StereoI_SetStereoState(const int & val);
        static float StereoI_GetSeparation();
        static float StereoI_SetSeparation(const float & val);
        static float StereoI_GetConvergence();
        static float StereoI_SetConvergence(const float & val);
        /* 0 for Jpeg, 1 for png, 
        Stereo images are dumped to [RootDir]\NVSTEREO.IMG JW */
        static void StereoI_CaptureStereoImage(const int & format, const int & quality);

#endif // BIAS_HAVE_STEREOI


    public:
        // global time, useful for animation: 
        static double time;
        // true to set time automatically based on real time or display counter (in child classes)
        static bool animationUpdateEnabled;

    protected: 

        // seq. frame counter=nr. of Display call.
        unsigned long framecount_;

        // pointer to avaible frame for output etc (if there is one), NULL otherwise. 
        wxFrame * p_ownerframe;

        // internally used for intializing once when GL conetxt is available 
        bool InitWithContextDone_;
        // instance counter
        unsigned int instance_;
        static unsigned int instancesTotalNo_;

        // GL status changeable through keys:
        BIAS::RenderModeGL rendermode;

        // useful for text output:
        // TODO: Linux version (JW)
#ifdef BIAS_HAVE_FONTGL
        BIAS::DrawTextGL * p_font;
#endif

        DECLARE_EVENT_TABLE()

    }; // OpenGLCanvasBase

} // namespace BIAS
#endif