OpenGLContext.hpp

Go to the documentation of this file.

/**************************************************************************************/
/*                                                                                    */
/*  Visualization Library                                                             */
/*  http://visualizationlibrary.org                                                   */
/*                                                                                    */
/*  Copyright (c) 2005-2020, Michele Bosi                                             */
/*  All rights reserved.                                                              */
/*                                                                                    */
/*  Redistribution and use in source and binary forms, with or without modification,  */
/*  are permitted provided that the following conditions are met:                     */
/*                                                                                    */
/*  - Redistributions of source code must retain the above copyright notice, this     */
/*  list of conditions and the following disclaimer.                                  */
/*                                                                                    */
/*  - Redistributions in binary form must reproduce the above copyright notice, this  */
/*  list of conditions and the following disclaimer in the documentation and/or       */
/*  other materials provided with the distribution.                                   */
/*                                                                                    */
/*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND   */
/*  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     */
/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE            */
/*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR  */
/*  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    */
/*  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;      */
/*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    */
/*  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT           */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS     */
/*  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                      */
/*                                                                                    */
/**************************************************************************************/

#ifndef OpenGLContext_INCLUDE_ONCE
#define OpenGLContext_INCLUDE_ONCE

#include <vlCore/Object.hpp>
#include <vlGraphics/UIEventListener.hpp>
#include <vlGraphics/FramebufferObject.hpp>
#include <vlGraphics/RenderState.hpp>
#include <vlGraphics/NaryQuickMap.hpp>
#include <vlGraphics/GLSL.hpp>
#include <vector>
#include <set>

namespace vl
{
  class EnableSet;
  class RenderStateSet;
  class UniformSet;
  class IVertexAttribSet;
  class ArrayAbstract;

  //-----------------------------------------------------------------------------
  // OpenGLContextFormat
  //-----------------------------------------------------------------------------
  class OpenGLContextFormat
  {
  public:
    OpenGLContextFormat():
      mRGBABits(ivec4(8,8,8,0)),
      mAccumRGBABits(ivec4(0,0,0,0)),
      mZBufferBits(24),
      mStencilBufferBits(8),
      mMultisampleSamples(16),
      mContextClientVersion(1),
      mMajVersion(0),
      mMinVersion(0),
      mHasDoubleBuffer(true),
      mHasMultisample(false),
      mStereo(false),
      mFullscreen(false),
      mVSync(false),
      mProfile(GLP_Compatibility) {}

    void setRGBABits(int r, int g, int b, int a) { mRGBABits = ivec4(r,g,b,a); }
    void setAccumRGBABits(int r, int g, int b, int a) { mAccumRGBABits = ivec4(r,g,b,a); }
    void setDoubleBuffer(bool double_buffer_on) { mHasDoubleBuffer = double_buffer_on; }
    void setDepthBufferBits(int bits) { mZBufferBits = bits; }
    void setStencilBufferBits(int bits) { mStencilBufferBits = bits; }
    void setMultisample(bool multisample_on) { mHasMultisample = multisample_on; }
    void setMultisampleSamples(int samples) { mMultisampleSamples = samples; }
    void setStereo(bool stereo_on) { mStereo = stereo_on; }
    void setFullscreen(bool fullscreent) { mFullscreen = fullscreent; }
    void setVSync(bool vsync_on) { mVSync = vsync_on; }
    void setContextClientVersion(int version) { mContextClientVersion = version; }

    const ivec4& rgbaBits() const { return mRGBABits; }
    const ivec4& accumRGBABits() const { return mAccumRGBABits; }
    bool doubleBuffer() const { return mHasDoubleBuffer; }
    int depthBufferBits() const { return mZBufferBits; }
    int stencilBufferBits() const { return mStencilBufferBits; }
    bool multisample() const { return mHasMultisample; }
    int multisampleSamples() const { return mMultisampleSamples; }
    bool stereo() const { return mStereo; }
    bool fullscreen() const { return mFullscreen; }
    bool vSync() const { return mVSync; }
    int contextClientVersion() const { return mContextClientVersion; }

    int bitsPerPixel() const { return rgbaBits().r() + rgbaBits().g() + rgbaBits().b() + rgbaBits().a(); }

    void setOpenGLProfile(EOpenGLProfile p) { mProfile = p; }
    EOpenGLProfile openGLProfile() const { return mProfile; }

    void setVersion( int majv, int minv ) { mMajVersion = majv; mMinVersion = minv; }
    int majVersion() const { return mMajVersion; }
    int minVersion() const { return mMinVersion; }

