glDisplay.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
 
#ifndef __GL_VIEWPORT_H__
#define __GL_VIEWPORT_H__
 
#include "videoOutput.h"
 
#include "glUtility.h"
#include "glTexture.h"
#include "glEvents.h"
#include "glWidget.h"
 
#include <time.h>
#include <vector>
 
 
class glDisplay : public videoOutput
{
public:
        static glDisplay* Create( const char* title=NULL, int width=-1, int height=-1,
                                                 float r=0.05f, float g=0.05f, float b=0.05f, float a=1.0f );
 
        static glDisplay* Create( const videoOptions& options );
 
        ~glDisplay();
 
        virtual bool Open();
 
        inline bool IsOpen() const                              { return mStreaming; }
 
        inline bool IsClosed() const                            { return !mStreaming; }
 
        inline bool IsRendering() const                 { return mRendering; }
 
        inline float GetFPS() const                             { return 1000000000.0f / mAvgTime; }
 
        inline uint32_t GetID() const                           { return mID; }
 
        virtual inline uint32_t GetType() const         { return Type; }
 
        static const uint32_t Type = (1 << 3);
 
 
 
 
        void BeginRender( bool processEvents=true );
 
        void EndRender();
 
 
 
 
        void Render( glTexture* texture, float x=5.0f, float y=30.0f );
 
        void Render( float* image, uint32_t width, uint32_t height, float x=0.0f, float y=30.0f, bool normalize=true );
 
        template<typename T> bool Render( T* image, uint32_t width, uint32_t height )           { return Render((void**)image, width, height, imageFormatFromType<T>()); }
        
        virtual bool Render( void* image, uint32_t width, uint32_t height, imageFormat format );
 
        void RenderImage( void* image, uint32_t width, uint32_t height, imageFormat format, float x=0.0f, float y=30.0f, bool normalize=true );
 
        void RenderOnce( void* image, uint32_t width, uint32_t height, imageFormat format, float x=5.0f, float y=30.0f, bool normalize=true );
 
        void RenderOnce( float* image, uint32_t width, uint32_t height, float x=5.0f, float y=30.0f, bool normalize=true );
 
 
 
 
        void RenderLine( float x1, float y1, float x2, float y2, float r, float g, float b, float a=1.0f, float thickness=2.0f );
 
        void RenderOutline( float x, float y, float width, float height, float r, float g, float b, float a=1.0f, float thickness=2.0f );
 
        void RenderRect( float x, float y, float width, float height, float r, float g, float b, float a=1.0f );
 
        void RenderRect( float r, float g, float b, float a=1.0f );
 
 
 
 
        void SetSize( uint32_t width, uint32_t height );
 
        void SetMaximized( bool maximized );
 
        bool IsMaximized();
        
        void SetFullscreen( bool fullscreen );
        
        bool IsFullscreen();
 
 
 
 
        void GetBackgroundColor( float* r, float* g, float* b, float* a=NULL );
 
        void SetBackgroundColor( float r, float g, float b, float a=1.0f );
 
        void SetViewport( int left, int top, int right, int bottom );
 
        void ResetViewport();
 
 
 
 
        virtual void SetStatus( const char* str );
 
        void SetTitle( const char* str );
 
        static const char* DEFAULT_TITLE;
 
 
 
 
        void ProcessEvents();
 
        void AddEventHandler( glEventHandler callback, void* user=NULL );
 
        void RemoveEventHandler( glEventHandler callback, void* user=NULL );
 
 
 
 
        inline const int* GetMousePosition() const                      { return mMousePos; }
 
        inline void GetMousePosition( int* x, int* y ) const    { if(x) *x = mMousePos[0]; if(y) *y = mMousePos[1]; }
 
        inline bool GetMouseButton( uint32_t button ) const     { if(button > sizeof(mMouseButtons)) return false; return mMouseButtons[button]; }
 
        inline bool GetKey( uint32_t key ) const                        { const uint32_t idx = key - KEY_OFFSET; if(idx > sizeof(mKeyStates)) return false; return mKeyStates[idx]; }
 
 
 
 
        void SetCursor( uint32_t cursor );
 
        void SetDefaultCursor( uint32_t cursor, bool activate=true );
 
        void ResetCursor();
 
        void ResetDefaultCursor( bool activate=true );
 
 
 
 
        enum DragMode
        {
                DragDefault,    
                DragDisabled,   
                DragSelect,     
                DragCreate      
        };
 
        inline DragMode GetDragMode() const                                     { return mDragMode; }
 
        inline void SetDragMode( DragMode mode )                                { mDragMode = mode; }
 
        inline bool IsDragging( DragMode mode=DragDefault ) const       { return mode == DragCreate ? (mMouseDragOrigin[0] >= 0 && mMouseDragOrigin[1] >= 0) : (mMouseDrag[0] >= 0 && mMouseDrag[1] >= 0); }
 
        bool GetDragRect( int* x, int* y, int* width, int* height );
 
        bool GetDragCoords( int* x1, int* y1, int* x2, int* y2 );
 
 
 
 
        glWidget* AddWidget( glWidget* widget );
 
        void RemoveWidget( glWidget* widget, bool deleteWidget=true );
 
        void RemoveWidget( uint32_t index, bool deleteWidget=true );
 
        void RemoveAllWidgets( bool deleteWidgets=true );
 
        inline uint32_t GetNumWidgets() const                                   { return mWidgets.size(); }
 
        inline glWidget* GetWidget( const uint32_t index ) const        { return mWidgets[index]; }
 
        int GetWidgetIndex( const glWidget* widget ) const;
 
        glWidget* FindWidget( int x, int y );
 
        std::vector<glWidget*> FindWidgets( int x, int y );
 
 
protected:
        glDisplay( const videoOptions& options );
                
        bool initWindow();
        bool initGL();
 
        glTexture* allocTexture( uint32_t width, uint32_t height, imageFormat format ); 
 
        void activateViewport();
 
        void dispatchEvent( uint16_t msg, int a, int b );
        static bool onEvent( uint16_t msg, int a, int b, void* user );
 
        struct eventHandler
        {
                glEventHandler callback;
                void* user;
        };
 
        static const int screenIdx = 0;
                
        Display*     mDisplayX;
        Screen*      mScreenX;
        XVisualInfo* mVisualX;
        Window       mWindowX;
        GLXContext   mContextGL;
        Cursor     mCursors[256];
        int             mActiveCursor;
        int          mDefaultCursor;
        bool               mInitialShow;
        bool               mRendering;
        bool               mResizedToFeed;
        Atom               mWindowClosedMsg;
        DragMode           mDragMode;
 
        uint32_t mID;
        uint32_t mScreenWidth;
        uint32_t mScreenHeight;
 
        timespec mLastTime;
        float    mAvgTime;
        float    mBgColor[4];
        int      mViewport[4];
 
        int         mMousePos[2];
        int         mMouseDrag[2];
        int      mMouseDragOrigin[2];
        bool        mMouseButtons[16];
        bool     mKeyStates[1024];
 
        float*   mNormalizedCUDA;
        uint32_t mNormalizedWidth;
        uint32_t mNormalizedHeight;
 
        std::vector<glWidget*> mWidgets;
        std::vector<glTexture*> mTextures;
        std::vector<eventHandler> mEventHandlers;
};
 
glDisplay* glGetDisplay( uint32_t display=0 );
 
uint32_t glGetNumDisplays();
 
#endif