embedded_display_frame.h

Go to the documentation of this file.

/*! \file
 \brief  disti::eglDisplayFrame class.  The class for creating standalone executables for EGL.
 
 \par Copyright Information
 
 Copyright (c) 2017 by The DiSTI Corporation.<br>
 11301 Corporate Blvd., Suite 100<br>
 Orlando, Florida 32817<br>
 USA<br>
 <br>
 All rights reserved.<br>
 
 This Software contains proprietary trade secrets of DiSTI and may not be
 reproduced, in whole or part, in any form, or by any means of electronic,
 mechanical, or otherwise, without the written permission of DiSTI.  Said
 permission may be derived through the purchase of applicable DiSTI product
 licenses which detail the distribution rights of this content and any
 Derivative Works based on this or other copyrighted DiSTI Software.
 
 NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
 AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
 PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
 AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
 PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.
 
 LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
 IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
 INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
 DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
 INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
 INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
 OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
 EXCEED FIVE DOLLARS (US$5.00).
 
 The aforementioned terms and restrictions are governed by the laws of the
 State of Florida and the United States of America.
 
 */
#ifndef EMBEDDED_DISPLAY_H
#define EMBEDDED_DISPLAY_H

#include "events.h"
#include "gls_include.h"
#include "runtime_display_frame.h"
#include "timer.h"

namespace disti
{
enum FL_Flags
{
    FL_RGB,
    FL_DOUBLE,
    FL_DEPTH
};

/**
 * Base class for all embedded (openGL ES) display frame classes
 */
class EmbeddedDisplayFrame : public RuntimeDisplayFrame
{
protected:
    Timer frameTimer;          /**< Timer used for scheduling */
    float _smoothedFrameDelay; /**< Frame interval, smoothed based on actual draw performance */
    bool  _redraw;             /**< Flag indicating if the window should be redrawn */

    float  _width_offset;  /**< Current "width" offset of window.  Used for panning of display horizontally in ortho mode. */
    float  _height_offset; /**< Current "height" offset of window.  Used for panning of display vertically in ortho mode.  */
    Vector _viewOffset;

    /** For better control over clipping and field of view, use a GlsEyePoint, but some limited functionality is available here */

    float  _depthFactor;   /**< Used for auto calculations */
    double _fov;           /**< Field Of View.  If 0.0 (the default), fov will be auto calculated. */
    double _nearZ;         /**< Near clipping plane.  Only meaningful if _autoCalcNearZ is false */
    bool   _autoCalcNearZ; /**< When true a _nearZ is automatically calculated. */
    double _farZ;          /**< Far clipping plane.  Only meaningfull if _autoCalcVarZ is false */
    bool   _autoCalcFarZ;  /**< When true a _farZ is automatically calculated. */

    int _current_view; /**< Current view of the canvas (e.g., ortho, perspective, eyepoint) */

    void WindowFlags( int ) {}

    /** Builds a DisplayEvent for passing to the handle method
     * \param x X device coordinate
     * \param y Y device coordinate
     * \param pressure Touchscreen pressure 
     * \param eventType  Touch event type (e.g. MOUSE_UP,MOUSE_DOWN,MOUSE_DRAG
     */
    virtual GLS_EXPORT void BuildAndSendEvent( int x, int y, int pressure, unsigned int eventType );

    /* \see DisplayFrame */
    virtual GLS_EXPORT EventCompressor<DisplayFrame>* GetEventComporessor() { return &eventCompressor; }

public:
    enum iDeviceOrientation
    {
        ORIENTATION_UNKNOWN              = 0,
        ORIENTATION_PORTRAIT             = 1,
        ORIENTATION_PORTRAIT_UPSIDE_DOWN = 2,
        ORIENTATION_LANDSCAPE_LEFT       = 3,
        ORIENTATION_LANDSCAPE_RIGHT      = 4,
        ORIENTATION_FACE_UP              = 5,
        ORIENTATION_FACE_DOWN            = 6
    };

    GLS_EXPORT EmbeddedDisplayFrame( const char* name, int width, int height );

    virtual GLS_EXPORT ~EmbeddedDisplayFrame();

    /** Used for event compression.  Not for general use by users. */
    EventCompressor<DisplayFrame> eventCompressor;

    /** Removes (hides) the spash screen
     *  Note on iOS the AppDelegate presents the splash screen for us, so this is just a stub
     */
    virtual GLS_EXPORT void RemoveSplash()
    {
    }

    /** Creates the spash screen
     *  Note on iOS the AppDelegate presents the splash screen for us, so this is just a stub
     */
    virtual GLS_EXPORT void CreateSplash()
    {
    }

    /** Sets up the default Orthographic projection (which supports things like pan and zoom) */
    virtual GLS_EXPORT void SetProjection( GlsMatrixType& projMatrix, GlsMatrixType& model );

    /** Redraw the window at the Hz rate set for the DisplayFrame, or at least
     * try to.  We might be slower if the hardware can't keep up.
     */
    virtual GLS_EXPORT bool FrameAnimate( void );

    /** Redraw the window now.  
     * This actually calls the OpenGL Drawing routines. 
     */
    virtual GLS_EXPORT void Redraw( void );

    /** Set a flag that UpdateAnimate can test to see if the window needs redrawing. 
     */
    virtual GLS_EXPORT void SetRedraw( void );

    /** Only draw on events or if SetRedraw has been called.
     * If this is called in a main loop, updates can occur very frequently if SetRedraw is
     * continuously being called.
     */
    virtual GLS_EXPORT bool UpdateAnimate( void );

    /** Pans the display horizontally
     * \param offset  The new X position at the center of the window
     */
    virtual GLS_EXPORT void WidthOffset( float offset );

    /** Gets the horizontal position of the display at the center of the window
     * \return  The X position at the center of the window
     */
    virtual GLS_EXPORT float WidthOffset( void );

    /** Pans the display vertically
     * \param offset  The new Y position of the center of the window
     */
    virtual GLS_EXPORT void HeightOffset( float offset );

    /** Gets the vertical position of the display at the center of the window
     * \return  The Y position at the center of the window
     */
    virtual GLS_EXPORT float HeightOffset( void );

    /** Sets the Depth Factor for the window
     * \param factor  The depth factor.  Used for autocalculating clipping planes */
    virtual GLS_EXPORT void DepthFactor( float factor );

    /** Gets the Depth Factor for the window
     * \return  The current depth factor 
     */
    virtual GLS_EXPORT float DepthFactor();

    /** Sets the FOV (Field of View) for the window.   If fov is set to 0.0, a reasonable FOV
     * will be calculated based on width and height.
     * \param fov  New field of view in degrees 
     */
    virtual GLS_EXPORT void FOV( double fov );

    /** Gets the FOV (Field of View) for the window.
     * \return  The current field of view in degrees
     */
    virtual GLS_EXPORT double FOV();

    /** Sets the current view mode for the window
     * \param view  The new view mode for the window.  
     * Acceptable view types are:
     * [VIEW_EYEPOINT    - The application will be viewed through an eyepoint]
     * [VIEW_XY          - The application will be viewed through a 2D orthographic view of the XY plane]
     * [VIEW_PERSPECTIVE - The application will be viewed through a perspective projection]
     */
    virtual GLS_EXPORT void CurrentView( const int view ) { _current_view = view; }

    /** Gets the current view mode for the window.
     * \return The current viewmode for the window (VIEW_EYEPOINT, VIEW_XY, VIEW_PERSPECTIVE)
     */
    virtual GLS_EXPORT int CurrentView( void ) const { return _current_view; }
};

} // namespace disti

#endif