  protected:
    ivec4 mRGBABits;
    ivec4 mAccumRGBABits;
    int mZBufferBits;
    int mStencilBufferBits;
    int mMultisampleSamples;
    int mContextClientVersion;
    int mMajVersion;
    int mMinVersion;
    bool mHasDoubleBuffer;
    bool mHasMultisample;
    bool mStereo;
    bool mFullscreen;
    bool mVSync;
    EOpenGLProfile mProfile;
  };
  //-----------------------------------------------------------------------------
  // OpenGLContext
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT OpenGLContext: public Object
  {
    VL_INSTRUMENT_ABSTRACT_CLASS(vl::OpenGLContext, Object)
    friend class VertexAttrib;
    friend class Color;
    friend class SecondaryColor;
    friend class Normal;

  public:
    OpenGLContext(int w=0, int h=0);

    ~OpenGLContext();

    virtual void swapBuffers() = 0;

    virtual void makeCurrent() = 0;

    bool initGLContext(bool log=true);

    void logOpenGLInfo();

    const std::string& extensions() const { return mExtensions; }

    bool isExtensionSupported(const char* ext_name);

    void* getProcAddress(const char* function_name);

    FramebufferObject* leftFramebuffer() { return mLeftFramebuffer.get(); }

    const FramebufferObject* leftFramebuffer() const { return mLeftFramebuffer.get(); }

    FramebufferObject* rightFramebuffer() { return mRightFramebuffer.get(); }

    const FramebufferObject* rightFramebuffer() const { return mRightFramebuffer.get(); }

    FramebufferObject* framebuffer() { return leftFramebuffer(); }

    const FramebufferObject* framebuffer() const { return leftFramebuffer(); }

    FramebufferObject* createFramebufferObject() { return createFramebufferObject(0,0); }

    FramebufferObject* createFramebufferObject(
      int width, 
      int height,
      EReadDrawBuffer draw_buffer=RDB_COLOR_ATTACHMENT0,
      EReadDrawBuffer read_buffer=RDB_COLOR_ATTACHMENT0);

    void destroyFramebufferObject(FramebufferObject* fbort);

    void destroyAllFramebufferObjects();

    void destroyAllOpenGLResources();

    virtual void quitApplication() {}

    virtual void update() = 0;

    virtual void setWindowTitle(const String&) {}

    virtual bool setFullscreen(bool) { mFullscreen = false; return false; }

    virtual bool fullscreen() const { return mFullscreen; }

    virtual void show() {}

    virtual void hide() {}

    virtual void setPosition(int /*x*/, int /*y*/) {}

    virtual ivec2 position() const { return ivec2(); }

    virtual void setSize(int /*w*/, int /*h*/) {}

    int width() const { return framebuffer()->width(); }

    int height() const { return framebuffer()->height(); }

    virtual void setMouseVisible(bool) { mMouseVisible=false; }

    virtual bool mouseVisible() const { return mMouseVisible; }

    virtual void setMousePosition(int /*x*/, int /*y*/) {}

    virtual void getFocus() {}

    void setVSyncEnabled(bool enable);

    bool vsyncEnabled() const;

    virtual void setContinuousUpdate(bool continuous) { mContinuousUpdate = continuous; }

    bool continuousUpdate() const { return mContinuousUpdate; }

    void addEventListener(UIEventListener* el);

    void removeEventListener(UIEventListener* el);

    void eraseAllEventListeners();

    const std::vector< ref<UIEventListener> >& eventListeners() const { return mEventListeners; }

    const UIEventListener* eventListener(int i) const { return mEventListeners[i].get(); }

    UIEventListener* eventListener(int i) { return mEventListeners[i].get(); }

    int eventListenerCount() const { return (int)mEventListeners.size(); }

    const OpenGLContextFormat& openglContextInfo() const { return mGLContextInfo; }

    void setOpenGLContextInfo(const OpenGLContextFormat& info) { mGLContextInfo = info; }

    void ignoreNextMouseMoveEvent() { mIgnoreNextMouseMoveEvent = true; }

    void dispatchResizeEvent(int w, int h)
    {
      makeCurrent();
      leftFramebuffer()->setWidth(w);
      leftFramebuffer()->setHeight(h);
      rightFramebuffer()->setWidth(w);
      rightFramebuffer()->setHeight(h);

      std::vector< ref<UIEventListener> > temp_clients = eventListeners();
      for( unsigned i=0; i<temp_clients.size(); ++i )
        if ( temp_clients[i]->isEnabled() )
          temp_clients[i]->resizeEvent( w, h );
    }

    void dispatchMouseMoveEvent(int x, int y)
    {
      makeCurrent();
      if (mIgnoreNextMouseMoveEvent)
        mIgnoreNextMouseMoveEvent = false;
      else
      {
        std::vector< ref<UIEventListener> > temp_clients = eventListeners();
        for( unsigned i=0; i<temp_clients.size(); ++i )
          if ( temp_clients[i]->isEnabled() )
            temp_clients[i]->mouseMoveEvent(x, y);
      }
    }

    void dispatchMouseUpEvent(EMouseButton button, int x, int y)
    {
      makeCurrent();
      std::vector< ref<UIEventListener> > temp_clients = eventListeners();
      for( unsigned i=0; i<temp_clients.size(); ++i )
        if ( temp_clients[i]->isEnabled() )
          temp_clients[i]->mouseUpEvent(button, x, y);
    }

    void dispatchMouseDownEvent(EMouseButton button, int x, int y)
    {
      makeCurrent();
      std::vector< ref<UIEventListener> > temp_clients = eventListeners();
      for( unsigned i=0; i<temp_clients.size(); ++i )
        if ( temp_clients[i]->isEnabled() )
          temp_clients[i]->mouseDownEvent(button, x, y);
    }

    void dispatchMouseWheelEvent(int n)
    {
      makeCurrent();
      std::vector< ref<UIEventListener> > temp_clients = eventListeners();
      for( unsigned i=0; i<temp_clients.size(); ++i )
        if ( temp_clients[i]->isEnabled() )
          temp_clients[i]->mouseWheelEvent(n);
    }

    void dispatchKeyPressEvent(unsigned short unicode_ch, EKey key)
    {
      makeCurrent();
      keyPress(key);
      std::vector< ref<UIEventListener> > temp_clients = eventListeners();
      for( unsigned i=0; i<temp_clients.size(); ++i )
        if ( temp_clients[i]->isEnabled() )
          temp_clients[i]->keyPressEvent(unicode_ch, key);
    }

    void dispatchKeyReleaseEvent(unsigned short unicode_ch, EKey key)
    {
      makeCurrent();
      keyRelease(key);
      std::vector< ref<UIEventListener> > temp_clients = eventListeners();
      for( unsigned i=0; i<temp_clients.size(); ++i )
        if ( temp_clients[i]->isEnabled() )
          temp_clients[i]->keyReleaseEvent(unicode_ch, key);
    }

    void dispatchDestroyEvent()
    {
      makeCurrent();
      std::vector< ref<UIEventListener> > temp_clients = eventListeners();
      for( unsigned i=0; i<temp_clients.size(); ++i )
        if ( temp_clients[i]->isEnabled() )
          temp_clients[i]->destroyEvent();
      destroyAllOpenGLResources();
      eraseAllEventListeners();
    }

    void dispatchUpdateEvent()
    {
      makeCurrent();
      std::vector< ref<UIEventListener> > temp_clients = eventListeners();
      for( unsigned i=0; i<temp_clients.size(); ++i )
        if ( temp_clients[i]->isEnabled() )
          temp_clients[i]->updateEvent();
    }

    void dispatchVisibilityEvent(bool visible)
    {
      makeCurrent();
      std::vector< ref<UIEventListener> > temp_clients = eventListeners();
      for( unsigned i=0; i<temp_clients.size(); ++i )
        if ( temp_clients[i]->isEnabled() )
          temp_clients[i]->visibilityEvent(visible);
    }

    // - called as soon as the OpenGL context is available but before the first resize event
    // - when initEvent() is called all the supported OpenGL extensions are already available
    // - when initEvent() is called the window has already acquired its width and height
    // - only the enabled event listeners receive this message
    void dispatchInitEvent()
    {
      makeCurrent();
      std::vector< ref<UIEventListener> > temp_clients = eventListeners();
      for( unsigned i=0; i<temp_clients.size(); ++i )
        if ( temp_clients[i]->isEnabled() )
          temp_clients[i]->initEvent();
    }

    void dispatchFileDroppedEvent(const std::vector<String>& files)
    {
      makeCurrent();
      std::vector< ref<UIEventListener> > temp_clients = eventListeners();
      for( unsigned i=0; i<temp_clients.size(); ++i )
        if ( temp_clients[i]->isEnabled() )
          temp_clients[i]->fileDroppedEvent(files);
    }

    const std::set<EKey>& keyboard() const { return mKeyboard; }

    bool isKeyPressed(EKey key) const { return mKeyboard.find(key) != mKeyboard.end(); }

    void keyPress(EKey key) { mKeyboard.insert(key); }

    void keyRelease(EKey key) { mKeyboard.erase(key); }

    bool isInitialized() const { return mIsInitialized; }

    int vertexAttribCount() const { return mVertexAttribCount; }

    int textureImageUnitCount() const { return mTextureImageUnitCount; }

    int textureCoordCount() const { return mTextureCoordCount; }

    bool hasDoubleBuffer() const { return mHasDoubleBuffer; }

    // --- render states management ---

    void useGLSLProgram(const GLSLProgram* glsl);

    void bindVAS(const IVertexAttribSet* vas, bool use_vbo, bool force);
    void bindVAS_Attribs(const IVertexAttribSet* vas, bool use_vbo);
    void bindVAS_Fixed(const IVertexAttribSet* vas, bool use_vbo);
    void bindVAS_Reset();

    void applyEnables( const EnableSet* cur );

    void applyRenderStates( const RenderStateSet* cur, const Camera* camera );

    void resetEnables();

    void resetRenderStates();

    void setDefaultRenderState(const RenderStateSlot& rs_slot)
    {
      mDefaultRenderStates[rs_slot.type()] = rs_slot;
      // if we are in the default render state then apply it immediately
      if (!mCurrentRenderStateSet->hasKey(rs_slot.type()))
      {
        mDefaultRenderStates[rs_slot.type()].apply(NULL, this); VL_CHECK_OGL();
      }
    }

    const RenderStateSlot& defaultRenderState(ERenderState rs) { return mDefaultRenderStates[rs]; }

    void resetContextStates(EResetContextStates start_or_finish);

    void setTexUnitBinding(int unit_i, ETextureDimension target)
    {
      VL_CHECK(unit_i <= VL_MAX_TEXTURE_IMAGE_UNITS);
      mTexUnitBinding[unit_i] = target;
    }

    ETextureDimension texUnitBinding(int unit_i) const
    {
      VL_CHECK(unit_i <= VL_MAX_TEXTURE_IMAGE_UNITS);
      return mTexUnitBinding[unit_i];
    }

    const GLSLProgram* glslProgram() const { return mGLSLProgram.get(); }
    GLSLProgram* glslProgram() { return mGLSLProgram.get(); }


    static bool areUniformsColliding(const UniformSet* u1, const UniformSet* u2);

    bool isCleanState(bool verbose);

  public:
    // constant color
    const fvec3& normal() const { return mNormal; }
    const fvec4& color() const { return mColor; }
    const fvec3& secondaryColor() const { return mSecondaryColor; }
    const fvec4& vertexAttribValue(int i) const { VL_CHECK(i<VA_MaxAttribCount); return mVertexAttribValue[i]; }

  protected:
    ref<FramebufferObject> mLeftFramebuffer;
    ref<FramebufferObject> mRightFramebuffer;
    std::vector< ref<FramebufferObject> > mFramebufferObject;
    std::vector< ref<UIEventListener> > mEventListeners;
    std::set<EKey> mKeyboard;
    OpenGLContextFormat mGLContextInfo;
    int mVertexAttribCount;
    int mTextureImageUnitCount;
    int mTextureCoordCount;
    bool mMouseVisible;
    bool mContinuousUpdate;
    bool mIgnoreNextMouseMoveEvent;
    bool mFullscreen;
    bool mHasDoubleBuffer;
    bool mIsInitialized;
    std::string mExtensions;

    // --- Render States ---

    // default render states
    RenderStateSlot mDefaultRenderStates[RS_RenderStateCount];

    // applyEnables()
    ref< NaryQuickMap<EEnable, EEnable, EN_EnableCount> > mCurrentEnableSet;
    ref< NaryQuickMap<EEnable, EEnable, EN_EnableCount> > mNewEnableSet;

    // applyRenderStates()
    ref< NaryQuickMap<ERenderState, RenderStateSlot, RS_RenderStateCount> > mCurrentRenderStateSet;
    ref< NaryQuickMap<ERenderState, RenderStateSlot, RS_RenderStateCount> > mNewRenderStateSet;

    // for each texture unit tells which target has been bound last.
    ETextureDimension mTexUnitBinding[VL_MAX_TEXTURE_IMAGE_UNITS];

    // current GLSL
    ref<GLSLProgram> mGLSLProgram;
    bool mGLSLUpdated;

  private:
    struct VertexArrayInfo
    {
      VertexArrayInfo(): mBufferObject(0), mPtr(0), mEnabled(false) {}
      int   mBufferObject;
      const unsigned char* mPtr;
      bool mEnabled;
    };

  protected:
    // --- VertexAttribSet Management ---
    const IVertexAttribSet* mCurVAS;
    VertexArrayInfo mVertexArray;
    VertexArrayInfo mNormalArray;
    VertexArrayInfo mColorArray;
    VertexArrayInfo mSecondaryColorArray;
    VertexArrayInfo mFogArray;
    VertexArrayInfo mTexCoordArray[VA_MaxTexCoordCount];
    VertexArrayInfo mVertexAttrib[VA_MaxAttribCount];

    // save and restore constant attributes
    fvec3 mNormal;
    fvec4 mColor;
    fvec3 mSecondaryColor;
    fvec4 mVertexAttribValue[VA_MaxAttribCount];
    GLuint mDefaultVAO;

  private:
    void setupDefaultRenderStates();
  };
  // ----------------------------------------------------------------------------
}

#endif